using System;
using System.Buffers;
using System.Collections.Generic;
using System.Diagnostics;
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.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Lua;
using Lua.Standard;
using Marioalexsan.ModAudio;
using Marioalexsan.ModAudio.HarmonyPatches;
using Marioalexsan.ModAudio.Scripting;
using Marioalexsan.ModAudio.Scripting.Data;
using Marioalexsan.ModAudio.Scripting.Proxies;
using Marioalexsan.ModAudio.SoftDependencies;
using Microsoft.CodeAnalysis;
using NAudio.Wave;
using NVorbis;
using Nessie.ATLYSS.EasySettings;
using Nessie.ATLYSS.EasySettings.UIElements;
using Unity.Profiling;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Marioalexsan.ModAudio")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("4.1.2.0")]
[assembly: AssemblyInformationalVersion("4.1.2+9efe84e1290bcb9bdf90db7ec1af6c2214035d81")]
[assembly: AssemblyProduct("ModAudio")]
[assembly: AssemblyTitle("Marioalexsan.ModAudio")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("4.1.2.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;
		}
	}
}
public struct RouteStep
{
	public AudioPack AudioPack;

	public Route Route;

	public string TargetGroup;

	public AudioClip SelectedClip;
}
public struct AudioStepState
{
	public AudioClip? Clip;

	public float Volume;

	public float Pitch;

	public bool Loop;
}
[Flags]
public enum AudioFlags : uint
{
	None = 0u,
	All = uint.MaxValue,
	DisableRouting = 1u,
	IsDedicatedOneShotSource = 2u,
	IsOverlay = 4u,
	OneShotStopsIfSourceStops = 8u,
	ShouldUpdateDynamicTargeting = 0x10u,
	IsSwappingTargets = 0x20u,
	LoopWasForced = 0x40u,
	VolumeLock = 0x80u,
	PitchLock = 0x100u,
	LoopLock = 0x200u,
	WasStoppedOrDisabled = 0x400u,
	HasEncounteredErrors = 0x800u
}
public class ModAudioSource
{
	public const int MaxChainedRoutes = 4;

	public readonly AudioSource Audio;

	public AudioSource? OneShotOrigin;

	public AudioStepState InitialState;

	public AudioStepState AppliedState;

	private readonly RouteStep[] Routes = new RouteStep[4];

	public AudioFlags Flags;

	public AudioStepState CurrentState
	{
		get
		{
			AudioStepState result = default(AudioStepState);
			result.Clip = Audio.clip;
			result.Volume = Audio.volume;
			result.Pitch = Audio.pitch;
			result.Loop = Audio.loop;
			return result;
		}
	}

	public int RouteCount { get; private set; }

	public ModAudioSource(AudioSource source)
	{
		Audio = source;
	}

	public RouteStep GetRoute(int index)
	{
		if (index < 0 || index >= Routes.Length)
		{
			throw new ArgumentOutOfRangeException("Tried to access a route index that is invalid for this audio source! Please notify the mod developer about this!");
		}
		return Routes[index];
	}

	public bool PushRoute(AudioPack pack, Route route, string targetGroup, AudioClip selectedClip)
	{
		if (RouteCount >= Routes.Length)
		{
			return false;
		}
		Routes[RouteCount++] = new RouteStep
		{
			AudioPack = pack,
			Route = route,
			TargetGroup = targetGroup,
			SelectedClip = selectedClip
		};
		return true;
	}

	public void ClearRoutes()
	{
		for (int i = 0; i < Routes.Length; i++)
		{
			Routes[i] = default(RouteStep);
		}
		RouteCount = 0;
	}

	public void Clear()
	{
		InitialState = default(AudioStepState);
		RouteCount = 0;
		for (int i = 0; i < 4; i++)
		{
			Routes[i] = default(RouteStep);
		}
		Flags = AudioFlags.None;
		OneShotOrigin = null;
	}

	public void RevertSource()
	{
		if ((Object)(object)Audio.clip != (Object)(object)AppliedState.Clip)
		{
			InitialState.Clip = Audio.clip;
		}
		else
		{
			Audio.clip = InitialState.Clip;
		}
		if (Audio.volume != AppliedState.Volume)
		{
			InitialState.Volume = Audio.volume;
		}
		else
		{
			Audio.volume = InitialState.Volume;
		}
		if (Audio.pitch != AppliedState.Pitch)
		{
			InitialState.Pitch = Audio.pitch;
		}
		else
		{
			Audio.pitch = InitialState.Pitch;
		}
		if (Audio.loop != AppliedState.Loop)
		{
			InitialState.Loop = Audio.loop;
		}
		else
		{
			Audio.loop = InitialState.Loop;
		}
		AppliedState.Clip = Audio.clip;
		AppliedState.Volume = Audio.volume;
		AppliedState.Pitch = Audio.pitch;
		AppliedState.Loop = Audio.loop;
		ClearRoutes();
		ClearFlag(AudioFlags.ShouldUpdateDynamicTargeting | AudioFlags.IsSwappingTargets);
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public void SetFlag(AudioFlags flag)
	{
		Flags |= flag;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public void ClearFlag(AudioFlags flag)
	{
		Flags &= ~flag;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public bool HasFlag(AudioFlags flag)
	{
		return (Flags & flag) == flag;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	public void AssignFlag(AudioFlags flag, bool shouldBeSet)
	{
		if (shouldBeSet)
		{
			SetFlag(flag);
		}
		else
		{
			ClearFlag(flag);
		}
	}

	public void PlayWithoutRouting()
	{
		bool shouldBeSet = HasFlag(AudioFlags.DisableRouting);
		SetFlag(AudioFlags.DisableRouting);
		Audio.Play();
		AssignFlag(AudioFlags.DisableRouting, shouldBeSet);
	}
}
namespace NAudio.Wave
{
	public class Mp3FileReader : Mp3FileReaderBase
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static FrameDecompressorBuilder <0>__CreateAcmFrameDecompressor;
		}

		public Mp3FileReader(string mp3FileName)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			FileStream fileStream = File.OpenRead(mp3FileName);
			object obj = <>O.<0>__CreateAcmFrameDecompressor;
			if (obj == null)
			{
				FrameDecompressorBuilder val = CreateAcmFrameDecompressor;
				<>O.<0>__CreateAcmFrameDecompressor = val;
				obj = (object)val;
			}
			((Mp3FileReaderBase)this)..ctor((Stream)fileStream, (FrameDecompressorBuilder)obj, true);
		}

		public Mp3FileReader(Stream inputStream)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			object obj = <>O.<0>__CreateAcmFrameDecompressor;
			if (obj == null)
			{
				FrameDecompressorBuilder val = CreateAcmFrameDecompressor;
				<>O.<0>__CreateAcmFrameDecompressor = val;
				obj = (object)val;
			}
			((Mp3FileReaderBase)this)..ctor(inputStream, (FrameDecompressorBuilder)obj, false);
		}

		public static IMp3FrameDecompressor CreateAcmFrameDecompressor(WaveFormat mp3Format)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			return (IMp3FrameDecompressor)new AcmMp3FrameDecompressor(mp3Format);
		}
	}
}
namespace Marioalexsan.ModAudio
{
	public static class AudioClipLoader
	{
		public static readonly string[] SupportedLoadExtensions = new string[3] { ".wav", ".ogg", ".mp3" };

		public static readonly string[] SupportedStreamExtensions = new string[3] { ".wav", ".ogg", ".mp3" };

		public static readonly string[] SupportedExtensions = SupportedLoadExtensions.Concat(SupportedStreamExtensions).Distinct().ToArray();

		public static AudioClip GenerateEmptyClip(string name, int samples)
		{
			AudioClip val = AudioClip.Create(name, samples, 1, 44100, false);
			val.SetData(new float[samples], 0);
			return val;
		}

		public static AudioClip LoadFromFile(string clipName, string path, float volumeModifier)
		{
			using IAudioStream audioStream = GetStream(path);
			audioStream.VolumeModifier = volumeModifier;
			AudioClip val = AudioClip.Create(clipName, audioStream.TotalFrames, audioStream.ChannelsPerFrame, audioStream.Frequency, false);
			int num = audioStream.TotalFrames * audioStream.ChannelsPerFrame;
			float[] array = new float[num];
			audioStream.ReadSamples(array);
			val.SetData(array, 0);
			return val;
		}

		public static AudioClip StreamFromFile(string clipName, string path, float volumeModifier, out IAudioStream openedStream)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0046: Expected O, but got Unknown
			IAudioStream audioStream = (openedStream = GetStream(path));
			audioStream.VolumeModifier = volumeModifier;
			return AudioClip.Create(clipName, audioStream.TotalFrames, audioStream.ChannelsPerFrame, audioStream.Frequency, true, new PCMReaderCallback(audioStream.ReadSamples), new PCMSetPositionCallback(audioStream.SetSamplePosition));
		}

		private static IAudioStream GetStream(string path)
		{
			if (path.EndsWith(".ogg"))
			{
				return new OggStream(File.OpenRead(path));
			}
			if (path.EndsWith(".mp3"))
			{
				return new Mp3Stream(File.OpenRead(path));
			}
			if (path.EndsWith(".wav"))
			{
				return new WavStream(File.OpenRead(path));
			}
			throw new NotImplementedException("The given file format isn't supported for streaming.");
		}
	}
	public interface IAudioStream : IDisposable
	{
		float VolumeModifier { get; set; }

		int TotalFrames { get; }

		int ChannelsPerFrame { get; }

		int Frequency { get; }

		void ReadSamples(float[] samples);

		void SetSamplePosition(int newPosition);
	}
	public class OggStream : IAudioStream, IDisposable
	{
		private readonly VorbisReader _reader = new VorbisReader(stream, true);

		public float VolumeModifier { get; set; } = 1f;


		public int TotalFrames => (int)_reader.TotalSamples;

		public int ChannelsPerFrame => _reader.Channels;

		public int Frequency => _reader.SampleRate;

		public OggStream(Stream stream)
		{
		}//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Expected O, but got Unknown


		public void ReadSamples(float[] samples)
		{
			_reader.ReadSamples(samples, 0, samples.Length);
			Utils.MultiplyFloatArray(samples, VolumeModifier);
		}

		public void SetSamplePosition(int newPosition)
		{
			_reader.SamplePosition = newPosition;
		}

		public void Dispose()
		{
			_reader.Dispose();
		}
	}
	public class WavStream : IAudioStream, IDisposable
	{
		private readonly WaveFileReader _reader;

		private readonly ISampleProvider _provider;

		public float VolumeModifier { get; set; } = 1f;


		public int TotalFrames => (int)_reader.SampleCount;

		public int ChannelsPerFrame => ((WaveStream)_reader).WaveFormat.Channels;

		public int Frequency => ((WaveStream)_reader).WaveFormat.SampleRate;

		public WavStream(Stream stream)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			_reader = new WaveFileReader(stream);
			_provider = WaveExtensionMethods.ToSampleProvider((IWaveProvider)(object)_reader);
		}

		public void ReadSamples(float[] samples)
		{
			_provider.Read(samples, 0, samples.Length);
			Utils.MultiplyFloatArray(samples, VolumeModifier);
		}

		public void SetSamplePosition(int newPosition)
		{
			((Stream)(object)_reader).Position = newPosition * ((WaveStream)_reader).BlockAlign;
		}

		public void Dispose()
		{
			((Stream)(object)_reader).Dispose();
		}
	}
	public class Mp3Stream : IAudioStream, IDisposable
	{
		private readonly Mp3FileReader _reader;

		private readonly ISampleProvider _provider;

		public float VolumeModifier { get; set; } = 1f;


		public int TotalFrames => (int)(((Stream)(object)_reader).Length * 8 / ChannelsPerFrame / ((WaveStream)_reader).WaveFormat.BitsPerSample);

		public int ChannelsPerFrame => ((WaveStream)_reader).WaveFormat.Channels;

		public int Frequency => ((WaveStream)_reader).WaveFormat.SampleRate;

		public Mp3Stream(Stream stream)
		{
			_reader = new Mp3FileReader(stream);
			_provider = WaveExtensionMethods.ToSampleProvider((IWaveProvider)(object)_reader);
		}

		public void ReadSamples(float[] samples)
		{
			_provider.Read(samples, 0, samples.Length);
			Utils.MultiplyFloatArray(samples, VolumeModifier);
		}

		public void SetSamplePosition(int newPosition)
		{
			((Stream)(object)_reader).Position = newPosition * ((WaveStream)_reader).BlockAlign;
		}

		public void Dispose()
		{
			((Stream)(object)_reader).Dispose();
		}
	}
	public enum DebugMessageCategories
	{
		AudioPack,
		AudioSource,
		Script,
		Engine
	}
	public class AudioDebugDisplay : MonoBehaviour
	{
		private struct MessageLog
		{
			public LogLevel Level;

			public DebugMessageCategories Category;

			public string Message;

			public string Tags;

			public float ExtraParam1;

			public bool ShouldDisplayCached;

			public bool FilterChecked;
		}

		private static readonly List<MessageLog> _messages = new List<MessageLog>(16384);

		private static Rect _windowPos = new Rect((float)Screen.width * 0.1f, (float)Screen.height * 0.1f, (float)Screen.width * 0.5f, (float)Screen.height * 0.5f);

		private readonly string[] _tabs = new string[3] { "Audio logs", "Audio packs", "Audio sources" };

		private static int _selectedTab = 0;

		private static Vector2 _audioPackScrollView;

		private static Vector2 _audioPackDetailsScrollView;

		private static int _selectedPack = -1;

		private static Vector2 _logScrollView;

		private static float _logScrollViewHeight = 100f;

		private static float _rowHeight = -1f;

		private static GUIStyle? _disabledPackButton;

		private static GUIStyle? _activePackButton;

		private static GUIStyle? _activeWithErrorsPackButton;

		private static GUIStyle? _disabledWithErrorsPackButton;

		private static GUIStyle? _logInfo;

		private static GUIStyle? _logWarn;

		private static GUIStyle? _logError;

		private static int _visibleLogElements = int.MinValue;

		private static int _hiddenLogElementsBefore = int.MinValue;

		private static int _hiddenLogElementsAfter = int.MinValue;

		private static bool _enabled = false;

		private static float _distanceFilterCached = 120f;

		private static float _distanceFilter = 120f;

		private static bool _useDistanceFilterCached = false;

		private static bool _useDistanceFilter = false;

		private static bool _showAudioPackMessagesCached = true;

		private static bool _showAudioPackMessages = true;

		private static bool _showAudioSourceMessagesCached = true;

		private static bool _showAudioSourceMessages = true;

		private static bool _showScriptMessagesCached = true;

		private static bool _showScriptMessages = true;

		private static bool _showEngineMessagesCached = true;

		private static bool _showEngineMessages = true;

		private static bool _showErrorAndWarnsOnlyCached = false;

		private static bool _showErrorAndWarnsOnly = false;

		private static bool _latestMessagesOnlyCached = false;

		private static bool _latestMessagesOnly = false;

		private static bool _filterModdedAudioCached = false;

		private static bool _filterModdedAudio = false;

		private static string _audioGroupFilterCached = "";

		private static string _audioGroupFilter = "";

		private static string _logIncludeFilter = "";

		private static string _logIncludeFilterCached = "";

		private static bool _shouldClearLogs = false;

		private static int _totalErrors = 0;

		private static int _totalWarnings = 0;

		private static int _totalMessages = 0;

		private static int _totalDisplayedErrors = 0;

		private static int _totalDisplayedWarnings = 0;

		private static int _totalDisplayedMessages = 0;

		private static readonly ProfilerMarker _updateLogsMarker = new ProfilerMarker("ModAudio debug menu update");

		private static readonly ProfilerMarker _renderLogsMarker = new ProfilerMarker("ModAudio debug menu render");

		private static int _totalActiveAudioSources;

		private static int _totalInactiveAudioSources;

		private static DateTime _totalSourcesLastFetchedAt = DateTime.UnixEpoch;

		public static void LogPack(LogLevel level, string message, string tags = "")
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			_messages.Add(new MessageLog
			{
				Level = level,
				Category = DebugMessageCategories.AudioPack,
				Message = message,
				Tags = tags
			});
		}

		public static void LogScript(LogLevel level, string message, string tags = "")
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			_messages.Add(new MessageLog
			{
				Level = level,
				Category = DebugMessageCategories.Script,
				Message = message,
				Tags = tags
			});
		}

		public static void LogAudio(LogLevel level, string message, string tags = "", float extraParam1 = 0f)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			_messages.Add(new MessageLog
			{
				Level = level,
				Category = DebugMessageCategories.AudioSource,
				Message = message,
				Tags = tags,
				ExtraParam1 = extraParam1
			});
		}

		public static void LogEngine(LogLevel level, string message, string tags = "")
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			_messages.Add(new MessageLog
			{
				Level = level,
				Category = DebugMessageCategories.Engine,
				Message = message,
				Tags = tags
			});
		}

		public void OnGUI()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Expected O, but got Unknown
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Expected O, but got Unknown
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			if (!_enabled)
			{
				return;
			}
			GUI.backgroundColor = new Color(0f, 0f, 0f, 1f);
			GUI.color = new Color(1f, 1f, 1f, 1f);
			if (_disabledPackButton == null)
			{
				GUIStyle val = new GUIStyle(GUI.skin.button);
				val.normal.textColor = Color.gray;
				_disabledPackButton = val;
			}
			if (_disabledWithErrorsPackButton == null)
			{
				GUIStyle val2 = new GUIStyle(GUI.skin.button);
				val2.normal.textColor = Color.red * 0.5f + Color.gray * 0.5f;
				_disabledWithErrorsPackButton = val2;
			}
			if (_activePackButton == null)
			{
				GUIStyle val3 = new GUIStyle(GUI.skin.button);
				val3.normal.textColor = Color.white;
				_activePackButton = val3;
			}
			if (_activeWithErrorsPackButton == null)
			{
				GUIStyle val4 = new GUIStyle(GUI.skin.button);
				val4.normal.textColor = Color.red;
				_activeWithErrorsPackButton = val4;
			}
			if (_logInfo == null)
			{
				GUIStyle val5 = new GUIStyle(GUI.skin.label);
				val5.normal.textColor = Color.white;
				_logInfo = val5;
			}
			if (_logWarn == null)
			{
				GUIStyle val6 = new GUIStyle(GUI.skin.label);
				val6.normal.textColor = Color.yellow;
				_logWarn = val6;
			}
			if (_logError == null)
			{
				GUIStyle val7 = new GUIStyle(GUI.skin.label);
				val7.normal.textColor = Color.red;
				_logError = val7;
			}
			if (_rowHeight < 0f)
			{
				_rowHeight = GUI.skin.label.CalcSize(new GUIContent("Text")).y;
			}
			_windowPos = GUILayout.Window(0, new Rect(((Rect)(ref _windowPos)).position, new Vector2((float)Screen.width * 0.5f, (float)Screen.height * 0.5f)), (WindowFunction)delegate
			{
				_selectedTab = GUILayout.Toolbar(_selectedTab, _tabs, Array.Empty<GUILayoutOption>());
				if (_selectedTab == 0)
				{
					RenderAudioLogs();
				}
				else if (_selectedTab == 1)
				{
					RenderAudioPacks();
				}
				else if (_selectedTab == 2)
				{
					RenderAudioSources();
				}
			}, "ModAudio", Array.Empty<GUILayoutOption>());
		}

		public void Update()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			ProfilerMarker updateLogsMarker = _updateLogsMarker;
			((ProfilerMarker)(ref updateLogsMarker)).Begin();
			if ((int)ModAudio.Plugin.DebugMenuButton.Value != 0 && Input.GetKeyDown(ModAudio.Plugin.DebugMenuButton.Value))
			{
				_enabled = !_enabled;
			}
			if (_messages.Count >= 10000)
			{
				_messages.RemoveRange(0, 5000);
				LogEngine((LogLevel)4, "There are more than 10000 messages in the log! Removing oldest 5000 messages to reclaim memory.");
			}
			if (_enabled)
			{
				if (_selectedTab == 0)
				{
					UpdateAudioLogs();
				}
				else if (_selectedTab == 1)
				{
					UpdateAudioPacks();
				}
				else if (_selectedTab == 2)
				{
					UpdateAudioSources();
				}
			}
			updateLogsMarker = _updateLogsMarker;
			((ProfilerMarker)(ref updateLogsMarker)).End();
		}

		private void UpdateAudioSources()
		{
			if (!(_totalSourcesLastFetchedAt + TimeSpan.FromSeconds(0.25) < DateTime.Now))
			{
				return;
			}
			_totalSourcesLastFetchedAt = DateTime.Now;
			AudioSource[] array = Object.FindObjectsByType<AudioSource>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			_totalActiveAudioSources = 0;
			_totalInactiveAudioSources = 0;
			for (int i = 0; i < array.Length; i++)
			{
				if (((Behaviour)array[i]).isActiveAndEnabled)
				{
					_totalActiveAudioSources++;
				}
				else
				{
					_totalInactiveAudioSources++;
				}
			}
		}

		private void RenderAudioSources()
		{
			GUILayout.Label("[Note: this tab is not finished yet!]", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Total active audio sources (Unity): {_totalActiveAudioSources}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Total inactive audio sources (Unity): {_totalInactiveAudioSources}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Total sources tracked by ModAudio: {AudioEngine.TrackedSources.Count}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Total playOnAwake sources tracked: {AudioEngine.TrackedPlayOnAwakeSourceStates.Count}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Total one shot sources tracked: {AudioEngine.TrackedOneShots.Count}", Array.Empty<GUILayoutOption>());
		}

		private void UpdateAudioPacks()
		{
		}

		private void RenderAudioPacks()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Audio packs: {AudioEngine.AudioPacks.Count}", Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			_audioPackScrollView = GUILayout.BeginScrollView(_audioPackScrollView, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width((float)Screen.width * 0.2f) });
			for (int i = 0; i < AudioEngine.AudioPacks.Count; i++)
			{
				AudioPack audioPack = AudioEngine.AudioPacks[i];
				if ((!audioPack.HasFlag(PackFlags.HasEncounteredErrors)) ? GUILayout.Button(audioPack.Config.DisplayName, audioPack.HasFlag(PackFlags.Enabled) ? _activePackButton : _disabledPackButton, Array.Empty<GUILayoutOption>()) : GUILayout.Button(audioPack.Config.DisplayName, audioPack.HasFlag(PackFlags.Enabled) ? _activeWithErrorsPackButton : _disabledWithErrorsPackButton, Array.Empty<GUILayoutOption>()))
				{
					_selectedPack = i;
				}
			}
			GUILayout.EndScrollView();
			if (0 <= _selectedPack && _selectedPack < AudioEngine.AudioPacks.Count)
			{
				AudioPack audioPack2 = AudioEngine.AudioPacks[_selectedPack];
				_audioPackDetailsScrollView = GUILayout.BeginScrollView(_audioPackDetailsScrollView, Array.Empty<GUILayoutOption>());
				GUILayout.Label("Display name: " + audioPack2.Config.DisplayName, Array.Empty<GUILayoutOption>());
				GUILayout.Label("ID: " + audioPack2.Config.Id, Array.Empty<GUILayoutOption>());
				GUILayout.Label("Path: " + audioPack2.PackPath, Array.Empty<GUILayoutOption>());
				GUILayout.Space(_rowHeight);
				GUILayout.Label($"All flag values: {audioPack2.Flags}", Array.Empty<GUILayoutOption>());
				if (audioPack2.Flags.HasFlag(PackFlags.HasEncounteredErrors))
				{
					GUILayout.Label("This pack encountered errors!", _logError, Array.Empty<GUILayoutOption>());
				}
				else
				{
					GUILayout.Label("Pack is working correctly", Array.Empty<GUILayoutOption>());
				}
				GUILayout.Space(_rowHeight);
				GUILayout.Label($"Total custom clips: {audioPack2.Config.CustomClips.Count}", Array.Empty<GUILayoutOption>());
				GUILayout.Label($"Clips streamed: {audioPack2.OpenStreams.Count}", Array.Empty<GUILayoutOption>());
				GUILayout.Label($"Clips loaded in memory: {audioPack2.ReadyClips.Count - audioPack2.OpenStreams.Count}", Array.Empty<GUILayoutOption>());
				GUILayout.Label($"Clips waiting to be streamed: {audioPack2.PendingClipsToStream.Count}", Array.Empty<GUILayoutOption>());
				GUILayout.Label($"Clips waiting to be loaded: {audioPack2.PendingClipsToLoad.Count}", Array.Empty<GUILayoutOption>());
				GUILayout.Space(_rowHeight);
				GUILayout.Label($"Total routes: {audioPack2.Config.Routes.Count}", Array.Empty<GUILayoutOption>());
				GUILayout.Space(_rowHeight);
				GUILayout.Label("Lua script loaded: " + ((audioPack2.Script != null) ? "True" : "False"), Array.Empty<GUILayoutOption>());
				GUILayout.EndScrollView();
			}
			GUILayout.EndHorizontal();
		}

		private static void UpdateCachedValue<T>(ref T cache, T value, ref bool changed)
		{
			if (!object.Equals(cache, value))
			{
				cache = value;
				changed = true;
			}
		}

		private void UpdateAudioLogs()
		{
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Invalid comparison between Unknown and I4
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Invalid comparison between Unknown and I4
			_visibleLogElements = int.MinValue;
			_hiddenLogElementsBefore = int.MinValue;
			_hiddenLogElementsAfter = int.MinValue;
			bool changed = false;
			UpdateCachedValue(ref _useDistanceFilterCached, _useDistanceFilter, ref changed);
			UpdateCachedValue(ref _distanceFilterCached, _distanceFilter, ref changed);
			UpdateCachedValue(ref _showAudioPackMessagesCached, _showAudioPackMessages, ref changed);
			UpdateCachedValue(ref _showAudioSourceMessagesCached, _showAudioSourceMessages, ref changed);
			UpdateCachedValue(ref _showScriptMessagesCached, _showScriptMessages, ref changed);
			UpdateCachedValue(ref _showEngineMessagesCached, _showEngineMessages, ref changed);
			UpdateCachedValue(ref _latestMessagesOnlyCached, _latestMessagesOnly, ref changed);
			UpdateCachedValue(ref _showErrorAndWarnsOnlyCached, _showErrorAndWarnsOnly, ref changed);
			UpdateCachedValue(ref _audioGroupFilterCached, _audioGroupFilter, ref changed);
			UpdateCachedValue(ref _filterModdedAudioCached, _filterModdedAudio, ref changed);
			UpdateCachedValue(ref _logIncludeFilterCached, _logIncludeFilter, ref changed);
			if (_shouldClearLogs)
			{
				_shouldClearLogs = false;
				_messages.Clear();
			}
			_totalMessages = 0;
			_totalErrors = 0;
			_totalWarnings = 0;
			_totalDisplayedMessages = 0;
			_totalDisplayedErrors = 0;
			_totalDisplayedWarnings = 0;
			for (int i = 0; i < _messages.Count; i++)
			{
				MessageLog log = _messages[i];
				bool flag;
				if (changed || !_messages[i].FilterChecked)
				{
					flag = ShouldDisplayLog(log);
					List<MessageLog> messages = _messages;
					int index = i;
					MessageLog value = _messages[i];
					value.ShouldDisplayCached = flag;
					value.FilterChecked = true;
					messages[index] = value;
				}
				else
				{
					flag = _messages[i].ShouldDisplayCached;
				}
				_totalMessages++;
				if (flag)
				{
					_totalDisplayedMessages++;
				}
				if ((int)log.Level == 2)
				{
					_totalErrors++;
					if (flag)
					{
						_totalDisplayedErrors++;
					}
				}
				else if ((int)log.Level == 4)
				{
					_totalWarnings++;
					if (flag)
					{
						_totalDisplayedWarnings++;
					}
				}
			}
		}

		private void RenderAudioLogs()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Invalid comparison between Unknown and I4
			//IL_054b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0550: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			ProfilerMarker renderLogsMarker = _renderLogsMarker;
			((ProfilerMarker)(ref renderLogsMarker)).Begin();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Options:", Array.Empty<GUILayoutOption>());
			_latestMessagesOnly = GUILayout.Toggle(_latestMessagesOnly, "Auto scroll to latest", Array.Empty<GUILayoutOption>());
			_showErrorAndWarnsOnly = GUILayout.Toggle(_showErrorAndWarnsOnly, "Show only errors and warnings", Array.Empty<GUILayoutOption>());
			_filterModdedAudio = GUILayout.Toggle(_filterModdedAudio, "Show only custom audio", Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Categories:", Array.Empty<GUILayoutOption>());
			_showAudioPackMessages = GUILayout.Toggle(_showAudioPackMessages, "Audio Packs", Array.Empty<GUILayoutOption>());
			_showAudioSourceMessages = GUILayout.Toggle(_showAudioSourceMessages, "Audio Sources", Array.Empty<GUILayoutOption>());
			_showScriptMessages = GUILayout.Toggle(_showScriptMessages, "Scripts", Array.Empty<GUILayoutOption>());
			_showEngineMessages = GUILayout.Toggle(_showEngineMessages, "Engine", Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Search for text:", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			_logIncludeFilter = GUILayout.TextField(_logIncludeFilter, 80, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUILayout.EndHorizontal();
			if (_showAudioSourceMessagesCached)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.Label("Audio categories:", Array.Empty<GUILayoutOption>());
				if (GUILayout.Toggle(_audioGroupFilter.Length == 0, "All", Array.Empty<GUILayoutOption>()))
				{
					_audioGroupFilter = "";
				}
				if (GUILayout.Toggle(_audioGroupFilter.Equals("AudGrp ambience"), "Ambience", Array.Empty<GUILayoutOption>()))
				{
					_audioGroupFilter = "AudGrp ambience";
				}
				if (GUILayout.Toggle(_audioGroupFilter.Equals("AudGrp game"), "Game", Array.Empty<GUILayoutOption>()))
				{
					_audioGroupFilter = "AudGrp game";
				}
				if (GUILayout.Toggle(_audioGroupFilter.Equals("AudGrp gui"), "GUI", Array.Empty<GUILayoutOption>()))
				{
					_audioGroupFilter = "AudGrp gui";
				}
				if (GUILayout.Toggle(_audioGroupFilter.Equals("AudGrp music"), "Music", Array.Empty<GUILayoutOption>()))
				{
					_audioGroupFilter = "AudGrp music";
				}
				if (GUILayout.Toggle(_audioGroupFilter.Equals("AudGrp voice"), "Voice", Array.Empty<GUILayoutOption>()))
				{
					_audioGroupFilter = "AudGrp voice";
				}
				GUILayout.FlexibleSpace();
				GUILayout.EndHorizontal();
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				_useDistanceFilter = GUILayout.Toggle(_useDistanceFilter, $"Filter audio by distance from player ({_distanceFilter:F2})", Array.Empty<GUILayoutOption>());
				_distanceFilter = GUILayout.HorizontalSlider(_distanceFilter, 0f, 1000f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MaxWidth(10000f) });
				GUILayout.EndHorizontal();
			}
			if (GUILayout.Button("Clear messages", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }))
			{
				_shouldClearLogs = true;
			}
			float num = _rowHeight * (float)_totalDisplayedMessages;
			if (_latestMessagesOnlyCached)
			{
				_logScrollView.y = num;
			}
			_logScrollView = GUILayout.BeginScrollView(_logScrollView, Array.Empty<GUILayoutOption>());
			float num2 = Math.Clamp(_logScrollView.y / (num - _logScrollViewHeight), 0f, 1f);
			if (_visibleLogElements == int.MinValue)
			{
				_hiddenLogElementsBefore = Math.Clamp((int)(Mathf.Lerp(0f, num - _logScrollViewHeight - _rowHeight, num2) / _rowHeight), 0, _totalDisplayedMessages);
				_hiddenLogElementsAfter = Math.Clamp((int)(Mathf.Lerp(num - _logScrollViewHeight - _rowHeight, 0f, num2) / _rowHeight), 0, _totalDisplayedMessages);
				_visibleLogElements = _totalDisplayedMessages - _hiddenLogElementsAfter - _hiddenLogElementsBefore;
			}
			GUILayout.Space(_rowHeight * (float)_hiddenLogElementsBefore);
			int num3 = 0;
			for (int i = 0; i < _hiddenLogElementsBefore + _visibleLogElements; i++)
			{
				MessageLog messageLog = _messages[num3];
				while (!messageLog.ShouldDisplayCached)
				{
					messageLog = _messages[++num3];
				}
				if (i >= _hiddenLogElementsBefore)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					GUILayout.Label(MapLogLevelToLabel(messageLog.Level), MapLogLevelToStyle(messageLog.Level), Array.Empty<GUILayoutOption>());
					GUILayout.Label(messageLog.Message, Array.Empty<GUILayoutOption>());
					GUILayout.FlexibleSpace();
					GUILayout.EndHorizontal();
				}
				num3++;
			}
			if (_hiddenLogElementsAfter >= 1)
			{
				GUILayout.Space(_rowHeight * (float)_hiddenLogElementsAfter);
			}
			GUILayout.EndScrollView();
			if ((int)Event.current.type == 7)
			{
				Rect lastRect = GUILayoutUtility.GetLastRect();
				_logScrollViewHeight = ((Rect)(ref lastRect)).height;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Total: {_totalDisplayedMessages}/{_totalMessages}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Errors: {_totalDisplayedErrors}/{_totalErrors}", Array.Empty<GUILayoutOption>());
			GUILayout.Label($"Warnings: {_totalDisplayedWarnings}/{_totalWarnings}", Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			GUI.DragWindow();
			renderLogsMarker = _renderLogsMarker;
			((ProfilerMarker)(ref renderLogsMarker)).End();
		}

		private bool ShouldDisplayLog(MessageLog log)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if ((int)log.Level != 2 && (int)log.Level != 4 && _showErrorAndWarnsOnlyCached)
			{
				return false;
			}
			if (log.Category switch
			{
				DebugMessageCategories.AudioPack => _showAudioPackMessagesCached ? 1 : 0, 
				DebugMessageCategories.AudioSource => _showAudioSourceMessagesCached ? 1 : 0, 
				DebugMessageCategories.Script => _showScriptMessagesCached ? 1 : 0, 
				DebugMessageCategories.Engine => _showEngineMessagesCached ? 1 : 0, 
				_ => 0, 
			} == 0)
			{
				return false;
			}
			if (log.Category == DebugMessageCategories.AudioSource && _useDistanceFilterCached && log.ExtraParam1 >= _distanceFilterCached)
			{
				return false;
			}
			if (log.Category == DebugMessageCategories.AudioSource)
			{
				if (_audioGroupFilterCached != "" && !log.Tags.Contains(_audioGroupFilterCached))
				{
					return false;
				}
				if (_filterModdedAudioCached && !log.Tags.Contains("Routed") && !log.Tags.Contains("Overlay"))
				{
					return false;
				}
			}
			if (_logIncludeFilterCached != "" && !log.Message.Contains(_logIncludeFilterCached, StringComparison.InvariantCultureIgnoreCase))
			{
				return false;
			}
			return true;
		}

		private string MapLogLevelToLabel(LogLevel level)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected I4, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			switch (level - 1)
			{
			default:
				if ((int)level != 16)
				{
					if ((int)level != 32)
					{
						break;
					}
					return "DEBUG";
				}
				return "INFO ";
			case 3:
				return "WARN ";
			case 1:
				return "ERROR";
			case 0:
				return "FATAL";
			case 2:
				break;
			}
			return "OTHER";
		}

		private GUIStyle? MapLogLevelToStyle(LogLevel level)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if ((int)level != 2)
			{
				if ((int)level != 4)
				{
					if ((int)level == 16)
					{
						return _logInfo;
					}
					return _logInfo;
				}
				return _logWarn;
			}
			return _logError;
		}
	}
	public enum SourceDetectionRate
	{
		Realtime,
		Fast,
		Medium,
		Slow
	}
	internal static class AudioEngine
	{
		private static readonly ProfilerMarker _routing = new ProfilerMarker("ModAudio Route()");

		private static readonly ProfilerMarker _playRouting = new ProfilerMarker("ModAudio Route() from AudioPlayed()");

		private static readonly ProfilerMarker _detectNewSources = new ProfilerMarker("ModAudio Update() fetch audio sources");

		private static readonly ProfilerMarker _playOnAwakeHandling = new ProfilerMarker("ModAudio Update() playOnAwake handling");

		private static readonly ProfilerMarker _executeUpdate = new ProfilerMarker("ModAudio Update() execute script updates");

		private static readonly ProfilerMarker _executeTargetGroups = new ProfilerMarker("ModAudio Update() execute script target groups");

		private static readonly ProfilerMarker _cleanupSources = new ProfilerMarker("ModAudio Update() cleanup sources");

		private static readonly ProfilerMarker _updateTargeting = new ProfilerMarker("ModAudio Update() update targeting");

		public const string DefaultClipKeyword = "___default___";

		public const string EmptyClipKeyword = "___nothing___";

		public const string ErrorClipKeyword = "!!! error !!!";

		public const string TargetGroupAll = "all";

		private const int MaxChainRoutes = 4;

		private static readonly Random RNG = new Random();

		private static readonly Stopwatch Watch = new Stopwatch();

		public static readonly Dictionary<AudioSource, ModAudioSource> TrackedSources = new Dictionary<AudioSource, ModAudioSource>(8192);

		public static readonly Dictionary<AudioSource, bool> TrackedPlayOnAwakeSourceStates = new Dictionary<AudioSource, bool>();

		public static readonly HashSet<ModAudioSource> TrackedOneShots = new HashSet<ModAudioSource>();

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

		public static Dictionary<string, AudioMixerGroup> LoadedMixerGroups = new Dictionary<string, AudioMixerGroup>();

		private static DateTime LastSourceFetch = DateTime.Now;

		private static readonly Dictionary<Route, TargetGroupData> CachedRoutingTargetGroupData = new Dictionary<Route, TargetGroupData>();

		private static AudioClip? _emptyClip;

		private static AudioClip? _errorClip;

		public static List<AudioPack> AudioPacks { get; } = new List<AudioPack>();


		private static AudioClip EmptyClip => _emptyClip ?? (_emptyClip = AudioClipLoader.GenerateEmptyClip("___nothing___", 16384));

		private static AudioClip ErrorClip => _errorClip ?? (_errorClip = AudioClipLoader.GenerateEmptyClip("!!! error !!!", 16384));

		public static bool IsVolumeLocked(AudioSource source)
		{
			return GetModAudioSourceIfExists(source)?.HasFlag(AudioFlags.VolumeLock) ?? false;
		}

		public static bool IsPitchLocked(AudioSource source)
		{
			return GetModAudioSourceIfExists(source)?.HasFlag(AudioFlags.PitchLock) ?? false;
		}

		public static bool IsLoopLocked(AudioSource source)
		{
			return GetModAudioSourceIfExists(source)?.HasFlag(AudioFlags.LoopLock) ?? false;
		}

		public static void HardReload()
		{
			Reload(hardReload: true);
		}

		public static void SoftReload()
		{
			Reload(hardReload: false);
		}

		public static void SoftReloadScripts()
		{
			try
			{
				foreach (AudioPack audioPack in AudioPacks)
				{
					audioPack.Script?.Dispose();
					audioPack.Script = null;
				}
				foreach (AudioPack audioPack2 in AudioPacks)
				{
					AudioPackLoader.LoadScriptData(audioPack2.PackPath, audioPack2);
					AudioPackLoader.FinalizePack(audioPack2);
				}
				SoftReload();
			}
			catch (Exception ex)
			{
				Logging.LogError("ModAudio crashed in SoftReloadScripts! Please report this error to the mod developer:");
				Logging.LogError(ex.ToString());
			}
		}

		private static void Reload(bool hardReload)
		{
			Watch.Restart();
			try
			{
				Logging.LogInfo("Reloading engine! this might take a while...");
				MapInstance_Handle_AudioSettings.ForceCombatMusic = false;
				if (hardReload)
				{
					Logging.LogInfo("Clearing loaded vanilla clips...");
					LoadedVanillaClips.Clear();
					LoadedMixerGroups.Clear();
					LoadedMixerGroups = SettingsManager._current._masterMixer.FindMatchingGroups("").ToDictionary((AudioMixerGroup x) => ((Object)x).name.ToLower());
				}
				CleanupSources();
				if (hardReload)
				{
					Span<KeyValuePair<AudioSource, ModAudioSource>> span = ForeachCache<KeyValuePair<AudioSource, ModAudioSource>>.CacheFrom(TrackedSources);
					for (int i = 0; i < span.Length; i++)
					{
						KeyValuePair<AudioSource, ModAudioSource> keyValuePair = span[i];
						if (keyValuePair.Value.HasFlag(AudioFlags.IsDedicatedOneShotSource))
						{
							TrackedSources.Remove(keyValuePair.Key);
							Object.Destroy((Object)(object)keyValuePair.Key);
						}
					}
				}
				Dictionary<AudioSource, bool> dictionary = new Dictionary<AudioSource, bool>();
				AudioSource[] array = Object.FindObjectsOfType<AudioSource>(true);
				foreach (AudioSource val in array)
				{
					dictionary[val] = val.isPlaying;
					if (dictionary[val])
					{
						val.Stop();
					}
					GetModAudioSourceIfExists(val)?.ClearFlag(AudioFlags.VolumeLock);
				}
				foreach (KeyValuePair<AudioSource, ModAudioSource> trackedSource in TrackedSources)
				{
					trackedSource.Value.RevertSource();
				}
				TrackedSources.Clear();
				TrackedPlayOnAwakeSourceStates.Clear();
				TrackedOneShots.Clear();
				if (hardReload)
				{
					Logging.LogInfo("Reloading audio packs...");
					foreach (AudioPack audioPack in AudioPacks)
					{
						audioPack.Dispose();
					}
					AudioPacks.Clear();
					AudioPacks.AddRange(AudioPackLoader.LoadAudioPacks());
					ModAudio.Plugin.InitializePackConfiguration();
				}
				Logging.LogInfo("Preloading audio data...");
				foreach (AudioPack audioPack2 in AudioPacks)
				{
					if (audioPack2.HasFlag(PackFlags.Enabled) && audioPack2.PendingClipsToLoad.Count > 0)
					{
						string[] array2 = audioPack2.PendingClipsToLoad.Keys.ToArray();
						string[] array3 = array2;
						foreach (string name in array3)
						{
							audioPack2.TryGetReadyClip(name, out AudioClip _);
						}
					}
				}
				Logging.LogInfo("Restarting audio sources...");
				AudioSource[] array4 = Object.FindObjectsOfType<AudioSource>(true);
				foreach (AudioSource val2 in array4)
				{
					if (dictionary[val2])
					{
						val2.Play();
					}
				}
			}
			catch (Exception ex)
			{
				Logging.LogError("ModAudio crashed in Reload! Please report this error to the mod developer:");
				Logging.LogError(ex.ToString());
			}
			Watch.Stop();
			Logging.LogInfo($"Done with reload! Reload took {Watch.ElapsedMilliseconds} milliseconds.");
		}

		public static void Update()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (!ModAudio.Plugin.CurrentlyEnabled)
			{
				return;
			}
			try
			{
				ModAudioScript.TriggerNewFrame();
				ProfilerMarker val;
				for (int i = 0; i < AudioPacks.Count; i++)
				{
					AudioPack audioPack = AudioPacks[i];
					if (audioPack.HasFlag(PackFlags.Enabled) && !string.IsNullOrEmpty(audioPack.Config.PackScripts.Update) && audioPack.Script != null)
					{
						val = _executeUpdate;
						((ProfilerMarker)(ref val)).Begin();
						audioPack.Script.ExecuteUpdate();
						val = _executeUpdate;
						((ProfilerMarker)(ref val)).End();
					}
				}
				DetectNewSources();
				val = _playOnAwakeHandling;
				((ProfilerMarker)(ref val)).Begin();
				Span<KeyValuePair<AudioSource, bool>> span = ForeachCache<KeyValuePair<AudioSource, bool>>.CacheFrom(TrackedPlayOnAwakeSourceStates);
				for (int j = 0; j < span.Length; j++)
				{
					AudioSource key = span[j].Key;
					if (!((Object)(object)key == (Object)null))
					{
						bool value = span[j].Value;
						if (value && !key.isPlaying)
						{
							TrackedPlayOnAwakeSourceStates[key] = false;
							AudioStopped(key, stopOneShots: false);
						}
						else if (!value && key.isPlaying)
						{
							TrackedPlayOnAwakeSourceStates[key] = true;
							AudioPlayed(key);
						}
					}
				}
				val = _playOnAwakeHandling;
				((ProfilerMarker)(ref val)).End();
				val = _cleanupSources;
				((ProfilerMarker)(ref val)).Begin();
				CleanupSources();
				val = _cleanupSources;
				((ProfilerMarker)(ref val)).End();
				val = _updateTargeting;
				((ProfilerMarker)(ref val)).Begin();
				UpdateDynamicTargeting();
				val = _updateTargeting;
				((ProfilerMarker)(ref val)).End();
			}
			catch (Exception ex)
			{
				Logging.LogError("ModAudio crashed in Update! Please report this error to the mod developer:");
				Logging.LogError(ex.ToString());
			}
		}

		private static void DetectNewSources()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			TimeSpan timeSpan = ModAudio.Plugin.SourceDetectionRate.Value switch
			{
				SourceDetectionRate.Realtime => TimeSpan.Zero, 
				SourceDetectionRate.Fast => TimeSpan.FromMilliseconds(100.0), 
				SourceDetectionRate.Medium => TimeSpan.FromMilliseconds(500.0), 
				_ => TimeSpan.FromMilliseconds(2500.0), 
			};
			if (!(DateTime.Now - LastSourceFetch < timeSpan))
			{
				LastSourceFetch = DateTime.Now;
				ProfilerMarker detectNewSources = _detectNewSources;
				((ProfilerMarker)(ref detectNewSources)).Begin();
				AudioSource[] array = Object.FindObjectsByType<AudioSource>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				for (int i = 0; i < array.Length; i++)
				{
					GetOrCreateModAudioSource(array[i]);
				}
				detectNewSources = _detectNewSources;
				((ProfilerMarker)(ref detectNewSources)).End();
			}
		}

		private static void UpdateDynamicTargeting()
		{
			CachedRoutingTargetGroupData.Clear();
			Span<KeyValuePair<AudioSource, ModAudioSource>> span = ForeachCache<KeyValuePair<AudioSource, ModAudioSource>>.CacheFrom(TrackedSources);
			for (int i = 0; i < span.Length; i++)
			{
				ModAudioSource value = span[i].Value;
				if ((Object)(object)value.Audio != (Object)null && value.HasFlag(AudioFlags.ShouldUpdateDynamicTargeting) && !UpdateDynamicTargeting(value))
				{
					value.ClearFlag(AudioFlags.ShouldUpdateDynamicTargeting);
				}
			}
			CachedRoutingTargetGroupData.Clear();
		}

		private static bool UpdateDynamicTargeting(ModAudioSource source)
		{
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			for (int i = 0; i < source.RouteCount; i++)
			{
				RouteStep route = source.GetRoute(i);
				flag2 = flag2 || route.Route.SmoothDynamicTargeting;
				flag3 = route.Route.ForcePlay;
				if (route.Route.EnableDynamicTargeting)
				{
					TargetGroupData cachedTargetGroup = GetCachedTargetGroup(source, route.AudioPack, route.Route);
					if (cachedTargetGroup.SkipRoute || cachedTargetGroup.TargetGroup != route.TargetGroup)
					{
						flag = true;
					}
				}
			}
			if (flag)
			{
				bool flag4 = false;
				if (flag2)
				{
					source.SetFlag(AudioFlags.IsSwappingTargets);
					source.ClearFlag(AudioFlags.VolumeLock);
					float num = Mathf.Lerp(source.Audio.volume, 0f, Time.deltaTime * 4f);
					source.Audio.volume = num;
					source.AssignFlag(AudioFlags.VolumeLock, shouldBeSet: true);
					if (num <= 0.05f)
					{
						flag4 = true;
					}
				}
				else
				{
					flag4 = true;
				}
				if (flag4)
				{
					bool isPlaying = source.Audio.isPlaying;
					source.Audio.Stop();
					Route(source, reuseOldRoutesIfPossible: true);
					source.LogDebugDisplay();
					if (flag2)
					{
						source.Audio.volume = 0f;
						source.SetFlag(AudioFlags.IsSwappingTargets);
						source.AssignFlag(AudioFlags.VolumeLock, shouldBeSet: true);
					}
					if (isPlaying || flag3)
					{
						source.PlayWithoutRouting();
					}
				}
			}
			else if (source.HasFlag(AudioFlags.IsSwappingTargets))
			{
				source.ClearFlag(AudioFlags.VolumeLock);
				float volume = Mathf.Lerp(source.Audio.volume, source.AppliedState.Volume, Time.deltaTime * 4f);
				source.Audio.volume = volume;
				if (Math.Abs(source.Audio.volume - source.AppliedState.Volume) <= 0.05f)
				{
					source.Audio.volume = source.AppliedState.Volume;
					source.ClearFlag(AudioFlags.IsSwappingTargets);
				}
				else
				{
					source.AssignFlag(AudioFlags.VolumeLock, shouldBeSet: true);
				}
			}
			return true;
		}

		private static void CleanupSources()
		{
			Span<KeyValuePair<AudioSource, bool>> span = ForeachCache<KeyValuePair<AudioSource, bool>>.CacheFrom(TrackedPlayOnAwakeSourceStates);
			for (int i = 0; i < span.Length; i++)
			{
				AudioSource key = span[i].Key;
				if ((Object)(object)key == (Object)null)
				{
					TrackedPlayOnAwakeSourceStates.Remove(key);
				}
			}
			Span<ModAudioSource> span2 = ForeachCache<ModAudioSource>.CacheFrom(TrackedOneShots);
			for (int j = 0; j < span2.Length; j++)
			{
				ModAudioSource modAudioSource = span2[j];
				if (modAudioSource == null)
				{
					TrackedOneShots.Remove(modAudioSource);
				}
			}
			Span<KeyValuePair<AudioSource, ModAudioSource>> span3 = ForeachCache<KeyValuePair<AudioSource, ModAudioSource>>.CacheFrom(TrackedSources);
			for (int k = 0; k < span3.Length; k++)
			{
				KeyValuePair<AudioSource, ModAudioSource> keyValuePair = span3[k];
				if ((Object)(object)keyValuePair.Key == (Object)null)
				{
					TrackedSources.Remove(keyValuePair.Key);
				}
				else if (keyValuePair.Value.HasFlag(AudioFlags.IsDedicatedOneShotSource) && !keyValuePair.Key.isPlaying)
				{
					AudioStopped(keyValuePair.Key, stopOneShots: false);
					TrackedSources.Remove(keyValuePair.Key);
					Object.Destroy((Object)(object)keyValuePair.Key);
				}
			}
		}

		private static ModAudioSource? GetModAudioSourceIfExists(AudioSource source)
		{
			if (TrackedSources.TryGetValue(source, out ModAudioSource value))
			{
				return value;
			}
			return null;
		}

		private static ModAudioSource GetOrCreateModAudioSource(AudioSource source)
		{
			if (TrackedSources.TryGetValue(source, out ModAudioSource value))
			{
				return value;
			}
			TrackedSources.Add(source, value = new ModAudioSource(source)
			{
				InitialState = 
				{
					Clip = source.clip,
					Pitch = source.pitch,
					Loop = source.loop,
					Volume = source.volume
				}
			});
			if (value.Audio.playOnAwake)
			{
				TrackedPlayOnAwakeSourceStates.Add(source, value: false);
			}
			value.AppliedState = value.InitialState;
			return value;
		}

		private static ModAudioSource CreateOneShotFromSource(ModAudioSource state)
		{
			GameObject gameObject = ((Component)state.Audio).gameObject;
			int num = 3;
			do
			{
				ParticleSystem component = gameObject.GetComponent<ParticleSystem>();
				if ((Object)(object)component == (Object)null || (Object)(object)gameObject.transform.parent == (Object)null)
				{
					break;
				}
				gameObject = ((Component)gameObject.transform.parent).gameObject;
			}
			while (num-- > 0);
			AudioSource val = state.Audio.CreateCloneOnTarget(gameObject);
			val.playOnAwake = false;
			val.loop = false;
			ModAudioSource orCreateModAudioSource = GetOrCreateModAudioSource(val);
			orCreateModAudioSource.SetFlag(AudioFlags.IsDedicatedOneShotSource | AudioFlags.OneShotStopsIfSourceStops);
			orCreateModAudioSource.OneShotOrigin = state.Audio;
			TrackedOneShots.Add(orCreateModAudioSource);
			return orCreateModAudioSource;
		}

		public static bool OneShotClipPlayed(AudioClip clip, AudioSource source, float volumeScale)
		{
			if (!ModAudio.Plugin.CurrentlyEnabled)
			{
				return true;
			}
			try
			{
				ModAudioSource modAudioSource = CreateOneShotFromSource(GetOrCreateModAudioSource(source));
				AudioSource audio = modAudioSource.Audio;
				audio.volume *= volumeScale;
				modAudioSource.Audio.clip = clip;
				modAudioSource.InitialState.Clip = modAudioSource.Audio.clip;
				modAudioSource.InitialState.Volume = modAudioSource.Audio.volume;
				modAudioSource.Audio.Play();
				return false;
			}
			catch (Exception ex)
			{
				Logging.LogError("ModAudio crashed in OneShotClipPlayed! Please report this error to the mod developer:");
				Logging.LogError(ex.ToString());
				Logging.LogError("AudioSource that caused the crash:");
				Logging.LogError("  name = " + (((source != null) ? ((Object)source).name : null) ?? "(null)"));
				object obj;
				if (source == null)
				{
					obj = null;
				}
				else
				{
					AudioClip clip2 = source.clip;
					obj = ((clip2 != null) ? ((Object)clip2).name : null);
				}
				if (obj == null)
				{
					obj = "(null)";
				}
				Logging.LogError("  clip = " + (string?)obj);
				Logging.LogError("AudioClip that caused the crash:");
				Logging.LogError("  name = " + (((clip != null) ? ((Object)clip).name : null) ?? "(null)"));
				Logging.LogError(string.Format("Parameter {0} was: {1}", "volumeScale", volumeScale));
				return true;
			}
		}

		public static bool AudioPlayed(AudioSource source)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!ModAudio.Plugin.CurrentlyEnabled)
			{
				return true;
			}
			ProfilerMarker playRouting;
			try
			{
				ModAudioSource orCreateModAudioSource = GetOrCreateModAudioSource(source);
				bool isPlaying = orCreateModAudioSource.Audio.isPlaying;
				playRouting = _playRouting;
				((ProfilerMarker)(ref playRouting)).Begin();
				Route(orCreateModAudioSource, reuseOldRoutesIfPossible: false);
				playRouting = _playRouting;
				((ProfilerMarker)(ref playRouting)).End();
				orCreateModAudioSource.LogDebugDisplay();
				orCreateModAudioSource.ClearFlag(AudioFlags.WasStoppedOrDisabled);
				bool flag = isPlaying && !orCreateModAudioSource.Audio.isPlaying;
				if (flag)
				{
					orCreateModAudioSource.PlayWithoutRouting();
				}
				return !flag;
			}
			catch (Exception ex)
			{
				playRouting = _playRouting;
				((ProfilerMarker)(ref playRouting)).End();
				Logging.LogError("ModAudio crashed in AudioPlayed! Please report this error to the mod developer:");
				Logging.LogError(ex.ToString());
				Logging.LogError("AudioSource that caused the crash:");
				Logging.LogError("  name = " + (((source != null) ? ((Object)source).name : null) ?? "(null)"));
				object obj;
				if (source == null)
				{
					obj = null;
				}
				else
				{
					AudioClip clip = source.clip;
					obj = ((clip != null) ? ((Object)clip).name : null);
				}
				if (obj == null)
				{
					obj = "(null)";
				}
				Logging.LogError("  clip = " + (string?)obj);
				return true;
			}
		}

		public static bool AudioStopped(AudioSource source, bool stopOneShots)
		{
			if (!ModAudio.Plugin.CurrentlyEnabled)
			{
				return true;
			}
			try
			{
				ModAudioSource modAudioSourceIfExists = GetModAudioSourceIfExists(source);
				if (stopOneShots)
				{
					Span<ModAudioSource> span = ForeachCache<ModAudioSource>.CacheFrom(TrackedOneShots);
					bool flag = false;
					for (int i = 0; i < span.Length; i++)
					{
						ModAudioSource modAudioSource = span[i];
						if (modAudioSource.HasFlag(AudioFlags.IsDedicatedOneShotSource | AudioFlags.OneShotStopsIfSourceStops) && !((Object)(object)modAudioSource.OneShotOrigin != (Object)(object)source) && !((Object)(object)modAudioSource.Audio == (Object)null) && modAudioSource.Audio.isPlaying)
						{
							if (!flag)
							{
								flag = true;
								span = span.ToArray();
							}
							modAudioSource.Audio.Stop();
						}
					}
				}
				if (source.playOnAwake)
				{
					TrackedPlayOnAwakeSourceStates.Remove(source);
				}
				if (modAudioSourceIfExists != null)
				{
					if (modAudioSourceIfExists.HasFlag(AudioFlags.IsDedicatedOneShotSource))
					{
						TrackedOneShots.Remove(modAudioSourceIfExists);
					}
					modAudioSourceIfExists.SetFlag(AudioFlags.WasStoppedOrDisabled);
				}
				return true;
			}
			catch (Exception ex)
			{
				Logging.LogError("ModAudio crashed in AudioStopped! Please report this error to the mod developer:");
				Logging.LogError(ex.ToString());
				Logging.LogError("AudioSource that caused the crash:");
				Logging.LogError("  name = " + (((source != null) ? ((Object)source).name : null) ?? "(null)"));
				object obj;
				if (source == null)
				{
					obj = null;
				}
				else
				{
					AudioClip clip = source.clip;
					obj = ((clip != null) ? ((Object)clip).name : null);
				}
				if (obj == null)
				{
					obj = "(null)";
				}
				Logging.LogError("  clip = " + (string?)obj);
				Logging.LogError(string.Format("Parameter {0} was: {1}", "stopOneShots", stopOneShots));
				return true;
			}
		}

		private static TargetGroupData GetCachedTargetGroup(ModAudioSource source, AudioPack pack, Route route)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			if (!CachedRoutingTargetGroupData.TryGetValue(route, out TargetGroupData value))
			{
				ProfilerMarker executeTargetGroups = _executeTargetGroups;
				((ProfilerMarker)(ref executeTargetGroups)).Begin();
				value = new TargetGroupData(source);
				pack.Script?.ExecuteTargetGroup(route, value);
				executeTargetGroups = _executeTargetGroups;
				((ProfilerMarker)(ref executeTargetGroups)).End();
				CachedRoutingTargetGroupData[route] = value;
			}
			return value;
		}

		private static bool MatchesSource(AudioStepState state, Route route)
		{
			AudioClip? clip = state.Clip;
			string text = ((clip != null) ? ((Object)clip).name : null);
			if (text == null)
			{
				return false;
			}
			for (int i = 0; i < route.OriginalClips.Count; i++)
			{
				if (route.OriginalClips[i] == text)
				{
					return true;
				}
			}
			return false;
		}

		private static bool Route(ModAudioSource source, bool reuseOldRoutesIfPossible)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			if (source.HasFlag(AudioFlags.DisableRouting))
			{
				return false;
			}
			ProfilerMarker routing = _routing;
			((ProfilerMarker)(ref routing)).Begin();
			CachedRoutingTargetGroupData.Clear();
			int num = 0;
			RouteStep[] array = ((source.RouteCount > 0) ? new RouteStep[source.RouteCount] : Array.Empty<RouteStep>());
			for (int i = 0; i < source.RouteCount; i++)
			{
				array[i] = source.GetRoute(i);
			}
			source.RevertSource();
			bool result = false;
			while (num++ < 4)
			{
				RouteStep? routeStep = ((reuseOldRoutesIfPossible && num <= array.Length) ? new RouteStep?(array[num - 1]) : null);
				AudioStepState appliedState = source.AppliedState;
				if (!ExecuteRouteStep(source, routeStep.HasValue ? new(AudioPack, Route)?((routeStep.Value.AudioPack, routeStep.Value.Route)) : null))
				{
					break;
				}
				RouteStep route = source.GetRoute(num - 1);
				if (source.HasFlag(AudioFlags.HasEncounteredErrors))
				{
					break;
				}
				PlayOverlays(source, appliedState, route.Route);
				if ((Object)(object)route.SelectedClip == (Object)(object)EmptyClip)
				{
					break;
				}
				result = true;
				if (source.RouteCount != num || !source.GetRoute(num - 1).Route.UseChainRouting)
				{
					break;
				}
				if (num >= 4)
				{
					AudioDebugDisplay.LogEngine((LogLevel)4, $"An audio source route ran into the max chain routing limit ({4})! Stopping routing...");
					break;
				}
			}
			CachedRoutingTargetGroupData.Clear();
			routing = _routing;
			((ProfilerMarker)(ref routing)).End();
			return result;
		}

		private static void PlayOverlay(ModAudioSource source, AudioPack pack, Route route)
		{
			ClipSelection clipSelection = Utils.SelectRandomWeighted(RNG, route.OverlayClips);
			if (clipSelection.Name == "___nothing___")
			{
				return;
			}
			if (pack.TryGetReadyClip(clipSelection.Name, out AudioClip clip))
			{
				ModAudioSource modAudioSource = CreateOneShotFromSource(source);
				modAudioSource.Audio.clip = clip;
				modAudioSource.Audio.volume = clipSelection.Volume;
				modAudioSource.Audio.pitch = clipSelection.Pitch;
				if (route.RelativeOverlayEffects)
				{
					AudioSource audio = modAudioSource.Audio;
					audio.volume *= modAudioSource.InitialState.Volume;
					AudioSource audio2 = modAudioSource.Audio;
					audio2.pitch *= modAudioSource.InitialState.Pitch;
				}
				if (route.ForceLoop.HasValue)
				{
					modAudioSource.SetFlag(AudioFlags.LoopWasForced);
					modAudioSource.Audio.loop = route.ForceLoop.Value;
				}
				else
				{
					source.ClearFlag(AudioFlags.LoopWasForced);
					source.Audio.loop = source.InitialState.Loop;
				}
				modAudioSource.AppliedState.Clip = modAudioSource.Audio.clip;
				modAudioSource.AppliedState.Volume = modAudioSource.Audio.volume;
				modAudioSource.AppliedState.Pitch = modAudioSource.Audio.pitch;
				modAudioSource.AppliedState.Loop = modAudioSource.Audio.loop;
				modAudioSource.SetFlag(AudioFlags.DisableRouting | AudioFlags.IsOverlay);
				modAudioSource.AssignFlag(AudioFlags.OneShotStopsIfSourceStops, route.OverlayStopsIfSourceStops);
				modAudioSource.Audio.Play();
			}
			else
			{
				AudioDebugDisplay.LogAudio((LogLevel)4, Texts.AudioClipNotFound(clipSelection.Name));
				pack.SetFlag(PackFlags.HasEncounteredErrors);
				source.SetFlag(AudioFlags.HasEncounteredErrors);
			}
		}

		private static void PlayOverlays(ModAudioSource source, AudioStepState stateBeforeRouting, Route? replacementRoute)
		{
			List<(AudioPack, Route)> list = new List<(AudioPack, Route)>();
			for (int i = 0; i < AudioPacks.Count; i++)
			{
				AudioPack audioPack = AudioPacks[i];
				if (!audioPack.HasFlag(PackFlags.Enabled))
				{
					continue;
				}
				List<Route> routes = audioPack.Config.Routes;
				for (int j = 0; j < routes.Count; j++)
				{
					Route route = routes[j];
					if ((!route.OverlaysIgnoreRestarts || source.HasFlag(AudioFlags.WasStoppedOrDisabled) || !source.Audio.isPlaying) && route.OverlayClips.Count > 0 && MatchesSource(stateBeforeRouting, route) && (!route.LinkOverlayAndReplacement || replacementRoute == route))
					{
						TargetGroupData cachedTargetGroup = GetCachedTargetGroup(source, audioPack, route);
						if (!cachedTargetGroup.SkipRoute)
						{
							list.Add((audioPack, route));
						}
					}
				}
			}
			for (int k = 0; k < list.Count; k++)
			{
				var (pack, route2) = list[k];
				PlayOverlay(source, pack, route2);
			}
		}

		private static bool ExecuteRouteStep(ModAudioSource source, (AudioPack Pack, Route Route)? preferredPackRoute)
		{
			if (source.HasFlag(AudioFlags.DisableRouting))
			{
				return false;
			}
			List<(AudioPack, Route)> list = new List<(AudioPack, Route)>();
			if (preferredPackRoute.HasValue)
			{
				AddReplacementIfEligible(source, preferredPackRoute.Value.Pack, preferredPackRoute.Value.Route, list);
			}
			if (list.Count == 0)
			{
				for (int i = 0; i < AudioPacks.Count; i++)
				{
					AudioPack audioPack = AudioPacks[i];
					if (!audioPack.HasFlag(PackFlags.Enabled))
					{
						continue;
					}
					List<Route> routes = audioPack.Config.Routes;
					for (int j = 0; j < routes.Count; j++)
					{
						Route route2 = routes[j];
						if (!preferredPackRoute.HasValue || route2 != preferredPackRoute.Value.Route)
						{
							AddReplacementIfEligible(source, audioPack, route2, list);
						}
					}
				}
			}
			if (list.Count == 0)
			{
				return false;
			}
			if (source.RouteCount >= 4)
			{
				Logging.LogWarning("Tried to route an audio source that has reached max chained routes! Aborting routing operation. Please notify the mod developer about this!");
				return false;
			}
			var (audioPack2, route3) = Utils.SelectRandomWeighted(RNG, list);
			source.Audio.volume = route3.Volume;
			source.Audio.pitch = route3.Pitch;
			if (route3.RelativeReplacementEffects)
			{
				AudioSource audio = source.Audio;
				audio.volume *= source.InitialState.Volume;
				AudioSource audio2 = source.Audio;
				audio2.pitch *= source.InitialState.Pitch;
			}
			if (route3.ForceLoop.HasValue)
			{
				source.SetFlag(AudioFlags.LoopWasForced);
				source.Audio.loop = route3.ForceLoop.Value;
			}
			else
			{
				source.ClearFlag(AudioFlags.LoopWasForced);
				source.Audio.loop = source.InitialState.Loop;
			}
			source.AppliedState.Volume = source.Audio.volume;
			source.AppliedState.Pitch = source.Audio.pitch;
			source.AppliedState.Loop = source.Audio.loop;
			TargetGroupData cachedTargetGroup = GetCachedTargetGroup(source, audioPack2, route3);
			List<ClipSelection> list2 = new List<ClipSelection>();
			for (int k = 0; k < route3.ReplacementClips.Count; k++)
			{
				ReplacementClipSelection replacementClipSelection = route3.ReplacementClips[k];
				if (cachedTargetGroup.TargetGroup == "all" || replacementClipSelection.Group == cachedTargetGroup.TargetGroup)
				{
					list2.Add(replacementClipSelection);
				}
			}
			AudioClip value = null;
			if (list2.Count == 0)
			{
				AudioDebugDisplay.LogPack((LogLevel)2, Texts.NoAudioClipsInGroup(cachedTargetGroup.TargetGroup));
				audioPack2.SetFlag(PackFlags.HasEncounteredErrors);
				source.SetFlag(AudioFlags.HasEncounteredErrors);
				value = ErrorClip;
			}
			else
			{
				ClipSelection clipSelection = Utils.SelectRandomWeighted(RNG, list2);
				if (clipSelection.Name == "___default___")
				{
					value = source.AppliedState.Clip;
				}
				else if (clipSelection.Name == "___nothing___")
				{
					value = EmptyClip;
				}
				else if (clipSelection.Name.StartsWith("<atlyss>"))
				{
					string name = clipSelection.Name;
					int length = "<atlyss>".Length;
					string key = name.Substring(length, name.Length - length);
					if ((!LoadedVanillaClips.TryGetValue(key, out value) || (Object)(object)value == (Object)null) && VanillaClips.NameToResourcePath.TryGetValue(key, out string value2))
					{
						value = Resources.Load<AudioClip>(value2);
						if (Object.op_Implicit((Object)(object)value))
						{
							LoadedVanillaClips[key] = value;
						}
					}
				}
				else
				{
					audioPack2.TryGetReadyClip(clipSelection.Name, out value);
				}
				if ((Object)(object)value != (Object)null)
				{
					AudioSource audio3 = source.Audio;
					audio3.volume *= clipSelection.Volume;
					AudioSource audio4 = source.Audio;
					audio4.pitch *= clipSelection.Pitch;
					source.AppliedState.Clip = value;
					source.AppliedState.Volume = source.Audio.volume;
					source.AppliedState.Pitch = source.Audio.pitch;
					source.AppliedState.Loop = source.Audio.loop;
					if ((Object)(object)source.Audio.clip != (Object)(object)value && source.Audio.isPlaying)
					{
						source.Audio.Stop();
					}
					source.Audio.clip = value;
					if (route3.EnableDynamicTargeting)
					{
						source.SetFlag(AudioFlags.ShouldUpdateDynamicTargeting);
					}
				}
				else
				{
					AudioDebugDisplay.LogPack((LogLevel)2, Texts.AudioClipNotFound(clipSelection.Name));
					audioPack2.SetFlag(PackFlags.HasEncounteredErrors);
					source.SetFlag(AudioFlags.HasEncounteredErrors);
					value = ErrorClip;
				}
			}
			source.PushRoute(audioPack2, route3, cachedTargetGroup.TargetGroup, value ?? ErrorClip);
			return true;
			static void AddReplacementIfEligible(ModAudioSource source, AudioPack pack, Route route, List<(AudioPack Pack, Route Route)> replacements)
			{
				if (MatchesSource(source.AppliedState, route))
				{
					bool flag = false;
					for (int l = 0; l < source.RouteCount; l++)
					{
						if (source.GetRoute(l).Route == route)
						{
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						TargetGroupData cachedTargetGroup2 = GetCachedTargetGroup(source, pack, route);
						if (!cachedTargetGroup2.SkipRoute)
						{
							replacements.Add((pack, route));
						}
					}
				}
			}
		}
	}
	[Flags]
	public enum PackFlags : uint
	{
		None = 0u,
		All = uint.MaxValue,
		Enabled = 1u,
		ForceDisableScripts = 2u,
		HasEncounteredErrors = 4u,
		NotConfigurable = 8u,
		BuiltinPack = 0x10u
	}
	public class AudioPack : IDisposable
	{
		public PackFlags Flags;

		public string PackPath { get; set; } = "???";


		public AudioPackConfig Config { get; set; } = new AudioPackConfig();


		public List<IAudioStream> OpenStreams { get; } = new List<IAudioStream>();


		public Dictionary<string, AudioClip> ReadyClips { get; } = new Dictionary<string, AudioClip>();


		public Dictionary<string, Func<AudioClip>> PendingClipsToLoad { get; } = new Dictionary<string, Func<AudioClip>>();


		public Dictionary<string, Func<AudioClip>> PendingClipsToStream { get; } = new Dictionary<string, Func<AudioClip>>();


		public ModAudioScript? Script { get; set; }

		public void Dispose()
		{
			foreach (IAudioStream openStream in OpenStreams)
			{
				openStream.Dispose();
			}
			Script?.Dispose();
		}

		public bool IsUserPack()
		{
			if (!PackPath.StartsWith(ModAudio.Plugin.ModAudioConfigFolder))
			{
				return PackPath.StartsWith(ModAudio.Plugin.ModAudioPluginFolder);
			}
			return true;
		}

		public bool TryGetReadyClip(string name, out AudioClip? clip)
		{
			if (ReadyClips.TryGetValue(name, out clip))
			{
				return true;
			}
			if (PendingClipsToStream.TryGetValue(name, out Func<AudioClip> value))
			{
				PendingClipsToStream.Remove(name);
				AudioClip val2 = (ReadyClips[name] = value());
				clip = val2;
				return true;
			}
			if (PendingClipsToLoad.TryGetValue(name, out Func<AudioClip> value2))
			{
				PendingClipsToLoad.Remove(name);
				AudioClip val2 = (ReadyClips[name] = value2());
				clip = val2;
				return true;
			}
			clip = null;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void SetFlag(PackFlags flag)
		{
			Flags |= flag;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void ClearFlag(PackFlags flag)
		{
			Flags &= ~flag;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool HasFlag(PackFlags flag)
		{
			return (Flags & flag) == flag;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AssignFlag(PackFlags flag, bool shouldBeSet)
		{
			if (shouldBeSet)
			{
				SetFlag(flag);
			}
			else
			{
				ClearFlag(flag);
			}
		}
	}
	public class AudioClipData
	{
		public string Name { get; set; } = "";


		public string Path { get; set; } = "";


		public float Volume { get; set; } = 1f;

	}
	public class AudioPackConfig
	{
		public string Id { get; set; } = "";


		public string DisplayName { get; set; } = "";


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


		public PackScripts PackScripts { get; set; } = new PackScripts();


		public List<AudioClipData> CustomClips { get; set; } = new List<AudioClipData>();


		public List<Route> Routes { get; set; } = new List<Route>();


		public bool Validate()
		{
			if (string.IsNullOrWhiteSpace(Id))
			{
				return false;
			}
			return true;
		}

		public static AudioPackConfig ReadRouteConfig(Stream stream)
		{
			RouteConfig routeConfig = RouteConfig.ReadTextFormat(stream);
			AudioPackConfig audioPackConfig = new AudioPackConfig
			{
				CustomClips = (from x in (from x in routeConfig.Routes.SelectMany((Route x) => x.ReplacementClips.Concat(x.OverlayClips))
						select x.Name into x
						where x != "___default___" && x != "___nothing___" && !x.Trim().StartsWith('<')
						select x).Distinct()
					select new AudioClipData
					{
						Name = x,
						Path = x,
						Volume = (routeConfig.ClipVolumes.ContainsKey(x) ? routeConfig.ClipVolumes[x] : 1f)
					}).ToList(),
				Routes = routeConfig.Routes,
				Id = routeConfig.Id,
				DisplayName = routeConfig.DisplayName,
				EnabledByDefault = routeConfig.EnabledByDefault,
				PackScripts = 
				{
					Update = routeConfig.UpdateScript
				}
			};
			foreach (KeyValuePair<string, float> clipVolume in routeConfig.ClipVolumes)
			{
				if (!audioPackConfig.CustomClips.Any((AudioClipData x) => x.Name == clipVolume.Key))
				{
					Logging.LogWarning("Couldn't find clip " + clipVolume.Key + " to set volume for.");
				}
			}
			return audioPackConfig;
		}
	}
	public class ClipSelection
	{
		public string Name { get; set; } = "";


		public float Weight { get; set; } = 1f;


		public float Volume { get; set; } = 1f;


		public float Pitch { get; set; } = 1f;

	}
	public class ReplacementClipSelection : ClipSelection
	{
		public string Group { get; set; } = "";

	}
	public class PackScripts
	{
		public string Update { get; set; } = "";

	}
	public class Route
	{
		public bool LinkOverlayAndReplacement { get; set; } = true;


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


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


		public bool RelativeOverlayEffects { get; set; }

		public bool OverlaysIgnoreRestarts { get; set; }

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


		public List<ReplacementClipSelection> ReplacementClips { get; set; } = new List<ReplacementClipSelection>();


		public List<ClipSelection> OverlayClips { get; set; } = new List<ClipSelection>();


		public float ReplacementWeight { get; set; } = 1f;


		public float Volume { get; set; } = 1f;


		public float Pitch { get; set; } = 1f;


		public bool? ForceLoop { get; set; }

		public bool ForcePlay { get; set; }

		public string TargetGroupScript { get; set; } = "";


		public bool EnableDynamicTargeting { get; set; }

		public bool SmoothDynamicTargeting { get; set; }

		public bool UseChainRouting { get; set; }
	}
	public class RouteConfig
	{
		private static readonly char[] ReplacementSeparator = new char[1] { '=' };

		private static readonly char[] OverlaySeparator = new char[1] { '@' };

		private static readonly char[] EffectSeparator = new char[1] { '~' };

		private static readonly char[] RouteSeparators;

		private static readonly char[] FieldSeparator;

		private static readonly char[] ListSeparator;

		public Dictionary<string, float> ClipVolumes { get; set; } = new Dictionary<string, float>();


		public List<Route> Routes { get; set; } = new List<Route>();


		public string Id { get; set; } = "";


		public string DisplayName { get; set; } = "";


		public string UpdateScript { get; set; } = "";


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


		public static RouteConfig ReadTextFormat(Stream stream)
		{
			using (StreamReader streamReader = new StreamReader(stream))
			{
				Dictionary<string, float> clipVolumes = new Dictionary<string, float>();
				List<Route> routes = new List<Route>();
				string id = "";
				string displayName = "";
				string updateScript = "";
				bool enabledByDefault = true;
				int lineNumber = 0;
				while (!streamReader.EndOfStream)
				{
					string text = "";
					int num = lineNumber + 1;
					bool flag = false;
					string text2;
					while ((text2 = streamReader.ReadLine()) != null)
					{
						lineNumber++;
						int num2 = text2.IndexOf('#');
						if (num2 != -1)
						{
							text2 = text2.Substring(0, num2);
						}
						int num3 = text2.LastIndexOf('\\');
						if (num3 == -1)
						{
							text += text2;
							break;
						}
						for (int i = num3 + 1; i < text2.Length; i++)
						{
							if (!char.IsWhiteSpace(text2[i]))
							{
								flag = true;
								break;
							}
						}
						text2 = text2.Substring(0, num3);
						text += text2;
					}
					if (flag)
					{
						Logging.LogWarning($"Line {lineNumber}: Expected only whitespace and comments after line continuation (\"\\\")");
					}
					else
					{
						if (text.Trim() == "")
						{
							continue;
						}
						if (text.Trim().StartsWith("%"))
						{
							ParseGlobalParamer(text);
						}
						else if (text.Contains("/") || (text.IndexOfAny(EffectSeparator) == -1 && text.IndexOfAny(OverlaySeparator) == -1 && text.IndexOfAny(FieldSeparator) == -1 && text.IndexOfAny(ListSeparator) == -1))
						{
							ParseSimpleRouteFormat(text);
						}
						else
						{
							if (!SplitRouteParts(text, out var clipNames2, out var replacements2, out var overlays2, out var effects2))
							{
								continue;
							}
							Route route = new Route
							{
								OriginalClips = clipNames2
							};
							for (int j = 0; j < replacements2.Count; j++)
							{
								string[] array = (from x in replacements2[j].Split(FieldSeparator)
									select x.Trim()).ToArray();
								if (array.Length > 5)
								{
									Logging.LogWarning($"Line {num}: Too many values defined for a target clip (expected at most 5), skipping it.");
									continue;
								}
								string text3 = array[0];
								if (text3 == "")
								{
									Logging.LogWarning($"Line {num}: empty clip, ignoring it.");
									replacements2.RemoveAt(j--);
								}
								float result = 1f;
								float result2 = 1f;
								float result3 = 1f;
								string group = "";
								if (array.Length > 1 && !float.TryParse(array[1], NumberStyles.Number, CultureInfo.InvariantCulture, out result))
								{
									Logging.LogWarning($"Line {num}: Couldn't parse random weight {array[1]} for {text3}, defaulting to {result}.");
								}
								if (array.Length > 2 && !float.TryParse(array[2], NumberStyles.Number, CultureInfo.InvariantCulture, out result2))
								{
									Logging.LogWarning($"Line {num}: Couldn't parse volume {array[2]} for {text3}, defaulting to {result2}.");
								}
								if (array.Length > 3 && !float.TryParse(array[3], NumberStyles.Number, CultureInfo.InvariantCulture, out result3))
								{
									Logging.LogWarning($"Line {num}: Couldn't parse pitch {array[3]} for {text3}, defaulting to {result3}.");
								}
								if (array.Length > 4)
								{
									group = array[4];
								}
								route.ReplacementClips.Add(new ReplacementClipSelection
								{
									Name = text3,
									Weight = result,
									Volume = result2,
									Pitch = result3,
									Group = group
								});
							}
							routes.Add(route);
							for (int k = 0; k < overlays2.Count; k++)
							{
								string[] array2 = (from x in overlays2[k].Split(FieldSeparator)
									select x.Trim()).ToArray();
								if (array2.Length > 4)
								{
									Logging.LogWarning($"Line {num}: Too many values defined for a target clip (expected at most 4), skipping it.");
									continue;
								}
								string text4 = array2[0];
								if (text4 == "")
								{
									ModAudio plugin = ModAudio.Plugin;
									if (plugin != null)
									{
										ManualLogSource logger = plugin.Logger;
										if (logger != null)
										{
											logger.LogWarning((object)$"Line {num}: empty clip, ignoring it.");
										}
									}
									overlays2.RemoveAt(k--);
								}
								float result4 = 1f;
								float result5 = 1f;
								float result6 = 1f;
								if (array2.Length > 1 && !float.TryParse(array2[1], NumberStyles.Number, CultureInfo.InvariantCulture, out result4))
								{
									Logging.LogWarning($"Line {num}: Couldn't parse random weight {array2[1]} for {text4}, defaulting to {1f}.");
								}
								if (array2.Length > 2 && !float.TryParse(array2[2], NumberStyles.Number, CultureInfo.InvariantCulture, out result5))
								{
									Logging.LogWarning($"Line {num}: Couldn't parse volume {array2[2]} for {text4}, defaulting to 1.");
								}
								if (array2.Length > 3 && !float.TryParse(array2[3], NumberStyles.Number, CultureInfo.InvariantCulture, out result6))
								{
									Logging.LogWarning($"Line {num}: Couldn't parse pitch {array2[3]} for {text4}, defaulting to 1.");
								}
								route.OverlayClips.Add(new ClipSelection
								{
									Name = text4,
									Weight = result4,
									Volume = result5,
									Pitch = result6
								});
							}
							for (int l = 0; l < effects2.Count; l++)
							{
								string[] array3 = (from x in effects2[l].Split(FieldSeparator)
									select x.Trim()).ToArray();
								if (array3.Length == 1)
								{
									Logging.LogWarning($"Line {num}: Expected a value for {array3[0]}.");
									continue;
								}
								bool flag2 = false;
								switch (array3[0])
								{
								case "link_overlay_and_replacement":
								{
									if (flag2 = bool.TryParse(array3[1], out var result15))
									{
										route.LinkOverlayAndReplacement = result15;
									}
									break;
								}
								case "relative_replacement_effects":
								{
									if (flag2 = bool.TryParse(array3[1], out var result19))
									{
										route.RelativeReplacementEffects = result19;
									}
									break;
								}
								case "overlay_stops_if_source_stops":
								{
									if (flag2 = bool.TryParse(array3[1], out var result10))
									{
										route.OverlayStopsIfSourceStops = result10;
									}
									break;
								}
								case "relative_overlay_effects":
								{
									if (flag2 = bool.TryParse(array3[1], out var result17))
									{
										route.RelativeOverlayEffects = result17;
									}
									break;
								}
								case "overlays_ignore_restarts":
								{
									if (flag2 = bool.TryParse(array3[1], out var result13))
									{
										route.OverlaysIgnoreRestarts = result13;
									}
									break;
								}
								case "target_group_script":
									route.TargetGroupScript = array3[1];
									flag2 = true;
									break;
								case "enable_dynamic_targeting":
								{
									if (flag2 = bool.TryParse(array3[1], out var result8))
									{
										route.EnableDynamicTargeting = result8;
									}
									break;
								}
								case "smooth_dynamic_targeting":
								{
									if (flag2 = bool.TryParse(array3[1], out var result18))
									{
										route.SmoothDynamicTargeting = result18;
									}
									break;
								}
								case "chain_route":
								{
									if (flag2 = bool.TryParse(array3[1], out var result16))
									{
										route.UseChainRouting = result16;
									}
									break;
								}
								case "weight":
								case "replacement_weight":
								{
									if (flag2 = float.TryParse(array3[1], NumberStyles.Number, CultureInfo.InvariantCulture, out var result14))
									{
										route.ReplacementWeight = result14;
									}
									break;
								}
								case "volume":
								{
									if (flag2 = float.TryParse(array3[1], NumberStyles.Number, CultureInfo.InvariantCulture, out var result12))
									{
										route.Volume = result12;
									}
									break;
								}
								case "pitch":
								{
									if (flag2 = float.TryParse(array3[1], NumberStyles.Number, CultureInfo.InvariantCulture, out var result11))
									{
										route.Pitch = result11;
									}
									break;
								}
								case "force_loop":
								{
									if (flag2 = bool.TryParse(array3[1], out var result9))
									{
										route.ForceLoop = result9;
									}
									break;
								}
								case "force_play":
								{
									if (flag2 = bool.TryParse(array3[1], out var result7))
									{
										route.ForcePlay = result7;
									}
									break;
								}
								default:
									Logging.LogWarning($"Line {num}: Unrecognized route effect / setting {array3[0]}.");
									break;
								}
								if (!flag2)
								{
									Logging.LogWarning($"Line {num}: Couldn't parse {array3[0]}.");
								}
							}
						}
					}
				}
				return new RouteConfig
				{
					ClipVolumes = clipVolumes,
					Id = id,
					DisplayName = displayName,
					Routes = routes,
					UpdateScript = updateScript,
					EnabledByDefault = enabledByDefault
				};
				void ParseGlobalParamer(string line)
				{
					if (line.Trim().StartsWith("%id "))
					{
						string text7 = line.Trim();
						int length = "%id ".Length;
						id = text7.Substring(length, text7.Length - length).Trim();
					}
					else if (line.Trim().StartsWith("%updatescript "))
					{
						string text7 = line.Trim();
						int length = "%updatescript ".Length;
						updateScript = text7.Substring(length, text7.Length - length).Trim();
					}
					else if (line.Trim().StartsWith("%displayname "))
					{
						string text7 = line.Trim();
						int length = "%displayname ".Length;
						displayName = text7.Substring(length, text7.Length - length).Trim();
					}
					else if (line.Trim().StartsWith("%enabledbydefault "))
					{
						string text7 = line.Trim();
						int length = "%enabledbydefault ".Length;
						if (!bool.TryParse(text7.Substring(length, text7.Length - length).Trim(), out enabledByDefault))
						{
							Logging.LogWarning($"Line {lineNumber}: Enable state must be either \"true\" or \"false\".");
							enabledByDefault = true;
						}
					}
					else if (line.Trim().StartsWith("%customclipvolume "))
					{
						string text7 = line.Trim();
						int length = "%customclipvolume ".Length;
						string[] array7 = text7.Substring(length, text7.Length - length).Split('=');
						if (array7.Length != 2)
						{
							Logging.LogWarning($"Line {lineNumber}: Expected %customclipvolume clipName = volume.");
						}
						if (array7[0].Trim() == "")
						{
							Logging.LogWarning($"Line {lineNumber}: Expected a clip name.");
						}
						if (!float.TryParse(array7[1], NumberStyles.Number, CultureInfo.InvariantCulture, out var result21))
						{
							Logging.LogWarning($"Line {lineNumber}: Volume is not a number.");
						}
						clipVolumes[array7[0].Trim()] = result21;
					}
					else
					{
						Logging.LogWarning($"Line {lineNumber}: Unrecognized attribute {line.Trim().Substring(1)}.");
					}
				}
				void ParseSimpleRouteFormat(string line)
				{
					string[] array5 = line.Split(ReplacementSeparator, 3);
					if (array5.Length != 2)
					{
						Logging.LogWarning($"Line {lineNumber}: Encountered a malformed route (expected key = value), skipping it.");
					}
					else
					{
						string[] array6 = array5[1].Split(new char[1] { '/' }, 3);
						if (array6.Length > 2)
						{
							Logging.LogWarning($"Line {lineNumber}: Too many values defined for a route (expected at most 2), skipping it.");
						}
						else
						{
							string text5 = array5[0].Trim();
							string text6 = array6[0].Trim();
							float result20 = 1f;
							if (text5.Trim() == "" || text6.Trim() == "")
							{
								Logging.LogWarning($"Line {lineNumber}: Either clip name or replacement was empty for a route, skipping it.");
							}
							else
							{
								if (array6.Length > 1 && !float.TryParse(array6[1], NumberStyles.Number, CultureInfo.InvariantCulture, out result20))
								{
									Logging.LogWarning($"Line {lineNumber}: Couldn't parse random weight {array6[1]} for {text5} => {text6}, defaulting to {1f}.");
								}
								routes.Add(new Route
								{
									OriginalClips = new List<string>(1) { text5 },
									ReplacementClips = new List<ReplacementClipSelection>(1)
									{
										new ReplacementClipSelection
										{
											Name = text6
										}
									},
									ReplacementWeight = result20
								});
							}
						}
					}
				}
				bool SplitRouteParts(string line, out List<string> clipNames, out List<string> replacements, out List<string> overlays, out List<string> effects)
				{
					clipNames = new List<string>();
					replacements = new List<string>();
					overlays = new List<string>();
					effects = new List<string>();
					string[] array4 = line.Split(RouteSeparators, 5, StringSplitOptions.None);
					int num4 = -1;
					int num5 = -1;
					int num6 = -1;
					if (array4.Length > 5 || array4.Length == 1)
					{
						Logging.LogWarning($"Line {lineNumber}: Encountered a malformed route (expected source = replacement @ overlay ~ modifier), skipping it.");
						return false;
					}
					int num7 = line.IndexOfAny(RouteSeparators, 0);
					int num8 = 1;
					if (num7 == -1)
					{
						Logging.LogWarning($"Line {lineNumber}: Encountered a malformed route (expected source = replacement @ overlay ~ effect), skipping it.");
						return false;
					}
					bool flag3 = false;
					while (num7 != -1)
					{
						if (line[num7] == ReplacementSeparator[0])
						{
							if (num4 != -1 || num5 != -1 || num6 != -1)
							{
								flag3 = true;
								break;
							}
							num4 = num8++;
						}
						else if (line[num7] == OverlaySeparator[0])
						{
							if (num5 != -1)
							{
								flag3 = true;
								break;
							}
							num5 = num8++;
						}
						else if (line[num7] == EffectSeparator[0])
						{
							if (num6 != -1)
							{
								flag3 = true;
								break;
							}
							num6 = num8++;
						}
						num7 = line.IndexOfAny(RouteSeparators, num7 + 1);
					}
					if (flag3)
					{
						Logging.LogWarning($"Line {lineNumber}: Encountered a malformed route (expected source = replacement @ overlay ~ effect), skipping it.");
						return false;
					}
					bool flag4 = num5 < num6;
					clipNames = ParseListEntries(array4[0]);
					for (int m = 0; m < clipNames.Count; m++)
					{
						if (clipNames[m] == "")
						{
							Logging.LogWarning($"Line {lineNumber}: empty source clip, ignoring it.");
							clipNames.RemoveAt(m--);
						}
					}
					if (clipNames.Count == 0)
					{
						Logging.LogWarning($"Line {lineNumber}: Expected at least one valid source clip, skipping route.");
						return false;
					}
					replacements = ((num4 == -1) ? new List<string>() : ParseListEntries(array4[num4]));
					overlays = ((num5 == -1) ? new List<string>() : ParseListEntries(array4[num5]));
					effects = ((num6 == -1) ? new List<string>() : ParseListEntries(array4[num6]));
					return true;
				}
			}
			static List<string> ParseListEntries(string part)
			{
				return (from x in part.Trim().Split(ListSeparator, StringSplitOptions.RemoveEmptyEntries)
					select x.Trim() into x
					where !string.IsNullOrWhiteSpace(x)
					select x).ToList();
			}
		}

		static RouteConfig()
		{
			char[] replacementSeparator = ReplacementSeparator;
			char[] overlaySeparator = OverlaySeparator;
			char[] effectSeparator = EffectSeparator;
			int num = 0;
			char[] array = new char[replacementSeparator.Length + overlaySeparator.Length + effectSeparator.Length];
			ReadOnlySpan<char> readOnlySpan = new ReadOnlySpan<char>(replacementSeparator);
			readOnlySpan.CopyTo(new Span<char>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			ReadOnlySpan<char> readOnlySpan2 = new ReadOnlySpan<char>(overlaySeparator);
			readOnlySpan2.CopyTo(new Span<char>(array).Slice(num, readOnlySpan2.Length));
			num += readOnlySpan2.Length;
			ReadOnlySpan<char> readOnlySpan3 = new ReadOnlySpan<char>(effectSeparator);
			readOnlySpan3.CopyTo(new Span<char>(array).Slice(num, readOnlySpan3.Length));
			num += readOnlySpan3.Length;
			RouteSeparators = array;
			FieldSeparator = new char[1] { ':' };
			ListSeparator = new char[1] { '|' };
		}
	}
	public static class AudioPackLoader
	{
		private static readonly char[] BepInExCharsToSanitize = new char[8] { '=', '\n', '\t', '\\', '"', '\'', '[', ']' };

		private static readonly char[] BannedChars = BepInExCharsToSanitize.ToArray();

		public const float OneMB = 1048576f;

		public const string RoutesScriptName = "__routes.lua";

		public const string RoutesConfigName = "__routes.txt";

		public const int FileSizeLimitForLoading = 1048576;

		public static string ReplaceRootPath(string path)
		{
			return Path.GetFullPath(path).Replace('\\', '/').Replace(Path.GetFullPath(Paths.PluginPath).Replace('\\', '/').TrimEnd('/') + "/", "plugin://")
				.Replace(Path.GetFullPath(Paths.ConfigPath).Replace('\\', '/').TrimEnd('/') + "/", "config://");
		}

		private static bool IsSanitizedId(string id)
		{
			return SanitizeId(id) == id;
		}

		private static string SanitizeId(string id)
		{
			string text = id;
			for (int i = 0; i < BannedChars.Length; i++)
			{
				int num = char.ConvertToUtf32($"{BannedChars[i]}", 0);
				text = text.Replace($"{BannedChars[i]}", $"_{num}");
			}
			return text;
		}

		private static string ConvertPathToId(string path)
		{
			return SanitizeId(ReplaceRootPath(path).Replace("\\", "/"));
		}

		private static string ConvertPathToDisplayName(string path)
		{
			string text = ReplaceRootPath(path);
			int num = text.IndexOf("://");
			string text3;
			if (num != -1)
			{
				string text2 = text;
				int num2 = num + "://".Length;
				text3 = text2.Substring(num2, text2.Length - num2);
			}
			else
			{
				text3 = text;
			}
			string text4 = text3;
			if (text4.EndsWith("__routes.txt"))
			{
				string text2