using System;
using System.Collections;
using System.Collections.Generic;
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 System.Security.Cryptography;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using DamienG.Security.Cryptography;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using YPlay.NetcodePatcher;
using YPlay.controller;
using YPlay.cruiser;
using YPlayUtil;
using YPlayUtil.Helpers;
using YPlayUtil.Metadata;
using YPlayUtil.Options;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("YPlay")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("YPlay")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("a9e02c48-30aa-4cf0-bbce-b71de7f55747")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace DamienG.Security.Cryptography
{
	public sealed class Crc32 : HashAlgorithm
	{
		public const uint DefaultPolynomial = 3988292384u;

		public const uint DefaultSeed = uint.MaxValue;

		private static uint[] defaultTable;

		private readonly uint seed;

		private readonly uint[] table;

		private uint hash;

		public override int HashSize => 32;

		public Crc32()
			: this(3988292384u, uint.MaxValue)
		{
		}

		public Crc32(uint polynomial, uint seed)
		{
			if (!BitConverter.IsLittleEndian)
			{
				throw new PlatformNotSupportedException("Not supported on Big Endian processors");
			}
			table = InitializeTable(polynomial);
			this.seed = (hash = seed);
		}

		public override void Initialize()
		{
			hash = seed;
		}

		protected override void HashCore(byte[] array, int ibStart, int cbSize)
		{
			hash = CalculateHash(table, hash, array, ibStart, cbSize);
		}

		protected override byte[] HashFinal()
		{
			return HashValue = UInt32ToBigEndianBytes(~hash);
		}

		public static uint Compute(byte[] buffer)
		{
			return Compute(uint.MaxValue, buffer);
		}

		public static uint Compute(uint seed, byte[] buffer)
		{
			return Compute(3988292384u, seed, buffer);
		}

		public static uint Compute(uint polynomial, uint seed, byte[] buffer)
		{
			return ~CalculateHash(InitializeTable(polynomial), seed, buffer, 0, buffer.Length);
		}

		private static uint[] InitializeTable(uint polynomial)
		{
			if (polynomial == 3988292384u && defaultTable != null)
			{
				return defaultTable;
			}
			uint[] array = new uint[256];
			for (int i = 0; i < 256; i++)
			{
				uint num = (uint)i;
				for (int j = 0; j < 8; j++)
				{
					num = (((num & 1) != 1) ? (num >> 1) : ((num >> 1) ^ polynomial));
				}
				array[i] = num;
			}
			if (polynomial == 3988292384u)
			{
				defaultTable = array;
			}
			return array;
		}

		private static uint CalculateHash(uint[] table, uint seed, IList<byte> buffer, int start, int size)
		{
			uint num = seed;
			for (int i = start; i < start + size; i++)
			{
				num = (num >> 8) ^ table[buffer[i] ^ (num & 0xFF)];
			}
			return num;
		}

		private static byte[] UInt32ToBigEndianBytes(uint uint32)
		{
			byte[] bytes = BitConverter.GetBytes(uint32);
			if (BitConverter.IsLittleEndian)
			{
				Array.Reverse((Array)bytes);
			}
			return bytes;
		}
	}
}
namespace YPlay
{
	internal class AudioLoader : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <GetAudioClip>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string path;

			public bool resync;

			public Controller controller;

			public int requestId;

			private string <filenameId>5__2;

			private bool <success>5__3;

			private AudioClip <audioClip>5__4;

			private UnityWebRequest <unityWebRequest>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<filenameId>5__2 = null;
				<audioClip>5__4 = null;
				<unityWebRequest>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Invalid comparison between Unknown and I4
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_0147: Invalid comparison between Unknown and I4
				try
				{
					bool flag;
					bool flag2;
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<filenameId>5__2 = Path.GetFileNameWithoutExtension(path);
						flag = false;
						<success>5__3 = false;
						if (FilenameIdAudioClips.ContainsKey(<filenameId>5__2))
						{
							<audioClip>5__4 = FilenameIdAudioClips[<filenameId>5__2];
							if (AudioClipLoadedInMemory(<audioClip>5__4))
							{
								<>2__current = null;
								<>1__state = 1;
								return true;
							}
							FilenameIdAudioClips.Remove(<filenameId>5__2);
							goto IL_00bf;
						}
						goto IL_00c6;
					case 1:
						<>1__state = -1;
						SetAudio(<filenameId>5__2, <audioClip>5__4);
						flag = true;
						<success>5__3 = true;
						goto IL_00bf;
					case 2:
						{
							<>1__state = -3;
							if ((int)<unityWebRequest>5__5.result == 1)
							{
								AudioClip content = DownloadHandlerAudioClip.GetContent(<unityWebRequest>5__5);
								if (AudioClipLoadedInMemory(content))
								{
									((Object)content).name = (AudioDownloader.AudioIdTitles.ContainsKey(<filenameId>5__2) ? AudioDownloader.AudioIdTitles[<filenameId>5__2] : null);
									SetAudio(<filenameId>5__2, content);
									<success>5__3 = true;
								}
							}
							<>m__Finally1();
							<unityWebRequest>5__5 = null;
							break;
						}
						IL_00c6:
						flag2 = AudioDownloader.IsFilenameIdDownloaded(<filenameId>5__2);
						if (!flag && flag2)
						{
							if (FilenameIdsDownloaded.Contains(<filenameId>5__2))
							{
								FilenameIdsDownloaded.Remove(<filenameId>5__2);
							}
							FilenameIdsDownloaded.Insert(0, <filenameId>5__2);
							AudioType audioType = AudioDownloader.AudioType;
							<unityWebRequest>5__5 = UnityWebRequestMultimedia.GetAudioClip(path, audioType);
							<>1__state = -3;
							((DownloadHandlerAudioClip)<unityWebRequest>5__5.downloadHandler).streamAudio = (int)audioType == 13;
							<>2__current = <unityWebRequest>5__5.SendWebRequest();
							<>1__state = 2;
							return true;
						}
						break;
						IL_00bf:
						<audioClip>5__4 = null;
						goto IL_00c6;
					}
					if (!<success>5__3)
					{
						string text = "Error " + (resync ? "resyncing" : "loading") + " request " + AudioDownloader.GetFilenameIdString(<filenameId>5__2);
						YPlay.LogWarning(text);
						Patch.AddChatMessage(text);
					}
					controller.SendLoadedServerDelegate(requestId, <success>5__3, resync);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

		internal static readonly Dictionary<string, AudioClip> FilenameIdAudioClips = new Dictionary<string, AudioClip>();

		internal static readonly List<string> FilenameIdsDownloaded = new List<string>();

		private static AudioLoader Instance;

		internal void Start(IEnumerator routine)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = new GameObject(typeof(AudioLoader).Name).AddComponent<AudioLoader>();
				Object.DontDestroyOnLoad((Object)(object)Instance);
			}
			((MonoBehaviour)Instance).StartCoroutine(routine);
		}

		[IteratorStateMachine(typeof(<GetAudioClip>d__4))]
		internal IEnumerator GetAudioClip(Controller controller, int requestId, string path, bool resync)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAudioClip>d__4(0)
			{
				controller = controller,
				requestId = requestId,
				path = path,
				resync = resync
			};
		}

		internal static void UnloadAudioClips()
		{
			foreach (KeyValuePair<string, AudioClip> item in new Dictionary<string, AudioClip>(FilenameIdAudioClips))
			{
				AudioClip value = item.Value;
				string key = item.Key;
				value.UnloadAudioData();
				FilenameIdAudioClips.Remove(key);
			}
		}

		private static bool AudioClipLoadedInMemory(AudioClip audioClip)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			if (Object.op_Implicit((Object)(object)audioClip) && audioClip.LoadAudioData())
			{
				return (int)audioClip.loadState == 2;
			}
			return false;
		}

		private static void SetAudio(string filenameId, AudioClip audioClip)
		{
			FilenameIdAudioClips[filenameId] = audioClip;
			Patch.AddChatMessage("Loaded " + AudioDownloader.GetFilenameIdString(filenameId));
		}
	}
	internal class AudioDownloader
	{
		[CompilerGenerated]
		private Controller <controller>P;

		internal static bool CanChangeSync = Patch.IsHost;

		internal static HashSet<string> FilenameIdsResyncing = new HashSet<string>();

		internal static readonly Dictionary<string, string> AudioIdTitles = new Dictionary<string, string>();

		private static readonly Dictionary<string, int> AudioIdDurations = new Dictionary<string, int>();

		internal int lastDownloadRequestId;

		internal string lastDownloadRequestFilenameId;

		private readonly AudioLoader audioLoader;

		private AudioAction audioAction;

		internal static AudioType AudioType = (AudioType)13;

		internal static readonly OptionSet OverrideOptions;

		public AudioDownloader(Controller controller)
		{
			<controller>P = controller;
			lastDownloadRequestId = -1;
			audioLoader = new AudioLoader();
			base..ctor();
		}

		internal async void DownloadTask(int requestId, string filenameId, string title, int duration, string url, float time, bool resync = false)
		{
			if (CanChangeSync)
			{
				CanChangeSync = false;
			}
			if (string.IsNullOrEmpty(filenameId?.Trim()) || string.IsNullOrEmpty(title?.Trim()) || string.IsNullOrEmpty(url?.Trim()))
			{
				Patch.AddChatMessage("Invalid " + (resync ? "resync" : "download") + " request");
				return;
			}
			if (resync)
			{
				FilenameIdsResyncing.Add(filenameId);
			}
			lastDownloadRequestId = requestId;
			lastDownloadRequestFilenameId = filenameId;
			time = Mathf.Max(time, 0f);
			REQUEST_STATUS requestStatusError = REQUEST_STATUS.NONE;
			string error = null;
			AudioIdTitles[filenameId] = title;
			AudioIdDurations[filenameId] = duration;
			string filenameIdString = GetFilenameIdString(filenameId);
			await Task.Run(delegate
			{
				string outputFileLocationForId = GetOutputFileLocationForId(filenameId);
				CancelCurrentProcess();
				if (IsFilenameLoaded(filenameId))
				{
					requestStatusError = LoadFile(filenameId, outputFileLocationForId, requestId, resync);
				}
				else if (!YPlay.IsYPlayUtilValid())
				{
					requestStatusError = REQUEST_STATUS.ERROR_UTIL_MISSING_DEPENDENCY;
					error = "Missing dependency, please try reinstalling YPlayBoombox";
				}
				else if (YPlay.IsDownloadingTools())
				{
					requestStatusError = REQUEST_STATUS.ERROR_UTIL_DOWNLOADING_TOOLS;
					error = "Downloading tools...";
				}
				else if (!YPlay.IsToolsExistAndNonEmpty())
				{
					requestStatusError = REQUEST_STATUS.ERROR_INVALID_TOOLS;
					error = "Invalid tools, please try /yp reset-tools";
				}
				else
				{
					audioAction = new AudioAction(this, requestId, filenameId, outputFileLocationForId, url);
					requestStatusError = audioAction.Start(resync);
					switch (requestStatusError)
					{
					case REQUEST_STATUS.ERROR_CLIENT_DOWNLOAD:
						error = "Error downloading request " + filenameIdString;
						break;
					case REQUEST_STATUS.ERROR_CLIENT_DOWNLOAD_EXCEPTION:
						error = "Error downloading request (exception) " + filenameIdString;
						break;
					case REQUEST_STATUS.ERROR_CLIENT_LOAD:
						error = "Error loading request " + filenameIdString;
						break;
					case REQUEST_STATUS.ERROR_METADATA_AGE_RESTRICTED:
						error = "Error downloading request (no access - age restricted) " + filenameIdString;
						break;
					case REQUEST_STATUS.ERROR_METADATA_BOT:
						error = "Error downloading request (no access - bot) " + filenameIdString;
						break;
					case REQUEST_STATUS.ERROR_METADATA_SIGN_IN:
						error = "Error downloading request (no access) " + filenameIdString;
						break;
					case REQUEST_STATUS.ERROR_METADATA_VIDEO_UNAVAILABLE:
						error = "Error downloading request (video unavailable) " + filenameIdString;
						break;
					}
				}
			});
			if (requestStatusError != 0)
			{
				<controller>P.SendLoadedServerDelegate(requestId, loaded: false, resync, requestStatusError);
				if (string.IsNullOrEmpty(error))
				{
					error = "Error downloading request " + filenameIdString;
				}
				YPlay.LogError(error);
				Patch.AddChatMessage(error);
			}
			FilenameIdsResyncing.Remove(filenameId);
		}

		internal void CancelCurrentProcess()
		{
			if (audioAction != null && audioAction.actionState == ACTION_STATE.PROCESSING)
			{
				audioAction.KillProcess();
				Patch.AddChatMessage("Previous process canceled " + GetFilenameIdString(audioAction.filenameId));
			}
		}

		internal void KillRequestId(int requestId)
		{
			if (audioAction != null && audioAction.requestId == requestId)
			{
				CancelCurrentProcess();
			}
		}

		internal async Task DownloadMetadata(RequestMetadata requestMetadata, string url, string filenameId, float time)
		{
			await Task.Run(delegate
			{
				REQUEST_STATUS rEQUEST_STATUS = REQUEST_STATUS.NONE;
				if (string.IsNullOrEmpty(url?.Trim()) || string.IsNullOrEmpty(filenameId?.Trim()))
				{
					rEQUEST_STATUS = REQUEST_STATUS.ERROR_METADATA;
				}
				else if (!YPlay.IsYPlayUtilValid())
				{
					rEQUEST_STATUS = REQUEST_STATUS.ERROR_UTIL_MISSING_DEPENDENCY;
				}
				else if (YPlay.IsDownloadingTools())
				{
					rEQUEST_STATUS = REQUEST_STATUS.ERROR_UTIL_DOWNLOADING_TOOLS;
				}
				else if (!YPlay.IsToolsExistAndNonEmpty())
				{
					rEQUEST_STATUS = REQUEST_STATUS.ERROR_INVALID_TOOLS;
				}
				if (rEQUEST_STATUS != 0)
				{
					requestMetadata.requestStatus = rEQUEST_STATUS;
				}
				else
				{
					string text = (AudioIdTitles.ContainsKey(filenameId) ? AudioIdTitles[filenameId] : null);
					int num = (AudioIdDurations.ContainsKey(filenameId) ? AudioIdDurations[filenameId] : 0);
					if (!IsMetadataLoadedForFilenameId(filenameId))
					{
						REQUEST_STATUS rEQUEST_STATUS2;
						(text, num, rEQUEST_STATUS2) = GetAudioTitleDuration(url);
						if (rEQUEST_STATUS2 != 0)
						{
							requestMetadata.requestStatus = rEQUEST_STATUS2;
							return;
						}
						if (string.IsNullOrEmpty(text?.Trim()) || num == 0)
						{
							requestMetadata.requestStatus = REQUEST_STATUS.ERROR_METADATA;
							return;
						}
						AudioIdTitles[filenameId] = text;
						AudioIdDurations[filenameId] = num;
					}
					int num2 = num / 60;
					if (num2 > 12)
					{
						requestMetadata.requestStatus = REQUEST_STATUS.ERROR_METADATA_MAX_DURATION;
					}
					else if (string.IsNullOrEmpty(text?.Trim()) || num == 0)
					{
						requestMetadata.requestStatus = REQUEST_STATUS.ERROR_METADATA;
					}
					else
					{
						requestMetadata.filenameId = filenameId;
						requestMetadata.url = url;
						requestMetadata.time = time;
						requestMetadata.title = text;
						requestMetadata.duration = num;
						if (requestMetadata.requestStatus != REQUEST_STATUS.REQUEST_CANCELED)
						{
							requestMetadata.requestStatus = REQUEST_STATUS.REQUEST_VALID;
						}
					}
				}
			});
		}

		private (string title, int duration, REQUEST_STATUS requestStatus) GetAudioTitleDuration(string url)
		{
			YoutubeDL val = YPlay.NewYoutubeDl();
			string text = "";
			int item = 0;
			REQUEST_STATUS rEQUEST_STATUS = REQUEST_STATUS.NONE;
			try
			{
				OptionSet overrideOptions = OverrideOptions;
				RunResult<VideoData> result = val.RunVideoDataFetch(url, default(CancellationToken), true, false, overrideOptions).GetAwaiter().GetResult();
				if (result != null)
				{
					string[] errorOutput = result.ErrorOutput;
					if (errorOutput != null && errorOutput.Length != 0)
					{
						string[] errorOutput2 = result.ErrorOutput;
						foreach (string text2 in errorOutput2)
						{
							YPlay.LogError("[yt-dlp] " + text2);
							rEQUEST_STATUS = GetRequestStatusDownloadError(text2);
							if (rEQUEST_STATUS != 0)
							{
								break;
							}
						}
						if (rEQUEST_STATUS == REQUEST_STATUS.NONE)
						{
							Patch.AddChatMessage("Metadata error, please check the console");
							rEQUEST_STATUS = REQUEST_STATUS.ERROR_METADATA;
						}
					}
					else
					{
						VideoData data = result.Data;
						text = data.Title;
						item = (int)data.Duration.GetValueOrDefault();
					}
				}
			}
			catch (Exception ex)
			{
				REQUEST_STATUS item2;
				if (Patch.StringContainsLowerCase(ex.Message, "canceled"))
				{
					item2 = REQUEST_STATUS.REQUEST_CANCELED;
				}
				else
				{
					YPlay.LogError("[yt-dlp] " + ex.Message);
					Patch.AddChatMessage("Metadata exception, please check the console");
					item2 = REQUEST_STATUS.ERROR_METADATA_EXCEPTION;
				}
				return ("", 0, item2);
			}
			if (string.IsNullOrEmpty(text?.Trim()))
			{
				text = GetFilenameIdFromUrl(url);
			}
			return (text, item, rEQUEST_STATUS);
		}

		internal REQUEST_STATUS LoadFile(string filenameId, string outputFileLocation, int requestId, bool resync)
		{
			if (IsFilenameLoaded(filenameId))
			{
				audioLoader.Start(audioLoader.GetAudioClip(<controller>P, requestId, outputFileLocation, resync));
				return REQUEST_STATUS.NONE;
			}
			return REQUEST_STATUS.ERROR_CLIENT_LOAD;
		}

		private bool IsFilenameLoaded(string filenameId)
		{
			if (!string.IsNullOrEmpty(filenameId?.Trim()))
			{
				if (!IsFilenameIdDownloaded(filenameId))
				{
					return AudioLoader.FilenameIdAudioClips.ContainsKey(filenameId);
				}
				return true;
			}
			return false;
		}

		internal static bool IsFilenameIdDownloaded(string filenameId)
		{
			if (!string.IsNullOrEmpty(filenameId?.Trim()))
			{
				return IsFileValid(GetOutputFileLocationForId(filenameId));
			}
			return false;
		}

		internal static bool IsFileValid(string path)
		{
			if (File.Exists(path))
			{
				return new FileInfo(path).Length > 0;
			}
			return false;
		}

		internal static bool IsMetadataLoadedForFilenameId(string filenameId)
		{
			if (!string.IsNullOrEmpty(filenameId?.Trim()) && AudioIdTitles.ContainsKey(filenameId))
			{
				return AudioIdDurations.ContainsKey(filenameId);
			}
			return false;
		}

		internal static string GetFilenameIdFromUrl(string url)
		{
			if (string.IsNullOrEmpty(url?.Trim()))
			{
				return null;
			}
			url = url.Replace("https://", "").Replace("http://", "").Replace("www.", "");
			string text = null;
			int num = url.IndexOf("?v=", StringComparison.OrdinalIgnoreCase);
			int num2 = url.IndexOf("&v=", StringComparison.OrdinalIgnoreCase);
			int num3 = url.IndexOf("/shorts/", StringComparison.OrdinalIgnoreCase);
			int num4 = url.IndexOf("/", StringComparison.OrdinalIgnoreCase);
			if (num > -1)
			{
				text = url.Substring(num + "?v=".Length);
			}
			else if (num2 > -1)
			{
				text = url.Substring(num2 + "&v=".Length);
			}
			else if (num3 > -1)
			{
				text = url.Substring(num3 + "/shorts/".Length);
			}
			else if (num4 > -1)
			{
				text = url.Substring(num4 + "/".Length);
			}
			if (!string.IsNullOrEmpty(text?.Trim()))
			{
				int num5 = text.IndexOf("&", StringComparison.OrdinalIgnoreCase);
				if (num5 > -1)
				{
					text = text.Substring(0, num5);
				}
				int num6 = text.IndexOf("?", StringComparison.OrdinalIgnoreCase);
				if (num6 > -1)
				{
					text = text.Substring(0, num6);
				}
			}
			if (text == null)
			{
				return null;
			}
			string text2 = text.Trim();
			if (text2.Length == 11)
			{
				return text2;
			}
			return null;
		}

		internal static void KillAllBoomboxDownloaderProcesses()
		{
			foreach (KeyValuePair<ulong, BoomboxController> item in new Dictionary<ulong, BoomboxController>(BoomboxController.BoomboxControllers))
			{
				BoomboxController value = item.Value;
				value.audioDownloader.CancelCurrentProcess();
			}
		}

		internal static string GetOutputFileLocationWithoutExtensionForId(string id)
		{
			return YPlay.AudioDirectory + "\\" + id;
		}

		internal static string GetOutputFileLocationTempForId(string id)
		{
			return GetOutputFileLocationWithoutExtensionForId(id) + ".part";
		}

		internal static string GetOutputFileLocationForId(string id)
		{
			return GetOutputFileLocationWithoutExtensionForId(id) + "." + GetFileExtension();
		}

		internal static string GetFilenameIdString(string filenameId)
		{
			if (string.IsNullOrEmpty(filenameId?.Trim()))
			{
				return null;
			}
			return "[" + filenameId + "]";
		}

		internal static string GetFileExtension()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)AudioType != 20)
			{
				return "mp3";
			}
			return "wav";
		}

		internal static REQUEST_STATUS GetRequestStatusDownloadError(string s)
		{
			if (s != null)
			{
				if (Patch.StringContainsLowerCase(s, "sign in"))
				{
					if (Patch.StringContainsLowerCase(s, "age"))
					{
						return REQUEST_STATUS.ERROR_METADATA_AGE_RESTRICTED;
					}
					if (Patch.StringContainsLowerCase(s, "bot"))
					{
						return REQUEST_STATUS.ERROR_METADATA_BOT;
					}
					return REQUEST_STATUS.ERROR_METADATA_SIGN_IN;
				}
				if (Patch.StringContainsLowerCase(s, "video unavailable"))
				{
					return REQUEST_STATUS.ERROR_METADATA_VIDEO_UNAVAILABLE;
				}
			}
			return REQUEST_STATUS.NONE;
		}

		static AudioDownloader()
		{
			//IL_002a: 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_0035: Expected O, but got Unknown
			OptionSet val = new OptionSet();
			val.FfmpegLocation = YPlay.FfmpegLocation;
			val.NoPlaylist = true;
			val.ForceIPv4 = true;
			val.NoRestrictFilenames = true;
			val.WindowsFilenames = true;
			val.Format = "140";
			val.PostprocessorArgs = MultiValue<string>.op_Implicit(new string[1] { "ffmpeg:-filter:a dynaudnorm" });
			OverrideOptions = val;
		}
	}
	internal class AudioAction
	{
		internal ACTION_STATE actionState;

		private readonly AudioDownloader audioDownloader;

		internal int requestId;

		internal string filenameId;

		private readonly string outputFileLocation;

		private readonly string url;

		private readonly string tmpFile;

		private readonly string tmpFileWithExt;

		private readonly YoutubeDL youtubeDL;

		private readonly CancellationTokenSource cancellationTokenSource;

		internal AudioAction(AudioDownloader audioDownloader, int requestId, string filenameId, string outputFileLocation, string url)
		{
			this.audioDownloader = audioDownloader;
			this.requestId = requestId;
			this.filenameId = filenameId;
			this.outputFileLocation = outputFileLocation;
			this.url = url;
			tmpFile = YPlay.GetRandomTempFileLocation();
			tmpFileWithExt = tmpFile + "." + AudioDownloader.GetFileExtension();
			youtubeDL = YPlay.NewYoutubeDl();
			youtubeDL.OutputFileTemplate = tmpFile;
			cancellationTokenSource = new CancellationTokenSource();
		}

		internal REQUEST_STATUS Start(bool resync)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Invalid comparison between Unknown and I4
			if (resync)
			{
				Patch.AddChatMessage("Resyncing...");
			}
			Patch.AddChatMessage("Downloading " + AudioDownloader.GetFilenameIdString(filenameId) + "...");
			REQUEST_STATUS requestStatusError = REQUEST_STATUS.NONE;
			bool progressError = false;
			Progress<DownloadProgress> progress = new Progress<DownloadProgress>(delegate(DownloadProgress p)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Invalid comparison between Unknown and I4
				if ((int)p.State == 4 && p.Data != null && p.Data.Contains("ERROR") && !p.Data.Contains("Error opening output files") && !p.Data.Contains("Function not implemented"))
				{
					if (requestStatusError == REQUEST_STATUS.NONE)
					{
						requestStatusError = AudioDownloader.GetRequestStatusDownloadError(p.Data);
					}
					YPlay.LogError("[yt-dlp] " + p.Data);
					progressError = true;
				}
			});
			if (progressError)
			{
				Patch.AddChatMessage("Download error, please check the console");
			}
			try
			{
				RunResult<string> result = youtubeDL.RunAudioDownload(url, (AudioConversionFormat)(((int)AudioDownloader.AudioType == 20) ? 7 : 3), cancellationTokenSource.Token, (IProgress<DownloadProgress>)progress, (IProgress<string>)null, AudioDownloader.OverrideOptions).GetAwaiter().GetResult();
			}
			catch (Exception ex)
			{
				if (Patch.StringContainsLowerCase(ex.Message, "canceled"))
				{
					requestStatusError = REQUEST_STATUS.ERROR_CLIENT_DOWNLOAD_CANCELED;
				}
				else
				{
					YPlay.LogError("[yt-dlp] " + ex.Message);
					Patch.AddChatMessage("Download exception, please check the console");
					requestStatusError = REQUEST_STATUS.ERROR_CLIENT_DOWNLOAD_EXCEPTION;
				}
			}
			bool flag = actionState == ACTION_STATE.PROCESSING && audioDownloader.lastDownloadRequestId == requestId;
			if (flag && requestStatusError != 0)
			{
				KillProcess();
				DeleteRequestFiles();
				return requestStatusError;
			}
			try
			{
				if (flag)
				{
					if (!File.Exists(outputFileLocation))
					{
						if (!AudioDownloader.IsFileValid(tmpFileWithExt))
						{
							throw new Exception("Invalid temp file");
						}
						YPlay.CreateParentDirectory(outputFileLocation);
						File.Move(tmpFileWithExt, outputFileLocation);
					}
					actionState = ACTION_STATE.FINISHED;
					return audioDownloader.LoadFile(filenameId, outputFileLocation, requestId, resync);
				}
			}
			catch (Exception ex2)
			{
				YPlay.LogError(ex2.Message);
				KillProcess();
				return REQUEST_STATUS.ERROR_CLIENT_DOWNLOAD;
			}
			finally
			{
				DeleteRequestFiles();
			}
			return REQUEST_STATUS.NONE;
		}

		internal void KillProcess()
		{
			if (actionState == ACTION_STATE.PROCESSING)
			{
				actionState = ACTION_STATE.KILLED;
				try
				{
					cancellationTokenSource?.Cancel();
				}
				catch (Exception)
				{
				}
			}
			DeleteRequestFiles();
		}

		private void DeleteRequestFiles()
		{
			Task.Delay(3000).ContinueWith(delegate
			{
				YPlay.DeleteFile(tmpFile);
				YPlay.DeleteFile(tmpFileWithExt);
			});
		}
	}
	internal class BoomboxController : Controller
	{
		[CompilerGenerated]
		private sealed class <ColorPatternRainbow>d__32 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public BoomboxController <>4__this;

			private Color <color>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Expected O, but got Unknown
				int num = <>1__state;
				BoomboxController boomboxController = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					boomboxController.colorPattern = COLOR_PATTERN.RAINBOW;
					<color>5__2 = boomboxController.GetBoomboxBodyColor();
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (boomboxController.colorPattern == COLOR_PATTERN.RAINBOW && boomboxController.IsItemActive())
				{
					<color>5__2 = ColorShift(<color>5__2, 0.2f * Time.deltaTime);
					boomboxController.ChangeBoomboxColor(<color>5__2.r, <color>5__2.g, <color>5__2.b);
					<>2__current = (object)new WaitForSeconds(0.05f);
					<>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 <ColorPatternRandomLoop>d__31 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public BoomboxController <>4__this;

			public ulong clientId;

			private bool <msg>5__2;

			private int <i>5__3;

			private bool <randomTextColorsSent>5__4;

			private string <colorPatternString>5__5;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Expected O, but got Unknown
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				BoomboxController boomboxController = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					boomboxController.colorPattern = COLOR_PATTERN.RANDOM_LOOP;
					<msg>5__2 = true;
					<i>5__3 = 0;
					<randomTextColorsSent>5__4 = false;
					boomboxController.colorPatternRandomTextColors = new List<Color>();
					string text = "RANDOM";
					foreach (char c in text)
					{
						boomboxController.colorPatternRandomTextColors.Add(GetRandomBoomboxColor());
					}
					<colorPatternString>5__5 = boomboxController.GetColorPatternString(boomboxController.colorPattern);
					break;
				}
				case 1:
					<>1__state = -1;
					break;
				}
				if (boomboxController.colorPattern == COLOR_PATTERN.RANDOM_LOOP && boomboxController.IsItemActive())
				{
					if (!<randomTextColorsSent>5__4 && boomboxController.colorPatternRandomTextColors.Count > 0)
					{
						boomboxController.SyncBoomboxColor(boomboxController.colorPatternRandomTextColors[<i>5__3++], boomboxController.colorPattern, <colorPatternString>5__5, clientId, <msg>5__2);
						if (<i>5__3 >= boomboxController.colorPatternRandomTextColors.Count)
						{
							<randomTextColorsSent>5__4 = true;
						}
					}
					else
					{
						boomboxController.SyncBoomboxColor(GetRandomBoomboxColor(), boomboxController.colorPattern, <colorPatternString>5__5, clientId);
					}
					<colorPatternString>5__5 = null;
					<msg>5__2 = false;
					<>2__current = (object)new WaitForSeconds(1f);
					<>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();
			}
		}

		internal static readonly Dictionary<ulong, BoomboxController> BoomboxControllers = new Dictionary<ulong, BoomboxController>();

		internal BoomboxItem boomboxItem;

		private COLOR_PATTERN colorPattern;

		private IEnumerator colorPatternCoroutine;

		private const string colorPatternRandomText = "RANDOM";

		private List<Color> colorPatternRandomTextColors = new List<Color>();

		private readonly Dictionary<string, string> colorPatternRainbowDict = new Dictionary<string, string>
		{
			{ "R", "red" },
			{ "A", "orange" },
			{ "I", "yellow" },
			{ "N", "green" },
			{ "B", "lightblue" },
			{ "O", "mediumpurple" },
			{ "W", "violet" }
		};

		internal override void Awake()
		{
			base.Awake();
			boomboxItem = ((Component)this).GetComponent<BoomboxItem>();
			((GrabbableObject)boomboxItem).itemProperties.requiresBattery = false;
			if (Patch.MuteAlways)
			{
				boomboxItem.boomboxAudio.mute = true;
			}
		}

		internal void Start()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			BoomboxControllers[((NetworkBehaviour)this).NetworkObjectId] = this;
			if (Config.BoomboxRandomColor && IsHostOrIsOffline())
			{
				SyncBoomboxColor(GetRandomBoomboxColor(), colorPattern, GetColorPatternString(colorPattern), ((NetworkBehaviour)this).NetworkManager.LocalClientId);
			}
		}

		internal void SyncBoomboxColorRequestServerDelegate(float r, float g, float b, COLOR_PATTERN colorPattern = COLOR_PATTERN.NONE)
		{
			//IL_003d: 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)
			if (Patch.IsOffline())
			{
				if (!ApplyColorPattern(colorPattern, ((NetworkBehaviour)this).NetworkManager.LocalClientId))
				{
					SyncBoomboxColorRequestClientShared(r, g, b, colorPattern, null, ((NetworkBehaviour)this).NetworkManager.LocalClientId, msg: true);
				}
			}
			else
			{
				SyncBoomboxColorRequestServerRpc(r, g, b, colorPattern);
			}
		}

		private void SyncBoomboxColor(Color color, COLOR_PATTERN colorPattern, string colorPatternString, ulong clientId, bool msg = false)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsHost)
			{
				SyncBoomboxColorRequestClientRpc(color.r, color.g, color.b, colorPattern, colorPatternString, clientId, msg);
			}
			else
			{
				SyncBoomboxColorRequestClientShared(color.r, color.g, color.b, colorPattern, colorPatternString, clientId, msg);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void SyncAllRequestServerRpc(ulong clientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4064489894u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4064489894u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !IsInvalidServerCall())
			{
				Request request = GetRequest(((NetworkBehaviour)this).NetworkObjectId);
				if (request != null)
				{
					ClientRpcParams clientRpcParamsForClient = Controller.GetClientRpcParamsForClient(clientId);
					SyncVolumeRequestClientRpc(request.volume, 0uL, msg: false, clientRpcParamsForClient);
					Color boomboxBodyColor = GetBoomboxBodyColor();
					SyncBoomboxColorRequestClientRpc(boomboxBodyColor.r, boomboxBodyColor.g, boomboxBodyColor.b, colorPattern, null, 0uL, msg: false, clientRpcParamsForClient);
					SyncRequestVerifyClientCall(request, clientRpcParamsForClient);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void SyncBoomboxColorRequestServerRpc(float r, float g, float b, COLOR_PATTERN colorPattern, ServerRpcParams serverRpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2959672043u, serverRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref r, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref g, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref b, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<COLOR_PATTERN>(ref colorPattern, default(ForEnums));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2959672043u, serverRpcParams, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !IsInvalidServerCall())
			{
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!ApplyColorPattern(colorPattern, senderClientId))
				{
					SyncBoomboxColorRequestClientRpc(r, g, b, colorPattern, null, senderClientId, msg: true);
				}
			}
		}

		[ClientRpc]
		internal void SyncBoomboxColorRequestClientRpc(float r, float g, float b, COLOR_PATTERN colorPattern, string colorPatternString, ulong clientId, bool msg = false, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2185452183u, clientRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref r, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref g, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref b, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<COLOR_PATTERN>(ref colorPattern, default(ForEnums));
				bool flag = colorPatternString != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(colorPatternString, false);
				}
				BytePacker.WriteValueBitPacked(val, clientId);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref msg, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2185452183u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
			{
				SyncBoomboxColorRequestClientShared(r, g, b, colorPattern, colorPatternString, clientId, msg);
			}
		}

		internal override void StartAudio(float forceTime = 0f)
		{
			if (IsItemActive())
			{
				StartAudioTime(forceTime);
				boomboxItem.boomboxAudio.pitch = 1f;
				boomboxItem.boomboxAudio.Play();
				boomboxItem.isPlayingMusic = (((GrabbableObject)boomboxItem).isBeingUsed = true);
			}
		}

		internal override void StopAudio(float forceTime = 0f, bool syncTime = true)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (IsItemActive())
			{
				StopAudioTime(forceTime);
				if (((NetworkBehaviour)this).IsHost && syncTime)
				{
					SyncTimeRequestServerRpc(timeSaved, REQUEST_TYPE.STOP);
				}
				bool isPlayingMusic = boomboxItem.isPlayingMusic;
				boomboxItem.boomboxAudio.Stop();
				if (isPlayingMusic)
				{
					boomboxItem.boomboxAudio.PlayOneShot(boomboxItem.stopAudios[Random.Range(0, boomboxItem.stopAudios.Length)]);
				}
				boomboxItem.isPlayingMusic = (((GrabbableObject)boomboxItem).isBeingUsed = false);
			}
		}

		internal override REQUEST_STATE Sync(bool request, string filenameId, string url, string title, int duration, float time, AudioClip audioClip, bool isPlaying)
		{
			serverFilenameId = filenameId;
			serverUrl = url;
			serverTitle = title;
			serverDuration = duration;
			serverTime = time;
			if (!IsItemActive())
			{
				return REQUEST_STATE.FAILURE;
			}
			if (Object.op_Implicit((Object)(object)audioClip))
			{
				base.filenameId = filenameId;
				base.url = url;
				base.title = title;
				base.duration = duration;
				boomboxItem.boomboxAudio.clip = audioClip;
				boomboxItem.boomboxAudio.time = (timeSaved = Controller.ClampAudioSource(boomboxItem.boomboxAudio, time));
			}
			else
			{
				ResetController();
				time = 0f;
			}
			if (request)
			{
				if (((GrabbableObject)boomboxItem).isHeld)
				{
					if (isPlaying)
					{
						ResetAudio(time);
					}
					return REQUEST_STATE.SUCCESS;
				}
				StartAudio();
				return REQUEST_STATE.AUTO_PLAY;
			}
			if (isPlaying)
			{
				StartAudio(time);
			}
			else
			{
				StopAudio(time, syncTime: false);
			}
			return REQUEST_STATE.SUCCESS;
		}

		internal override void ResetController()
		{
			AudioSource audioSource = GetAudioSource();
			audioSource.clip = GetDefaultAudioClip();
			audioSource.time = 0f;
			ResetControllerBase();
		}

		internal override Controller GetControllerForItemId(ulong itemId)
		{
			if (!BoomboxControllers.ContainsKey(itemId))
			{
				return null;
			}
			return BoomboxControllers[itemId];
		}

		internal override bool IsPlaying()
		{
			return boomboxItem.isPlayingMusic;
		}

		internal override bool IsResettable()
		{
			if (IsBoomboxHeldByUsOrUnattended(boomboxItem))
			{
				return base.IsResettable();
			}
			return false;
		}

		internal static bool IsBoomboxHeldByUsOrUnattended(BoomboxItem boomboxItem)
		{
			if (Object.op_Implicit((Object)(object)boomboxItem))
			{
				if (!IsBoomboxHeldByUs(boomboxItem))
				{
					return !((GrabbableObject)boomboxItem).isHeld;
				}
				return true;
			}
			return false;
		}

		internal static void ToggleMuteBoomboxItems(List<BoomboxItem> boomboxItems)
		{
			if (boomboxItems != null && boomboxItems.Count == 0)
			{
				return;
			}
			bool flag = Object.op_Implicit((Object)(object)boomboxItems.Find((BoomboxItem boomboxItem) => !boomboxItem.boomboxAudio.mute));
			foreach (BoomboxItem boomboxItem in boomboxItems)
			{
				boomboxItem.boomboxAudio.mute = flag;
			}
			bool flag2 = boomboxItems.Count == 1;
			string text = (flag2 ? "boombox" : "boomboxes");
			string text2 = (flag2 ? "it" : "them");
			string text3 = (flag ? Patch.GetMutedString() : Patch.GetUnmutedString());
			string text4 = (flag ? "unmute" : "mute");
			Patch.AddChatMessage($"{boomboxItems.Count} {text} {text3} locally, to {text4} {text2} press [{Patch.TealColorString(((object)(KeyboardShortcut)(ref Config.KeyboardShortcutMute)).ToString())}]");
		}

		internal static bool IsBoomboxHeldByUs(BoomboxItem boomboxItem)
		{
			if (Object.op_Implicit((Object)(object)boomboxItem) && Object.op_Implicit((Object)(object)Patch.LocalPlayerController) && Object.op_Implicit((Object)(object)((GrabbableObject)boomboxItem).playerHeldBy))
			{
				return (Object)(object)((GrabbableObject)boomboxItem).playerHeldBy == (Object)(object)Patch.LocalPlayerController;
			}
			return false;
		}

		internal static bool IsBoomboxHeldBySomeoneElse(BoomboxItem boomboxItem)
		{
			if (Object.op_Implicit((Object)(object)boomboxItem) && Object.op_Implicit((Object)(object)Patch.LocalPlayerController) && Object.op_Implicit((Object)(object)((GrabbableObject)boomboxItem).playerHeldBy))
			{
				return (Object)(object)((GrabbableObject)boomboxItem).playerHeldBy != (Object)(object)Patch.LocalPlayerController;
			}
			return false;
		}

		internal static bool IsBoomboxHeldBySomeoneElseOrUnattended(BoomboxItem boomboxItem)
		{
			if (Object.op_Implicit((Object)(object)boomboxItem))
			{
				if (!IsBoomboxHeldBySomeoneElse(boomboxItem))
				{
					return !((GrabbableObject)boomboxItem).isHeld;
				}
				return true;
			}
			return false;
		}

		internal static Color GetRandomBoomboxColor()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			float num = Random.Range(0f, 1f);
			float num2 = Random.Range(0f, 1f);
			float num3 = Random.Range(0f, 1f);
			return new Color(num, num2, num3);
		}

		internal static BoomboxItem GetHeldBoomboxItem(PlayerControllerB playerControllerB)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)playerControllerB))
			{
				return null;
			}
			if (playerControllerB.currentItemSlot >= playerControllerB.ItemSlots.Length)
			{
				return null;
			}
			object obj = playerControllerB.ItemSlots[playerControllerB.currentItemSlot];
			if (obj == null)
			{
				return null;
			}
			if (!(obj.GetType() == typeof(BoomboxItem)))
			{
				return null;
			}
			return (BoomboxItem)obj;
		}

		internal static List<BoomboxItem> GetHeldBoomboxItems(PlayerControllerB playerControllerB)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)playerControllerB))
			{
				return new List<BoomboxItem>();
			}
			List<BoomboxItem> list = new List<BoomboxItem>();
			GrabbableObject[] array = playerControllerB.ItemSlots.ToArray();
			foreach (object obj in array)
			{
				if (obj != null && obj.GetType() == typeof(BoomboxItem))
				{
					list.Add((BoomboxItem)obj);
				}
			}
			return list;
		}

		internal void ToggleMutePlayer()
		{
			if (LookingPatch.LookingAtPlayerBoomboxItems.Count > 1)
			{
				ToggleMuteBoomboxItems(LookingPatch.LookingAtPlayerBoomboxItems.ToList());
			}
			else
			{
				ToggleMute();
			}
		}

		private bool ApplyColorPattern(COLOR_PATTERN colorPattern, ulong clientId)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (colorPatternCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(colorPatternCoroutine);
			}
			switch (colorPattern)
			{
			case COLOR_PATTERN.RANDOM_LOOP:
				((MonoBehaviour)this).StartCoroutine(colorPatternCoroutine = ColorPatternRandomLoop(clientId));
				return true;
			case COLOR_PATTERN.RAINBOW:
				SyncBoomboxColor(GetBoomboxBodyColor(), colorPattern, GetColorPatternString(colorPattern), clientId, msg: true);
				return true;
			default:
				return false;
			}
		}

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

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

		private static Color ColorShift(Color color, float amount)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			float num2 = default(float);
			float num3 = default(float);
			float num = default(float);
			Color.RGBToHSV(color, ref num, ref num2, ref num3);
			num += amount;
			return Color.HSVToRGB(num, 1f, 1f);
		}

		private string GetColorPatternString(COLOR_PATTERN colorPattern)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			switch (colorPattern)
			{
			case COLOR_PATTERN.RANDOM_LOOP:
			{
				string text2;
				if (colorPatternRandomTextColors.Count > 0)
				{
					List<string> list3 = new List<string>();
					int num = 0;
					string text = "RANDOM";
					for (int i = 0; i < text.Length; i++)
					{
						string str = text[i].ToString();
						string color2 = Patch.ColorToHex(colorPatternRandomTextColors[num++]);
						list3.Add(Patch.ColorString(str, color2));
					}
					text2 = string.Concat(list3);
				}
				else
				{
					text2 = "RANDOM";
				}
				return text2 + " loop";
			}
			case COLOR_PATTERN.RAINBOW:
			{
				List<string> list = colorPatternRainbowDict.Keys.ToList();
				List<string> list2 = new List<string>();
				foreach (string item in list)
				{
					Color value = Patch.ParseColor(colorPatternRainbowDict[item]).Value;
					string color = Patch.ColorToHex(value);
					list2.Add(Patch.ColorString(item, color));
				}
				return string.Concat(string.Concat(list2), "!");
			}
			default:
				return null;
			}
		}

		internal override void SyncAllRequestServer(ulong clientId)
		{
			SyncAllRequestServerRpc(clientId);
		}

		internal override AudioSource GetAudioSource()
		{
			return boomboxItem.boomboxAudio;
		}

		internal override string GetSetTimeString(float time)
		{
			return string.Format("{0} set to {1} seconds", IsBoomboxHeldByUs(boomboxItem) ? "Your boombox playback time was" : "Boombox playback time", Math.Round(time, 1));
		}

		internal override AudioClip GetDefaultAudioClip()
		{
			if (boomboxItem.musicAudios.Length == 0)
			{
				return null;
			}
			return boomboxItem.musicAudios[boomboxItem.musicRandomizer.Next(0, boomboxItem.musicAudios.Length)];
		}

		internal Color GetBoomboxBodyColor()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			return ((Renderer)((Component)boomboxItem).gameObject.GetComponent<MeshRenderer>()).materials[3].color;
		}

		internal bool ShouldResyncColor(float r, float g, float b)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Color boomboxBodyColor = GetBoomboxBodyColor();
			if (r == boomboxBodyColor.r && g == boomboxBodyColor.g)
			{
				return b != boomboxBodyColor.b;
			}
			return true;
		}

		internal void SyncBoomboxColorRequestClientShared(float r, float g, float b, COLOR_PATTERN colorPattern, string colorPatternString, ulong clientId, bool msg = false)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			if (!IsItemActive())
			{
				return;
			}
			Color? val = ChangeBoomboxColor(r, g, b);
			if (!val.HasValue)
			{
				if (msg)
				{
					Patch.AddChatMessage("Failed to change boombox color.");
				}
				return;
			}
			if (colorPatternCoroutine != null && this.colorPattern != colorPattern)
			{
				((MonoBehaviour)this).StopCoroutine(colorPatternCoroutine);
			}
			if (colorPattern == COLOR_PATTERN.RAINBOW)
			{
				((MonoBehaviour)this).StartCoroutine(colorPatternCoroutine = ColorPatternRainbow(clientId));
			}
			this.colorPattern = colorPattern;
			if (msg && IsClientIdLocal(clientId))
			{
				string text = (IsBoomboxHeldByUs(boomboxItem) ? "Your boombox color was" : "Boombox color");
				if (colorPatternString == null)
				{
					colorPatternString = Patch.ColorToString(val.Value);
				}
				Patch.AddChatMessage(text + " set to " + colorPatternString);
			}
		}

		internal Color? ChangeBoomboxColor(float r, float g, float b)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			if (!IsItemActive())
			{
				return null;
			}
			r = Mathf.Clamp(r, 0f, 1f);
			g = Mathf.Clamp(g, 0f, 1f);
			b = Mathf.Clamp(b, 0f, 1f);
			Color val = default(Color);
			((Color)(ref val))..ctor(r, g, b);
			MeshRenderer component = ((Component)boomboxItem).gameObject.GetComponent<MeshRenderer>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return null;
			}
			((Renderer)component).materials[1].color = val;
			((Renderer)component).materials[3].color = val;
			return val;
		}

		internal override ITEM_TYPE GetItemType()
		{
			return ITEM_TYPE.BOOMBOX;
		}

		internal override string GetItemName()
		{
			return "Boombox";
		}

		internal override bool IsItemActive()
		{
			return IsBoomboxItemActive(boomboxItem);
		}

		internal static bool IsBoomboxItemActive(BoomboxItem boomboxItem)
		{
			return Controller.IsNetworkBehaviourActive((NetworkBehaviour)(object)boomboxItem);
		}

		internal override bool IsBeingUsedByUs()
		{
			return IsBoomboxHeldByUs(boomboxItem);
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_BoomboxController()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(4064489894u, new RpcReceiveHandler(__rpc_handler_4064489894));
			NetworkManager.__rpc_func_table.Add(2959672043u, new RpcReceiveHandler(__rpc_handler_2959672043));
			NetworkManager.__rpc_func_table.Add(2185452183u, new RpcReceiveHandler(__rpc_handler_2185452183));
		}

		private static void __rpc_handler_4064489894(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BoomboxController)(object)target).SyncAllRequestServerRpc(clientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2959672043(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				float r = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref r, default(ForPrimitives));
				float g = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref g, default(ForPrimitives));
				float b = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref b, default(ForPrimitives));
				COLOR_PATTERN cOLOR_PATTERN = default(COLOR_PATTERN);
				((FastBufferReader)(ref reader)).ReadValueSafe<COLOR_PATTERN>(ref cOLOR_PATTERN, default(ForEnums));
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BoomboxController)(object)target).SyncBoomboxColorRequestServerRpc(r, g, b, cOLOR_PATTERN, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2185452183(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: 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_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				float r = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref r, default(ForPrimitives));
				float g = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref g, default(ForPrimitives));
				float b = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref b, default(ForPrimitives));
				COLOR_PATTERN cOLOR_PATTERN = default(COLOR_PATTERN);
				((FastBufferReader)(ref reader)).ReadValueSafe<COLOR_PATTERN>(ref cOLOR_PATTERN, default(ForEnums));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string colorPatternString = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref colorPatternString, false);
				}
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				bool msg = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref msg, default(ForPrimitives));
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((BoomboxController)(object)target).SyncBoomboxColorRequestClientRpc(r, g, b, cOLOR_PATTERN, colorPatternString, clientId, msg, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "BoomboxController";
		}
	}
	internal enum ACTION_STATE
	{
		PROCESSING,
		KILLED,
		FINISHED
	}
	internal enum REQUEST_TYPE
	{
		TIME,
		STOP
	}
	internal enum REQUEST_STATE
	{
		FAILURE,
		AUTO_PLAY,
		SUCCESS
	}
	internal enum REQUEST_STATUS
	{
		NONE,
		REQUEST_INITIALIZING,
		REQUEST_VALID,
		REQUEST_CANCELED,
		REQUEST_TIMEOUT,
		REQUEST_NEW_REQUEST,
		ERROR_CLIENT_DOWNLOAD,
		ERROR_CLIENT_DOWNLOAD_CANCELED,
		ERROR_CLIENT_DOWNLOAD_EXCEPTION,
		ERROR_CLIENT_LOAD,
		ERROR_CLIENT_TIMEOUT,
		ERROR_CLIENT_DISCONNECT,
		ERROR_CLIENT_OFFLINE,
		ERROR_UTIL_MISSING_DEPENDENCY,
		ERROR_UTIL_DOWNLOADING_TOOLS,
		ERROR_INVALID_TOOLS,
		ERROR_INVALID_ITEM,
		ERROR_INVALID_URL,
		ERROR_METADATA,
		ERROR_METADATA_EXCEPTION,
		ERROR_METADATA_AGE_RESTRICTED,
		ERROR_METADATA_BOT,
		ERROR_METADATA_SIGN_IN,
		ERROR_METADATA_VIDEO_UNAVAILABLE,
		ERROR_METADATA_MAX_DURATION
	}
	internal enum MUTE
	{
		NONE,
		SINGLE,
		ALL,
		ALWAYS
	}
	internal enum NETWORK_MODE
	{
		OFFLINE,
		ONLINE
	}
	internal enum COLOR_PATTERN
	{
		NONE,
		RANDOM_LOOP,
		RAINBOW
	}
	internal enum TOOLS_STATUS
	{
		NONE,
		DOWNLOADING
	}
	internal enum ITEM_TYPE
	{
		BOOMBOX,
		CRUISER
	}
	internal enum CRUISER_COMPONENT
	{
		NONE,
		TURN_ON_RADIO,
		CHANGE_CHANNEL
	}
	internal class Request
	{
		internal float volume;

		internal bool isPlaying;

		internal string filenameId;

		internal string url;

		internal string title;

		internal int duration;

		internal float time;

		public Request(float volume, bool isPlaying, string filenameId, string url, string title, int duration, float time)
		{
			this.volume = volume;
			this.isPlaying = isPlaying;
			this.filenameId = filenameId;
			this.url = url;
			this.title = title;
			this.duration = duration;
			this.time = time;
			base..ctor();
		}
	}
	internal class Config
	{
		internal static string BindingCategorySettings = "Settings";

		internal static string BindingCategoryKeybinds = "Keybinds";

		private static ConfigEntry<bool> ConfigEntrySync;

		private static ConfigEntry<bool> ConfigEntryPocketPlay;

		private static ConfigEntry<bool> ConfigEntryBoomboxRandomColor;

		public static bool Sync;

		public static bool PocketPlay;

		public static bool BoomboxRandomColor;

		internal static ConfigEntry<KeyboardShortcut> KeyboardShortcutSync;

		internal static ConfigEntry<KeyboardShortcut> KeyboardShortcutReset;

		internal static KeyboardShortcut KeyboardShortcutMute;

		internal static ConfigEntry<KeyboardShortcut> KeyboardShortcutVolumeUp;

		internal static ConfigEntry<KeyboardShortcut> KeyboardShortcutVolumeDown;

		internal static ConfigEntry<KeyboardShortcut> KeyboardShortcutHistoryNext;

		internal static ConfigEntry<KeyboardShortcut> KeyboardShortcutHistoryPrevious;

		internal Config(ConfigFile configFile)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntrySync = configFile.Bind<bool>(BindingCategorySettings, "Sync", false, "[HOST] Copy the audio and time of another boombox or cruiser, and allow them to play the same audio. NOTE: This is resource intensive but offers more features and accurate syncing.");
			ConfigEntryPocketPlay = configFile.Bind<bool>(BindingCategorySettings, "Pocket play", false, "[HOST] Allows the boombox to continue playing in the inventory.");
			ConfigEntryBoomboxRandomColor = configFile.Bind<bool>(BindingCategorySettings, "Boombox random color", false, "[HOST] Boomboxes are spawned with a random color!");
			KeyboardShortcutSync = configFile.Bind<KeyboardShortcut>(BindingCategoryKeybinds, "Sync keybind", new KeyboardShortcut((KeyCode)113, Array.Empty<KeyCode>()), "Sync to another boombox or cruiser, or resync (redownload) the audio.");
			KeyboardShortcutReset = configFile.Bind<KeyboardShortcut>(BindingCategoryKeybinds, "Reset keybind", new KeyboardShortcut((KeyCode)114, Array.Empty<KeyCode>()), "Reset the playback time to 0 and stop playback.");
			KeyboardShortcutMute = new KeyboardShortcut((KeyCode)8, Array.Empty<KeyCode>());
			KeyboardShortcutVolumeUp = configFile.Bind<KeyboardShortcut>(BindingCategoryKeybinds, "Boombox volume up keybind", new KeyboardShortcut((KeyCode)280, Array.Empty<KeyCode>()), "Increase the boombox volume.");
			KeyboardShortcutVolumeDown = configFile.Bind<KeyboardShortcut>(BindingCategoryKeybinds, "Boombox volume down keybind", new KeyboardShortcut((KeyCode)281, Array.Empty<KeyCode>()), "Decrease the boombox volume.");
			KeyboardShortcutHistoryNext = configFile.Bind<KeyboardShortcut>(BindingCategoryKeybinds, "Play history next keybind", new KeyboardShortcut((KeyCode)275, Array.Empty<KeyCode>()), "Navigate to the next page in your play history.");
			KeyboardShortcutHistoryPrevious = configFile.Bind<KeyboardShortcut>(BindingCategoryKeybinds, "Play history previous keybind", new KeyboardShortcut((KeyCode)276, Array.Empty<KeyCode>()), "Navigate to the previous page in your play history.");
			MigrateAndClearOrphanedEntries(configFile);
			Sync = ConfigEntrySync.Value;
			PocketPlay = ConfigEntryPocketPlay.Value;
			BoomboxRandomColor = ConfigEntryBoomboxRandomColor.Value;
		}

		private void MigrateAndClearOrphanedEntries(ConfigFile configFile)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			Dictionary<ConfigDefinition, ConfigEntryBase> dictionary = new Dictionary<ConfigDefinition, ConfigEntryBase>
			{
				{
					new ConfigDefinition(BindingCategorySettings, "Boombox sync"),
					(ConfigEntryBase)(object)ConfigEntrySync
				},
				{
					new ConfigDefinition(BindingCategorySettings, "Boombox pocket play"),
					(ConfigEntryBase)(object)ConfigEntryPocketPlay
				},
				{
					new ConfigDefinition(BindingCategoryKeybinds, "Sync boombox keybind"),
					(ConfigEntryBase)(object)KeyboardShortcutSync
				},
				{
					new ConfigDefinition(BindingCategoryKeybinds, "Reset boombox keybind"),
					(ConfigEntryBase)(object)KeyboardShortcutReset
				}
			};
			PropertyInfo property = ((object)configFile).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
			Dictionary<ConfigDefinition, string> dictionary2 = (Dictionary<ConfigDefinition, string>)property.GetValue(configFile, null);
			foreach (KeyValuePair<ConfigDefinition, string> item in dictionary2)
			{
				if (dictionary.TryGetValue(item.Key, out var value))
				{
					value.SetSerializedValue(item.Value);
					YPlay.LogInfo("Config migrated: [" + item.Key.Key + "] > [" + value.Definition.Key + "]: " + item.Value);
				}
			}
			dictionary2.Clear();
			configFile.Save();
		}

		internal static void SetConfigEntrySync(bool b)
		{
			ConfigEntrySync.Value = b;
		}

		internal static void SetConfigEntryPocketPlay(bool b)
		{
			ConfigEntryPocketPlay.Value = b;
		}

		internal static void SetConfigEntryBoomboxRandomColor(bool b)
		{
			ConfigEntryBoomboxRandomColor.Value = b;
		}
	}
	internal class RequestMetadata
	{
		private static int GlobalRequestId;

		internal HashSet<ulong> originalClientIdRequests = new HashSet<ulong>();

		internal HashSet<ulong> pendingClientIdRequests = new HashSet<ulong>();

		internal REQUEST_STATUS requestStatus = REQUEST_STATUS.REQUEST_INITIALIZING;

		internal int requestId = GlobalRequestId++;

		internal string filenameId;

		internal string title;

		internal string url;

		internal float time;

		internal int duration;
	}
	internal class CommandBuilder
	{
		internal string url;

		internal float time;

		internal float volume = 1f;

		internal string historyUrl;

		internal Color color;

		internal COLOR_PATTERN colorPattern;

		internal MUTE muteMode = MUTE.SINGLE;

		internal bool urlUrlSet;

		internal bool urlSet;

		internal bool offlineSet;

		internal bool historySet;

		internal bool muteSet;

		internal bool timeSet;

		internal bool actionsSet;

		internal bool helpSet;

		internal bool statusSet;

		internal bool resetToolsSet;

		internal bool settingsSet;

		internal bool syncSet;

		internal bool pocketPlaySet;

		internal bool boomboxRandomColorSet;

		internal bool volumeSet;

		internal bool colorSet;

		internal bool urlSuccess;

		internal bool timeSuccess;

		internal bool volumeSuccess;

		internal bool colorSuccess;

		internal bool historyUrlIndexFailed;
	}
	internal static class YPlayConfig
	{
		internal const int MaxChatCharacters = 50;

		internal const int PlayHistoryResultsPerPage = 3;

		internal const int PlayHistoryResultsMax = 15;

		internal const int MaxClips = 15;

		internal const int MaxAudioLengthMinutes = 12;

		internal const float MinVolume = 0f;

		internal const float MaxVolume = 1f;

		internal const int DownloadMetadataTimeoutMs = 15000;

		internal const int DownloadAudioTimeoutBaseMs = 27000;

		internal const int DownloadRequestWaitMs = 5000;
	}
	internal static class Patch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static HandleNamedMessageDelegate <0>__MessageHandlerPocketPlayClient;

			public static HandleNamedMessageDelegate <1>__MessageHandlerSyncEnabledClient;

			public static HandleNamedMessageDelegate <2>__MessageHandlerBoomboxRandomColorClient;

			public static HandleNamedMessageDelegate <3>__MessageHandlerMessageClient;

			public static HandleNamedMessageDelegate <4>__MessageHandlerSyncRequestServer;

			public static HandleNamedMessageDelegate <5>__MessageHandlerModEnabledServer;

			public static HandleNamedMessageDelegate <6>__MessageHandlerModeServer;

			public static HandleNamedMessageDelegate <7>__MessageHandlerSyncRequestClient;
		}

		internal static NETWORK_MODE NetworkMode = NETWORK_MODE.OFFLINE;

		private static readonly HashSet<string> ConflictingBoomboxModNames = new HashSet<string>();

		internal static readonly HashSet<ulong> ModEnabledForClientIds = new HashSet<ulong>();

		internal static bool MuteAlways;

		internal static string MuteAlwaysSymbol = PinkColorString("*");

		internal const string InvalidYouTubeURLString = "Invalid YouTube URL, please check it is valid";

		private const string VersionMismatchErrorString = "Host does not have YPlayBoombox installed or has an outdated version, running in offline mode";

		private const string ClientOnlyCommandString = "Sorry, hosts can't use this command!";

		private const string HostOnlyCommandString = "Sorry, this command can only be used by the host";

		private const string HostOrOfflineOnlyCommandString = "Sorry, this command can only be used by the host or while in offline mode";

		private static readonly Type TypeAddChatMessage = typeof(HUDManager);

		private static readonly MethodInfo MethodInfoAddChatMessage = TypeAddChatMessage.GetMethod("AddChatMessage", BindingFlags.Instance | BindingFlags.NonPublic);

		private const string ConfigTag = "[CONFIG]";

		private static readonly string[] InvalidFilenameIds = new string[3] { "results", "search", "search_query" };

		private static CancellationTokenSource syncedCancellationTokenSource;

		private static string serverModVersion;

		private static readonly string MessageHandlerModEnabledS = GetMessageHandlerKey("MessageHandlerModEnabledS");

		private static readonly string MessageHandlerModeS = GetMessageHandlerKey("MessageHandlerModeS");

		private static readonly string MessageHandlerPocketPlayC = GetMessageHandlerKey("MessageHandlerPocketPlayC");

		private static readonly string MessageHandlerSyncEnabledC = GetMessageHandlerKey("MessageHandlerSyncEnabledC");

		private static readonly string MessageHandlerBoomboxRandomColorC = GetMessageHandlerKey("MessageHandlerBoomboxRandomColorC");

		private static readonly string MessageHandlerSyncRequestS = GetMessageHandlerKey("MessageHandlerSyncRequestS");

		private static readonly string MessageHandlerSyncRequestC = GetMessageHandlerKey("MessageHandlerSyncRequestC");

		private static readonly string MessageHandlerMessageHandlerC = GetMessageHandlerKey("MessageHandlerMessageHandlerC");

		internal static readonly HashSet<VehicleController> VehicleControllers = new HashSet<VehicleController>();

		private static string LastChatCommandMessage;

		private static float LastChatMessageTime;

		private const float SameChatMessageTimeMin = 0.1f;

		private static readonly List<string> PlayHistoryUrls = new List<string>();

		private static bool InPlayHistory;

		private static int PlayHistoryPage;

		private static string PlayHistoryNavigatePreviousString;

		private static string PlayHistoryNavigateNextString;

		private static CustomMessagingManager CustomMessageManager => NetworkManager.Singleton.CustomMessagingManager;

		internal static bool IsHost => NetworkManager.Singleton.IsHost;

		internal static PlayerControllerB LocalPlayerController => StartOfRound.Instance.localPlayerController;

		private static string GetMessageHandlerKey(string name)
		{
			return "YPlayBoombox_" + name;
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		[HarmonyPrefix]
		internal static void GameNetworkManager_Start_Patch(GameNetworkManager __instance)
		{
			bool flag = false;
			bool flag2 = false;
			foreach (NetworkPrefab prefab in ((Component)__instance).GetComponent<NetworkManager>().NetworkConfig.Prefabs.Prefabs)
			{
				if (!flag && Object.op_Implicit((Object)(object)prefab.Prefab.GetComponent<BoomboxItem>()))
				{
					prefab.Prefab.AddComponent<BoomboxController>();
					flag = true;
				}
				else if (!flag2 && Object.op_Implicit((Object)(object)prefab.Prefab.GetComponent<VehicleController>()))
				{
					prefab.Prefab.AddComponent<CruiserController>();
					flag2 = true;
				}
				if (flag && flag2)
				{
					break;
				}
			}
			CheckConflictingBoomboxMods();
		}

		[HarmonyPatch(typeof(StartOfRound), "OnClientConnect")]
		[HarmonyPostfix]
		internal static void OnClientConnect_Patch(StartOfRound __instance, ulong clientId)
		{
			Controller.shouldVerify = true;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPrefix]
		internal static void PlayerControllerB_ConnectClientToPlayerObject_Patch(PlayerControllerB __instance)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Expected O, but got Unknown
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			NetworkMode = (IsHost ? NETWORK_MODE.ONLINE : NETWORK_MODE.OFFLINE);
			serverModVersion = (IsHost ? "2.3.1" : null);
			SetPocketPlay(Config.PocketPlay);
			SetSyncEnabled(Config.Sync);
			SetBoomboxRandomColor(Config.BoomboxRandomColor);
			CustomMessagingManager customMessageManager = CustomMessageManager;
			string messageHandlerPocketPlayC = MessageHandlerPocketPlayC;
			object obj = <>O.<0>__MessageHandlerPocketPlayClient;
			if (obj == null)
			{
				HandleNamedMessageDelegate val = MessageHandlerPocketPlayClient;
				<>O.<0>__MessageHandlerPocketPlayClient = val;
				obj = (object)val;
			}
			customMessageManager.RegisterNamedMessageHandler(messageHandlerPocketPlayC, (HandleNamedMessageDelegate)obj);
			CustomMessagingManager customMessageManager2 = CustomMessageManager;
			string messageHandlerSyncEnabledC = MessageHandlerSyncEnabledC;
			object obj2 = <>O.<1>__MessageHandlerSyncEnabledClient;
			if (obj2 == null)
			{
				HandleNamedMessageDelegate val2 = MessageHandlerSyncEnabledClient;
				<>O.<1>__MessageHandlerSyncEnabledClient = val2;
				obj2 = (object)val2;
			}
			customMessageManager2.RegisterNamedMessageHandler(messageHandlerSyncEnabledC, (HandleNamedMessageDelegate)obj2);
			CustomMessagingManager customMessageManager3 = CustomMessageManager;
			string messageHandlerBoomboxRandomColorC = MessageHandlerBoomboxRandomColorC;
			object obj3 = <>O.<2>__MessageHandlerBoomboxRandomColorClient;
			if (obj3 == null)
			{
				HandleNamedMessageDelegate val3 = MessageHandlerBoomboxRandomColorClient;
				<>O.<2>__MessageHandlerBoomboxRandomColorClient = val3;
				obj3 = (object)val3;
			}
			customMessageManager3.RegisterNamedMessageHandler(messageHandlerBoomboxRandomColorC, (HandleNamedMessageDelegate)obj3);
			CustomMessagingManager customMessageManager4 = CustomMessageManager;
			string messageHandlerMessageHandlerC = MessageHandlerMessageHandlerC;
			object obj4 = <>O.<3>__MessageHandlerMessageClient;
			if (obj4 == null)
			{
				HandleNamedMessageDelegate val4 = MessageHandlerMessageClient;
				<>O.<3>__MessageHandlerMessageClient = val4;
				obj4 = (object)val4;
			}
			customMessageManager4.RegisterNamedMessageHandler(messageHandlerMessageHandlerC, (HandleNamedMessageDelegate)obj4);
			if (IsHost)
			{
				CustomMessagingManager customMessageManager5 = CustomMessageManager;
				string messageHandlerSyncRequestS = MessageHandlerSyncRequestS;
				object obj5 = <>O.<4>__MessageHandlerSyncRequestServer;
				if (obj5 == null)
				{
					HandleNamedMessageDelegate val5 = MessageHandlerSyncRequestServer;
					<>O.<4>__MessageHandlerSyncRequestServer = val5;
					obj5 = (object)val5;
				}
				customMessageManager5.RegisterNamedMessageHandler(messageHandlerSyncRequestS, (HandleNamedMessageDelegate)obj5);
				CustomMessagingManager customMessageManager6 = CustomMessageManager;
				string messageHandlerModEnabledS = MessageHandlerModEnabledS;
				object obj6 = <>O.<5>__MessageHandlerModEnabledServer;
				if (obj6 == null)
				{
					HandleNamedMessageDelegate val6 = MessageHandlerModEnabledServer;
					<>O.<5>__MessageHandlerModEnabledServer = val6;
					obj6 = (object)val6;
				}
				customMessageManager6.RegisterNamedMessageHandler(messageHandlerModEnabledS, (HandleNamedMessageDelegate)obj6);
				CustomMessagingManager customMessageManager7 = CustomMessageManager;
				string messageHandlerModeS = MessageHandlerModeS;
				object obj7 = <>O.<6>__MessageHandlerModeServer;
				if (obj7 == null)
				{
					HandleNamedMessageDelegate val7 = MessageHandlerModeServer;
					<>O.<6>__MessageHandlerModeServer = val7;
					obj7 = (object)val7;
				}
				customMessageManager7.RegisterNamedMessageHandler(messageHandlerModeS, (HandleNamedMessageDelegate)obj7);
				SetModEnabled(__instance.actualClientId, "2.3.1");
			}
			else
			{
				CustomMessagingManager customMessageManager8 = CustomMessageManager;
				string messageHandlerSyncRequestC = MessageHandlerSyncRequestC;
				object obj8 = <>O.<7>__MessageHandlerSyncRequestClient;
				if (obj8 == null)
				{
					HandleNamedMessageDelegate val8 = MessageHandlerSyncRequestClient;
					<>O.<7>__MessageHandlerSyncRequestClient = val8;
					obj8 = (object)val8;
				}
				customMessageManager8.RegisterNamedMessageHandler(messageHandlerSyncRequestC, (HandleNamedMessageDelegate)obj8);
				InitializeClient();
			}
			YPlay.LogInfo("Successfully initialized");
		}

		[HarmonyPatch(typeof(NetworkObject), "Spawn")]
		[HarmonyPrefix]
		internal static void NetworkObject_Spawn_Patch(NetworkObject __instance)
		{
			ApplyControllers(((Component)__instance).gameObject);
		}

		[HarmonyPatch(typeof(BoomboxItem), "StartMusic")]
		[HarmonyPrefix]
		internal static bool BoomboxItem_StartMusic_Patch(BoomboxItem __instance, bool startMusic, bool pitchDown)
		{
			ulong networkObjectId = ((NetworkBehaviour)__instance).NetworkObjectId;
			if (startMusic && BoomboxController.IsBoomboxHeldByUs(__instance))
			{
				if (__instance.boomboxAudio.mute)
				{
					__instance.boomboxAudio.mute = false;
					AddChatMessage("Your boombox was " + GetUnmutedString() + " locally automatically");
					Controller.VolumeZeroHint(__instance);
				}
				else
				{
					Controller.MutedVolumeZeroHint(__instance);
				}
			}
			if (!Object.op_Implicit((Object)(object)__instance.boomboxAudio.clip))
			{
				return true;
			}
			if (!BoomboxController.BoomboxControllers.ContainsKey(networkObjectId))
			{
				return true;
			}
			BoomboxController boomboxController = BoomboxController.BoomboxControllers[networkObjectId];
			if (!boomboxController.IsAudioLoadedInMemory())
			{
				if (startMusic && !string.IsNullOrEmpty(boomboxController.serverFilenameId?.Trim()))
				{
					boomboxController.StopControllersIfStealable();
				}
				return true;
			}
			if (startMusic)
			{
				boomboxController.StartAudio();
			}
			else if (__instance.isPlayingMusic)
			{
				boomboxController.StopAudio();
			}
			return false;
		}

		[HarmonyPatch(typeof(VehicleController), "SetRadioValues")]
		[HarmonyPrefix]
		internal static void VehicleController_SetRadioValues_Patch(VehicleController __instance)
		{
			__instance.radioAudio.volume = 1f;
			__instance.radioInterference.volume = 0f;
			CruiserController.FieldInfoRadioSignalQuality.SetValue(__instance, 3);
		}

		[HarmonyPatch(typeof(VehicleController), "SetRadioOnLocalClient")]
		[HarmonyPrefix]
		internal static void VehicleController_SetRadioOnLocalClient_Patch(VehicleController __instance, bool on, bool setClip)
		{
			float f = (__instance.radioAudio.time = 0f);
			CruiserController.SetCurrentSongTime(__instance, f);
			ulong networkObjectId = ((NetworkBehaviour)__instance).NetworkObjectId;
			CruiserController cruiserController = null;
			if (CruiserController.CruiserControllers.ContainsKey(networkObjectId))
			{
				cruiserController = CruiserController.CruiserControllers[networkObjectId];
			}
			if (on && Object.op_Implicit((Object)(object)cruiserController))
			{
				if (cruiserController.IsOnValidFirstClip())
				{
					cruiserController.StopControllersIfStealable();
					f = (__instance.radioAudio.time = Controller.ClampAudioSource(__instance.radioAudio, cruiserController.timeSaved));
					CruiserController.SetCurrentSongTime(__instance, f);
				}
				else if (CruiserController.IsFirstClip(__instance) && !string.IsNullOrEmpty(cruiserController.serverFilenameId?.Trim()))
				{
					cruiserController.StopControllersIfStealable();
				}
			}
		}

		[HarmonyPatch(typeof(VehicleController), "SetRadioStationClientRpc")]
		[HarmonyPostfix]
		[ClientRpc]
		internal static void VehicleController_SetRadioStation_Postfix_ClientRpc(VehicleController __instance, int radioStation, int signalQuality)
		{
			__instance.radioAudio.clip = __instance.radioClips[radioStation];
			ulong networkObjectId = ((NetworkBehaviour)__instance).NetworkObjectId;
			CruiserController cruiserController = null;
			if (CruiserController.CruiserControllers.ContainsKey(networkObjectId))
			{
				cruiserController = CruiserController.CruiserControllers[networkObjectId];
			}
			if (CruiserController.IsRadioOn(__instance) && Object.op_Implicit((Object)(object)cruiserController) && cruiserController.IsOnValidFirstClip())
			{
				float f = (__instance.radioAudio.time = Controller.ClampAudioSource(__instance.radioAudio, cruiserController.timeSaved));
				CruiserController.SetCurrentSongTime(__instance, f);
			}
			else
			{
				float f = (__instance.radioAudio.time = 0f);
				CruiserController.SetCurrentSongTime(__instance, f);
			}
			__instance.radioAudio.Play();
		}

		[HarmonyPatch(typeof(VehicleController), "ChangeRadioStation")]
		[HarmonyPrefix]
		internal static void VehicleController_ChangeRadioStation_Patch(VehicleController __instance)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			float f = (__instance.radioAudio.time = 0f);
			CruiserController.SetCurrentSongTime(__instance, f);
			ulong networkObjectId = ((NetworkBehaviour)__instance).NetworkObjectId;
			CruiserController cruiserController = null;
			if (CruiserController.CruiserControllers.ContainsKey(networkObjectId))
			{
				cruiserController = CruiserController.CruiserControllers[networkObjectId];
			}
			if (!Object.op_Implicit((Object)(object)cruiserController) || !cruiserController.IsFirstClipLoaded())
			{
				return;
			}
			bool flag = CruiserController.IsRadioOn(__instance);
			int currentRadioStation = CruiserController.GetCurrentRadioStation(__instance);
			int num2 = (currentRadioStation + 1) % __instance.radioClips.Length;
			bool flag2 = cruiserController.IsOnValidFirstClip();
			bool flag3 = num2 == 0;
			if (!(flag2 || flag3))
			{
				return;
			}
			if (flag)
			{
				if (flag2)
				{
					cruiserController.SyncTimeRequestServerRpc(cruiserController.timeSaved = 0f, REQUEST_TYPE.STOP);
				}
			}
			else
			{
				CruiserController.FieldInfoRadioOn.SetValue(__instance, true);
				__instance.radioInterference.Play();
			}
			if ((flag3 && __instance.radioClips.Length > 1) || __instance.radioClips.Length == 1)
			{
				cruiserController.StopControllersIfStealable();
			}
		}

		[HarmonyPatch(typeof(VehicleController), "SwitchRadio")]
		[HarmonyPrefix]
		internal static bool VehicleController_SwitchRadio_Patch(VehicleController __instance)
		{
			ulong networkObjectId = ((NetworkBehaviour)__instance).NetworkObjectId;
			CruiserController cruiserController = null;
			if (CruiserController.CruiserControllers.ContainsKey(networkObjectId))
			{
				cruiserController = CruiserController.CruiserControllers[networkObjectId];
			}
			if (!Object.op_Implicit((Object)(object)cruiserController) || !cruiserController.IsOnValidFirstClip())
			{
				return true;
			}
			CruiserController.FieldInfoRadioOn.SetValue(__instance, !CruiserController.IsRadioOn(__instance));
			if (CruiserController.IsRadioOn(__instance))
			{
				__instance.radioAudio.clip = __instance.radioClips[CruiserController.GetCurrentRadioStation(__instance)];
				float f = (__instance.radioAudio.time = Controller.ClampAudioSource(__instance.radioAudio, cruiserController.timeSaved));
				CruiserController.SetCurrentSongTime(__instance, f);
				cruiserController.StartAudio();
				__instance.radioInterference.Play();
			}
			else
			{
				cruiserController.StopAudio();
				__instance.radioInterference.Stop();
			}
			return false;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPostfix]
		internal static void PlayerControllerB_Update_Patch(PlayerControllerB __instance)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance != (Object)(object)LocalPlayerController || !PlayerCanInteract(__instance))
			{
				return;
			}
			KeyboardShortcut value;
			if (InPlayHistory && PlayHistoryUrls.Count > 0)
			{
				if (!string.IsNullOrEmpty(PlayHistoryNavigatePreviousString?.Trim()))
				{
					value = Config.KeyboardShortcutHistoryPrevious.Value;
					if (((KeyboardShortcut)(ref value)).IsDown())
					{
						ShowPlayHistory(PlayHistoryPage - 1);
						return;
					}
				}
				if (!string.IsNullOrEmpty(PlayHistoryNavigateNextString?.Trim()))
				{
					value = Config.KeyboardShortcutHistoryNext.Value;
					if (((KeyboardShortcut)(ref value)).IsDown())
					{
						ShowPlayHistory(PlayHistoryPage + 1);
						return;
					}
				}
			}
			BoomboxController boomboxController = null;
			BoomboxItem heldBoomboxItem = BoomboxController.GetHeldBoomboxItem(__instance);
			if (Object.op_Implicit((Object)(object)heldBoomboxItem))
			{
				ulong networkObjectId = ((NetworkBehaviour)heldBoomboxItem).NetworkObjectId;
				if (BoomboxController.BoomboxControllers.ContainsKey(networkObjectId))
				{
					boomboxController = BoomboxController.BoomboxControllers[networkObjectId];
				}
			}
			BoomboxController boomboxController2 = null;
			BoomboxItem lookingAtBoomboxItem = LookingPatch.LookingAtBoomboxItem;
			if (Object.op_Implicit((Object)(object)lookingAtBoomboxItem))
			{
				ulong networkObjectId2 = ((NetworkBehaviour)lookingAtBoomboxItem).NetworkObjectId;
				if (BoomboxController.BoomboxControllers.ContainsKey(networkObjectId2))
				{
					boomboxController2 = BoomboxController.BoomboxControllers[networkObjectId2];
				}
			}
			BoomboxController boomboxController3 = null;
			BoomboxItem lookingAtPlayerBoomboxItem = LookingPatch.LookingAtPlayerBoomboxItem;
			if (Object.op_Implicit((Object)(object)lookingAtPlayerBoomboxItem))
			{
				ulong networkObjectId3 = ((NetworkBehaviour)lookingAtPlayerBoomboxItem).NetworkObjectId;
				if (BoomboxController.BoomboxControllers.ContainsKey(networkObjectId3))
				{
					boomboxController3 = BoomboxController.BoomboxControllers[networkObjectId3];
				}
			}
			BoomboxController boomboxController4 = boomboxController3 ?? boomboxController2;
			CruiserController cruiserController = null;
			VehicleController playerVehicleController = CruiserController.GetPlayerVehicleController(__instance);
			if (Object.op_Implicit((Object)(object)playerVehicleController))
			{
				ulong networkObjectId4 = ((NetworkBehaviour)playerVehicleController).NetworkObjectId;
				if (CruiserController.CruiserControllers.ContainsKey(networkObjectId4))
				{
					cruiserController = CruiserController.CruiserControllers[networkObjectId4];
				}
			}
			CruiserController cruiserController2 = null;
			VehicleController lookingAtVehicleController = LookingPatch.LookingAtVehicleController;
			if (Object.op_Implicit((Object)(object)lookingAtVehicleController))
			{
				ulong networkObjectId5 = ((NetworkBehaviour)lookingAtVehicleController).NetworkObjectId;
				if (CruiserController.CruiserControllers.ContainsKey(networkObjectId5))
				{
					cruiserController2 = CruiserController.CruiserControllers[networkObjectId5];
				}
			}
			value = Config.KeyboardShortcutSync.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				if (Object.op_Implicit((Object)(object)lookingAtPlayerBoomboxItem) && LookingPatch.LookingAtPlayerBoomboxItems.Count > 1)
				{
					bool flag = false;
					foreach (BoomboxItem item in LookingPatch.LookingAtPlayerBoomboxItems.ToList())
					{
						ulong networkObjectId6 = ((NetworkBehaviour)item).NetworkObjectId;
						if (BoomboxController.BoomboxControllers.ContainsKey(networkObjectId6))
						{
							BoomboxController boomboxController5 = BoomboxController.BoomboxControllers[networkObjectId6];
							if (boomboxController5.IsResyncable())
							{
								boomboxController5.Resync();
								flag = true;
							}
						}
					}
					if (flag)
					{
						return;
					}
				}
				Controller controller = (Controller)(((object)boomboxController4) ?? ((object)cruiserController2));
				if (Object.op_Implicit((Object)(object)controller) && controller.IsResyncable())
				{
					controller.Resync();
					return;
				}
				Controller controller2 = (Controller)(((object)cruiserController) ?? ((object)boomboxController));
				if (Object.op_Implicit((Object)(object)controller2) && (Object)(object)controller2 != (Object)(object)controller && Object.op_Implicit((Object)(object)control