using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using LethalConfig.Mods;
using Microsoft.CodeAnalysis;
using Mirage.Domain.Audio;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Networking;
using com.github.zehsteam.MelaniesVoice.Dependencies;
using com.github.zehsteam.MelaniesVoice.Extensions;
using com.github.zehsteam.MelaniesVoice.Helpers;
using com.github.zehsteam.MelaniesVoice.Managers;
using com.github.zehsteam.MelaniesVoice.MonoBehaviours;
using com.github.zehsteam.MelaniesVoice.NetcodePatcher;
using com.github.zehsteam.MelaniesVoice.Objects;
using com.github.zehsteam.MelaniesVoice.Objects.Config;
using com.github.zehsteam.MelaniesVoice.Objects.Voices;
using com.github.zehsteam.MelaniesVoice.Patches;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("LethalConfig")]
[assembly: IgnoresAccessChecksTo("Mirage")]
[assembly: IgnoresAccessChecksTo("Mirage.Plugin")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.github.zehsteam.MelaniesVoice")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2025 Zehs")]
[assembly: AssemblyDescription("[v73+] Allows players to talk through Text-To-Speech (TTS) by using the in-game chat.")]
[assembly: AssemblyFileVersion("1.7.1.0")]
[assembly: AssemblyInformationalVersion("1.7.1+8c4053cd6b7ff3035525326c94660163e55ec054")]
[assembly: AssemblyProduct("MelaniesVoice")]
[assembly: AssemblyTitle("com.github.zehsteam.MelaniesVoice")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.7.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
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 com.github.zehsteam.MelaniesVoice
{
	internal static class Assets
	{
		public static AssetBundle AssetBundle { get; private set; }

		public static GameObject VoiceControllerPrefab { get; private set; }

		public static void Load()
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			string text = "melaniesvoice_assets";
			string text2 = Path.Combine(directoryName, text);
			if (!File.Exists(text2))
			{
				Logger.LogFatal("Failed to load assets. AssetBundle file could not be found at path \"" + text2 + "\". Make sure the \"" + text + "\" file is in the same folder as the mod's DLL file.");
			}
			else
			{
				AssetBundle val = AssetBundle.LoadFromFile(text2);
				if ((Object)(object)val == (Object)null)
				{
					Logger.LogFatal("Failed to load assets. AssetBundle is null.");
				}
				else
				{
					OnAssetBundleLoaded(val);
				}
			}
		}

		private static void OnAssetBundleLoaded(AssetBundle assetBundle)
		{
			AssetBundle = assetBundle;
			VoiceControllerPrefab = LoadAsset<GameObject>("VoiceController", assetBundle);
		}

		private static T LoadAsset<T>(string name, AssetBundle assetBundle) where T : Object
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				Logger.LogError("Failed to load asset of type \"" + typeof(T).Name + "\" from AssetBundle. Name is null or whitespace.");
				return default(T);
			}
			if ((Object)(object)assetBundle == (Object)null)
			{
				Logger.LogError("Failed to load asset of type \"" + typeof(T).Name + "\" with name \"" + name + "\" from AssetBundle. AssetBundle is null.");
				return default(T);
			}
			T val = assetBundle.LoadAsset<T>(name);
			if ((Object)(object)val == (Object)null)
			{
				Logger.LogError("Failed to load asset of type \"" + typeof(T).Name + "\" with name \"" + name + "\" from AssetBundle. No asset found with that type and name.");
				return default(T);
			}
			return val;
		}

		private static bool TryLoadAsset<T>(string name, AssetBundle assetBundle, out T asset) where T : Object
		{
			asset = LoadAsset<T>(name, assetBundle);
			return (Object)(object)asset != (Object)null;
		}
	}
	internal static class Utils
	{
		[CompilerGenerated]
		private sealed class <WaitForTask>d__4<T> : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Task<T> task;

			public Action<T> result;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!task.IsCompleted)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if (task.IsFaulted)
				{
					throw task.Exception;
				}
				result?.Invoke(task.Result);
				return false;
			}

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

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

		public static string GetPluginPersistentDataPath()
		{
			return Path.Combine(Application.persistentDataPath, "MelaniesVoice");
		}

		public static ConfigFile CreateConfigFile(BaseUnityPlugin plugin, string path, string name = null, bool saveOnInit = false)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			BepInPlugin metadata = MetadataHelper.GetMetadata((object)plugin);
			if (name == null)
			{
				name = metadata.GUID;
			}
			name += ".cfg";
			return new ConfigFile(Path.Combine(path, name), saveOnInit, metadata);
		}

		public static ConfigFile CreateLocalConfigFile(BaseUnityPlugin plugin, string name = null, bool saveOnInit = false)
		{
			return CreateConfigFile(plugin, Paths.ConfigPath, name, saveOnInit);
		}

		public static ConfigFile CreateGlobalConfigFile(BaseUnityPlugin plugin, string name = null, bool saveOnInit = false)
		{
			string pluginPersistentDataPath = GetPluginPersistentDataPath();
			if (name == null)
			{
				name = "global";
			}
			return CreateConfigFile(plugin, pluginPersistentDataPath, name, saveOnInit);
		}

		[IteratorStateMachine(typeof(<WaitForTask>d__4<>))]
		public static IEnumerator WaitForTask<T>(Task<T> task, Action<T> result)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForTask>d__4<T>(0)
			{
				task = task,
				result = result
			};
		}

		public static string SanitizeFileName(string input)
		{
			char[] invalidChars = Path.GetInvalidFileNameChars();
			return string.Concat(input.Where((char c) => !invalidChars.Contains(c)));
		}

		public static void DisplayMessage(string text, bool isError = false)
		{
			string text2 = "MelaniesVoice";
			if (isError)
			{
				text2 += " - ERROR";
			}
			HUDManager instance = HUDManager.Instance;
			if (instance != null)
			{
				instance.DisplayTip(text2, text, isError, false, "LC_Tip1");
			}
		}
	}
	internal static class Logger
	{
		public static ManualLogSource ManualLogSource { get; private set; }

		public static void Initialize(ManualLogSource manualLogSource)
		{
			ManualLogSource = manualLogSource;
		}

		public static void LogDebug(object data, bool extended = false)
		{
			Log((LogLevel)32, data, extended);
		}

		public static void LogInfo(object data, bool extended = false)
		{
			Log((LogLevel)16, data, extended);
		}

		public static void LogMessage(object data, bool extended = false)
		{
			Log((LogLevel)8, data, extended);
		}

		public static void LogWarning(object data, bool extended = false)
		{
			Log((LogLevel)4, data, extended);
		}

		public static void LogError(object data, bool extended = false)
		{
			Log((LogLevel)2, data, extended);
		}

		public static void LogFatal(object data, bool extended = false)
		{
			Log((LogLevel)1, data, extended);
		}

		public static void Log(LogLevel logLevel, object data, bool extended = false)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!extended || IsExtendedLoggingEnabled())
			{
				ManualLogSource manualLogSource = ManualLogSource;
				if (manualLogSource != null)
				{
					manualLogSource.Log(logLevel, data);
				}
			}
		}

		public static bool IsExtendedLoggingEnabled()
		{
			if (ConfigManager.ExtendedLogging == null)
			{
				return false;
			}
			return ConfigManager.ExtendedLogging.Value;
		}
	}
	[BepInPlugin("com.github.zehsteam.MelaniesVoice", "MelaniesVoice", "1.7.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal class Plugin : BaseUnityPlugin
	{
		private readonly Harmony _harmony = new Harmony("com.github.zehsteam.MelaniesVoice");

		public static Plugin Instance { get; private set; }

		public ConfigFile Config { get; private set; }

		private void Awake()
		{
			Instance = this;
			Logger.Initialize(Logger.CreateLogSource("com.github.zehsteam.MelaniesVoice"));
			Logger.LogInfo("MelaniesVoice has awoken!");
			Config = Utils.CreateGlobalConfigFile((BaseUnityPlugin)(object)this);
			_harmony.PatchAll(typeof(GameNetworkManagerPatch));
			_harmony.PatchAll(typeof(StartOfRoundPatch));
			_harmony.PatchAll(typeof(HUDManagerPatch));
			_harmony.PatchAll(typeof(PlayerControllerBPatch));
			Assets.Load();
			ConfigManager.Initialize(Config);
			NetcodePatcherAwake();
		}

		private void NetcodePatcherAwake()
		{
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				Type[] types = executingAssembly.GetTypes();
				Type[] array = types;
				foreach (Type type in array)
				{
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
					MethodInfo[] array2 = methods;
					foreach (MethodInfo methodInfo in array2)
					{
						try
						{
							object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
							if (customAttributes.Length != 0)
							{
								try
								{
									methodInfo.Invoke(null, null);
								}
								catch (TargetInvocationException ex)
								{
									((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to invoke method " + methodInfo.Name + ": " + ex.Message));
								}
							}
						}
						catch (Exception ex2)
						{
							((BaseUnityPlugin)this).Logger.LogWarning((object)("Error processing method " + methodInfo.Name + " in type " + type.Name + ": " + ex2.Message));
						}
					}
				}
			}
			catch (Exception ex3)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("An error occurred in NetcodePatcherAwake: " + ex3.Message));
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.github.zehsteam.MelaniesVoice";

		public const string PLUGIN_NAME = "MelaniesVoice";

		public const string PLUGIN_VERSION = "1.7.1";
	}
}
namespace com.github.zehsteam.MelaniesVoice.Patches
{
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal static class GameNetworkManagerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void StartPatch()
		{
			AddNetworkPrefabs();
			TTSVoice_TTSMonster.FetchVoices();
		}

		private static void AddNetworkPrefabs()
		{
			AddNetworkPrefab(Assets.VoiceControllerPrefab);
		}

		private static void AddNetworkPrefab(GameObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				Logger.LogError("Failed to register network prefab. GameObject is null.");
				return;
			}
			NetworkManager.Singleton.AddNetworkPrefab(prefab);
			Logger.LogInfo("Registered \"" + ((Object)prefab).name + "\" network prefab.");
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	internal static class HUDManagerPatch
	{
		[HarmonyPatch("AddTextToChatOnServer")]
		[HarmonyPostfix]
		private static void AddTextToChatOnServerPatch(string chatMessage, int playerId)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (playerId == -1 || ConfigManager.TTS_DisableMyVoice.Value || chatMessage.StartsWithAny(ConfigManager.TTS_IgnorePefixesArray))
			{
				return;
			}
			PlayerControllerB localPlayerScript = PlayerUtils.GetLocalPlayerScript();
			if (!((Object)(object)localPlayerScript == (Object)null))
			{
				VoiceController componentInChildren = ((Component)localPlayerScript).GetComponentInChildren<VoiceController>();
				if (!((Object)(object)componentInChildren == (Object)null))
				{
					componentInChildren.CreateVoiceMessage_ServerRpc(ConfigManager.TTS_Voice.Value, chatMessage);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal static class PlayerControllerBPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void StartPatch(PlayerControllerB __instance)
		{
			if (NetworkUtils.IsServer)
			{
				GameObject val = Object.Instantiate<GameObject>(Assets.VoiceControllerPrefab, ((Component)__instance).transform);
				NetworkObject component = val.GetComponent<NetworkObject>();
				component.DontDestroyWithOwner = true;
				component.SpawnWithOwnership(__instance.actualClientId, false);
				component.TrySetParent(((Component)__instance).transform, true);
			}
		}

		[HarmonyPatch("OnDestroy")]
		[HarmonyPrefix]
		private static void OnDestroyPatch(PlayerControllerB __instance)
		{
			if (NetworkUtils.IsServer)
			{
				VoiceController componentInChildren = ((Component)__instance).GetComponentInChildren<VoiceController>();
				NetworkObject val = default(NetworkObject);
				if (!((Object)(object)componentInChildren == (Object)null) && ((Component)componentInChildren).TryGetComponent<NetworkObject>(ref val) && val.IsSpawned)
				{
					val.Despawn(true);
				}
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal static class StartOfRoundPatch
	{
		[HarmonyPatch("OnClientConnect")]
		[HarmonyPostfix]
		private static void OnClientConnectPatch(ulong clientId)
		{
			PlayerControllerB playerScriptByClientId = PlayerUtils.GetPlayerScriptByClientId(clientId);
			if (!((Object)(object)playerScriptByClientId == (Object)null))
			{
				VoiceController componentInChildren = ((Component)playerScriptByClientId).GetComponentInChildren<VoiceController>();
				NetworkObject val = default(NetworkObject);
				if (!((Object)(object)componentInChildren == (Object)null) && ((Component)componentInChildren).TryGetComponent<NetworkObject>(ref val) && val.IsSpawned)
				{
					val.ChangeOwnership(playerScriptByClientId.actualClientId);
				}
			}
		}
	}
}
namespace com.github.zehsteam.MelaniesVoice.Objects
{
	public class PlayerAudioGroup
	{
		public AudioSource VoiceAudio { get; private set; }

		public AudioSource DeadAudio { get; private set; }

		public bool IsPlaying => VoiceAudio.isPlaying;

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

		public float MaxDistance
		{
			get
			{
				return VoiceAudio.maxDistance;
			}
			set
			{
				VoiceAudio.maxDistance = value;
				DeadAudio.maxDistance = value;
			}
		}

		public AudioClip Clip
		{
			get
			{
				return VoiceAudio.clip;
			}
			set
			{
				VoiceAudio.clip = value;
				DeadAudio.clip = value;
			}
		}

		public bool Mute
		{
			get
			{
				if (VoiceAudio.mute)
				{
					return DeadAudio.mute;
				}
				return false;
			}
			set
			{
				VoiceAudio.mute = value;
				DeadAudio.mute = value;
			}
		}

		public PlayerAudioGroup(AudioSource voiceAudio, AudioSource deadAudio)
		{
			VoiceAudio = voiceAudio;
			DeadAudio = deadAudio;
		}

		public void Play()
		{
			AudioSource voiceAudio = VoiceAudio;
			if (voiceAudio != null)
			{
				voiceAudio.Play();
			}
			AudioSource deadAudio = DeadAudio;
			if (deadAudio != null)
			{
				deadAudio.Play();
			}
		}

		public void Pause()
		{
			AudioSource voiceAudio = VoiceAudio;
			if (voiceAudio != null)
			{
				voiceAudio.Pause();
			}
			AudioSource deadAudio = DeadAudio;
			if (deadAudio != null)
			{
				deadAudio.Pause();
			}
		}

		public void Stop()
		{
			AudioSource voiceAudio = VoiceAudio;
			if (voiceAudio != null)
			{
				voiceAudio.Stop();
			}
			AudioSource deadAudio = DeadAudio;
			if (deadAudio != null)
			{
				deadAudio.Stop();
			}
		}
	}
	public struct RequestHeader
	{
		public string Name { get; set; }

		public string Value { get; set; }

		public RequestHeader(string name, string value)
		{
			Name = name;
			Value = value;
		}
	}
	public class VoiceMessage
	{
		public int Channels = 1;

		public int SampleRate = 48000;

		private float _timer;

		public int Id { get; private set; }

		public string VoiceName { get; private set; }

		public string Message { get; private set; }

		public AudioClip AudioClip { get; set; }

		public List<ulong> ClientsReceivedAudioClip { get; private set; } = new List<ulong>();


		public List<float> BufferedSamples { get; private set; } = new List<float>();


		public bool IsClipBuilt { get; private set; }

		public bool HasBufferedAudio => BufferedSamples.Count > 0;

		public bool IsReady
		{
			get
			{
				if (!ClientsReceivedAudioClip.Contains(NetworkUtils.GetLocalClientId()))
				{
					return false;
				}
				return ClientsReceivedAudioClip.Count >= NetworkUtils.ConnectedPlayerCount;
			}
		}

		public bool IsTimedout => _timer >= ConfigManager.TTS_RequestTimeoutDuration.Value;

		public VoiceMessage(int id, string voiceName, string message)
		{
			Id = id;
			VoiceName = voiceName;
			Message = message;
		}

		public void Tick()
		{
			_timer += Time.deltaTime;
		}

		public void BuildClipIfNeeded()
		{
			if (!IsClipBuilt && BufferedSamples.Count != 0)
			{
				AudioClip = AudioClip.Create($"VoiceMessage_{Id}", BufferedSamples.Count / Channels, Channels, SampleRate, false);
				AudioClip.SetData(BufferedSamples.ToArray(), 0);
				IsClipBuilt = true;
			}
		}

		public override string ToString()
		{
			return $"(Id: {Id}, VoiceName: \"{VoiceName}\", Message: \"{Message}\")";
		}
	}
}
namespace com.github.zehsteam.MelaniesVoice.Objects.Voices
{
	public enum VoiceService
	{
		Unknown = -1,
		Streamlabs,
		LazyPy,
		TTSMonster
	}
	public abstract class TTSVoice
	{
		protected const int DEFAULT_VOLUME = 100;

		protected static string UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36 OPR/123.0.0.0";

		public string Name { get; protected set; }

		public string VoiceId { get; protected set; }

		public int DefaultVolume { get; protected set; } = 100;


		public abstract VoiceService Service { get; }

		protected TTSVoice(string name, string voiceId, int defaultVolume = 100)
		{
			Name = name;
			VoiceId = voiceId;
			DefaultVolume = defaultVolume;
		}

		public virtual void RequestAudio(string text, Action<AudioClip> onClipReady)
		{
			CoroutineRunner.Start(RequestAudioCoroutine(text, onClipReady));
		}

		public abstract IEnumerator RequestAudioCoroutine(string text, Action<AudioClip> onClipReady);

		protected async Task<JObject> FetchJsonAsync(string url, WWWForm form, List<RequestHeader> requestHeaders = null)
		{
			LogInfo("Sending POST request to \"" + url + "\"", extended: true);
			UnityWebRequest www = UnityWebRequest.Post(url, form);
			try
			{
				www.SetRequestHeader("User-Agent", UserAgent);
				if (requestHeaders != null)
				{
					foreach (RequestHeader requestHeader in requestHeaders)
					{
						www.SetRequestHeader(requestHeader.Name, requestHeader.Value);
					}
				}
				UnityWebRequestAsyncOperation operation = www.SendWebRequest();
				while (!((AsyncOperation)operation).isDone)
				{
					await Task.Yield();
				}
				if ((int)www.result == 4)
				{
					LogError("Failed to process data: " + www.error, extended: false, displayMessage: true);
					return null;
				}
				if ((int)www.result != 1)
				{
					LogError("Failed to fetch audio: " + www.error, extended: false, displayMessage: true);
					return null;
				}
				string text = www.downloadHandler.text;
				try
				{
					JObject val = JObject.Parse(text);
					LogInfo("Response data:\n" + JsonConvert.SerializeObject((object)val, (Formatting)1), extended: true);
					return val;
				}
				catch (Exception arg)
				{
					LogError($"Failed to parse response as JSON:\n\nResponse:\n\"{text}\"\n\nError:\n{arg}");
					DisplayMessage("Failed to parse response. Check logs", isError: true);
					return null;
				}
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}

		protected async Task<JObject> FetchJsonAsync(string url, JObject body, List<RequestHeader> requestHeaders = null)
		{
			LogInfo("Sending POST request to \"" + url + "\"", extended: true);
			string s = ((body != null) ? ((JToken)body).ToString((Formatting)0, Array.Empty<JsonConverter>()) : "{}");
			byte[] bytes = Encoding.UTF8.GetBytes(s);
			UnityWebRequest www = new UnityWebRequest(url, "POST");
			try
			{
				www.uploadHandler = (UploadHandler)new UploadHandlerRaw(bytes);
				www.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				www.SetRequestHeader("Content-Type", "application/json");
				www.SetRequestHeader("User-Agent", UserAgent);
				if (requestHeaders != null)
				{
					foreach (RequestHeader requestHeader in requestHeaders)
					{
						www.SetRequestHeader(requestHeader.Name, requestHeader.Value);
					}
				}
				UnityWebRequestAsyncOperation operation = www.SendWebRequest();
				while (!((AsyncOperation)operation).isDone)
				{
					await Task.Yield();
				}
				if ((int)www.result == 4)
				{
					LogError("Failed to process data: " + www.error, extended: false, displayMessage: true);
					return null;
				}
				if ((int)www.result != 1)
				{
					LogError("Failed to fetch audio: " + www.error, extended: false, displayMessage: true);
					LogError(www.downloadHandler.text, extended: true);
					return null;
				}
				string text = www.downloadHandler.text;
				try
				{
					JObject val = JObject.Parse(text);
					LogInfo("Response data:\n" + JsonConvert.SerializeObject((object)val, (Formatting)1), extended: true);
					return val;
				}
				catch (Exception arg)
				{
					LogError($"Failed to parse response as JSON:\n\nResponse:\n\"{text}\"\n\nError:\n{arg}");
					DisplayMessage("Failed to parse response. Check logs", isError: true);
					return null;
				}
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}

		protected async Task<AudioClip> DownloadAudioClipAsync(string url, AudioType audioType = 13)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			LogInfo("Sending GET request to \"" + url + "\"", extended: true);
			UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip(url, audioType);
			try
			{
				www.SetRequestHeader("User-Agent", UserAgent);
				UnityWebRequestAsyncOperation operation = www.SendWebRequest();
				while (!((AsyncOperation)operation).isDone)
				{
					await Task.Yield();
				}
				if ((int)www.result != 1)
				{
					LogError("Failed to download audio: " + www.error, extended: false, displayMessage: true);
					return null;
				}
				try
				{
					AudioClip content = DownloadHandlerAudioClip.GetContent(www);
					((Object)content).name = string.Format("{0}_{1}_{2}", "MelaniesVoice", Utils.SanitizeFileName(Name), Guid.NewGuid());
					return content;
				}
				catch (Exception ex)
				{
					LogError("Failed to download audio: " + ex.Message, extended: false, displayMessage: true);
					return null;
				}
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}

		protected void DisplayMessage(string text, bool isError = false)
		{
			Utils.DisplayMessage(text, isError);
		}

		public override string ToString()
		{
			return $"(Name: \"{Name}\", Service: {Service}, VoiceId: \"{VoiceId}\")";
		}

		protected void Log(LogLevel logLevel, object data, bool extended = false, bool displayMessage = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			Logger.Log(logLevel, $"[{GetType().Name}] [{Name}] {data}", extended);
			if (displayMessage)
			{
				DisplayMessage(data.ToString(), (int)logLevel == 2);
			}
		}

		protected void LogInfo(object data, bool extended = false, bool displayMessage = false)
		{
			Log((LogLevel)16, data, extended, displayMessage);
		}

		protected void LogWarning(object data, bool extended = false, bool displayMessage = false)
		{
			Log((LogLevel)4, data, extended, displayMessage);
		}

		protected void LogError(object data, bool extended = false, bool displayMessage = false)
		{
			Log((LogLevel)2, data, extended, displayMessage);
		}
	}
	public class TTSVoice_LazyPy : TTSVoice
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass7_0
		{
			public JObject responseJson;

			public Action<AudioClip> onClipReady;

			internal void <RequestAudioCoroutine>b__0(JObject result)
			{
				responseJson = result;
			}

			internal void <RequestAudioCoroutine>b__1(AudioClip clip)
			{
				onClipReady?.Invoke(clip);
			}
		}

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

			private object <>2__current;

			public Action<AudioClip> onClipReady;

			public TTSVoice_LazyPy <>4__this;

			public string text;

			private <>c__DisplayClass7_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Expected O, but got Unknown
				int num = <>1__state;
				TTSVoice_LazyPy tTSVoice_LazyPy = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass7_0();
					<>8__1.onClipReady = onClipReady;
					string url = "https://lazypy.ro/tts/request_tts.php";
					WWWForm val = new WWWForm();
					val.AddField("service", tTSVoice_LazyPy.RedirectService);
					val.AddField("voice", tTSVoice_LazyPy.VoiceId);
					val.AddField("text", this.text);
					Task<JObject> task2 = tTSVoice_LazyPy.FetchJsonAsync(url, val);
					<>8__1.responseJson = null;
					<>2__current = Utils.WaitForTask(task2, delegate(JObject result)
					{
						<>8__1.responseJson = result;
					});
					<>1__state = 1;
					return true;
				}
				case 1:
				{
					<>1__state = -1;
					if (<>8__1.responseJson == null)
					{
						tTSVoice_LazyPy.LogError("Failed to request audio. Response from server is invalid.");
						<>8__1.onClipReady?.Invoke(null);
						return false;
					}
					JToken obj = <>8__1.responseJson["success"];
					if (obj == null || !obj.ToObject<bool>())
					{
						string text = ((object)<>8__1.responseJson["error_msg"])?.ToString();
						tTSVoice_LazyPy.LogError("Failed to fetch audio: " + text);
						tTSVoice_LazyPy.DisplayMessage(text, isError: true);
						<>8__1.onClipReady?.Invoke(null);
						return false;
					}
					string text2 = ((object)<>8__1.responseJson["audio_url"])?.ToString();
					if (string.IsNullOrEmpty(text2))
					{
						tTSVoice_LazyPy.LogError("Failed to fetch audio: 'audio_url' is missing.", extended: false, displayMessage: true);
						<>8__1.onClipReady?.Invoke(null);
						return false;
					}
					Task<AudioClip> task = tTSVoice_LazyPy.DownloadAudioClipAsync(text2, (AudioType)13);
					<>2__current = Utils.WaitForTask(task, delegate(AudioClip clip)
					{
						<>8__1.onClipReady?.Invoke(clip);
					});
					<>1__state = 2;
					return true;
				}
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

		public override VoiceService Service => VoiceService.LazyPy;

		public string RedirectService { get; protected set; }

		public TTSVoice_LazyPy(string name, string redirectService, string voiceId, int defaultVolume = 100)
			: base(name, voiceId, defaultVolume)
		{
			RedirectService = redirectService;
		}

		[IteratorStateMachine(typeof(<RequestAudioCoroutine>d__7))]
		public override IEnumerator RequestAudioCoroutine(string text, Action<AudioClip> onClipReady)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RequestAudioCoroutine>d__7(0)
			{
				<>4__this = this,
				text = text,
				onClipReady = onClipReady
			};
		}
	}
	public class TTSVoice_Streamlabs : TTSVoice
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass3_0
		{
			public JObject responseJson;

			public Action<AudioClip> onClipReady;

			internal void <RequestAudioCoroutine>b__0(JObject result)
			{
				responseJson = result;
			}

			internal void <RequestAudioCoroutine>b__1(AudioClip clip)
			{
				onClipReady?.Invoke(clip);
			}
		}

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

			private object <>2__current;

			public Action<AudioClip> onClipReady;

			public TTSVoice_Streamlabs <>4__this;

			public string text;

			private <>c__DisplayClass3_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Expected O, but got Unknown
				int num = <>1__state;
				TTSVoice_Streamlabs tTSVoice_Streamlabs = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass3_0();
					<>8__1.onClipReady = onClipReady;
					string url = "https://streamlabs.com/tts/polly/speak";
					WWWForm val = new WWWForm();
					val.AddField("voice", tTSVoice_Streamlabs.VoiceId);
					val.AddField("text", this.text);
					Task<JObject> task2 = tTSVoice_Streamlabs.FetchJsonAsync(url, val);
					<>8__1.responseJson = null;
					<>2__current = Utils.WaitForTask(task2, delegate(JObject result)
					{
						<>8__1.responseJson = result;
					});
					<>1__state = 1;
					return true;
				}
				case 1:
				{
					<>1__state = -1;
					if (<>8__1.responseJson == null)
					{
						tTSVoice_Streamlabs.LogError("Failed to request audio. Response from server is invalid.");
						<>8__1.onClipReady?.Invoke(null);
						return false;
					}
					JToken obj = <>8__1.responseJson["success"];
					if (obj == null || !obj.ToObject<bool>())
					{
						string text = ((object)<>8__1.responseJson["message"])?.ToString();
						tTSVoice_Streamlabs.LogError("Failed to fetch audio: " + (object)<>8__1.responseJson["message"]);
						tTSVoice_Streamlabs.DisplayMessage(text, isError: true);
						<>8__1.onClipReady?.Invoke(null);
						return false;
					}
					string text2 = ((object)<>8__1.responseJson["speak_url"])?.ToString();
					if (string.IsNullOrEmpty(text2))
					{
						tTSVoice_Streamlabs.LogError("Failed to fetch audio: 'speak_url' is missing.", extended: false, displayMessage: true);
						<>8__1.onClipReady?.Invoke(null);
						return false;
					}
					Task<AudioClip> task = tTSVoice_Streamlabs.DownloadAudioClipAsync(text2, (AudioType)13);
					<>2__current = Utils.WaitForTask(task, delegate(AudioClip clip)
					{
						<>8__1.onClipReady?.Invoke(clip);
					});
					<>1__state = 2;
					return true;
				}
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

		public override VoiceService Service => VoiceService.Streamlabs;

		public TTSVoice_Streamlabs(string name, string voiceId, int defaultVolume = 100)
			: base(name, voiceId, defaultVolume)
		{
		}

		[IteratorStateMachine(typeof(<RequestAudioCoroutine>d__3))]
		public override IEnumerator RequestAudioCoroutine(string text, Action<AudioClip> onClipReady)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RequestAudioCoroutine>d__3(0)
			{
				<>4__this = this,
				text = text,
				onClipReady = onClipReady
			};
		}
	}
	public class TTSVoice_TTSMonster : TTSVoice
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass5_0
		{
			public JObject responseJson;

			public Action<AudioClip> onClipReady;

			internal void <RequestAudioCoroutine>b__0(JObject result)
			{
				responseJson = result;
			}

			internal void <RequestAudioCoroutine>b__1(AudioClip clip)
			{
				onClipReady?.Invoke(clip);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass8_0
		{
			public JObject responseJson;

			internal void <FetchVoicesCoroutine>b__0(JObject result)
			{
				responseJson = result;
			}
		}

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

			private object <>2__current;

			private <>c__DisplayClass8_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass8_0();
					string value = ConfigManager.TTSMonster_APIKey.Value;
					if (string.IsNullOrEmpty(value))
					{
						StaticLogError("Failed to fetch voices. TTS.Monster API key required. Set in config file.");
						return false;
					}
					Task<JObject> task = FetchVoicesJsonAsync(value);
					<>8__1.responseJson = null;
					<>2__current = Utils.WaitForTask(task, delegate(JObject result)
					{
						<>8__1.responseJson = result;
					});
					<>1__state = 1;
					return true;
				}
				case 1:
				{
					<>1__state = -1;
					if (<>8__1.responseJson == null)
					{
						StaticLogError("Failed to fetch voices. Response from server is invalid.");
						return false;
					}
					List<TTSMonsterVoice> list = ParseVoicesJson(<>8__1.responseJson);
					if (list.Count == 0)
					{
						StaticLogError("Failed to fetch voices. No voices found from response data.");
						return false;
					}
					List<TTSVoice_TTSMonster> list2 = ConvertToTTSVoices(list);
					if (list2.Count == 0)
					{
						StaticLogError("Failed to fetch voices. Could not convert TTSMonsterVoice(s) to TTSVoice_TTSMonster(s)");
						return false;
					}
					UpdateExistingVoicesData(list2);
					List<TTSVoice_TTSMonster> list3 = TextToSpeech.AddVoices(list2, logErrors: false);
					if (list3.Count > 0)
					{
						VoiceConfigManager.BindConfigs(list3);
						ConfigManager.UpdateTTSVoiceAcceptableValues();
					}
					StaticLogInfo($"Found {list.Count} voices. Registered {list3.Count} new voices.");
					return false;
				}
				}
			}

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

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

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

			private object <>2__current;

			public Action<AudioClip> onClipReady;

			public TTSVoice_TTSMonster <>4__this;

			public string text;

			private <>c__DisplayClass5_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Expected O, but got Unknown
				int num = <>1__state;
				TTSVoice_TTSMonster tTSVoice_TTSMonster = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass5_0();
					<>8__1.onClipReady = onClipReady;
					string url = "https://api.console.tts.monster/generate";
					string value = ConfigManager.TTSMonster_APIKey.Value;
					if (string.IsNullOrEmpty(value))
					{
						tTSVoice_TTSMonster.LogError("TTS.Monster API key required. Set in config file.", extended: false, displayMessage: true);
						<>8__1.onClipReady?.Invoke(null);
						return false;
					}
					List<RequestHeader> requestHeaders = new List<RequestHeader>(1)
					{
						new RequestHeader("Authorization", value)
					};
					JObject body = new JObject
					{
						["voice_id"] = JToken.op_Implicit(tTSVoice_TTSMonster.VoiceId),
						["message"] = JToken.op_Implicit(this.text)
					};
					Task<JObject> task2 = tTSVoice_TTSMonster.FetchJsonAsync(url, body, requestHeaders);
					<>8__1.responseJson = null;
					<>2__current = Utils.WaitForTask(task2, delegate(JObject result)
					{
						<>8__1.responseJson = result;
					});
					<>1__state = 1;
					return true;
				}
				case 1:
				{
					<>1__state = -1;
					if (<>8__1.responseJson == null)
					{
						tTSVoice_TTSMonster.LogError("Failed to request audio. Response from server is invalid.");
						<>8__1.onClipReady?.Invoke(null);
						return false;
					}
					JToken obj = <>8__1.responseJson["status"];
					int num2 = ((obj != null) ? obj.ToObject<int>() : 0);
					if (num2 != 200)
					{
						string text = num2 switch
						{
							401 => "Unauthorized: Invalid API key", 
							402 => "Character quota exceeded. Upgrade your account or turn on usage-based-billing", 
							429 => "Too many requests. Try again later", 
							500 => "Internal server error", 
							_ => $"Unknown error. Code {num2}", 
						};
						tTSVoice_TTSMonster.LogError("Failed to fetch audio: " + text);
						tTSVoice_TTSMonster.DisplayMessage(text, isError: true);
						<>8__1.onClipReady?.Invoke(null);
						return false;
					}
					string text2 = ((object)<>8__1.responseJson["url"])?.ToString();
					if (string.IsNullOrEmpty(text2))
					{
						tTSVoice_TTSMonster.LogError("Failed to fetch audio: 'url' is missing.", extended: false, displayMessage: true);
						<>8__1.onClipReady?.Invoke(null);
						return false;
					}
					Task<AudioClip> task = tTSVoice_TTSMonster.DownloadAudioClipAsync(text2, (AudioType)20);
					<>2__current = Utils.WaitForTask(task, delegate(AudioClip clip)
					{
						<>8__1.onClipReady?.Invoke(clip);
					});
					<>1__state = 2;
					return true;
				}
				case 2:
					<>1__state = -1;
					return false;
				}
			}

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

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

		private static readonly Dictionary<string, string> _voiceNameProxies;

		public override VoiceService Service => VoiceService.TTSMonster;

		static TTSVoice_TTSMonster()
		{
			_voiceNameProxies = new Dictionary<string, string>();
			_voiceNameProxies.Add("Chef", "Gordon Ramsay");
			_voiceNameProxies.Add("Circuit", "Linus Tech Tips");
			_voiceNameProxies.Add("Dash", "Sonic");
			_voiceNameProxies.Add("Diplomat", "Joe Biden");
			_voiceNameProxies.Add("Elder", "Morgan Freeman");
			_voiceNameProxies.Add("Frogman", "Kermit");
			_voiceNameProxies.Add("Gravel", "MoistCr1TiKaL");
			_voiceNameProxies.Add("Leader", "Obama");
			_voiceNameProxies.Add("Micro", "Plankton");
			_voiceNameProxies.Add("Oracle", "GLaDOS");
			_voiceNameProxies.Add("Phantom", "Vega");
			_voiceNameProxies.Add("Scout", "Bart Simpson");
			_voiceNameProxies.Add("Spongey", "Sponge Bob");
			_voiceNameProxies.Add("Star", "Patrick Star");
			_voiceNameProxies.Add("Tentacle", "Squidward");
			_voiceNameProxies.Add("Tycoon", "Donald Trump");
		}

		public TTSVoice_TTSMonster(string name, string voiceId, int defaultVolume = 100)
			: base(name, voiceId, defaultVolume)
		{
		}

		[IteratorStateMachine(typeof(<RequestAudioCoroutine>d__5))]
		public override IEnumerator RequestAudioCoroutine(string text, Action<AudioClip> onClipReady)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RequestAudioCoroutine>d__5(0)
			{
				<>4__this = this,
				text = text,
				onClipReady = onClipReady
			};
		}

		public static List<TTSVoice_TTSMonster> CreateDefaultVoices()
		{
			try
			{
				JObject val = PluginResourceHelper.ReadJObject("Data/TTSMonsterVoicesDefault.json");
				if (val == null)
				{
					return new List<TTSVoice_TTSMonster>();
				}
				return ConvertToTTSVoices(ParseVoicesJson(val));
			}
			catch (Exception arg)
			{
				StaticLogError($"Failed to load default voices. {arg}");
				return new List<TTSVoice_TTSMonster>();
			}
		}

		public static void FetchVoices()
		{
			CoroutineRunner.Start(FetchVoicesCoroutine());
		}

		[IteratorStateMachine(typeof(<FetchVoicesCoroutine>d__8))]
		public static IEnumerator FetchVoicesCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FetchVoicesCoroutine>d__8(0);
		}

		protected static async Task<JObject> FetchVoicesJsonAsync(string apiKey)
		{
			string text = "https://api.console.tts.monster/voices";
			StaticLogInfo("Sending POST request to \"" + text + "\"", extended: true);
			UnityWebRequest www = UnityWebRequest.Post(text, new WWWForm());
			try
			{
				www.SetRequestHeader("User-Agent", TTSVoice.UserAgent);
				www.SetRequestHeader("Authorization", apiKey);
				UnityWebRequestAsyncOperation operation = www.SendWebRequest();
				while (!((AsyncOperation)operation).isDone)
				{
					await Task.Yield();
				}
				if ((int)www.result == 4)
				{
					StaticLogError("Failed to process voices data: " + www.error);
					return null;
				}
				if ((int)www.result != 1)
				{
					StaticLogError("Failed to fetch voices: " + www.error);
					return null;
				}
				string text2 = www.downloadHandler.text;
				try
				{
					JObject val = JObject.Parse(text2);
					StaticLogInfo("Response data:\n" + JsonConvert.SerializeObject((object)val, (Formatting)1), extended: true);
					return val;
				}
				catch (Exception arg)
				{
					StaticLogError($"Failed to parse response as JSON:\n\nResponse:\n\"{text2}\"\n\nError:\n{arg}");
					return null;
				}
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}

		protected static void UpdateExistingVoicesData(List<TTSVoice_TTSMonster> voices)
		{
			List<TTSVoice_TTSMonster> list = (from x in TextToSpeech.GetVoicesByService(VoiceService.TTSMonster)
				select x as TTSVoice_TTSMonster into x
				where x != null
				select x).ToList();
			foreach (TTSVoice_TTSMonster existingVoice in list)
			{
				TTSVoice_TTSMonster tTSVoice_TTSMonster = voices.FirstOrDefault((TTSVoice_TTSMonster x) => x.Name == existingVoice.Name);
				if (tTSVoice_TTSMonster != null && existingVoice.VoiceId != tTSVoice_TTSMonster.VoiceId)
				{
					existingVoice.VoiceId = tTSVoice_TTSMonster.VoiceId;
					StaticLogInfo("Updated already registerd voice \"" + existingVoice.Name + "\" VoiceId to \"" + tTSVoice_TTSMonster.VoiceId + "\"", extended: true);
				}
			}
		}

		protected static string GetProxyName(string name)
		{
			return _voiceNameProxies.GetValueOrDefault(name, name);
		}

		protected static List<TTSMonsterVoice> ParseVoicesJson(string text)
		{
			try
			{
				JObject data = JObject.Parse(text);
				return ParseVoicesJson(data);
			}
			catch (Exception arg)
			{
				StaticLogError($"Failed to parse text as JSON:\n\nResponse:\n\"{text}\"\n\nError:\n{arg}");
				return new List<TTSMonsterVoice>();
			}
		}

		protected static List<TTSMonsterVoice> ParseVoicesJson(JObject data)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			List<TTSMonsterVoice> list = new List<TTSMonsterVoice>();
			string text = "TTSM - ";
			JToken obj = data["customVoices"];
			JArray val = (JArray)(object)((obj is JArray) ? obj : null);
			JToken obj2 = data["voices"];
			JArray val2 = (JArray)(object)((obj2 is JArray) ? obj2 : null);
			foreach (JObject item in val)
			{
				JObject val3 = item;
				string text2 = ((object)val3["name"])?.ToString();
				string text3 = ((object)val3["voice_id"])?.ToString();
				if (!string.IsNullOrEmpty(text2) && !string.IsNullOrEmpty(text3))
				{
					list.Add(new TTSMonsterVoice(text + text2, text3, isCustom: true));
				}
			}
			foreach (JObject item2 in val2)
			{
				JObject val4 = item2;
				string text4 = ((object)val4["name"])?.ToString();
				string text5 = ((object)val4["voice_id"])?.ToString();
				if (!string.IsNullOrEmpty(text4) && !string.IsNullOrEmpty(text5))
				{
					list.Add(new TTSMonsterVoice(text + GetProxyName(text4), text5));
				}
			}
			return list;
		}

		protected static List<TTSVoice_TTSMonster> ConvertToTTSVoices(List<TTSMonsterVoice> ttsMonsterVoices)
		{
			List<TTSVoice_TTSMonster> list = new List<TTSVoice_TTSMonster>();
			foreach (TTSMonsterVoice ttsMonsterVoice in ttsMonsterVoices)
			{
				TTSVoice_TTSMonster tTSVoice_TTSMonster = ConvertToTTSVoice(ttsMonsterVoice);
				if (tTSVoice_TTSMonster != null)
				{
					list.Add(tTSVoice_TTSMonster);
				}
			}
			return list;
		}

		protected static TTSVoice_TTSMonster ConvertToTTSVoice(TTSMonsterVoice ttsMonsterVoice)
		{
			if (!ttsMonsterVoice.IsValid())
			{
				return null;
			}
			return new TTSVoice_TTSMonster(ttsMonsterVoice.Name, ttsMonsterVoice.VoiceId);
		}

		public static void OpenLoginWebpage()
		{
			Application.OpenURL("https://console.tts.monster/login");
		}

		protected static void StaticLog(LogLevel logLevel, object data, bool extended = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Logger.Log(logLevel, string.Format("[{0}] {1}", "TTSVoice_TTSMonster", data), extended);
		}

		protected static void StaticLogInfo(object data, bool extended = false)
		{
			StaticLog((LogLevel)16, data, extended);
		}

		protected static void StaticLogWarning(object data, bool extended = false)
		{
			StaticLog((LogLevel)4, data, extended);
		}

		protected static void StaticLogError(object data, bool extended = false)
		{
			StaticLog((LogLevel)2, data, extended);
		}
	}
	public struct TTSMonsterVoice
	{
		public string Name { get; set; }

		public string VoiceId { get; set; }

		public bool IsCustom { get; set; }

		public TTSMonsterVoice(string name, string voiceId, bool isCustom = false)
		{
			Name = name;
			VoiceId = voiceId;
			IsCustom = isCustom;
		}

		public bool IsValid()
		{
			if (!string.IsNullOrEmpty(Name))
			{
				return !string.IsNullOrEmpty(VoiceId);
			}
			return false;
		}

		public override string ToString()
		{
			return $"(Name: \"{Name}\", IsCustom: {IsCustom}, VoiceId: \"{VoiceId}\")";
		}
	}
}
namespace com.github.zehsteam.MelaniesVoice.Objects.Config
{
	public class VoiceConfigEntry
	{
		public TTSVoice Voice { get; private set; }

		public ConfigEntry<int> Volume { get; private set; }

		public VoiceConfigEntry(TTSVoice voice, int defaultVolume)
		{
			Bind(voice, defaultVolume);
		}

		private void Bind(TTSVoice voice, int defaultVolume)
		{
			Voice = voice;
			string section = "Voice: " + Voice.Name;
			Volume = ConfigHelper.Bind(section, "Volume", defaultVolume, "The volume of the voice.", requiresRestart: false, (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 200));
		}
	}
}
namespace com.github.zehsteam.MelaniesVoice.MonoBehaviours
{
	internal class CoroutineRunner : MonoBehaviour
	{
		public static CoroutineRunner Instance { get; private set; }

		public static void Spawn()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Instance != (Object)null))
			{
				new GameObject("MelaniesVoice CoroutineRunner", new Type[1] { typeof(CoroutineRunner) });
			}
		}

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Instance = this;
			((Object)this).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)this);
		}

		public static Coroutine Start(IEnumerator routine)
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Spawn();
			}
			CoroutineRunner instance = Instance;
			return ((instance != null) ? ((MonoBehaviour)instance).StartCoroutine(routine) : null) ?? null;
		}

		public static void Stop(IEnumerator routine)
		{
			if (!((Object)(object)Instance == (Object)null))
			{
				((MonoBehaviour)Instance).StopCoroutine(routine);
			}
		}

		public static void Stop(Coroutine routine)
		{
			if (!((Object)(object)Instance == (Object)null))
			{
				((MonoBehaviour)Instance).StopCoroutine(routine);
			}
		}
	}
	public class VoiceController : NetworkBehaviour
	{
		[CompilerGenerated]
		private sealed class <StreamAudio_Local>d__35 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AudioClip clip;

			public VoiceMessage voiceMessage;

			public VoiceController <>4__this;

			private float[] <data>5__2;

			private int <pos>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				VoiceController voiceController = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)clip == (Object)null)
					{
						return false;
					}
					voiceMessage.AudioClip = clip;
					if (NetworkUtils.ConnectedPlayerCount == 1)
					{
						voiceController.ReceivedVoiceMessageAudioClip_ServerRpc(voiceMessage.Id);
						return false;
					}
					<data>5__2 = new float[clip.samples * clip.channels];
					clip.GetData(<data>5__2, 0);
					<pos>5__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<pos>5__3 < <data>5__2.Length)
				{
					int num2 = Mathf.Min(voiceController._chunkSize, <data>5__2.Length - <pos>5__3);
					float[] array = new float[num2];
					Array.Copy(<data>5__2, <pos>5__3, array, 0, num2);
					voiceController.StreamAudioChunk_ServerRpc(voiceMessage.Id, array, clip.channels, clip.frequency);
					<pos>5__3 += num2;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				voiceController.StreamAudioComplete_ServerRpc(voiceMessage.Id);
				voiceController.ReceivedVoiceMessageAudioClip_ServerRpc(voiceMessage.Id);
				return false;
			}

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

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

		private static readonly List<VoiceController> _instances = new List<VoiceController>();

		[SerializeField]
		private AudioSource _voiceAudio;

		[SerializeField]
		private AudioSource _deadAudio;

		private List<VoiceMessage> _voiceMessageQueue = new List<VoiceMessage>();

		private float _noiseRange = 30f;

		private float _noiseLoudness = 0.7f;

		private float _noiseTimer;

		private float _noiseCooldown = 0.2f;

		private readonly int _chunkSize = 480;

		public static IReadOnlyList<VoiceController> Instances => _instances;

		public PlayerAudioGroup PlayerAudioGroup { get; private set; }

		public PlayerControllerB PlayerScript { get; private set; }

		public bool IsLocal => PlayerUtils.IsLocalPlayer(PlayerScript);

		private void OnEnable()
		{
			if (!_instances.Contains(this))
			{
				_instances.Add(this);
			}
		}

		private void OnDisable()
		{
			_instances.Remove(this);
		}

		private void Start()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB playerScript = default(PlayerControllerB);
			if ((Object)(object)((Component)this).transform.parent == (Object)null)
			{
				LogError("Failed to initialize. Transform parent is null.");
				if (NetworkUtils.IsServer)
				{
					((Component)this).GetComponent<NetworkObject>().Despawn(true);
				}
			}
			else if (!((Component)((Component)this).transform.parent).TryGetComponent<PlayerControllerB>(ref playerScript))
			{
				LogError("Failed to initialize. PlayerControllerB is null.");
				if (NetworkUtils.IsServer)
				{
					((Component)this).GetComponent<NetworkObject>().Despawn(true);
				}
			}
			else
			{
				PlayerScript = playerScript;
				((Component)this).transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
				PlayerAudioGroup = new PlayerAudioGroup(_voiceAudio, _deadAudio);
				PlayerAudioGroup.Volume = 1f;
				ApplySettings();
				LogInfo("Initialized.", extended: true);
			}
		}

		private void Update()
		{
			VoiceMessageTick();
			NoiseTick();
		}

		private void VoiceMessageTick()
		{
			if (!NetworkUtils.IsServer || PlayerAudioGroup == null || IsPlayingVoiceMessage() || _voiceMessageQueue.Count == 0)
			{
				return;
			}
			VoiceMessage voiceMessage = _voiceMessageQueue[0];
			if (voiceMessage == null)
			{
				_voiceMessageQueue.RemoveAt(0);
				return;
			}
			if (voiceMessage.IsReady)
			{
				PlayVoiceMessage_ClientRpc(voiceMessage.Id);
				return;
			}
			voiceMessage.Tick();
			if (voiceMessage.IsTimedout)
			{
				VoiceMessageTimedout_Server(voiceMessage.Id);
			}
		}

		private void NoiseTick()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkUtils.IsServer && PlayerAudioGroup != null && PlayerAudioGroup.IsPlaying && !((Object)(object)PlayerScript == (Object)null))
			{
				if (_noiseTimer >= _noiseCooldown)
				{
					_noiseTimer = 0f;
					RoundManager.Instance.PlayAudibleNoise(((Component)PlayerScript).transform.position, _noiseRange, _noiseLoudness, 0, PlayerScript.isInHangarShipRoom && StartOfRound.Instance.hangarDoorsClosed, 75);
				}
				else
				{
					_noiseTimer += Time.deltaTime;
				}
			}
		}

		private void UpdateVoiceMute()
		{
			if ((Object)(object)PlayerScript == (Object)null || PlayerAudioGroup == null)
			{
				return;
			}
			if (IsLocal)
			{
				PlayerAudioGroup.Mute = !ConfigManager.TTS_HearMyself.Value;
				if (!PlayerAudioGroup.Mute)
				{
					PlayerAudioGroup.VoiceAudio.mute = PlayerScript.isPlayerDead;
					PlayerAudioGroup.DeadAudio.mute = !PlayerScript.isPlayerDead;
				}
			}
			else
			{
				PlayerAudioGroup.VoiceAudio.mute = PlayerScript.isPlayerDead;
				PlayerControllerB localPlayerScript = PlayerUtils.GetLocalPlayerScript();
				if ((Object)(object)localPlayerScript == (Object)null || !localPlayerScript.isPlayerDead)
				{
					PlayerAudioGroup.DeadAudio.mute = true;
				}
				else
				{
					PlayerAudioGroup.DeadAudio.mute = !PlayerScript.isPlayerDead;
				}
			}
		}

		private bool IsPlayingVoiceMessage()
		{
			return PlayerAudioGroup.IsPlaying;
		}

		private VoiceMessage GetVoiceMessage(int id)
		{
			return _voiceMessageQueue.FirstOrDefault((VoiceMessage x) => x.Id == id);
		}

		[ServerRpc]
		public void CreateVoiceMessage_ServerRpc(string voiceName, string message, 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_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Invalid comparison between Unknown and I4
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: 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_00ae: 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_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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2160464779u, serverRpcParams, (RpcDelivery)0);
				bool flag = voiceName != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(voiceName, false);
				}
				bool flag2 = message != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(message, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2160464779u, serverRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (((NetworkBehaviour)this).NetworkManager.ConnectedClients.ContainsKey(senderClientId) && !((Object)(object)PlayerScript == (Object)null) && PlayerScript.actualClientId == senderClientId)
				{
					int id = Random.Range(0, 1000000);
					CreateVoiceMessage_ClientRpc(id, voiceName, message);
				}
			}
		}

		[ClientRpc]
		private void CreateVoiceMessage_ClientRpc(int id, string voiceName, string message)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: 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_014a: 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_0105: 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.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1380029231u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, id);
				bool flag = voiceName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(voiceName, false);
				}
				bool flag2 = message != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(message, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1380029231u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			int id2 = id;
			string voiceName2 = voiceName;
			VoiceMessage voiceMessage = new VoiceMessage(id2, voiceName2, message);
			_voiceMessageQueue.Add(voiceMessage);
			LogInfo($"Created VoiceMessage. {voiceMessage}", extended: true);
			if (!IsLocal)
			{
				return;
			}
			TextToSpeech.RequestAudio(voiceMessage.VoiceName, voiceMessage.Message, delegate(AudioClip clip)
			{
				if ((Object)(object)clip == (Object)null)
				{
					DeleteVoiceMessage_ServerRpc(id2);
				}
				else
				{
					((Object)clip).name = string.Format("{0}_{1}_{2}", "MelaniesVoice", Utils.SanitizeFileName(voiceName2), id2);
					((MonoBehaviour)this).StartCoroutine(StreamAudio_Local(voiceMessage, clip));
					if (MirageProxy.Enabled)
					{
						MirageProxy.SaveAudioClip(clip);
					}
				}
			});
		}

		[ServerRpc]
		private void DeleteVoiceMessage_ServerRpc(int id)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			//IL_0114: 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_00ae: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4045068609u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, id);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4045068609u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				DeleteVoiceMessage_ClientRpc(id);
				DeleteVoiceMessage_Local(id);
			}
		}

		[ClientRpc]
		private void DeleteVoiceMessage_ClientRpc(int id)
		{
			//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_00ce: 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.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2880339731u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, id);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2880339731u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!NetworkUtils.IsServer)
				{
					DeleteVoiceMessage_Local(id);
				}
			}
		}

		private void DeleteVoiceMessage_Local(int id)
		{
			VoiceMessage voiceMessage = GetVoiceMessage(id);
			if (voiceMessage != null)
			{
				_voiceMessageQueue.Remove(voiceMessage);
			}
		}

		[IteratorStateMachine(typeof(<StreamAudio_Local>d__35))]
		private IEnumerator StreamAudio_Local(VoiceMessage voiceMessage, AudioClip clip)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StreamAudio_Local>d__35(0)
			{
				<>4__this = this,
				voiceMessage = voiceMessage,
				clip = clip
			};
		}

		[ServerRpc]
		private void StreamAudioChunk_ServerRpc(int id, float[] chunk, int channels, int sampleRate)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Invalid comparison between Unknown and I4
			//IL_0179: 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_00ae: 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_00b7: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			//IL_010f: 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_0134: 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_0105: 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))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1252295788u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, id);
				bool flag = chunk != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<float>(chunk, default(ForPrimitives));
				}
				BytePacker.WriteValueBitPacked(val2, channels);
				BytePacker.WriteValueBitPacked(val2, sampleRate);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1252295788u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				StreamAudioChunk_ClientRpc(id, chunk, channels, sampleRate);
			}
		}

		[ClientRpc]
		private void StreamAudioChunk_ClientRpc(int id, float[] chunk, int channels, int sampleRate)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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_00bf: 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.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2319454299u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, id);
				bool flag = chunk != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<float>(chunk, default(ForPrimitives));
				}
				BytePacker.WriteValueBitPacked(val2, channels);
				BytePacker.WriteValueBitPacked(val2, sampleRate);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2319454299u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!IsLocal)
			{
				VoiceMessage voiceMessage = GetVoiceMessage(id);
				if (voiceMessage != null)
				{
					voiceMessage.Channels = channels;
					voiceMessage.SampleRate = sampleRate;
					voiceMessage.BufferedSamples.AddRange(chunk);
				}
			}
		}

		[ServerRpc]
		private void StreamAudioComplete_ServerRpc(int id, 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3290872701u, serverRpcParams, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, id);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3290872701u, serverRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (((NetworkBehaviour)this).NetworkManager.ConnectedClients.ContainsKey(senderClientId))
				{
					StreamAudioComplete_ClientRpc(id);
				}
			}
		}

		[ClientRpc]
		private void StreamAudioComplete_ClientRpc(int id)
		{
			//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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: 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.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4122899824u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, id);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4122899824u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!IsLocal)
			{
				VoiceMessage voiceMessage = GetVoiceMessage(id);
				if (voiceMessage != null)
				{
					voiceMessage.BuildClipIfNeeded();
					ReceivedVoiceMessageAudioClip_ServerRpc(voiceMessage.Id);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void ReceivedVoiceMessageAudioClip_ServerRpc(int id, 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_00ce: 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_00d4: 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(2085373701u, serverRpcParams, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, id);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2085373701u, serverRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			ulong senderClientId = serverRpcParams.Receive.SenderClientId;
			if (((NetworkBehaviour)this).NetworkManager.ConnectedClients.ContainsKey(senderClientId))
			{
				VoiceMessage voiceMessage = GetVoiceMessage(id);
				if (voiceMessage != null && !voiceMessage.ClientsReceivedAudioClip.Contains(senderClientId))
				{
					voiceMessage.ClientsReceivedAudioClip.Add(senderClientId);
				}
			}
		}

		private void VoiceMessageTimedout_Server(int id)
		{
			if (NetworkUtils.IsServer)
			{
				VoiceMessageTimedout_ClientRpc(id);
				VoiceMessageTimedout_Local(id);
			}
		}

		[ClientRpc]
		private void VoiceMessageTimedout_ClientRpc(int id)
		{
			//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_00ce: 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.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3812723390u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, id);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3812723390u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!NetworkUtils.IsServer)
				{
					VoiceMessageTimedout_Local(id);
				}
			}
		}

		private void VoiceMessageTimedout_Local(int id)
		{
			VoiceMessage voiceMessage = GetVoiceMessage(id);
			if (voiceMessage != null)
			{
				if (IsLocal)
				{
					string text = "TTS audio for \"" + voiceMessage.VoiceName + "\" timed out";
					LogError(text);
					Utils.DisplayMessage(text, isError: true);
				}
				_voiceMessageQueue.Remove(voiceMessage);
			}
		}

		[ClientRpc]
		private void PlayVoiceMessage_ClientRpc(int id)
		{
			//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_00ce: 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.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(544932966u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, id);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 544932966u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					PlayVoiceMessage_Local(id);
				}
			}
		}

		private void PlayVoiceMessage_Local(int id)
		{
			VoiceMessage voiceMessage = GetVoiceMessage(id);
			if (voiceMessage == null)
			{
				LogWarning($"Failed to play VoiceMessage. Could not find VoiceMessage. (Id: {id})", extended: true);
				return;
			}
			if ((Object)(object)voiceMessage.AudioClip == (Object)null)
			{
				LogWarning($"Failed to play VoiceMessage. AudioClip is null. {voiceMessage}", extended: true);
				_voiceMessageQueue.Remove(voiceMessage);
				return;
			}
			LogInfo($"Playing VoiceMessage. {voiceMessage}", extended: true);
			float num = ConfigManager.TTS_MasterVolume.Value;
			VoiceService service = VoiceService.Unknown;
			if (TextToSpeech.TryGetVoiceByName(voiceMessage.VoiceName, out var result))
			{
				service = result.Service;
			}
			float serviceMasterVolume = ConfigManager.GetServiceMasterVolume(service);
			float num2 = 100f;
			if (VoiceConfigManager.TryGetVoiceConfigEntry(voiceMessage.VoiceName, out var voiceConfigEntry))
			{
				num2 = voiceConfigEntry.Volume.Value;
			}
			AudioClip clip = AudioUtils.CreateAdjustedClip(voiceMessage.AudioClip, num, serviceMasterVolume, num2);
			UpdateVoiceMute();
			PlayerAudioGroup.Clip = clip;
			PlayerAudioGroup.Play();
			_voiceMessageQueue.Remove(voiceMessage);
		}

		private void ApplySettings()
		{
			if (PlayerAudioGroup != null)
			{
				UpdateVoiceMute();
				PlayerAudioGroup.MaxDistance = ConfigManager.TTS_MaxDistance.Value;
			}
		}

		public static void HandleConfigSettingsChanged()
		{
			foreach (VoiceController instance in _instances)
			{
				instance.ApplySettings();
			}
		}

		private void Log(LogLevel logLevel, object data, bool extended = false)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			string arg = (((Object)(object)PlayerScript == (Object)null) ? ("[" + ((object)this).GetType().Name + "]") : ("[" + ((object)this).GetType().Name + " : " + PlayerScript.playerUsername + "]"));
			Logger.Log(logLevel, $"{arg} {data}", extended);
		}

		private void LogInfo(object data, bool extended = false)
		{
			Log((LogLevel)16, data, extended);
		}

		private void LogWarning(object data, bool extended = false)
		{
			Log((LogLevel)4, data, extended);
		}

		private void LogError(object data, bool extended = false)
		{
			Log((LogLevel)2, data, extended);
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2160464779u, new RpcReceiveHandler(__rpc_handler_2160464779), "CreateVoiceMessage_ServerRpc");
			((NetworkBehaviour)this).__registerRpc(1380029231u, new RpcReceiveHandler(__rpc_handler_1380029231), "CreateVoiceMessage_ClientRpc");
			((NetworkBehaviour)this).__registerRpc(4045068609u, new RpcReceiveHandler(__rpc_handler_4045068609), "DeleteVoiceMessage_ServerRpc");
			((NetworkBehaviour)this).__registerRpc(2880339731u, new RpcReceiveHandler(__rpc_handler_2880339731), "DeleteVoiceMessage_ClientRpc");
			((NetworkBehaviour)this).__registerRpc(1252295788u, new RpcReceiveHandler(__rpc_handler_1252295788), "StreamAudioChunk_ServerRpc");
			((NetworkBehaviour)this).__registerRpc(2319454299u, new RpcReceiveHandler(__rpc_handler_2319454299), "StreamAudioChunk_ClientRpc");
			((NetworkBehaviour)this).__registerRpc(3290872701u, new RpcReceiveHandler(__rpc_handler_3290872701), "StreamAudioComplete_ServerRpc");
			((NetworkBehaviour)this).__registerRpc(4122899824u, new RpcReceiveHandler(__rpc_handler_4122899824), "StreamAudioComplete_ClientRpc");
			((NetworkBehaviour)this).__registerRpc(2085373701u, new RpcReceiveHandler(__rpc_handler_2085373701), "ReceivedVoiceMessageAudioClip_ServerRpc");
			((NetworkBehaviour)this).__registerRpc(3812723390u, new RpcReceiveHandler(__rpc_handler_3812723390), "VoiceMessageTimedout_ClientRpc");
			((NetworkBehaviour)this).__registerRpc(544932966u, new RpcReceiveHandler(__rpc_handler_544932966), "PlayVoiceMessage_ClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_2160464779(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			bool flag = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
			string voiceName = null;
			if (flag)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref voiceName, false);
			}
			bool flag2 = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
			string message = null;
			if (flag2)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref message, false);
			}
			ServerRpcParams server = rpcParams.Server;
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((VoiceController)(object)target).CreateVoiceMessage_ServerRpc(voiceName, message, server);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}

		private static void __rpc_handler_1380029231(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int id = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string voiceName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref voiceName, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string message = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref message, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((VoiceController)(object)target).CreateVoiceMessage_ClientRpc(id, voiceName, message);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4045068609(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
			}
			else
			{
				int id = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((VoiceController)(object)target).DeleteVoiceMessage_ServerRpc(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

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

		private static void __rpc_handler_1252295788(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			int id = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref id);
			bool flag = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
			float[] chunk = null;
			if (flag)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref chunk, default(ForPrimitives));
			}
			int channels = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref channels);
			int sampleRate = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref sampleRate);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((VoiceController)(object)target).StreamAudioChunk_ServerRpc(id, chunk, channels, sampleRate);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}

		private static void __rpc_handler_2319454299(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int id = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				float[] chunk = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref chunk, default(ForPrimitives));
				}
				int channels = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref channels);
				int sampleRate = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref sampleRate);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((VoiceController)(object)target).StreamAudioChunk_ClientRpc(id, chunk, channels, sampleRate);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private sta