using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using Discord;
using HarmonyLib;
using Jukebox.Components;
using Jukebox.Input;
using Jukebox.UI;
using Jukebox.UI.Elements;
using Jukebox.UI.Windows;
using Jukebox.Utils;
using JukeboxCore.Collections;
using JukeboxCore.Components;
using JukeboxCore.Events;
using JukeboxCore.Models.Preferences;
using JukeboxCore.Models.Song;
using JukeboxCore.Utils;
using Newtonsoft.Json;
using SettingsMenu.Components;
using SettingsMenu.Components.Pages;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Jukebox")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Jukebox")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("B01B8657-61B6-4BC3-BFAF-F43D4C264B4B")]
[assembly: AssemblyFileVersion("2.2.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("2.2.1.0")]
namespace Jukebox
{
	[BepInProcess("ULTRAKILL.exe")]
	[BepInPlugin("dev.flazhik.jukebox", "Jukebox", "2.2.1")]
	public class JukeboxPlugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass11_0
		{
			public InputAction menu;

			internal string <MotD>b__0(InputBinding binding)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return InputExtensions.GetBindingDisplayStringWithoutOverride(menu, binding, (DisplayStringOptions)0);
			}
		}

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

			private object <>2__current;

			private <>c__DisplayClass11_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: Expected O, but got Unknown
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass11_0();
					<>2__current = (object)new WaitForSeconds(1.5f);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					<>8__1.menu = MonoSingleton<JukeboxInputs>.Instance.Menu;
					string text = GeneralExtensions.Join<InputBinding>((IEnumerable<InputBinding>)(object)<>8__1.menu.bindings, (Func<InputBinding, string>)((InputBinding binding) => InputExtensions.GetBindingDisplayStringWithoutOverride(<>8__1.menu, binding, (DisplayStringOptions)0)), ", ");
					MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("CGME menu is available by pressing <color=orange>" + text + "</color>", "", "", 0, false, false, true);
					_motDShown = true;
					return false;
				}
				}
			}

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

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

		private static GameObject _bootstrap;

		public static string catalogDir;

		private static Harmony _harmony;

		private static bool _motDShown;

		private static bool _init;

		static JukeboxPlugin()
		{
			catalogDir = Path.Combine(PathsUtils.AssemblyPath, "Assets");
		}

		private void Awake()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Addressables.InitializeAsync().WaitForCompletion();
			Addressables.LoadContentCatalogAsync(Path.Combine(catalogDir, "catalog.json"), true, (string)null).WaitForCompletion();
			_harmony = new Harmony("dev.flazhik.jukebox");
			Startup();
		}

		private void Start()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			_bootstrap = Addressables.LoadAssetAsync<GameObject>((object)"Assets/Jukebox/Bootstrap.prefab").WaitForCompletion();
			Addressables.LoadAssetAsync<InputActionAsset>((object)"Assets/Jukebox/JukeboxControls.inputactions").WaitForCompletion();
			Addressables.LoadAssetAsync<Sprite>((object)"Assets/Jukebox/Textures/music_note.png").WaitForCompletion();
		}

		private void Startup()
		{
			_harmony.PatchAll();
			FileInfo fileInfo = new FileInfo(Path.Combine(PathsUtils.AssemblyPath, "cookies.txt"));
			if (fileInfo.Exists)
			{
				fileInfo.Delete();
			}
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (scene != SceneManager.GetActiveScene())
			{
				return;
			}
			switch (SceneHelper.CurrentScene)
			{
			case "Bootstrap":
				SetDefaultPrefsValues();
				break;
			case "Main Menu":
				if (!_init)
				{
					_init = true;
				}
				break;
			case "Endless":
				Object.Instantiate<GameObject>(_bootstrap);
				if (!_motDShown)
				{
					((MonoBehaviour)MonoSingleton<JukeboxManager>.Instance).StartCoroutine(MotD());
				}
				break;
			}
		}

		private static void SetDefaultPrefsValues()
		{
			foreach (KeyValuePair<string, object> item in new Dictionary<string, object>
			{
				{ "jukebox.volumeBoost", 0f },
				{ "jukebox.individualBoostPerTrack", false },
				{ "jukebox.showTrackPanelIndefinitely", false },
				{ "jukebox.alwaysPlayIntro", true },
				{ "jukebox.resumeLastSong", false },
				{ "jukebox.discordAndSteamIntegration", true },
				{ "jukebox.enableTracksPreview", true },
				{ "jukebox.preventDuplicateTracks", false },
				{ "jukebox.nowPlayingHud", true },
				{ "jukebox.enableCalmThemes", true },
				{ "jukebox.songPanelStyle", 0 },
				{ "jukebox.currentPlaylist", "slot1" },
				{ "jukebox.calmThemeEnemiesThreshold", 2 },
				{ "jukebox.effects.parry", null },
				{ "jukebox.effects.wavecomplete", null },
				{ "jukebox.effects.gameover", null },
				{ "jukebox.effects.aww", null },
				{ "jukebox.effects.terminal-music", null },
				{ "jukebox.downloader.separateFolderPerPlaylist", true }
			})
			{
				MonoSingleton<PrefsManager>.Instance.defaultValues.Add(item.Key, item.Value);
			}
		}

		[IteratorStateMachine(typeof(<MotD>d__11))]
		private static IEnumerator MotD()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MotD>d__11(0);
		}
	}
	internal static class PluginInfo
	{
		public const string Guid = "dev.flazhik.jukebox";

		public const string Name = "Jukebox";

		public const string Version = "2.2.1";
	}
}
namespace Jukebox.Utils
{
	public static class FloatExtensions
	{
		public static string SecondsToHumanReadable(this float value)
		{
			int num = (int)value;
			int num2 = num / 60;
			int num3 = num - num2 * 60;
			return $"{num2:00}:{num3:00}";
		}
	}
	public static class IntExtensions
	{
		public static int Mod(this int num, int mod)
		{
			return (num % mod + mod) % mod;
		}
	}
	public abstract class ReflectionUtils
	{
		private const BindingFlags PrivateFields = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		public static T GetPrivate<T>(object instance, Type classType, string field)
		{
			FieldInfo field2 = classType.GetField(field, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			return (T)((field2 != null) ? field2.GetValue(instance) : null);
		}

		public static void SetPrivate<T, TV>(T instance, Type classType, string field, TV value)
		{
			FieldInfo field2 = classType.GetField(field, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.SetField);
			if (field2 != null)
			{
				field2.SetValue(instance, value);
			}
		}

		public static void CallPrivate(object instance, Type classType, string methodName, params object[] args)
		{
			classType.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(instance, args);
		}
	}
	public static class ScrollingTextUnscaled
	{
		[CompilerGenerated]
		private sealed class <HideText>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public TMP_Text text;

			public float secondsBetweenLetters;

			private int <currentLetter>5__2;

			private string <message>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<currentLetter>5__2 = text.text.Length - 1;
					<message>5__3 = text.text;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<currentLetter>5__2 >= 0)
				{
					int num;
					if (text.text[<currentLetter>5__2] == '>')
					{
						while (text.text[<currentLetter>5__2] != '<' && <currentLetter>5__2 >= 0)
						{
							num = <currentLetter>5__2 - 1;
							<currentLetter>5__2 = num;
						}
					}
					num = <currentLetter>5__2 - 1;
					<currentLetter>5__2 = num;
					text.text = <message>5__3.Substring(0, <currentLetter>5__2 + 1);
					<>2__current = (object)new WaitForSecondsRealtime(secondsBetweenLetters);
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

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

			private object <>2__current;

			public TMP_Text text;

			public string message;

			public AudioSource clickAudio;

			public float secondsBetweenLetters;

			private int <currentLetter>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<currentLetter>5__2 = 0;
					text.text = "";
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<currentLetter>5__2 < message.Length)
				{
					int num;
					if (message[<currentLetter>5__2] == '<')
					{
						while (message[<currentLetter>5__2] != '>' && <currentLetter>5__2 <= message.Length)
						{
							num = <currentLetter>5__2 + 1;
							<currentLetter>5__2 = num;
						}
					}
					else if (<currentLetter>5__2 < message.Length - 1)
					{
						while (<currentLetter>5__2 < message.Length - 1 && message[<currentLetter>5__2 + 1] == ' ')
						{
							num = <currentLetter>5__2 + 1;
							<currentLetter>5__2 = num;
						}
					}
					num = <currentLetter>5__2 + 1;
					<currentLetter>5__2 = num;
					text.text = message.Substring(0, <currentLetter>5__2);
					if ((Object)(object)clickAudio != (Object)null && message[<currentLetter>5__2 - 1] != '\n' && message[<currentLetter>5__2 - 1] != ' ')
					{
						clickAudio.Play();
					}
					<>2__current = (object)new WaitForSecondsRealtime(secondsBetweenLetters);
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

		[IteratorStateMachine(typeof(<ShowText>d__0))]
		public static IEnumerator ShowText(TMP_Text text, string message, float secondsBetweenLetters = 0.005f, AudioSource clickAudio = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ShowText>d__0(0)
			{
				text = text,
				message = message,
				secondsBetweenLetters = secondsBetweenLetters,
				clickAudio = clickAudio
			};
		}

		[IteratorStateMachine(typeof(<HideText>d__1))]
		public static IEnumerator HideText(TMP_Text text, float secondsBetweenLetters = 0.005f)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HideText>d__1(0)
			{
				text = text,
				secondsBetweenLetters = secondsBetweenLetters
			};
		}
	}
}
namespace Jukebox.UI
{
	public class JukeboxCredits : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <WindowsRoutine>d__8 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public JukeboxCredits <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				JukeboxCredits jukeboxCredits = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = jukeboxCredits.TerminalTextRoutine(0);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					jukeboxCredits.firstWindow.SetActive(true);
					<>2__current = jukeboxCredits.TerminalTextRoutine(1);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = jukeboxCredits.TerminalTextRoutine(2);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					jukeboxCredits.secondWindow.SetActive(true);
					<>2__current = jukeboxCredits.TerminalTextRoutine(3);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = jukeboxCredits.TerminalTextRoutine(4);
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					foreach (GameObject lastWindow in jukeboxCredits.lastWindows)
					{
						lastWindow.SetActive(true);
					}
					return false;
				}
			}

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

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

		[SerializeField]
		private TMP_Text[] terminalText;

		[SerializeField]
		private AudioSource click;

		[SerializeField]
		private GameObject firstWindow;

		[SerializeField]
		private GameObject secondWindow;

		[SerializeField]
		private List<GameObject> lastWindows;

		private string[] originalText;

		private void Awake()
		{
			originalText = terminalText.Select((TMP_Text t) => t.text).ToArray();
		}

		private void OnEnable()
		{
			firstWindow.SetActive(false);
			secondWindow.SetActive(false);
			foreach (GameObject lastWindow in lastWindows)
			{
				lastWindow.SetActive(false);
			}
			TMP_Text[] array = terminalText;
			for (int i = 0; i < array.Length; i++)
			{
				array[i].text = string.Empty;
			}
			((MonoBehaviour)this).StartCoroutine(WindowsRoutine());
		}

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

		private IEnumerator TerminalTextRoutine(int index)
		{
			return ScrollingTextUnscaled.ShowText(terminalText[index], originalText[index], 0.01f, click);
		}
	}
	public class JukeboxCustomContentButton : CustomContentButton
	{
		[SerializeField]
		public GameObject introAndLoopIcon;

		[SerializeField]
		public GameObject calmThemeIcon;
	}
	public class JukeboxUI : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <WhatIsNewRoutine>d__14 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public JukeboxUI <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				JukeboxUI jukeboxUI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1.4f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					jukeboxUI.whatIsNew.GetComponent<WhatsNew>().Open();
					return false;
				}
			}

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

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

		[SerializeField]
		public GameObject jukeboxMenuTemplate;

		[SerializeField]
		public GameObject playbackMenuTemplate;

		[SerializeField]
		public GameObject whatIsNewMenuTemplate;

		[SerializeField]
		public GameObject nowPlayingHudTemplate;

		[SerializeField]
		public GameObject nowPlayingHudClassicTemplate;

		private GameObject jukeboxMenu;

		private GameObject playbackMenu;

		private GameObject whatIsNew;

		private ReadOnlyCollection<JukeboxWindow> windows;

		public void OpenDownloader()
		{
			JukeboxMenuWindow component = jukeboxMenu.GetComponent<JukeboxMenuWindow>();
			component.Open();
			component.OpenDownloader();
		}

		protected void Awake()
		{
			InstantiateUI();
			windows = new ReadOnlyCollection<JukeboxWindow>(new List<JukeboxWindow>
			{
				jukeboxMenu.GetComponent<JukeboxWindow>(),
				playbackMenu.GetComponent<JukeboxPlaybackWindow>(),
				whatIsNew.GetComponent<WhatsNew>()
			});
			foreach (JukeboxWindow window in windows)
			{
				((Component)window).gameObject.SetActive(false);
			}
			((MonoBehaviour)this).StartCoroutine(WhatIsNewRoutine());
		}

		protected void Update()
		{
			ManageWindows();
		}

		private void ManageWindows()
		{
			if (GameIsPaused())
			{
				return;
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Pause.WasPerformedThisFrame)
			{
				foreach (JukeboxWindow window in windows)
				{
					if (window.IsOpened())
					{
						window.Close();
					}
				}
				return;
			}
			JukeboxWindow jukeboxWindow = windows.FirstOrDefault((JukeboxWindow w) => (Object)(object)w.hotkey != (Object)null && w.hotkey.ToInputAction().WasPerformedThisFrame());
			if ((Object)(object)jukeboxWindow != (Object)null)
			{
				foreach (JukeboxWindow window2 in windows)
				{
					if ((Object)(object)window2.hotkey != (Object)null && InputExtensions.IsActionEqual(window2.hotkey.ToInputAction(), jukeboxWindow.hotkey.ToInputAction(), (string)null))
					{
						window2.Toggle();
					}
					else
					{
						window2.Close();
					}
				}
			}
			if (!windows.Any((JukeboxWindow w) => GameStateManager.Instance.IsStateActive(w.StateKey())) && MonoSingleton<OptionsManager>.Instance.paused)
			{
				MonoSingleton<JukeboxPauseManager>.Instance.UnPause();
			}
		}

		private void InstantiateUI()
		{
			//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_0010: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject
			{
				name = "JukeboxCanvas"
			};
			val.AddComponent<Canvas>();
			GameObject val2 = GameObject.Find("/Canvas");
			Canvas component = val.GetComponent<Canvas>();
			component.renderMode = (RenderMode)1;
			component.sortingOrder = val2.GetComponent<Canvas>().sortingOrder + 1;
			val.AddComponent<CanvasScaler>();
			val.AddComponent<GraphicRaycaster>();
			jukeboxMenu = Object.Instantiate<GameObject>(jukeboxMenuTemplate, val2.transform);
			playbackMenu = Object.Instantiate<GameObject>(playbackMenuTemplate, val2.transform);
			whatIsNew = Object.Instantiate<GameObject>(whatIsNewMenuTemplate, val2.transform);
			Object.Instantiate<GameObject>(nowPlayingHudTemplate, GameObject.Find("/Player/Main Camera/HUD Camera/HUD/GunCanvas").transform, false);
			Object.Instantiate<GameObject>(nowPlayingHudClassicTemplate, val2.transform.Find("Crosshair Filler"), false);
		}

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

		private static bool GameIsPaused()
		{
			return GameStateManager.Instance.IsStateActive("pause");
		}
	}
	public class ScrollUIImageUnscaled : MonoBehaviour
	{
		private RawImage img;

		public float xSpeed;

		public float ySpeed;

		private void Start()
		{
			img = ((Component)this).GetComponent<RawImage>();
		}

		private void Update()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			Rect uvRect = img.uvRect;
			Vector2 val = ((Rect)(ref uvRect)).position + new Vector2(xSpeed, ySpeed) * Time.unscaledDeltaTime;
			while ((double)val.x > 1.0)
			{
				val.x -= 1f;
			}
			while ((double)val.x < -1.0)
			{
				val.x += 1f;
			}
			while ((double)val.y > 1.0)
			{
				val.y -= 1f;
			}
			while ((double)val.y < -1.0)
			{
				val.y += 1f;
			}
			RawImage obj = img;
			uvRect = img.uvRect;
			Vector2 val2 = ((Rect)(ref uvRect)).position + new Vector2(xSpeed, ySpeed) * Time.unscaledDeltaTime;
			uvRect = img.uvRect;
			obj.uvRect = new Rect(val2, ((Rect)(ref uvRect)).size);
		}
	}
}
namespace Jukebox.UI.Windows
{
	public class JukeboxMenuWindow : JukeboxWindow
	{
		[SerializeField]
		protected Button[] buttons;

		[SerializeField]
		protected GameObject activeBgObject;

		[SerializeField]
		protected GameObject generalSettings;

		[SerializeField]
		protected Button downloaderButton;

		[SerializeField]
		protected GameObject downloaderPage;

		public override string StateKey()
		{
			return "jukeboxMenu";
		}

		protected override void Awake()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			base.Awake();
			Button[] array = buttons;
			foreach (Button button in array)
			{
				((UnityEvent)button.onClick).AddListener((UnityAction)delegate
				{
					SetActiveButton(button);
				});
			}
			JukeboxMusicPlayer.OnNextAudioClip += NextAudioClip;
		}

		public void NextAudioClip(ClipChangedArgs clip)
		{
			if (clip.NewSong && clip.Song.IsCustom)
			{
				ReflectionUtils.GetPrivate<Slider>(generalSettings.GetComponentInChildren<SettingsSlider>(true), typeof(SettingsSlider), "slider").value = MonoSingleton<JukeboxManager>.Instance.player.VolumeBoost;
			}
		}

		public void OpenDownloader()
		{
			SettingsMenu component = ((Component)this).gameObject.GetComponent<SettingsMenu>();
			if (!ReflectionUtils.GetPrivate<bool>(component, typeof(SettingsMenu), "initialized"))
			{
				component.Initialize();
			}
			component.SetActivePage(downloaderPage);
			SetActiveButton(downloaderButton);
		}

		protected void OnDestroy()
		{
			JukeboxMusicPlayer.OnNextAudioClip -= NextAudioClip;
		}

		private void SetActiveButton(Button button)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			activeBgObject.transform.SetParent(((Component)button).transform);
			activeBgObject.transform.SetSiblingIndex(0);
			activeBgObject.transform.localPosition = Vector3.zero;
		}
	}
	public class JukeboxPlaybackWindow : JukeboxWindow
	{
		public override string StateKey()
		{
			return "jukeboxPlayback";
		}
	}
	public abstract class JukeboxWindow : MonoBehaviour
	{
		[SerializeField]
		public InputActionReference hotkey;

		public abstract string StateKey();

		public void Open()
		{
			((Component)this).gameObject.SetActive(true);
			MonoSingleton<JukeboxPauseManager>.Instance.Pause(StateKey(), ((Component)this).gameObject);
		}

		public void Close()
		{
			GameStateManager.Instance.PopState(StateKey());
			((Component)this).gameObject.SetActive(false);
		}

		public void Toggle()
		{
			if (IsOpened())
			{
				Close();
			}
			else
			{
				Open();
			}
		}

		protected virtual void Awake()
		{
			if ((Object)(object)hotkey != (Object)null)
			{
				hotkey = InputActionReference.Create(MonoSingleton<InputManager>.Instance.InputSource.Actions.asset.FindAction(hotkey.ToInputAction().id));
			}
		}

		public bool IsOpened()
		{
			return ((Component)this).gameObject.activeSelf;
		}
	}
	public class WhatsNew : JukeboxWindow
	{
		private const string PrefsKey = "Jukebox.NewDiscordServer";

		public override string StateKey()
		{
			return "jukebox.whatisnew";
		}

		private void Start()
		{
			if (PlayerPrefs.GetInt("Jukebox.NewDiscordServer") != 1)
			{
				PlayerPrefs.SetInt("Jukebox.NewDiscordServer", 1);
			}
			else
			{
				Close();
			}
		}
	}
}
namespace Jukebox.UI.Themes
{
	public class ThemeEnemySettings : MonoBehaviour
	{
		[SerializeField]
		public TMP_Text title;

		[SerializeField]
		public Image icon;

		[SerializeField]
		public GameObject radianceBg;

		[SerializeField]
		public Toggle toggle;

		[SerializeField]
		public Counter counter;
	}
	public class ThemeSettingsMenu : MonoBehaviour
	{
		[SerializeField]
		private Counter threshold;

		[SerializeField]
		private GameObject enemyTemplate;

		[SerializeField]
		private GameObject regularEnemies;

		[SerializeField]
		private GameObject radiantEnemies;

		[SerializeField]
		private Button[] tabButtons;

		[SerializeField]
		private GameObject activeTab;

		[SerializeField]
		private List<AssetReferenceT<SpawnableObject>> enemies;

		private void Awake()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			JukeboxThemesManager themesManager = MonoSingleton<JukeboxThemesManager>.Instance;
			threshold.SetDefaultValue(MonoSingleton<PrefsManager>.Instance.GetIntLocal("jukebox.calmThemeEnemiesThreshold", 0));
			threshold.OnChanged += OnThresholdChanged;
			Button[] array = tabButtons;
			foreach (Button button in array)
			{
				((UnityEvent)button.onClick).AddListener((UnityAction)delegate
				{
					//IL_0055: Unknown result type (might be due to invalid IL or missing references)
					activeTab.transform.SetParent(((Component)button).transform);
					activeTab.transform.SetSiblingIndex(0);
					activeTab.transform.localPosition = Vector3.zero;
				});
			}
			foreach (AssetReferenceT<SpawnableObject> enemy2 in enemies)
			{
				AsyncOperationHandle<SpawnableObject> val = enemy2.LoadAssetAsync();
				SpawnableObject enemy = val.WaitForCompletion();
				Addressables.Release<SpawnableObject>(val);
				Dictionary<bool, ThemeEnemySettings> respectiveSettings = new Dictionary<bool, ThemeEnemySettings>();
				GameObject[] array2 = (GameObject[])(object)new GameObject[2] { regularEnemies, radiantEnemies };
				foreach (GameObject val2 in array2)
				{
					GameObject val3 = Object.Instantiate<GameObject>(enemyTemplate, val2.transform);
					bool radiant = (Object)(object)val2 == (Object)(object)radiantEnemies;
					Sprite gridIcon = enemy.gridIcon;
					ThemeEnemySettings enemySettings = val3.GetComponent<ThemeEnemySettings>();
					enemySettings.icon.sprite = gridIcon;
					enemySettings.title.text = (radiant ? ("Radiant " + enemy.objectName) : enemy.objectName);
					enemySettings.radianceBg.SetActive(radiant);
					int? thresholdFor = themesManager.GetThresholdFor(enemy.enemyType, radiant);
					if (!thresholdFor.HasValue)
					{
						enemySettings.counter.SetDefaultValue(0);
					}
					else
					{
						enemySettings.counter.SetDefaultValue(thresholdFor.Value);
					}
					enemySettings.toggle.isOn = thresholdFor.HasValue;
					enemySettings.counter.OnChanged += delegate(int value)
					{
						//IL_002c: Unknown result type (might be due to invalid IL or missing references)
						enemySettings.toggle.isOn = true;
						themesManager.SetThresholdFor(enemy.enemyType, value, radiant);
					};
					((UnityEvent<bool>)(object)enemySettings.toggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool on)
					{
						//IL_005a: Unknown result type (might be due to invalid IL or missing references)
						//IL_001e: Unknown result type (might be due to invalid IL or missing references)
						if (on)
						{
							themesManager.SetThresholdFor(enemy.enemyType, enemySettings.counter.Value, radiant);
						}
						else
						{
							themesManager.DisableThresholdFor(enemy.enemyType, radiant);
						}
					});
					respectiveSettings[radiant] = enemySettings;
					val3.SetActive(true);
				}
				respectiveSettings[false].counter.OnChanged += delegate(int value)
				{
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_0041: Unknown result type (might be due to invalid IL or missing references)
					int? thresholdFor2 = themesManager.GetThresholdFor(enemy.enemyType, radiant: true);
					if (!thresholdFor2.HasValue || thresholdFor2.Value > value)
					{
						themesManager.SetThresholdFor(enemy.enemyType, value, radiant: true);
						respectiveSettings[true].toggle.isOn = true;
						respectiveSettings[true].counter.Value = value;
					}
				};
				((UnityEvent<bool>)(object)respectiveSettings[false].toggle.onValueChanged).AddListener((UnityAction<bool>)delegate(bool on)
				{
					//IL_0015: Unknown result type (might be due to invalid IL or missing references)
					if (on && !themesManager.GetThresholdFor(enemy.enemyType, radiant: true).HasValue)
					{
						respectiveSettings[true].toggle.isOn = true;
						respectiveSettings[true].counter.Value = respectiveSettings[false].counter.Value;
					}
				});
			}
		}

		private void OnDestroy()
		{
			threshold.OnChanged -= OnThresholdChanged;
		}

		private static void OnThresholdChanged(int value)
		{
			MonoSingleton<PrefsManager>.Instance.SetIntLocal("jukebox.calmThemeEnemiesThreshold", value);
		}
	}
}
namespace Jukebox.UI.SongPanel
{
	public class ClassicSongPanel : SongPanel
	{
		[CompilerGenerated]
		private sealed class <Await>d__3 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ClassicSongPanel <>4__this;

			private float <time>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				ClassicSongPanel classicSongPanel = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<time>5__2 = classicSongPanel.panelStayTime;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((double)<time>5__2 > 0.0 || classicSongPanel.showIndefinitely)
				{
					classicSongPanel.panelGroup.alpha = (classicSongPanel.active ? 1 : 0);
					if ((double)<time>5__2 > 0.0)
					{
						<time>5__2 -= Time.unscaledDeltaTime;
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

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

			private object <>2__current;

			public ClassicSongPanel <>4__this;

			private float <time>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				ClassicSongPanel classicSongPanel = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<time>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((double)<time>5__2 < (double)classicSongPanel.panelApproachTime)
				{
					<time>5__2 += Time.unscaledDeltaTime;
					classicSongPanel.panelGroup.alpha = (classicSongPanel.active ? (<time>5__2 / classicSongPanel.panelApproachTime) : 0f);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				classicSongPanel.panelGroup.alpha = (classicSongPanel.active ? 1 : 0);
				return false;
			}

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

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

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

			private object <>2__current;

			public ClassicSongPanel <>4__this;

			private float <time>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				ClassicSongPanel classicSongPanel = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<time>5__2 = classicSongPanel.panelApproachTime;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((double)<time>5__2 > 0.0)
				{
					<time>5__2 -= Time.unscaledDeltaTime;
					classicSongPanel.panelGroup.alpha = (classicSongPanel.active ? (<time>5__2 / classicSongPanel.panelApproachTime) : 0f);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				classicSongPanel.panelGroup.alpha = 0f;
				return false;
			}

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

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

		protected override SongPanelStyle Style => SongPanelStyle.Classic;

		[IteratorStateMachine(typeof(<FadeIn>d__2))]
		protected override IEnumerator FadeIn(JukeboxSongMetadata metadata)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeIn>d__2(0)
			{
				<>4__this = this
			};
		}

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

		[IteratorStateMachine(typeof(<FadeOut>d__4))]
		protected override IEnumerator FadeOut()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeOut>d__4(0)
			{
				<>4__this = this
			};
		}
	}
	public class JukeboxSongPanel : SongPanel
	{
		[CompilerGenerated]
		private sealed class <Await>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public JukeboxSongPanel <>4__this;

			private float <time>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				JukeboxSongPanel jukeboxSongPanel = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<time>5__2 = jukeboxSongPanel.panelStayTime;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((double)<time>5__2 > 0.0 || jukeboxSongPanel.showIndefinitely)
				{
					jukeboxSongPanel.panelGroup.alpha = (jukeboxSongPanel.active ? 1 : 0);
					if ((double)<time>5__2 > 0.0)
					{
						<time>5__2 -= Time.unscaledDeltaTime;
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

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

			private object <>2__current;

			public JukeboxSongPanel <>4__this;

			public JukeboxSongMetadata metadata;

			private RectTransform <rect>5__2;

			private float <time>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: 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)
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				JukeboxSongPanel jukeboxSongPanel = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					((Graphic)jukeboxSongPanel.text).color = new Color(1f, 1f, 1f, 1f);
					<rect>5__2 = ((Component)jukeboxSongPanel.panelGroup).GetComponent<RectTransform>();
					<rect>5__2.sizeDelta = jukeboxSongPanel.startDimensions;
					string text = ((!string.IsNullOrEmpty(metadata.Artist)) ? ("<color=#999>" + metadata.Artist + "</color>") : string.Empty);
					if (jukeboxSongPanel.rollingTextRoutine != null)
					{
						((MonoBehaviour)jukeboxSongPanel).StopCoroutine(jukeboxSongPanel.rollingTextRoutine);
					}
					jukeboxSongPanel.text.text = string.Empty;
					jukeboxSongPanel.rollingTextRoutine = ((MonoBehaviour)jukeboxSongPanel).StartCoroutine(ScrollingTextUnscaled.ShowText(jukeboxSongPanel.text, metadata.Title.ToUpper() + " " + text, 0.022f));
					<time>5__3 = 0f;
					break;
				}
				case 1:
					<>1__state = -1;
					break;
				}
				if (<time>5__3 < jukeboxSongPanel.panelApproachTime)
				{
					jukeboxSongPanel.panelGroup.alpha = (jukeboxSongPanel.active ? 1 : 0);
					<time>5__3 += Time.unscaledDeltaTime;
					if (<time>5__3 > jukeboxSongPanel.panelApproachTime)
					{
						<time>5__3 = jukeboxSongPanel.panelApproachTime;
					}
					<rect>5__2.sizeDelta = jukeboxSongPanel.startDimensions + (jukeboxSongPanel.targetDimensions - jukeboxSongPanel.startDimensions) * <time>5__3 / jukeboxSongPanel.panelApproachTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

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

			private object <>2__current;

			public JukeboxSongPanel <>4__this;

			private RectTransform <rect>5__2;

			private float <time>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Expected O, but got Unknown
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				JukeboxSongPanel CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					CS$<>8__locals0.rollingTextRoutine = ((MonoBehaviour)CS$<>8__locals0).StartCoroutine(ScrollingTextUnscaled.HideText(CS$<>8__locals0.text, 0.022f));
					<rect>5__2 = ((Component)CS$<>8__locals0.panelGroup).GetComponent<RectTransform>();
					<time>5__3 = CS$<>8__locals0.panelApproachTime;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => CS$<>8__locals0.text.text.Length <= 20));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if ((double)<time>5__3 > 0.0)
				{
					CS$<>8__locals0.panelGroup.alpha = (CS$<>8__locals0.active ? 1 : 0);
					<time>5__3 -= Time.unscaledDeltaTime;
					if (<time>5__3 < 0f)
					{
						<time>5__3 = 0f;
					}
					<rect>5__2.sizeDelta = CS$<>8__locals0.startDimensions + (CS$<>8__locals0.targetDimensions - CS$<>8__locals0.startDimensions) * <time>5__3 / CS$<>8__locals0.panelApproachTime;
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				CS$<>8__locals0.panelGroup.alpha = 0f;
				return false;
			}

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

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

		[SerializeField]
		public Vector2 startDimensions;

		[SerializeField]
		public Vector2 targetDimensions;

		private Coroutine rollingTextRoutine;

		protected override SongPanelStyle Style => SongPanelStyle.Jukebox;

		[IteratorStateMachine(typeof(<FadeIn>d__5))]
		protected override IEnumerator FadeIn(JukeboxSongMetadata metadata)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeIn>d__5(0)
			{
				<>4__this = this,
				metadata = metadata
			};
		}

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

		[IteratorStateMachine(typeof(<FadeOut>d__7))]
		protected override IEnumerator FadeOut()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeOut>d__7(0)
			{
				<>4__this = this
			};
		}
	}
	public class PlaylistSelectable : DirectoryTreeBrowser<JukeboxSong>
	{
		[SerializeField]
		public GameObject selectPlaylistPanel;

		[SerializeField]
		public string playlistName;

		[SerializeField]
		public Button button;

		[SerializeField]
		public GameObject empty;

		protected override int maxPageLength => 6;

		protected override IDirectoryTree<JukeboxSong> baseDirectory
		{
			get
			{
				JukeboxPlaylist val;
				using (StreamReader streamReader = new StreamReader(File.Open(JukeboxPlaylist.PathForPlaylist(playlistName), FileMode.OpenOrCreate)))
				{
					val = JsonConvert.DeserializeObject<JukeboxPlaylist>(streamReader.ReadToEnd());
				}
				List<SongIdentifier> source = ((val != null) ? ((Playlist)val).ids : new List<SongIdentifier>());
				return (IDirectoryTree<JukeboxSong>)(object)new FakeDirectoryTree<JukeboxSong>("Songs", from id in source
					where (int)id.type != 1 || File.Exists(id.path)
					select MonoSingleton<JukeboxSongsLoader>.Instance.Load(id), (IEnumerable<IDirectoryTree<JukeboxSong>>)null, (IDirectoryTree<JukeboxSong>)null);
			}
		}

		private void Awake()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			((UnityEvent)button.onClick).AddListener((UnityAction)delegate
			{
				MonoSingleton<PrefsManager>.Instance.SetStringLocal("jukebox.currentPlaylist", playlistName);
				MonoSingleton<JukeboxManager>.Instance.playlistEditor.ReloadPlaylist();
				selectPlaylistPanel.SetActive(false);
			});
		}

		private void OnEnable()
		{
			base.currentDirectory = ((DirectoryTreeBrowser<JukeboxSong>)this).baseDirectory;
			((DirectoryTreeBrowser<JukeboxSong>)this).Rebuild(true);
		}

		protected override Action BuildLeaf(JukeboxSong item, int indexInPage)
		{
			GameObject go = Object.Instantiate<GameObject>(base.itemButtonTemplate, base.itemButtonTemplate.transform.parent);
			go.SetActive(true);
			go.GetComponent<Image>().sprite = item.Metadata.Icon;
			return delegate
			{
				Object.Destroy((Object)(object)go);
			};
		}

		public override void Rebuild(bool setToPageZero = true)
		{
			base.Rebuild(setToPageZero);
			Transform itemParent = base.itemParent;
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((itemParent is RectTransform) ? itemParent : null));
			empty.SetActive(!base.currentDirectory.files.Any());
		}
	}
	public abstract class SongPanel : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <ShowPanelRoutine>d__16 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public JukeboxSongMetadata metadata;

			public SongPanel <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				SongPanel songPanel = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					string text = ((!string.IsNullOrEmpty(metadata.Artist)) ? ("<color=#999>" + metadata.Artist + "</color>") : string.Empty);
					songPanel.text.text = metadata.Title.ToUpper() + " " + text;
					songPanel.icon.sprite = (((Object)(object)metadata.Icon != (Object)null) ? metadata.Icon : songPanel.defaultIcon);
					<>2__current = songPanel.FadeIn(metadata);
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					<>2__current = songPanel.Await();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = songPanel.FadeOut();
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[SerializeField]
		public CanvasGroup panelGroup;

		[SerializeField]
		public Sprite defaultIcon;

		[SerializeField]
		public float panelApproachTime;

		[SerializeField]
		public float panelStayTime;

		public TMP_Text text;

		public Image icon;

		protected bool showIndefinitely;

		protected bool active;

		private Coroutine displayRoutine;

		protected abstract SongPanelStyle Style { get; }

		protected abstract IEnumerator FadeIn(JukeboxSongMetadata metadata);

		protected abstract IEnumerator Await();

		protected abstract IEnumerator FadeOut();

		public void Awake()
		{
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Combine(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
			JukeboxMusicPlayer.OnNextAudioClip += NextAudioClip;
			JukeboxMusicPlayer.OnStop += OnStop;
			showIndefinitely = MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.showTrackPanelIndefinitely", false);
			active = MonoSingleton<PrefsManager>.Instance.GetIntLocal("jukebox.songPanelStyle", 0) == (int)Style;
		}

		public void OnDestroy()
		{
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Remove(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
			JukeboxMusicPlayer.OnNextAudioClip -= NextAudioClip;
			JukeboxMusicPlayer.OnStop -= OnStop;
		}

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

		private void NextAudioClip(ClipChangedArgs clip)
		{
			if (clip.NewSong)
			{
				active = MonoSingleton<PrefsManager>.Instance.GetIntLocal("jukebox.songPanelStyle", 0) == (int)Style;
				if (displayRoutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(displayRoutine);
				}
				displayRoutine = ((MonoBehaviour)this).StartCoroutine(ShowPanelRoutine(clip.Song.Metadata));
			}
		}

		private void OnStop()
		{
			active = false;
		}

		private void OnPrefChanged(string key, object value)
		{
			if (key.Equals("jukebox.showTrackPanelIndefinitely"))
			{
				showIndefinitely = (bool)value;
			}
			if (key.Equals("jukebox.songPanelStyle"))
			{
				active = (int)value == (int)Style;
			}
		}
	}
	public class SongPanelOption : MonoBehaviour
	{
		private static readonly Color Active = new Color(0.68f, 0.68f, 0.68f, 0.25f);

		private static readonly Color Inactive = new Color(0f, 0f, 0f, 0.59f);

		public SongPanelStyle style;

		private void Start()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)((Component)this).gameObject.GetComponent<Image>()).color = ((MonoSingleton<PrefsManager>.Instance.GetIntLocal("jukebox.songPanelStyle", 0) == (int)style) ? Active : Inactive);
		}

		public void Select()
		{
			//IL_003e: 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)
			Button[] componentsInChildren = ((Component)((Component)this).transform.parent).GetComponentsInChildren<Button>();
			foreach (Button val in componentsInChildren)
			{
				((Graphic)((Component)val).gameObject.GetComponent<Image>()).color = (((Object)(object)val == (Object)(object)((Component)this).gameObject.GetComponent<Button>()) ? Active : Inactive);
			}
			MonoSingleton<PrefsManager>.Instance.SetIntLocal("jukebox.songPanelStyle", (int)style);
		}
	}
	public enum SongPanelStyle
	{
		Jukebox,
		Classic
	}
}
namespace Jukebox.UI.Elements
{
	public class Counter : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <ChangeValueRoutine>d__18 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Action<int> callback;

			public Counter <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Expected O, but got Unknown
				int num = <>1__state;
				Counter counter = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					callback(counter.tmpValue);
					<>2__current = (object)new WaitForSecondsRealtime(0.3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				callback(counter.tmpValue);
				<>2__current = (object)new WaitForSecondsRealtime(0.1f);
				<>1__state = 2;
				return true;
			}

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

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

		[SerializeField]
		private TextMeshProUGUI textValue;

		[SerializeField]
		private CounterButton increase;

		[SerializeField]
		private CounterButton decrease;

		[SerializeField]
		private int minValue;

		[SerializeField]
		private int maxValue;

		private int tmpValue;

		private IEnumerator changeValueRoutine;

		private int value;

		public int Value
		{
			get
			{
				return value;
			}
			set
			{
				this.value = value;
				((TMP_Text)textValue).text = Value.ToString();
				this.OnChanged?.Invoke(value);
			}
		}

		public event Action<int> OnChanged;

		public void Awake()
		{
			AddEvents(increase, delegate
			{
				tmpValue = ChangeValue((int i) => i + 1);
			});
			AddEvents(decrease, delegate
			{
				tmpValue = ChangeValue((int i) => i - 1);
			});
		}

		public void SetDefaultValue(int defaultValue)
		{
			Value = defaultValue;
			tmpValue = defaultValue;
			((TMP_Text)textValue).text = defaultValue.ToString();
		}

		private void AddEvents(CounterButton button, Action<int> callback)
		{
			button.OnDown += delegate
			{
				changeValueRoutine = ChangeValueRoutine(callback);
				((MonoBehaviour)this).StartCoroutine(changeValueRoutine);
			};
			button.OnUp += SaveValue;
			button.OnExit += SaveValue;
		}

		private void SaveValue()
		{
			if (changeValueRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(changeValueRoutine);
			}
			Value = tmpValue;
			this.OnChanged?.Invoke(Value);
		}

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

		private int ChangeValue(Func<int, int> operation)
		{
			int result = ValidateOperation(operation);
			((TMP_Text)textValue).text = result.ToString();
			return result;
		}

		private int ValidateOperation(Func<int, int> operation)
		{
			int num = operation(tmpValue);
			if (num >= minValue && num <= maxValue)
			{
				return num;
			}
			return tmpValue;
		}
	}
	public class CounterButton : Button
	{
		public bool pressed;

		public event Action OnDown;

		public event Action OnUp;

		public event Action OnExit;

		public override void OnPointerDown(PointerEventData eventData)
		{
			pressed = true;
			((Selectable)this).OnPointerDown(eventData);
			this.OnDown?.Invoke();
		}

		public override void OnPointerUp(PointerEventData eventData)
		{
			pressed = false;
			((Selectable)this).OnPointerUp(eventData);
			this.OnUp?.Invoke();
		}

		public override void OnPointerExit(PointerEventData eventData)
		{
			((Selectable)this).OnPointerExit(eventData);
			if (pressed)
			{
				this.OnExit?.Invoke();
			}
			pressed = false;
		}
	}
	public class RewindSlider : MonoBehaviour, IEndDragHandler, IEventSystemHandler, IDragHandler
	{
		public bool beingDragged;

		[SerializeField]
		public Slider slider;

		public event Action<float> OnValueChanged;

		public void OnEndDrag(PointerEventData eventData)
		{
			this.OnValueChanged?.Invoke(slider.value);
			beingDragged = false;
		}

		public void OnDrag(PointerEventData eventData)
		{
			beingDragged = true;
		}
	}
}
namespace Jukebox.UI.Effects
{
	public class SoundEffectButton : MonoBehaviour
	{
		[SerializeField]
		private string prefsKey;

		[SerializeField]
		private TMP_Text title;

		[SerializeField]
		private TMP_Text fileNameText;

		[SerializeField]
		private TMP_Text browserWindowTitle;

		protected void Awake()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			ChangeFileName(MonoSingleton<PrefsManager>.Instance.GetStringLocal(prefsKey, (string)null));
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Combine(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
			((UnityEvent)((Component)this).GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				browserWindowTitle.text = "Select file for " + title.text;
			});
		}

		protected void OnDestroy()
		{
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Remove(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
		}

		private void OnPrefChanged(string key, object value)
		{
			if (key.Equals(prefsKey))
			{
				ChangeFileName((string)value);
			}
		}

		private void ChangeFileName(string fileName)
		{
			fileNameText.text = ((fileName != null) ? new FileInfo(fileName).Name : "Default");
		}
	}
}
namespace Jukebox.UI.Decorators
{
	public class ControlBindDecorator : MonoBehaviour
	{
		[SerializeField]
		public InputActionReference action;

		protected void Awake()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			InputAction val = MonoSingleton<InputManager>.Instance.InputSource.Actions.asset.FindAction(action.ToInputAction().id);
			((Component)this).GetComponentInChildren<ControlsOptionsKey>().RebuildBindings(val, MonoSingleton<InputManager>.Instance.InputSource.Actions.KeyboardMouseScheme);
		}
	}
	public abstract class UIDecorator<T> : MonoBehaviour where T : MonoBehaviour
	{
		[SerializeField]
		public GameObject hint;

		protected GameObject control;

		protected abstract GameObject Template();

		protected abstract void Init();

		public void Start()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			control = Object.Instantiate<GameObject>(Template(), ((Component)this).transform);
			control.transform.position = ((Component)this).transform.position;
			Object.Destroy((Object)(object)hint);
			Init();
			Object.Destroy((Object)(object)((Component)this).GetComponent<T>());
		}
	}
}
namespace Jukebox.Patches
{
	[HarmonyPatch(typeof(AudioMixerController))]
	public static class AudioMixerControllerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(AudioMixerController), "Update")]
		public static void AudioMixerController_Update_Postfix(AudioMixerController __instance)
		{
			if (!((Object)(object)MonoSingleton<JukeboxManager>.Instance == (Object)null))
			{
				__instance.musicSound.SetFloat("allVolume", __instance.CalculateVolume(__instance.musicVolume) + MonoSingleton<JukeboxManager>.Instance.player.VolumeBoost);
			}
		}
	}
	[HarmonyPatch(typeof(DiscordController))]
	public static class DiscordControllerPatch
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UpdateActivityHandler <>9__0_0;

			internal void <DiscordController_UpdateWave_Prefix>b__0_0(Result _)
			{
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(DiscordController), "UpdateWave")]
		public static bool DiscordController_UpdateWave_Prefix(int wave)
		{
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			if (JukeboxMusicPlayer.CurrentSong == null || !MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.discordAndSteamIntegration", false))
			{
				return true;
			}
			if ((Object)(object)DiscordController.Instance == (Object)null)
			{
				return false;
			}
			Activity @private = ReflectionUtils.GetPrivate<Activity>(DiscordController.Instance, typeof(DiscordController), "cachedActivity");
			string details = @private.Details;
			try
			{
				bool private2 = ReflectionUtils.GetPrivate<bool>(DiscordController.Instance, typeof(DiscordController), "disabled");
				ActivityManager private3 = ReflectionUtils.GetPrivate<ActivityManager>(DiscordController.Instance, typeof(DiscordController), "activityManager");
				Discord private4 = ReflectionUtils.GetPrivate<Discord>(DiscordController.Instance, typeof(DiscordController), "discord");
				if (private2)
				{
					return false;
				}
				@private.Details = $"WAVE: {wave} | \ud83c\udfb5 {JukeboxMusicPlayer.CurrentSong.ArtistAndTrack}";
				ReflectionUtils.SetPrivate<DiscordController, Activity>(DiscordController.Instance, typeof(DiscordController), "cachedActivity", @private);
				if (private4 == null || private3 == null)
				{
					return false;
				}
				Activity val = @private;
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					UpdateActivityHandler val2 = delegate
					{
					};
					<>c.<>9__0_0 = val2;
					obj = (object)val2;
				}
				private3.UpdateActivity(val, (UpdateActivityHandler)obj);
				return false;
			}
			catch (Exception)
			{
				@private.Details = details;
				ReflectionUtils.SetPrivate<DiscordController, Activity>(DiscordController.Instance, typeof(DiscordController), "cachedActivity", @private);
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(FinalCyberRank))]
	public static class FinalCyberRankPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(FinalCyberRank), "GameOver")]
		public static bool FinalCyberRank_GameOver_Prefix()
		{
			JukeboxMusicPlayer player = MonoSingleton<JukeboxManager>.Instance.player;
			if ((Object)(object)player != (Object)null)
			{
				if (MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.resumeLastSong", false) && JukeboxMusicPlayer.CurrentSong != null && (Object)(object)player.Source.clip != (Object)null)
				{
					JukeboxPreferencesManager instance = MonoSingleton<JukeboxPreferencesManager>.Instance;
					instance.SetPlaybackPosition(JukeboxMusicPlayer.CurrentSong.Id, JukeboxMusicPlayer.CurrentClipIndex, player.Source.time);
					instance.ForceSavePreferences();
				}
				player.Stop();
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(InputActions))]
	public static class InputActionsPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static void InputActions_Constructor_Postfix(InputActions __instance)
		{
			if (__instance.asset.FindActionMap("Jukebox", false) == null)
			{
				MergeInputActionAssets(__instance);
			}
		}

		private static void MergeInputActionAssets(InputActions ukInputActions)
		{
			//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)
			if (Resources.FindObjectsOfTypeAll(typeof(InputActionAsset)).Length == 0)
			{
				Debug.LogError((object)"Couldn't load InputActionAsset");
				return;
			}
			InputActionAsset val = Addressables.LoadAssetAsync<InputActionAsset>((object)"Assets/Jukebox/JukeboxControls.inputactions").WaitForCompletion();
			if (ukInputActions.asset.FindActionMap("Jukebox", false) == null)
			{
				ukInputActions.Disable();
				InputActionSetupExtensions.AddActionMap(ukInputActions.asset, InputActionMap.FromJson(val.ToJson())[0]);
				ukInputActions.Enable();
			}
		}
	}
	[HarmonyPatch(typeof(InputManager))]
	public static class InputManagerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(InputManager), "Rebind")]
		public static bool InputManager_Rebind_Prefix(InputManager __instance, InputAction action, int? existingIndex, Action onComplete, Action onCancel, InputControlScheme scheme)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (action.actionMap.name != "Jukebox")
			{
				return true;
			}
			__instance.WaitForButton((Action<string>)delegate(string path)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				if (path == "<Mouse>/leftButton")
				{
					onComplete?.Invoke();
				}
				else if (((IEnumerable<InputBinding>)(object)action.bindings).Any((InputBinding binding) => InputSystem.FindControl(((InputBinding)(ref binding)).path) == InputSystem.FindControl(path)))
				{
					onComplete?.Invoke();
				}
				else
				{
					BindingSyntax val = ((!existingIndex.HasValue) ? InputActionSetupExtensions.AddBinding(action, default(InputBinding)) : InputActionSetupExtensions.ChangeBinding(action, existingIndex.GetValueOrDefault()));
					val = ((BindingSyntax)(ref val)).WithPath(path);
					((BindingSyntax)(ref val)).WithGroup(((InputControlScheme)(ref scheme)).bindingGroup);
					__instance.actionModified?.Invoke(action);
					if (onComplete != null)
					{
						onComplete();
					}
				}
			}, (Action)delegate
			{
				onCancel?.Invoke();
			}, ((IEnumerable<DeviceRequirement>)(object)((InputControlScheme)(ref scheme)).deviceRequirements).Select((DeviceRequirement requirement) => ((DeviceRequirement)(ref requirement)).controlPath).ToList());
			return false;
		}
	}
	[HarmonyPatch(typeof(ScreenZone))]
	public static class ScreenZonePatch
	{
		private static PreviewHelper _helper;

		private static ScreenZone _cgTerminal;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ScreenZone), "Awake")]
		public static void ScreenZone_Awake_Postfix(ScreenZone __instance)
		{
			if (!(((Object)__instance).name != "Cybergrind Shop"))
			{
				PreviewHelper previewHelper = default(PreviewHelper);
				if (!((Component)__instance).TryGetComponent<PreviewHelper>(ref previewHelper))
				{
					((Component)__instance).gameObject.AddComponent<PreviewHelper>();
				}
				_cgTerminal = __instance;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ScreenZone), "Update")]
		public static bool ScreenZone_Update_Prefix(bool ___inZone, ScreenZone __instance)
		{
			if ((Object)(object)_cgTerminal != (Object)(object)__instance)
			{
				return true;
			}
			if ((Object)(object)_helper == (Object)null)
			{
				PreviewHelper helper = default(PreviewHelper);
				if (!((Component)__instance).TryGetComponent<PreviewHelper>(ref helper))
				{
					return true;
				}
				_helper = helper;
			}
			_helper.inZone = ___inZone;
			return true;
		}
	}
	[HarmonyPatch(typeof(SteamController))]
	public static class SteamControllerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(SteamController), "UpdateWave")]
		public static bool SteamController_UpdateWave_Prefix(int wave)
		{
			if (JukeboxMusicPlayer.CurrentSong == null || !MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.discordAndSteamIntegration", false))
			{
				return true;
			}
			if (!SteamClient.IsValid)
			{
				return false;
			}
			SteamFriends.SetRichPresence("wave", $"WAVE: {wave} | \ud83c\udfb5 {JukeboxMusicPlayer.CurrentSong.ArtistAndTrack}");
			return false;
		}
	}
}
namespace Jukebox.Input
{
	[ConfigureSingleton(/*Could not decode attribute arguments.*/)]
	public class JukeboxInputs : MonoSingleton<JukeboxInputs>
	{
		private InputActionMap jukeboxActionMap;

		public InputAction Menu { get; private set; }

		public InputAction Playback { get; private set; }

		public InputAction NextTrack { get; private set; }

		public InputAction RandomTrack { get; private set; }

		public InputAction DisablePlayer { get; private set; }

		public void Awake()
		{
			jukeboxActionMap = MonoSingleton<InputManager>.Instance.InputSource.Actions.asset.FindActionMap("Jukebox", false);
			Menu = jukeboxActionMap.FindAction("Jukebox Menu", false);
			Playback = jukeboxActionMap.FindAction("Playback Menu", false);
			NextTrack = jukeboxActionMap.FindAction("Next Track", false);
			RandomTrack = jukeboxActionMap.FindAction("Random Track", false);
			DisablePlayer = jukeboxActionMap.FindAction("Disable Player", false);
		}
	}
}
namespace Jukebox.Components
{
	public class CybergrindEffectsChanger : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass19_0
		{
			public AudioSource terminalMusic;

			internal void <PrepareTerminalMusic>b__0(AudioClip clip)
			{
				terminalMusic.Stop();
				terminalMusic.volume = 1f;
				terminalMusic.clip = clip;
				terminalMusic.Play();
			}
		}

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

			private object <>2__current;

			public FileSystemInfo path;

			public Action<AudioClip> callback;

			private DownloadHandlerAudioClip <handler>5__2;

			private UnityWebRequest <wr>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Expected O, but got Unknown
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Expected O, but got Unknown
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<handler>5__2 = new DownloadHandlerAudioClip(new Uri(path.FullName).AbsoluteUri, CustomMusicFileBrowser.extensionTypeDict[path.Extension.ToLower()]);
						<wr>5__3 = new UnityWebRequest(new Uri(path.FullName).AbsoluteUri, "GET", (DownloadHandler)(object)<handler>5__2, (UploadHandler)null);
						<>1__state = -3;
						<>2__current = <wr>5__3.SendWebRequest();
						<>1__state = 1;
						result = true;
						break;
					case 1:
						<>1__state = -3;
						if (<wr>5__3.responseCode == 200)
						{
							callback(<handler>5__2.audioClip);
						}
						result = false;
						<>m__Finally1();
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<wr>5__3 != null)
				{
					((IDisposable)<wr>5__3).Dispose();
				}
			}

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

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

			private object <>2__current;

			public CybergrindEffectsChanger <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				CybergrindEffectsChanger CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = CS$<>8__locals0.PrepareClip(CS$<>8__locals0.prefsManager.GetStringLocal("jukebox.effects.aww", (string)null), delegate(AudioClip clip)
					{
						CS$<>8__locals0.crowdReactions.aww = clip;
					}, CS$<>8__locals0.awwDefault);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public string path;

			public CybergrindEffectsChanger <>4__this;

			public Action<AudioClip> callback;

			public AudioClip fallback;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				CybergrindEffectsChanger cybergrindEffectsChanger = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (path != null)
					{
						<>2__current = cybergrindEffectsChanger.Download(new FileInfo(path), callback);
						<>1__state = 1;
						return true;
					}
					callback(fallback);
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

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

			private object <>2__current;

			public CybergrindEffectsChanger <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				CybergrindEffectsChanger cybergrindEffectsChanger = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = cybergrindEffectsChanger.PrepareClip(cybergrindEffectsChanger.prefsManager.GetStringLocal("jukebox.effects.gameover", (string)null), delegate(AudioClip clip)
					{
						EndMusicAudioSource.clip = clip;
					}, cybergrindEffectsChanger.gameOverDefault);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public CybergrindEffectsChanger <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				CybergrindEffectsChanger CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = CS$<>8__locals0.PrepareClip(CS$<>8__locals0.prefsManager.GetStringLocal("jukebox.effects.parry", (string)null), delegate(AudioClip clip)
					{
						CS$<>8__locals0.crowdReactions.cheer = clip;
					}, CS$<>8__locals0.cheerDefault);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public CybergrindEffectsChanger <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				CybergrindEffectsChanger cybergrindEffectsChanger = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>c__DisplayClass19_0 CS$<>8__locals0 = new <>c__DisplayClass19_0
					{
						terminalMusic = MenuMusicAudioSource
					};
					<>2__current = cybergrindEffectsChanger.PrepareClip(cybergrindEffectsChanger.prefsManager.GetStringLocal("jukebox.effects.terminal-music", (string)null), delegate(AudioClip clip)
					{
						CS$<>8__locals0.terminalMusic.Stop();
						CS$<>8__locals0.terminalMusic.volume = 1f;
						CS$<>8__locals0.terminalMusic.clip = clip;
						CS$<>8__locals0.terminalMusic.Play();
					}, cybergrindEffectsChanger.terminalMusicDefault);
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public CybergrindEffectsChanger <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				CybergrindEffectsChanger CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = CS$<>8__locals0.PrepareClip(CS$<>8__locals0.prefsManager.GetStringLocal("jukebox.effects.wavecomplete", (string)null), delegate(AudioClip clip)
					{
						CS$<>8__locals0.crowdReactions.cheerLong = clip;
					}, CS$<>8__locals0.cheerLongDefault);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public CybergrindEffectsChanger <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				CybergrindEffectsChanger cybergrindEffectsChanger = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = cybergrindEffectsChanger.PrepareParrySfx();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = cybergrindEffectsChanger.PrepareWaveCompleteSfx();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = cybergrindEffectsChanger.PrepareAwwSfx();
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = cybergrindEffectsChanger.PrepareGameOverSfx();
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = cybergrindEffectsChanger.PrepareTerminalMusic();
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					return false;
				}
			}

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

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

		private const string TerminalPath = "/FirstRoom/Room/Cybergrind Shop/Music";

		private CrowdReactions crowdReactions;

		private PrefsManager prefsManager;

		private AudioClip awwDefault;

		private AudioClip cheerDefault;

		private AudioClip cheerLongDefault;

		private AudioClip terminalMusicDefault;

		private AudioClip gameOverDefault;

		private static AudioSource EndMusicAudioSource
		{
			get
			{
				//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)
				Scene activeScene = SceneManager.GetActiveScene();
				return ((Scene)(ref activeScene)).GetRootGameObjects().First((GameObject o) => ((Object)o).name == "EndMusic").GetComponent<AudioSource>();
			}
		}

		private static AudioSource MenuMusicAudioSource => GameObject.Find("/FirstRoom/Room/Cybergrind Shop/Music").GetComponent<AudioSource>();

		private void Awake()
		{
			crowdReactions = MonoSingleton<CrowdReactions>.Instance;
			prefsManager = MonoSingleton<PrefsManager>.Instance;
			awwDefault = Object.Instantiate<AudioClip>(crowdReactions.aww, ((Component)this).gameObject.transform);
			cheerDefault = Object.Instantiate<AudioClip>(crowdReactions.cheer, ((Component)this).gameObject.transform);
			cheerLongDefault = Object.Instantiate<AudioClip>(crowdReactions.cheerLong, ((Component)this).gameObject.transform);
			terminalMusicDefault = Object.Instantiate<AudioClip>(MenuMusicAudioSource.clip, ((Component)this).gameObject.transform);
			gameOverDefault = Object.Instantiate<AudioClip>(EndMusicAudioSource.clip, ((Component)this).gameObject.transform);
			((MonoBehaviour)this).StartCoroutine(Setup());
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Combine(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
		}

		private void OnDestroy()
		{
			PrefsManager.onPrefChanged = (Action<string, object>)Delegate.Remove(PrefsManager.onPrefChanged, new Action<string, object>(OnPrefChanged));
		}

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

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

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

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

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

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

		[IteratorStateMachine(typeof(<PrepareClip>d__20))]
		private IEnumerator PrepareClip(string path, Action<AudioClip> callback, AudioClip fallback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PrepareClip>d__20(0)
			{
				<>4__this = this,
				path = path,
				callback = callback,
				fallback = fallback
			};
		}

		[IteratorStateMachine(typeof(<Download>d__21))]
		private IEnumerator Download(FileSystemInfo path, Action<AudioClip> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Download>d__21(0)
			{
				path = path,
				callback = callback
			};
		}

		private void OnPrefChanged(string key, object value)
		{
			switch (key)
			{
			case "jukebox.effects.wavecomplete":
				((MonoBehaviour)this).StartCoroutine(PrepareWaveCompleteSfx());
				break;
			case "jukebox.effects.aww":
				((MonoBehaviour)this).StartCoroutine(PrepareAwwSfx());
				break;
			case "jukebox.effects.gameover":
				((MonoBehaviour)this).StartCoroutine(PrepareGameOverSfx());
				break;
			case "jukebox.effects.terminal-music":
				((MonoBehaviour)this).StartCoroutine(PrepareTerminalMusic());
				break;
			case "jukebox.effects.parry":
				ReflectionUtils.GetPrivate<AudioSource>(crowdReactions, typeof(CrowdReactions), "aud").Stop();
				((MonoBehaviour)this).StartCoroutine(PrepareParrySfx());
				break;
			}
		}
	}
	public class JukeboxEffectsBrowser : DirectoryTreeBrowser<FileInfo>
	{
		private static readonly DirectoryInfo EffectsDirectory = new DirectoryInfo(Path.Combine(PathsUtils.ApplicationPath, "Cybergrind", "Effects"));

		[SerializeField]
		private JukeboxTerminalPanel navigator;

		[SerializeField]
		private GameObject effectsMenu;

		private string currentPrefKey;

		protected override int maxPageLength => 3;

		protected override IDirectoryTree<FileInfo> baseDirectory => (IDirectoryTree<FileInfo>)new FileDirectoryTree(EffectsDirectory, (IDirectoryTree<FileInfo>)null);

		public void NextPage()
		{
			base.SetPage((base.currentPage != base.maxPages - 1) ? (base.currentPage + 1) : 0);
		}

		public void PreviousPage()
		{
			base.SetPage((base.currentPage == 0) ? (base.maxPages - 1) : (base.currentPage - 1));
		}

		public void SetCurrentPrefKey(string key)
		{
			currentPrefKey = key;
		}

		public void ResetToDefault()
		{
			MonoSingleton<PrefsManager>.Instance.SetStringLocal(currentPrefKey, (string)null);
		}

		protected override Action BuildLeaf(FileInfo item, int indexInPage)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			GameObject go = Object.Instantiate<GameObject>(base.itemButtonTemplate, base.itemParent);
			CustomContentButton component = go.GetComponent<CustomContentButton>();
			component.text.text = item.Name;
			go.SetActive(true);
			((UnityEvent)component.button.onClick).AddListener((UnityAction)delegate
			{
				MonoSingleton<PrefsManager>.Instance.SetStringLocal(currentPrefKey, item.FullName);
				navigator.GoToNoMenu(effectsMenu);
			});
			return delegate
			{
				Object.Destroy((Object)(object)go);
			};
		}

		public void OpenEffectsFolder()
		{
			Application.OpenURL(new Uri(EffectsDirectory.FullName).AbsoluteUri);
		}

		public override void Rebuild(bool setToPageZero = true)
		{
			Transform itemParent = base.itemParent;
			LayoutRebuilder.ForceRebuildLayoutImmediate((RectTransform)(object)((itemParent is RectTransform) ? itemParent : null));
			base.Rebuild(setToPageZero);
		}
	}
	public class JukeboxMusicChanger : MonoBehaviour
	{
		private enum ThemeVariation
		{
			Battle,
			Calm
		}

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

			private object <>2__current;

			public JukeboxMusicChanger <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Expected O, but got Unknown
				int num = <>1__state;
				JukeboxMusicChanger jukeboxMusicChanger = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
				}
				else
				{
					<>1__state = -1;
				}
				if (CalmThemesAllowed && jukeboxMusicChanger.themesManager.FewEnemies)
				{
					jukeboxMusicChanger.PlayCalmTheme();
				}
				else
				{
					jukeboxMusicChanger.PlayBattleTheme();
				}
				<>2__current = (object)new WaitForSecondsRealtime(0.1f);
				<>1__state = 1;
				return true;
			}

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

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

		private const int FadeSpeed = 1;

		public AudioSource clean;

		public AudioSource battle;

		private JukeboxThemesManager themesManager;

		private Coroutine updateRoutine;

		private ThemeVariation currentTheme;

		private static bool CalmThemesAllowed => MonoSingleton<PrefsManager>.Instance.GetBoolLocal("jukebox.enableCalmThemes", false);

		public void Awake()
		{
			themesManager = MonoSingleton<JukeboxThemesManager>.Instance;
		}

		private void Update()
		{
			if (!((Object)(object)clean.clip == (Object)null))
			{
				if (currentTheme == ThemeVariation.Calm)
				{
					clean.volume = Mathf.MoveTowards(clean.volume, 1f, 1f * Time.deltaTime);
					battle.volume = Mathf.MoveTowards(battle.volume, 0f, 1f * Time.deltaTime);
				}
				else
				{
					clean.volume = Mathf.MoveTowards(clean.volume, 0f, 1f * Time.deltaTime);
					battle.volume = Mathf.MoveTowards(battle.volume, 1f, 1f * Time.deltaTime);
				}
			}
		}

		public void ChangeTo(AudioClip battleTheme, AudioClip calmTheme, float startingFrom = 0f)
		{
			if (updateRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(updateRoutine);
			}
			clean.clip = calmTheme;
			battle.clip = battleTheme;
			battle.Play();
			battle.time = startingFrom;
			battle.volume = 1f;
			if ((Object)(object)clean.clip != (Object)null)
			{
				clean.Play();
				clean.time = startingFrom;
				if (CalmThemesAllowed && themesManager.FewEnemies)
				{
					clean.volume = 1f;
					battle.volume = 0f;
				}
			}
			updateRoutine = ((MonoBehaviour)this).StartCoroutine(SlowUpdate());
		}

		public void RewindTo(float position = 0f)
		{
			clean.time = Math.Min(position, ((Object)(object)clean.clip != (Object)null) ? clean.clip.length : 0f);
			battle.time = Math.Min(position, ((Object)(object)battle.clip != (Object)null) ? battle.clip.length : 0f);
		}

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

		private void PlayBattleTheme()
		{
			if (currentTheme != 0)
			{
				currentTheme = ThemeVariation.Battle;
				if ((Object)(object)clean.clip != (Object)null)
				{
					battle.timeSamples = clean.timeSamples;
				}
			}
		}

		private void PlayCalmTheme()
		{
			if (currentTheme != ThemeVariation.Calm)
			{
				currentTheme = ThemeVariation.Calm;
				if ((Object)(object)clean.clip != (Object)null)
				{
					clean.timeSamples = battle.timeSamples;
				}
			}
		}
	}
	[ConfigureSingleton(/*Could not decode attribute arguments.*/)]
	public class JukeboxThemesManager : MonoSingleton<