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;
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 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 BoomboxAudioLoader : MonoBehaviour
	{
		internal static readonly Dictionary<string, AudioClip> filenameIdAudioClips = new Dictionary<string, AudioClip>();

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

		private static BoomboxAudioLoader 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(BoomboxAudioLoader).Name).AddComponent<BoomboxAudioLoader>();
				Object.DontDestroyOnLoad((Object)(object)Instance);
			}
			((MonoBehaviour)Instance).StartCoroutine(routine);
		}

		internal IEnumerator GetAudioClip(BoomboxItemController boomboxItemController, int requestId, string path, bool resync)
		{
			string filenameId = Path.GetFileNameWithoutExtension(path);
			bool flag = false;
			bool success = false;
			if (filenameIdAudioClips.ContainsKey(filenameId))
			{
				AudioClip audioClip = filenameIdAudioClips[filenameId];
				if (Object.op_Implicit((Object)(object)audioClip) && (int)audioClip.loadState == 2)
				{
					yield return null;
					SetAudio(filenameId, audioClip);
					flag = true;
					success = true;
				}
				else
				{
					filenameIdAudioClips.Remove(filenameId);
				}
			}
			bool flag2 = BoomboxAudioDownloader.IsFilenameIdDownloaded(filenameId);
			if (!flag && flag2)
			{
				if (filenameIdsDownloaded.Contains(filenameId))
				{
					filenameIdsDownloaded.Remove(filenameId);
				}
				filenameIdsDownloaded.Insert(0, filenameId);
				AudioType audioType = BoomboxAudioDownloader.audioType;
				UnityWebRequest unityWebRequest = UnityWebRequestMultimedia.GetAudioClip(path, audioType);
				try
				{
					((DownloadHandlerAudioClip)unityWebRequest.downloadHandler).streamAudio = (int)audioType == 13;
					yield return unityWebRequest.SendWebRequest();
					if ((int)unityWebRequest.result == 1)
					{
						AudioClip content = DownloadHandlerAudioClip.GetContent(unityWebRequest);
						if ((int)content.loadState == 2)
						{
							boomboxItemController.audioType = audioType;
							SetAudio(filenameId, content);
							success = true;
						}
					}
				}
				finally
				{
					((IDisposable)unityWebRequest)?.Dispose();
				}
			}
			if (!success)
			{
				string text = "Error " + (resync ? "resyncing" : "loading") + " request " + BoomboxAudioDownloader.GetFilenameIdString(filenameId);
				YPlay.LogWarning(text);
				YPlayCorePatch.AddChatMessageYP(text);
			}
			boomboxItemController.SendBoomboxLoadedServerDelegate(requestId, success, 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 void SetAudio(string filenameId, AudioClip audioClip)
		{
			filenameIdAudioClips[filenameId] = audioClip;
			YPlayCorePatch.AddChatMessageYP("Loaded " + BoomboxAudioDownloader.GetFilenameIdString(filenameId));
		}
	}
	internal class BoomboxAudioDownloader
	{
		[CompilerGenerated]
		private BoomboxItemController <boomboxItemController>P;

		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 BoomboxAudioLoader boomboxAudioLoader;

		private BoomboxAudioAction boomboxAudioAction;

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

		internal static string audioTypeExtension = "mp3";

		internal static AudioType audioType = (AudioType)13;

		private static readonly OptionSet optionSet = new OptionSet
		{
			NoPlaylist = true,
			ForceIPv4 = true
		};

		public BoomboxAudioDownloader(BoomboxItemController boomboxItemController)
		{
			<boomboxItemController>P = boomboxItemController;
			lastDownloadRequestId = -1;
			boomboxAudioLoader = new BoomboxAudioLoader();
			base..ctor();
		}

		internal async void DownloadTask(int requestId, string filenameId, string title, int duration, string url, float time, bool resync = false)
		{
			if (string.IsNullOrEmpty(filenameId?.Trim()) || string.IsNullOrEmpty(title?.Trim()) || string.IsNullOrEmpty(url?.Trim()))
			{
				YPlayCorePatch.AddChatMessageYP("Invalid " + (resync ? "resync" : "download") + " request");
				return;
			}
			if (resync)
			{
				filenameIdsResyncing.Add(filenameId);
			}
			lastDownloadRequestId = requestId;
			lastDownloadRequestFilenameId = filenameId;
			time = Mathf.Max(time, 0f);
			POST_TASK postTask = POST_TASK.NONE;
			audioIdTitles[filenameId] = title;
			audioIdDurations[filenameId] = duration;
			await Task.Run(delegate
			{
				string outputFileLocationForId = GetOutputFileLocationForId(filenameId);
				CancelCurrentProcess();
				if (IsFilenameLoaded(filenameId))
				{
					postTask = LoadFile(filenameId, outputFileLocationForId, requestId, resync);
				}
				else if (!YPlay.IsYPlayUtilValid())
				{
					postTask = POST_TASK.ERROR_MISSING_DEPENDENCY;
				}
				else if (YPlay.IsDownloadingTools())
				{
					postTask = POST_TASK.ERROR_DOWNLOADING_TOOLS;
				}
				else if (!YPlay.IsToolsExistAndNonEmpty())
				{
					postTask = POST_TASK.ERROR_INVALID_TOOLS;
				}
				else
				{
					boomboxAudioAction = new BoomboxAudioAction(this, requestId, filenameId, outputFileLocationForId, url);
					postTask = boomboxAudioAction.Start(resync);
				}
			});
			string text = null;
			RLE_REASON rLE_REASON = RLE_REASON.NONE;
			switch (postTask)
			{
			case POST_TASK.ERROR_MISSING_DEPENDENCY:
				rLE_REASON = RLE_REASON.MISSING_DEPENDENCY;
				text = "Missing dependency, please try reinstalling YPlayBoombox";
				break;
			case POST_TASK.ERROR_DOWNLOADING_TOOLS:
				rLE_REASON = RLE_REASON.DOWNLOADING_TOOLS;
				text = "Downloading tools...";
				break;
			case POST_TASK.ERROR_INVALID_TOOLS:
				rLE_REASON = RLE_REASON.INVALID_TOOLS;
				text = "Invalid tools, please try /yp reset-tools";
				break;
			case POST_TASK.ERROR_DOWNLOADING_AUDIO:
				rLE_REASON = RLE_REASON.FAILED_DOWNLOAD;
				text = "Error downloading request " + GetFilenameIdString(filenameId);
				break;
			case POST_TASK.ERROR_LOADING_AUDIO:
				rLE_REASON = RLE_REASON.FAILED_LOAD;
				text = "Error loading request " + GetFilenameIdString(filenameId);
				break;
			}
			if (rLE_REASON != 0)
			{
				<boomboxItemController>P.SendBoomboxLoadedServerDelegate(requestId, loaded: false, resync, rLE_REASON);
				YPlay.LogError(text);
				YPlayCorePatch.AddChatMessageYP(text);
			}
			filenameIdsResyncing.Remove(filenameId);
		}

		internal void CancelCurrentProcess()
		{
			if (boomboxAudioAction != null && boomboxAudioAction.actionState == ACTION_STATE.PROCESSING)
			{
				boomboxAudioAction.KillProcess();
				YPlayCorePatch.AddChatMessageYP("Previous process cancelled " + GetFilenameIdString(boomboxAudioAction.filenameId));
			}
		}

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

		internal async Task DownloadMetadata(BoomboxRequestMetadata boomboxRequestMetadata, string url, string filenameId, float time)
		{
			await Task.Run(delegate
			{
				RM_STATUS rM_STATUS = RM_STATUS.NONE;
				if (string.IsNullOrEmpty(url?.Trim()) || string.IsNullOrEmpty(filenameId?.Trim()))
				{
					rM_STATUS = RM_STATUS.INVALID_METADATA;
				}
				else if (!YPlay.IsYPlayUtilValid())
				{
					rM_STATUS = RM_STATUS.MISSING_DEPENDENCY;
				}
				else if (YPlay.IsDownloadingTools())
				{
					rM_STATUS = RM_STATUS.DOWNLOADING_TOOLS;
				}
				else if (!YPlay.IsToolsExistAndNonEmpty())
				{
					rM_STATUS = RM_STATUS.INVALID_TOOLS;
				}
				if (rM_STATUS != 0)
				{
					boomboxRequestMetadata.rmStatus = rM_STATUS;
				}
				else
				{
					string text = (audioIdTitles.ContainsKey(filenameId) ? audioIdTitles[filenameId] : null);
					int num = (audioIdDurations.ContainsKey(filenameId) ? audioIdDurations[filenameId] : 0);
					if (!IsMetadataLoadedForFilenameId(filenameId))
					{
						(text, num) = GetAudioTitleDuration(url);
						if (string.IsNullOrEmpty(text?.Trim()) || num == 0)
						{
							boomboxRequestMetadata.rmStatus = RM_STATUS.INVALID_METADATA;
							return;
						}
						audioIdTitles[filenameId] = text;
						audioIdDurations[filenameId] = num;
					}
					int num2 = num / 60;
					if (num2 > 12)
					{
						boomboxRequestMetadata.rmStatus = RM_STATUS.INVALID_MAX_DURATION;
					}
					else if (string.IsNullOrEmpty(text?.Trim()) || num == 0)
					{
						boomboxRequestMetadata.rmStatus = RM_STATUS.INVALID_METADATA;
					}
					else
					{
						boomboxRequestMetadata.filenameId = filenameId;
						boomboxRequestMetadata.url = url;
						boomboxRequestMetadata.time = time;
						boomboxRequestMetadata.title = text;
						boomboxRequestMetadata.duration = num;
						if (boomboxRequestMetadata.rmStatus != RM_STATUS.CANCELLED)
						{
							boomboxRequestMetadata.rmStatus = RM_STATUS.VALID;
						}
					}
				}
			});
		}

		private (string title, int duration) GetAudioTitleDuration(string url)
		{
			YoutubeDL val = YPlay.NewYoutubeDl();
			string text = "";
			int item = 0;
			try
			{
				OptionSet val2 = optionSet;
				RunResult<VideoData> result = val.RunVideoDataFetch(url, default(CancellationToken), true, false, val2).GetAwaiter().GetResult();
				VideoData data = result.Data;
				if (result != null)
				{
					text = data.Title;
					item = (int)data.Duration.GetValueOrDefault();
				}
			}
			catch (Exception)
			{
				return ("", 0);
			}
			if (string.IsNullOrEmpty(text?.Trim()))
			{
				text = GetFilenameIdFromUrl(url);
			}
			return (text, item);
		}

		internal POST_TASK LoadFile(string filenameId, string outputFileLocation, int requestId, bool resync)
		{
			if (IsFilenameLoaded(filenameId))
			{
				boomboxAudioLoader.Start(boomboxAudioLoader.GetAudioClip(<boomboxItemController>P, requestId, outputFileLocation, resync));
				return POST_TASK.NONE;
			}
			return POST_TASK.ERROR_LOADING_AUDIO;
		}

		private bool IsFilenameLoaded(string filenameId)
		{
			if (!string.IsNullOrEmpty(filenameId?.Trim()))
			{
				if (!IsFilenameIdDownloaded(filenameId))
				{
					return BoomboxAudioLoader.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 (!string.IsNullOrEmpty(text?.Trim()))
			{
				return text;
			}
			return null;
		}

		internal static void KillAllBoomboxDownloaderProcesses()
		{
			foreach (KeyValuePair<ulong, BoomboxItemController> item in new Dictionary<ulong, BoomboxItemController>(BoomboxItemController.boomboxItemControllers))
			{
				BoomboxItemController value = item.Value;
				value.boomboxAudioDownloader.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) + "." + audioTypeExtension;
		}

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

		private readonly BoomboxAudioDownloader boomboxAudioDownloader;

		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;

		private static readonly OptionSet optionSet;

		internal BoomboxAudioAction(BoomboxAudioDownloader boomboxAudioDownloader, int requestId, string filenameId, string outputFileLocation, string url)
		{
			this.boomboxAudioDownloader = boomboxAudioDownloader;
			this.requestId = requestId;
			this.filenameId = filenameId;
			this.outputFileLocation = outputFileLocation;
			this.url = url;
			tmpFile = YPlay.GetRandomTempFileLocation();
			tmpFileWithExt = tmpFile + "." + BoomboxAudioDownloader.audioTypeExtension;
			youtubeDL = YPlay.NewYoutubeDl();
			youtubeDL.OutputFileTemplate = tmpFile;
			cancellationTokenSource = new CancellationTokenSource();
		}

		internal POST_TASK Start(bool resync)
		{
			YPlayCorePatch.AddChatMessageYP("Downloading " + BoomboxAudioDownloader.GetFilenameIdString(filenameId) + "...");
			try
			{
				RunResult<string> result = youtubeDL.RunAudioDownload(url, (AudioConversionFormat)(BoomboxAudioDownloader.audioTypeExtension.Equals("wav") ? 7 : 3), cancellationTokenSource.Token, (IProgress<DownloadProgress>)null, (IProgress<string>)null, optionSet).GetAwaiter().GetResult();
			}
			catch (Exception)
			{
			}
			try
			{
				if (actionState == ACTION_STATE.PROCESSING && boomboxAudioDownloader.lastDownloadRequestId == requestId)
				{
					if (!File.Exists(outputFileLocation))
					{
						if (!BoomboxAudioDownloader.IsFileValid(tmpFileWithExt))
						{
							throw new Exception("Temp file not valid");
						}
						YPlay.CreateParentDirectory(outputFileLocation);
						File.Move(tmpFileWithExt, outputFileLocation);
					}
					actionState = ACTION_STATE.FINISHED;
					return boomboxAudioDownloader.LoadFile(filenameId, outputFileLocation, requestId, resync);
				}
			}
			catch (Exception)
			{
				KillProcess();
				return POST_TASK.ERROR_DOWNLOADING_AUDIO;
			}
			finally
			{
				DeleteRequestFiles();
			}
			return POST_TASK.NONE;
		}

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

		private void DeleteRequestFiles()
		{
			Task.Delay(2000).ContinueWith(delegate
			{
				YPlay.DeleteFile(tmpFile);
				YPlay.DeleteFile(tmpFileWithExt);
			});
		}

		static BoomboxAudioAction()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			OptionSet val = new OptionSet();
			val.NoPlaylist = true;
			val.ForceIPv4 = true;
			val.Format = "140";
			val.PostprocessorArgs = MultiValue<string>.op_Implicit(new string[1] { "ffmpeg:-filter:a dynaudnorm" });
			optionSet = val;
		}
	}
	internal class BoomboxItemController : NetworkBehaviour
	{
		internal static readonly Dictionary<ulong, BoomboxItemController> boomboxItemControllers = new Dictionary<ulong, BoomboxItemController>();

		private static readonly Dictionary<AudioClip, BoomboxItemController> audioClipBoomboxItemController = new Dictionary<AudioClip, BoomboxItemController>();

		private static readonly Dictionary<ulong, double> clientIdsLastRequestSentMs = new Dictionary<ulong, double>();

		private double lastRequestSentMs;

		internal BoomboxAudioDownloader boomboxAudioDownloader;

		internal BoomboxItem boomboxItem;

		internal string serverFilenameId;

		internal string serverUrl;

		internal string serverTitle;

		internal int serverDuration;

		internal float serverTime;

		internal string filenameId;

		private string url;

		private string title;

		private int duration;

		private float timeSaved;

		private float timeRequested;

		internal AudioType audioType = (AudioType)13;

		private bool showSyncRandomBoomboxColorMsg;

		private COLOR_PATTERN colorPattern;

		private IEnumerator colorPatternCoroutine;

		internal BoomboxRequestMetadata boomboxRequestMetadata;

		private CancellationTokenSource metadataCompletionCancellationTokenSource;

		private CancellationTokenSource requestCompletionCancellationTokenSource;

		private static readonly DateTime epochDateTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

		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 void Awake()
		{
			boomboxAudioDownloader = new BoomboxAudioDownloader(this);
			boomboxItem = ((Component)this).GetComponent<BoomboxItem>();
			((GrabbableObject)boomboxItem).itemProperties.requiresBattery = false;
		}

		internal void Start()
		{
			ulong networkObjectId = ((NetworkBehaviour)boomboxItem).NetworkObjectId;
			boomboxItemControllers[networkObjectId] = this;
			if (Config.configEntryRandomColor.Value && IsHostOrIsOffline())
			{
				SyncRandomBoomboxColor(((NetworkBehaviour)this).NetworkManager.LocalClientId);
			}
		}

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
		}

		internal void SendRequestServerDelegate(string url, float time)
		{
			//IL_0015: 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)
			if (YPlayCorePatch.IsOfflineMode())
			{
				SendRequestServerLocal(url, time);
			}
			else
			{
				SendRequestServerRpc(url, time);
			}
		}

		internal void SendBoomboxLoadedServerDelegate(int requestId, bool loaded, bool resync, RLE_REASON rleReason = RLE_REASON.NONE)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (YPlayCorePatch.IsOfflineMode())
			{
				SendBoomboxLoadedServerLocal(requestId, loaded, resync, rleReason);
			}
			else
			{
				SendBoomboxLoadedServerRpc(requestId, loaded, resync, rleReason);
			}
		}

		internal void SyncBoomboxVolumeRequestServerDelegate(float volume, bool msg = false)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (YPlayCorePatch.IsOfflineMode())
			{
				SyncBoomboxVolumeRequestClientShared(volume, YPlayCorePatch.LocalPlayerController.actualClientId, msg);
			}
			else
			{
				SyncBoomboxVolumeRequestServerRpc(volume, msg);
			}
		}

		internal void SyncBoomboxColorRequestServerDelegate(float r, float g, float b, COLOR_PATTERN colorPattern = COLOR_PATTERN.NONE)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (YPlayCorePatch.IsOfflineMode())
			{
				if (!ApplyColorPattern(colorPattern, ((NetworkBehaviour)this).NetworkManager.LocalClientId))
				{
					SyncBoomboxColorRequestClientShared(r, g, b, colorPattern, YPlayCorePatch.LocalPlayerController.actualClientId, msg: true);
				}
			}
			else
			{
				SyncBoomboxColorRequestServerRpc(r, g, b, colorPattern);
			}
		}

		internal void ResetBoomboxRequestServerDelegate()
		{
			if (YPlayCorePatch.IsOfflineMode())
			{
				ResetBoombox();
			}
			else
			{
				ResetBoomboxRequestServerRpc();
			}
		}

		internal void SyncBoomboxTimeRequestServerDelegate(float time, REQUEST_TYPE requestType = REQUEST_TYPE.NONE)
		{
			//IL_0015: 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)
			if (YPlayCorePatch.IsOfflineMode())
			{
				SyncBoomboxTimeRequestServerLocal(time, requestType);
			}
			else
			{
				SyncBoomboxTimeRequestServerRpc(time, requestType);
			}
		}

		internal void SyncBoomboxRequestLookingAtServerDelegate(ulong boomboxLookingAtId)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (YPlayCorePatch.IsOfflineMode())
			{
				SyncBoomboxRequestLookingAtServerLocal(boomboxLookingAtId);
			}
			else
			{
				SyncBoomboxRequestLookingAtServerRpc(boomboxLookingAtId);
			}
		}

		private void SyncRandomBoomboxColor(ulong clientId, bool msg = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Color randomBoomboxColor = GetRandomBoomboxColor();
			if (((NetworkBehaviour)this).IsHost)
			{
				SyncBoomboxColorRequestClientRpc(randomBoomboxColor.r, randomBoomboxColor.g, randomBoomboxColor.b, colorPattern, clientId, msg);
			}
			else
			{
				SyncBoomboxColorRequestClientShared(randomBoomboxColor.r, randomBoomboxColor.g, randomBoomboxColor.b, colorPattern, clientId, msg);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void SendRequestServerRpc(string url, float time, 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: 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_0088: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: 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)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3425911769u, serverRpcParams, (RpcDelivery)0);
				bool flag = url != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(url, false);
				}
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref time, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3425911769u, serverRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost) || IsInvalidServerCall())
			{
				return;
			}
			ulong senderClientId = serverRpcParams.Receive.SenderClientId;
			if (ClientRequestWait(senderClientId))
			{
				return;
			}
			ClientRpcParams clientRpcParams = default(ClientRpcParams);
			clientRpcParams.Send.TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId);
			RM_STATUS rM_STATUS = RM_STATUS.NONE;
			string filenameIdFromUrl = BoomboxAudioDownloader.GetFilenameIdFromUrl(url);
			if (string.IsNullOrEmpty(url?.Trim()) || string.IsNullOrEmpty(filenameIdFromUrl?.Trim()))
			{
				rM_STATUS = RM_STATUS.INVALID_URL;
			}
			else if (!IsBoomboxValid(boomboxItem))
			{
				rM_STATUS = RM_STATUS.INVALID_BOOMBOX;
			}
			else if (!YPlay.IsYPlayUtilValid())
			{
				rM_STATUS = RM_STATUS.MISSING_DEPENDENCY;
			}
			else if (YPlay.IsDownloadingTools())
			{
				rM_STATUS = RM_STATUS.DOWNLOADING_TOOLS;
			}
			else if (!YPlay.IsToolsExistAndNonEmpty())
			{
				rM_STATUS = RM_STATUS.INVALID_TOOLS;
			}
			if (rM_STATUS != 0)
			{
				if (senderClientId != YPlayCorePatch.LocalPlayerController.actualClientId)
				{
					string text = rM_STATUS switch
					{
						RM_STATUS.MISSING_DEPENDENCY => "you are missing a dependency, please try reinstalling YPlayBoombox", 
						RM_STATUS.DOWNLOADING_TOOLS => "you are still downloading tools", 
						RM_STATUS.INVALID_TOOLS => "you have invalid tools, please try /yp reset-tools", 
						_ => null, 
					};
					if (text != null)
					{
						string text2 = "You cannot process this client request because " + text;
						YPlay.LogError(text2);
						YPlayCorePatch.AddChatMessageYP(text2);
					}
				}
				SendRequestFailedClientRpc(filenameIdFromUrl, rM_STATUS, clientRpcParams);
			}
			else
			{
				if (boomboxRequestMetadata != null && boomboxRequestMetadata.rmStatus == RM_STATUS.INITIALIZING)
				{
					CancelBoomboxRequestServer(boomboxRequestMetadata.requestId, boomboxRequestMetadata.filenameId, senderClientId, RC_REASON.NEW_REQUEST);
				}
				DownloadMetadataServer(url, filenameIdFromUrl, time, senderClientId);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void SendBoomboxLoadedServerRpc(int requestId, bool loaded, bool resync, RLE_REASON rleReason = RLE_REASON.NONE, 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_008a: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1074417815u, serverRpcParams, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, requestId);
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref loaded, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref resync, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<RLE_REASON>(ref rleReason, default(ForEnums));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1074417815u, serverRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost) || IsInvalidServerCall())
			{
				return;
			}
			ulong senderClientId = serverRpcParams.Receive.SenderClientId;
			if (resync && loaded)
			{
				SyncBoomboxRequestVerifyMultipleServer(resync, senderClientId);
			}
			else if (IsBoomboxRequestMetadataActive(boomboxRequestMetadata))
			{
				RC_REASON rC_REASON = RcReasonErrorCheck();
				if (rC_REASON != 0)
				{
					CancelBoomboxRequestServer(requestId, boomboxRequestMetadata.filenameId, senderClientId, rC_REASON);
				}
				else
				{
					SendBoomboxLoadedCallServer(boomboxRequestMetadata, senderClientId, loaded, rleReason);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void ResetBoomboxRequestServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2681523663u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2681523663u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !IsInvalidServerCall() && IsBoomboxValid(boomboxItem))
				{
					ResetBoomboxRequestClientRpc();
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void SyncBoomboxRequestLookingAtServerRpc(ulong boomboxLookingAtId, 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_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_0107: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3702246251u, serverRpcParams, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, boomboxLookingAtId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3702246251u, serverRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !IsInvalidServerCall() && boomboxItemControllers.ContainsKey(boomboxLookingAtId))
			{
				BoomboxItemController boomboxItemController = boomboxItemControllers[boomboxLookingAtId];
				BoomboxItem val2 = boomboxItemController.boomboxItem;
				if (IsBoomboxValid(val2) && ShouldResync(boomboxItemController))
				{
					ulong senderClientId = serverRpcParams.Receive.SenderClientId;
					SyncBoomboxRequestLookingAtClientRpc(boomboxLookingAtId, senderClientId);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void SyncBoomboxTimeRequestServerRpc(float time, REQUEST_TYPE requestType = REQUEST_TYPE.NONE, 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2185615963u, serverRpcParams, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref time, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe<REQUEST_TYPE>(ref requestType, default(ForEnums));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2185615963u, serverRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !IsInvalidServerCall() && IsBoomboxValid(boomboxItem) && IsBoomboxTimeValid(time) && ShouldResyncTime(time))
				{
					ulong senderClientId = serverRpcParams.Receive.SenderClientId;
					SyncBoomboxTimeRequestClientRpc(time, senderClientId, filenameId, requestType);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void SyncBoomboxVolumeRequestServerRpc(float volume, bool msg, 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: 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)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(160244116u, serverRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref volume, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref msg, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 160244116u, serverRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !IsInvalidServerCall() && IsBoomboxValid(boomboxItem))
			{
				volume = Mathf.Clamp((float)Math.Round(volume, 1), 0f, 1f);
				if (ShouldResyncVolume(volume))
				{
					ulong senderClientId = serverRpcParams.Receive.SenderClientId;
					SyncBoomboxVolumeRequestClientRpc(volume, senderClientId, msg);
				}
			}
		}

		[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_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3044477801u, 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, 3044477801u, serverRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !IsInvalidServerCall())
			{
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!ApplyColorPattern(colorPattern, senderClientId))
				{
					SyncBoomboxColorRequestClientRpc(r, g, b, colorPattern, senderClientId, msg: true);
				}
			}
		}

		private bool ApplyColorPattern(COLOR_PATTERN colorPattern, ulong clientId)
		{
			this.colorPattern = colorPattern;
			if (colorPatternCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(colorPatternCoroutine);
			}
			if (this.colorPattern == COLOR_PATTERN.RAINBOW)
			{
				((MonoBehaviour)this).StartCoroutine(colorPatternCoroutine = ColorPatternRainbow(clientId));
				return true;
			}
			return false;
		}

		private IEnumerator ColorPatternRainbow(ulong clientId)
		{
			showSyncRandomBoomboxColorMsg = true;
			while (colorPattern == COLOR_PATTERN.RAINBOW)
			{
				SyncRandomBoomboxColor(clientId, showSyncRandomBoomboxColorMsg);
				showSyncRandomBoomboxColorMsg = false;
				yield return (object)new WaitForSeconds(1f);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		internal void SyncAllBoomboxRequestServerRpc(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_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: 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_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: 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)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1929840421u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1929840421u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !IsInvalidServerCall() && IsBoomboxValid(boomboxItem))
			{
				ulong networkObjectId = ((NetworkBehaviour)boomboxItem).NetworkObjectId;
				BoomboxRequest boomboxRequest = GetBoomboxRequest(networkObjectId, request: true);
				if (boomboxRequest != null)
				{
					ClientRpcParams clientRpcParams = default(ClientRpcParams);
					clientRpcParams.Send.TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(clientId);
					SyncBoomboxVolumeRequestClientRpc(boomboxRequest.volume, 0uL, msg: false, clientRpcParams);
					Color boomboxBodyColor = GetBoomboxBodyColor();
					SyncBoomboxColorRequestClientRpc(boomboxBodyColor.r, boomboxBodyColor.g, boomboxBodyColor.b, colorPattern, 0uL, msg: false, clientRpcParams);
					SyncBoomboxPlayingRequestClientRpc(boomboxRequest.filenameId, boomboxRequest.url, boomboxRequest.title, boomboxRequest.duration, boomboxRequest.time, boomboxRequest.isPlayingMusic, clientRpcParams);
				}
			}
		}

		private bool ClientRequestWait(ulong clientId)
		{
			//IL_005a: 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)
			double timeMs = GetTimeMs();
			double val = 0.0;
			if (clientIdsLastRequestSentMs.ContainsKey(clientId))
			{
				val = clientIdsLastRequestSentMs[clientId];
			}
			else
			{
				clientIdsLastRequestSentMs[clientId] = timeMs;
			}
			double val2 = lastRequestSentMs;
			double num = Math.Max(val, val2);
			double num2 = timeMs - num;
			if (num2 <= 5000.0)
			{
				ClientRpcParams clientRpcParams = default(ClientRpcParams);
				clientRpcParams.Send.TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(clientId);
				double waitMs = Math.Max(0.0, 5000.0 - num2);
				SendRequestFailedWaitClientRpc(waitMs, clientRpcParams);
				return true;
			}
			clientIdsLastRequestSentMs[clientId] = (lastRequestSentMs = timeMs);
			return false;
		}

		private void SyncBoomboxRequestVerifyMultipleServer(bool resync = false, ulong clientId = 0uL)
		{
			//IL_008c: 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_0122: Unknown result type (might be due to invalid IL or missing references)
			if (IsInvalidServerCall())
			{
				return;
			}
			Dictionary<ulong, BoomboxItemController> dictionary = new Dictionary<ulong, BoomboxItemController>(boomboxItemControllers);
			List<BoomboxItemController> list = new List<BoomboxItemController>();
			foreach (KeyValuePair<ulong, BoomboxItemController> item in dictionary)
			{
				BoomboxItemController value = item.Value;
				if (!((Object)(object)value == (Object)null) && (resync || !((Object)(object)value == (Object)(object)this)) && !(value.filenameId != filenameId))
				{
					list.Add(value);
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			ClientRpcParams clientRpcParams = default(ClientRpcParams);
			if (resync)
			{
				clientRpcParams.Send.TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(clientId);
			}
			foreach (BoomboxItemController item2 in list)
			{
				ulong networkObjectId = ((NetworkBehaviour)item2).NetworkObjectId;
				BoomboxRequest boomboxRequest = item2.GetBoomboxRequest(networkObjectId);
				if (boomboxRequest != null)
				{
					item2.SyncBoomboxRequestVerifyMultipleClientRpc(boomboxRequest.filenameId, boomboxRequest.url, boomboxRequest.title, boomboxRequest.duration, boomboxRequest.time, boomboxRequest.isPlayingMusic, clientRpcParams);
				}
			}
			if (resync)
			{
				SendResyncedMessageClientRpc(clientRpcParams);
			}
		}

		internal void SendBoomboxLoadedCallServer(BoomboxRequestMetadata boomboxRequestMetadata, ulong clientId, bool loaded, RLE_REASON rleReason = RLE_REASON.NONE)
		{
			if (IsInvalidServerCall() || !IsBoomboxRequestMetadataActive(boomboxRequestMetadata) || !boomboxRequestMetadata.pendingClientIdRequests.Contains(clientId))
			{
				return;
			}
			boomboxRequestMetadata.pendingClientIdRequests.Remove(clientId);
			int count = boomboxRequestMetadata.originalClientIdRequests.Count;
			int count2 = boomboxRequestMetadata.pendingClientIdRequests.Count;
			int loadedClientCount = Mathf.Clamp(count - count2, 0, count);
			SendBoomboxLoadedClientRpc(boomboxRequestMetadata.requestId, boomboxRequestMetadata.filenameId, clientId, loaded, loadedClientCount, count, rleReason);
			if (!loaded && clientId == YPlayCorePatch.LocalPlayerController.actualClientId)
			{
				CancelBoomboxRequestServer(boomboxRequestMetadata.requestId, boomboxRequestMetadata.filenameId, clientId, RC_REASON.HOST_FAILED);
			}
			else if (count2 == 0)
			{
				boomboxRequestMetadata.pendingClientIdRequests.Clear();
				ulong networkObjectId = ((NetworkBehaviour)boomboxItem).NetworkObjectId;
				BoomboxRequest boomboxRequest = GetBoomboxRequest(networkObjectId, request: true);
				if (boomboxRequest != null)
				{
					boomboxRequest.filenameId = boomboxRequestMetadata.filenameId;
					boomboxRequest.url = boomboxRequestMetadata.url;
					boomboxRequest.title = boomboxRequestMetadata.title;
					boomboxRequest.duration = boomboxRequestMetadata.duration;
					boomboxRequest.time = boomboxRequestMetadata.time;
					SyncBoomboxRequestClientRpc(request: true, boomboxRequest.filenameId, boomboxRequest.url, boomboxRequest.title, boomboxRequest.duration, boomboxRequest.time, boomboxRequest.isPlayingMusic);
					SyncBoomboxRequestVerifyMultipleServer(resync: false, 0uL);
				}
			}
		}

		private async void DownloadMetadataServer(string url, string filenameId, float time, ulong clientId)
		{
			if (IsInvalidServerCall())
			{
				return;
			}
			SendRequestInitialisingMessageClientRpc(clientId, filenameId);
			if (boomboxRequestMetadata != null)
			{
				KillRequestIdClientRpc(boomboxRequestMetadata.requestId);
			}
			CancelMetadataAndRequestTimersShared();
			HashSet<ulong> collection = new HashSet<ulong>(YPlayCorePatch.modEnabledForClientIds);
			BoomboxRequestMetadata boomboxRequestMetadataLocal = (boomboxRequestMetadata = new BoomboxRequestMetadata
			{
				originalClientIdRequests = new HashSet<ulong>(collection),
				pendingClientIdRequests = new HashSet<ulong>(collection)
			});
			CancellationTokenSource metadataCompletionCancellationTokenSourceLocal = (metadataCompletionCancellationTokenSource = new CancellationTokenSource());
			Task metadataTask = boomboxAudioDownloader.DownloadMetadata(boomboxRequestMetadataLocal, url, filenameId, time);
			if (await Task.WhenAny(new Task[2]
			{
				metadataTask,
				Task.Delay(15000, metadataCompletionCancellationTokenSourceLocal.Token)
			}) != metadataTask)
			{
				if (metadataCompletionCancellationTokenSourceLocal.IsCancellationRequested || !IsBoomboxRequestMetadataActive(boomboxRequestMetadataLocal))
				{
					return;
				}
				SendRequestFailedClientRpc(filenameId, boomboxRequestMetadataLocal.rmStatus = RM_STATUS.TIMEOUT);
			}
			if (boomboxRequestMetadataLocal.rmStatus != RM_STATUS.VALID)
			{
				SendRequestFailedClientRpc(filenameId, boomboxRequestMetadataLocal.rmStatus);
				return;
			}
			DownloadTaskClientRpc(boomboxRequestMetadataLocal.requestId, boomboxRequestMetadataLocal.filenameId, boomboxRequestMetadataLocal.title, boomboxRequestMetadataLocal.duration, boomboxRequestMetadataLocal.url, time);
			CancellationTokenSource requestCompletionCancellationTokenSourceLocal = (requestCompletionCancellationTokenSource = new CancellationTokenSource());
			Task requestCompletionTimeoutTask = RequestCompletionTimeoutTask(45000);
			if (await Task.WhenAny(new Task[2]
			{
				requestCompletionTimeoutTask,
				Task.Delay(45000, requestCompletionCancellationTokenSourceLocal.Token)
			}) == requestCompletionTimeoutTask || requestCompletionCancellationTokenSourceLocal.IsCancellationRequested || !IsBoomboxRequestMetadataActive(boomboxRequestMetadataLocal))
			{
				return;
			}
			ulong actualClientId = YPlayCorePatch.LocalPlayerController.actualClientId;
			HashSet<ulong> hashSet = new HashSet<ulong>();
			foreach (ulong pendingClientIdRequest in boomboxRequestMetadataLocal.pendingClientIdRequests)
			{
				hashSet.Add(pendingClientIdRequest);
			}
			HashSet<ulong> hashSet2 = hashSet;
			if (hashSet2.Contains(YPlayCorePatch.LocalPlayerController.actualClientId))
			{
				hashSet2 = new HashSet<ulong> { actualClientId };
			}
			foreach (ulong item in hashSet2)
			{
				SendBoomboxLoadedCallServer(boomboxRequestMetadataLocal, item, loaded: false, RLE_REASON.TIMEOUT);
			}
		}

		private async Task RequestCompletionTimeoutTask(int timeout)
		{
			await Task.Run(delegate
			{
				Thread.Sleep(timeout);
			});
		}

		private void CancelBoomboxRequestServer(int requestId, string filenameId, ulong clientId, RC_REASON rcReason)
		{
			if (!IsInvalidServerCall())
			{
				CancelBoomboxServer(requestId);
				SendBoomboxRequestCancelledMessageClientRpc(filenameId, clientId, rcReason);
			}
		}

		private void CancelBoomboxServer(int requestId)
		{
			if (!IsInvalidServerCall())
			{
				if (boomboxRequestMetadata != null && boomboxRequestMetadata.requestId == requestId)
				{
					boomboxRequestMetadata.rmStatus = RM_STATUS.CANCELLED;
					boomboxRequestMetadata.pendingClientIdRequests.Clear();
					CancelRequestTimerShared();
				}
				ClearPreviousAudioClipsClientRpc();
			}
		}

		public override void OnDestroy()
		{
			if (!IsInvalidServerCall())
			{
				if (boomboxRequestMetadata != null)
				{
					CancelBoomboxServer(boomboxRequestMetadata.requestId);
				}
				((NetworkBehaviour)this).OnDestroy();
			}
		}

		[ClientRpc]
		private void KillRequestIdClientRpc(int requestId)
		{
			//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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3126721376u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, requestId);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3126721376u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
				{
					boomboxAudioDownloader.KillRequestId(requestId);
				}
			}
		}

		[ClientRpc]
		private void ClearPreviousAudioClipsClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3187082761u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3187082761u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
				{
					ClearUnusedAudioClips();
				}
			}
		}

		[ClientRpc]
		private void SyncBoomboxRequestLookingAtClientRpc(ulong boomboxLookingAtId, 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3898947593u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, boomboxLookingAtId);
					BytePacker.WriteValueBitPacked(val2, clientId);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3898947593u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
				{
					SyncBoomboxRequestLookingAtClientShared(boomboxLookingAtId, clientId);
				}
			}
		}

		[ClientRpc]
		private void SendRequestInitialisingMessageClientRpc(ulong clientId, string filenameId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_0095: 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_00c7: 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)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2497770173u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientId);
				bool flag = filenameId != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(filenameId, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2497770173u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
			{
				string playerUsernameFromClientId = YPlayCorePatch.GetPlayerUsernameFromClientId(clientId);
				YPlayCorePatch.AddChatMessageYP(playerUsernameFromClientId + " requested [" + filenameId + "]...");
			}
		}

		[ClientRpc]
		private void SendResyncedMessageClientRpc(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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3136043952u, clientRpcParams, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3136043952u, clientRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
				{
					YPlayCorePatch.AddChatMessageYP("Resync successful");
				}
			}
		}

		[ClientRpc]
		private void DownloadTaskClientRpc(int requestId, string filenameId, string title, int duration, string url, float time)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: 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_0095: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(923605557u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, requestId);
				bool flag = filenameId != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(filenameId, false);
				}
				bool flag2 = title != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(title, false);
				}
				BytePacker.WriteValueBitPacked(val2, duration);
				bool flag3 = url != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag3, default(ForPrimitives));
				if (flag3)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(url, false);
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref time, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 923605557u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
			{
				DownloadTaskClientShared(requestId, filenameId, title, duration, url, time);
			}
		}

		[ClientRpc]
		private void SendRequestFailedClientRpc(string filenameId, RM_STATUS rmStatus, 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: 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_0088: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2668383935u, clientRpcParams, (RpcDelivery)0);
				bool flag = filenameId != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(filenameId, false);
				}
				((FastBufferWriter)(ref val)).WriteValueSafe<RM_STATUS>(ref rmStatus, default(ForEnums));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2668383935u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
			{
				SendRequestFailedClientShared(filenameId, rmStatus);
			}
		}

		[ClientRpc]
		private void SendRequestFailedWaitClientRpc(double waitMs, 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(115722075u, clientRpcParams, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<double>(ref waitMs, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 115722075u, clientRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
				{
					int num = Math.Max(1, (int)Math.Ceiling(TimeSpan.FromMilliseconds(waitMs).TotalSeconds));
					YPlayCorePatch.AddChatMessageYP(string.Format("Please wait {0} second{1} before calling this command", num, (num == 1) ? null : "s"));
				}
			}
		}

		[ClientRpc]
		private void SendBoomboxRequestCancelledMessageClientRpc(string filenameId, ulong clientId, RC_REASON rcReason)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: 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_0088: 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_00af: 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_00ce: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4201653590u, val, (RpcDelivery)0);
				bool flag = filenameId != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(filenameId, false);
				}
				BytePacker.WriteValueBitPacked(val2, clientId);
				((FastBufferWriter)(ref val2)).WriteValueSafe<RC_REASON>(ref rcReason, default(ForEnums));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4201653590u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
			{
				SendBoomboxRequestCancelledMessageClientShared(filenameId, rcReason);
			}
		}

		[ClientRpc]
		private void SendBoomboxLoadedClientRpc(int requestId, string filenameId, ulong clientId, bool loaded, int loadedClientCount, int originalRequestCount, RLE_REASON rleReason)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: 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_0095: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: 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)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3390314703u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, requestId);
				bool flag = filenameId != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(filenameId, false);
				}
				BytePacker.WriteValueBitPacked(val2, clientId);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref loaded, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, loadedClientCount);
				BytePacker.WriteValueBitPacked(val2, originalRequestCount);
				((FastBufferWriter)(ref val2)).WriteValueSafe<RLE_REASON>(ref rleReason, default(ForEnums));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3390314703u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
			{
				SendBoomboxLoadedClientShared(requestId, filenameId, clientId, loaded, loadedClientCount, originalRequestCount, rleReason);
			}
		}

		[ClientRpc]
		private void ResetBoomboxRequestClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3381308416u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3381308416u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
				{
					ResetBoombox();
				}
			}
		}

		[ClientRpc]
		private void SyncBoomboxRequestClientRpc(bool request, string filenameId, string url, string title, int duration, float time, bool isPlayingMusic)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: 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_00a3: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: 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)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3399703514u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref request, default(ForPrimitives));
				bool flag = filenameId != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(filenameId, false);
				}
				bool flag2 = url != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(url, false);
				}
				bool flag3 = title != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag3, default(ForPrimitives));
				if (flag3)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(title, false);
				}
				BytePacker.WriteValueBitPacked(val2, duration);
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref time, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isPlayingMusic, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3399703514u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
			{
				SyncBoomboxRequestClientShared(request, filenameId, url, title, duration, time, isPlayingMusic);
			}
		}

		[ClientRpc]
		private void SyncBoomboxRequestVerifyMultipleClientRpc(string filenameId, string url, string title, int duration, float time, bool isPlayingMusic, 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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_0088: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1261714853u, clientRpcParams, (RpcDelivery)0);
				bool flag = filenameId != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(filenameId, false);
				}
				bool flag2 = url != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(url, false);
				}
				bool flag3 = title != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag3, default(ForPrimitives));
				if (flag3)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(title, false);
				}
				BytePacker.WriteValueBitPacked(val, duration);
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref time, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref isPlayingMusic, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1261714853u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall() && !(filenameId == this.filenameId))
			{
				AudioClip audioClipFromFilenameId = GetAudioClipFromFilenameId(filenameId);
				SyncBoombox(request: false, filenameId, url, title, duration, time, audioClipFromFilenameId, isPlayingMusic, autoRequestPlayState: false);
				ClearUnusedAudioClips();
			}
		}

		[ClientRpc]
		private void SyncBoomboxTimeRequestClientRpc(float time, ulong clientId, string filenameId, REQUEST_TYPE requestType)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_00fd: 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)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1175447752u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref time, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, clientId);
				bool flag = filenameId != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(filenameId, false);
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe<REQUEST_TYPE>(ref requestType, default(ForEnums));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1175447752u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
			{
				SyncBoomboxTimeRequestClientShared(time, clientId, filenameId, requestType);
			}
		}

		[ClientRpc]
		internal void SyncBoomboxVolumeRequestClientRpc(float volume, 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1318585972u, clientRpcParams, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref volume, default(ForPrimitives));
					BytePacker.WriteValueBitPacked(val, clientId);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref msg, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1318585972u, clientRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
				{
					SyncBoomboxVolumeRequestClientShared(volume, clientId, msg);
				}
			}
		}

		[ClientRpc]
		internal void SyncBoomboxColorRequestClientRpc(float r, float g, float b, COLOR_PATTERN colorPattern, 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_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3867183133u, 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));
					BytePacker.WriteValueBitPacked(val, clientId);
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref msg, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3867183133u, clientRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall())
				{
					SyncBoomboxColorRequestClientShared(r, g, b, colorPattern, clientId, msg);
				}
			}
		}

		[ClientRpc]
		internal void SyncBoomboxPlayingRequestClientRpc(string filenameId, string url, string title, int duration, float time, bool isPlayingMusic, 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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_0088: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1911341357u, clientRpcParams, (RpcDelivery)0);
				bool flag = filenameId != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(filenameId, false);
				}
				bool flag2 = url != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(url, false);
				}
				bool flag3 = title != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag3, default(ForPrimitives));
				if (flag3)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(title, false);
				}
				BytePacker.WriteValueBitPacked(val, duration);
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref time, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref isPlayingMusic, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1911341357u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !IsInvalidClientCall() && IsBoomboxValid(boomboxItem))
			{
				AudioClip audioClipFromFilenameId = GetAudioClipFromFilenameId(filenameId);
				if (!Object.op_Implicit((Object)(object)audioClipFromFilenameId))
				{
					ResetAudioClip();
				}
				SyncBoombox(request: false, filenameId, url, title, duration, time, audioClipFromFilenameId, isPlayingMusic && !boomboxItem.isPlayingMusic);
			}
		}

		internal void PlayBoombox(float forceTime = 0f)
		{
			if (!IsBoomboxValid(boomboxItem))
			{
				return;
			}
			AudioClip clip = boomboxItem.boomboxAudio.clip;
			if (!Config.configEntrySync.Value && (Object)(object)clip != (Object)null)
			{
				if (audioClipBoomboxItemController.ContainsKey(clip))
				{
					BoomboxItemController boomboxItemController = audioClipBoomboxItemController[clip];
					if ((Object)(object)boomboxItemController != (Object)(object)this && IsBoomboxValid(boomboxItemController.boomboxItem) && !string.IsNullOrEmpty(filenameId?.Trim()) && boomboxItemController.filenameId == filenameId && boomboxItemController.boomboxItem.isPlayingMusic)
					{
						boomboxItemController.StopBoombox();
					}
				}
				audioClipBoomboxItemController[clip] = this;
			}
			if (!IsAudioLoadedInMemory())
			{
				boomboxItem.boomboxAudio.time = 0f;
			}
			else if (forceTime > 0f)
			{
				boomboxItem.boomboxAudio.time = forceTime;
			}
			else if (timeSaved > 0f)
			{
				boomboxItem.boomboxAudio.time = timeSaved;
			}
			boomboxItem.boomboxAudio.pitch = 1f;
			boomboxItem.boomboxAudio.Play();
			boomboxItem.isPlayingMusic = (((GrabbableObject)boomboxItem).isBeingUsed = true);
		}

		internal void StopBoombox(float forceTime = 0f)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (IsBoomboxValid(boomboxItem))
			{
				if (!IsAudioLoadedInMemory())
				{
					boomboxItem.boomboxAudio.time = (timeSaved = 0f);
				}
				else if (forceTime > 0f)
				{
					boomboxItem.boomboxAudio.time = (timeSaved = forceTime);
				}
				else
				{
					timeSaved = boomboxItem.boomboxAudio.time;
				}
				if (((NetworkBehaviour)this).IsHost)
				{
					SyncBoomboxTimeRequestServerRpc(boomboxItem.boomboxAudio.time, REQUEST_TYPE.STOP);
				}
				bool isPlayingMusic = boomboxItem.is