using System;
using System.CodeDom.Compiler;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;
using NAudio.CoreAudioApi;
using NAudio.Wave;
using Newtonsoft.Json;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using Wendigos.NetcodePatcher;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Wendigos")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("My first plugin")]
[assembly: AssemblyFileVersion("1.9.0.0")]
[assembly: AssemblyInformationalVersion("1.9.0+d082ac4e98995b3df721d152b29bb2c951bf5d65")]
[assembly: AssemblyProduct("Wendigos")]
[assembly: AssemblyTitle("Wendigos")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.9.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
		NetworkVariableSerializationTypes.InitializeSerializer_FixedString<FixedString128Bytes>();
		NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<FixedString128Bytes>();
	}
}
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;
		}
	}
}
public static class SavWav
{
	private const uint HeaderSize = 44u;

	private const float RescaleFactor = 32767f;

	public static void Save(string filename, AudioClip clip, bool trim = false)
	{
		if (!filename.ToLower().EndsWith(".wav"))
		{
			filename += ".wav";
		}
		string path = Path.Combine(Application.persistentDataPath, filename);
		Directory.CreateDirectory(Path.GetDirectoryName(path));
		using FileStream output = new FileStream(path, FileMode.Create);
		using BinaryWriter binaryWriter = new BinaryWriter(output);
		uint length;
		byte[] wav = GetWav(clip, out length, trim);
		binaryWriter.Write(wav, 0, (int)length);
	}

	public static byte[] GetWav(AudioClip clip, out uint length, bool trim = false)
	{
		uint samplesAfterTrimming;
		byte[] array = ConvertAndWrite(clip, out length, out samplesAfterTrimming, trim);
		WriteHeader(array, clip, length, samplesAfterTrimming);
		return array;
	}

	private static byte[] ConvertAndWrite(AudioClip clip, out uint length, out uint samplesAfterTrimming, bool trim)
	{
		float[] array = new float[clip.samples * clip.channels];
		clip.GetData(array, 0);
		int num = array.Length;
		int num2 = 0;
		int num3 = num - 1;
		if (trim)
		{
			for (int i = 0; i < num; i++)
			{
				if ((short)(array[i] * 32767f) != 0)
				{
					num2 = i;
					break;
				}
			}
			for (int num4 = num - 1; num4 >= 0; num4--)
			{
				if ((short)(array[num4] * 32767f) != 0)
				{
					num3 = num4;
					break;
				}
			}
		}
		byte[] array2 = new byte[(long)(num * 2) + 44L];
		uint num5 = 44u;
		for (int j = num2; j <= num3; j++)
		{
			short num6 = (short)(array[j] * 32767f);
			array2[num5++] = (byte)num6;
			array2[num5++] = (byte)(num6 >> 8);
		}
		length = num5;
		samplesAfterTrimming = (uint)(num3 - num2 + 1);
		return array2;
	}

	private static void AddDataToBuffer(byte[] buffer, ref uint offset, byte[] addBytes)
	{
		foreach (byte b in addBytes)
		{
			buffer[offset++] = b;
		}
	}

	private static void WriteHeader(byte[] stream, AudioClip clip, uint length, uint samples)
	{
		int frequency = clip.frequency;
		ushort num = (ushort)clip.channels;
		uint offset = 0u;
		byte[] bytes = Encoding.UTF8.GetBytes("RIFF");
		AddDataToBuffer(stream, ref offset, bytes);
		byte[] bytes2 = BitConverter.GetBytes(length - 8);
		AddDataToBuffer(stream, ref offset, bytes2);
		byte[] bytes3 = Encoding.UTF8.GetBytes("WAVE");
		AddDataToBuffer(stream, ref offset, bytes3);
		byte[] bytes4 = Encoding.UTF8.GetBytes("fmt ");
		AddDataToBuffer(stream, ref offset, bytes4);
		byte[] bytes5 = BitConverter.GetBytes(16u);
		AddDataToBuffer(stream, ref offset, bytes5);
		byte[] bytes6 = BitConverter.GetBytes((ushort)1);
		AddDataToBuffer(stream, ref offset, bytes6);
		byte[] bytes7 = BitConverter.GetBytes(num);
		AddDataToBuffer(stream, ref offset, bytes7);
		byte[] bytes8 = BitConverter.GetBytes((uint)frequency);
		AddDataToBuffer(stream, ref offset, bytes8);
		byte[] bytes9 = BitConverter.GetBytes((uint)(frequency * num * 2));
		AddDataToBuffer(stream, ref offset, bytes9);
		ushort value = (ushort)(num * 2);
		AddDataToBuffer(stream, ref offset, BitConverter.GetBytes(value));
		byte[] bytes10 = BitConverter.GetBytes((ushort)16);
		AddDataToBuffer(stream, ref offset, bytes10);
		byte[] bytes11 = Encoding.UTF8.GetBytes("data");
		AddDataToBuffer(stream, ref offset, bytes11);
		byte[] bytes12 = BitConverter.GetBytes(samples * 2);
		AddDataToBuffer(stream, ref offset, bytes12);
	}
}
namespace Wendigos
{
	internal class AzureSTT
	{
		public static int num_gens = 0;

		public static bool is_init = false;

		public static string ChatGPT_System_Prompt = "You are playing the online game Lethal Company with friends. When someone speaks to you, reply with short and informal responses.";

		public static SpeechRecognizer speechRecognizer;

		public static string player_name = "";

		private static async Task FromMic()
		{
			try
			{
				Console.WriteLine("Wendigos: Start transcribing audio...");
				TaskCompletionSource<int> stopRecognition = new TaskCompletionSource<int>();
				speechRecognizer.Recognizing += delegate
				{
				};
				speechRecognizer.Recognized += delegate(object s, SpeechRecognitionEventArgs e)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Invalid comparison between Unknown and I4
					//IL_0195: Unknown result type (might be due to invalid IL or missing references)
					if ((int)((RecognitionResult)e.Result).Reason == 3)
					{
						if (((RecognitionResult)e.Result).Text.Length > 1)
						{
							Console.WriteLine("RECOGNIZED: Text=" + ((RecognitionResult)e.Result).Text);
							MaskedPlayerEnemy closestMasked = Plugin.GetClosestMasked();
							if (!((Object)(object)closestMasked == (Object)null) && !((EnemyAI)closestMasked).creatureVoice.isPlaying)
							{
								try
								{
									if (ChatManager.init_success)
									{
										string text = ChatManager.SendPromptToChatGPT(ChatGPT_System_Prompt + ((player_name == "") ? "\n" : ("\n" + player_name + ": ")) + ((RecognitionResult)e.Result).Text);
										Console.WriteLine("RESPONSE: " + text);
										string id = ((Component)closestMasked).GetComponent<Plugin.MaskedEnemyIdentifier>().id;
										string text2;
										try
										{
											ulong key = Plugin.sharedMaskedClientDict[id];
											text2 = Plugin.clientVoiceIDLookup[key];
										}
										catch
										{
											text2 = ElevenLabs.VOICE_ID;
										}
										Task<string> task = ElevenLabs.RequestAudio(text, text2, text2, Plugin.assembly_path + "\\temp_elevenlabs_lines\\", 0);
										task.Wait();
										AudioClip obj2 = Plugin.LoadAudioFile(task.Result);
										((Object)obj2).name = Convert.ToChar(NetworkManager.Singleton.LocalClientId + 33).ToString() + num_gens;
										num_gens++;
										Plugin.SendClipForMe(obj2, id);
										Console.WriteLine("ROUND TRIP DONE");
										File.Delete(task.Result);
									}
								}
								catch (Exception ex2)
								{
									Console.WriteLine("GETRESPONSE BROKE: " + ex2.ToString());
								}
							}
						}
					}
					else if ((int)((RecognitionResult)e.Result).Reason == 0)
					{
						Console.WriteLine("NOMATCH: Speech could not be recognized.");
					}
				};
				speechRecognizer.Canceled += delegate(object s, SpeechRecognitionCanceledEventArgs e)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0021: Invalid comparison between Unknown and I4
					//IL_0029: Unknown result type (might be due to invalid IL or missing references)
					Console.WriteLine($"CANCELED: Reason={e.Reason}");
					if ((int)e.Reason == 1)
					{
						Console.WriteLine($"CANCELED: ErrorCode={e.ErrorCode}");
						Console.WriteLine("CANCELED: ErrorDetails=" + e.ErrorDetails);
						Console.WriteLine("CANCELED: Did you set the speech resource key and region values?");
					}
					stopRecognition.TrySetResult(0);
				};
				((Recognizer)speechRecognizer).SessionStopped += delegate
				{
					Console.WriteLine("\n    Session stopped event.");
					stopRecognition.TrySetResult(0);
				};
				await speechRecognizer.StartContinuousRecognitionAsync();
				Task[] tasks = new Task<int>[1] { stopRecognition.Task };
				Task.WaitAny(tasks);
			}
			catch (Exception ex)
			{
				Console.WriteLine("STT BROKE");
				Console.WriteLine(ex.ToString());
			}
		}

		public static async Task Main(string prompt)
		{
			try
			{
				ChatGPT_System_Prompt = prompt;
				await FromMic();
			}
			catch (Exception ex)
			{
				Console.WriteLine(ex.ToString());
			}
		}

		public static void Init(string api_key, string region, string language)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (api_key.Length == 0)
			{
				Console.WriteLine("No azure API key. STT disabled.");
				return;
			}
			AudioConfig val = AudioConfig.FromDefaultMicrophoneInput();
			try
			{
				SpeechConfig obj = SpeechConfig.FromSubscription(api_key, region);
				obj.SpeechRecognitionLanguage = language;
				speechRecognizer = new SpeechRecognizer(obj, val);
				is_init = true;
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		private static void GetAudioDevices(string[] args)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			foreach (MMDevice item in new MMDeviceEnumerator().EnumerateAudioEndPoints((DataFlow)1, (DeviceState)1))
			{
				Console.WriteLine("{0} ({1})", item.FriendlyName, item.ID);
			}
		}
	}
	public static class ChatManager
	{
		private static HttpClient client;

		public static bool init_success;

		private static string gpt_model;

		public static void Init(string api_key, string modelToUse)
		{
			try
			{
				if (api_key.Length == 0)
				{
					throw new ArgumentException("No ChatGPT API key!");
				}
				client = new HttpClient();
				client.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", "Bearer " + api_key);
				gpt_model = modelToUse;
				Console.WriteLine("CHATGPT INIT SUCCESS");
				init_success = true;
			}
			catch (Exception ex)
			{
				Console.WriteLine("CHATGPT INIT FAILED");
				Console.WriteLine(ex.Message);
			}
		}

		public static string SendPromptToChatGPT(string prompt)
		{
			try
			{
				StringContent content = new StringContent(JsonConvert.SerializeObject((object)new
				{
					model = gpt_model,
					messages = new[]
					{
						new
						{
							role = "user",
							content = prompt
						}
					},
					max_tokens = 200
				}), Encoding.UTF8, "application/json");
				Task<HttpResponseMessage> task = client.PostAsync("https://api.openai.com/v1/chat/completions", content);
				task.Wait();
				HttpResponseMessage result = task.Result;
				result.EnsureSuccessStatusCode();
				Task<string> task2 = result.Content.ReadAsStringAsync();
				task2.Wait();
				dynamic val = JsonConvert.DeserializeObject(task2.Result);
				Console.WriteLine("MESSAGE RECIEVED");
				return val.choices[0].message.content;
			}
			catch (Exception ex)
			{
				Console.WriteLine("CHAT BROKE");
				Console.WriteLine(ex.ToString());
				return "";
			}
		}
	}
	internal static class ElevenLabs
	{
		private const string baseDir = ".\\";

		private const string baseURL = "https://api.elevenlabs.io/v1/text-to-speech/";

		public static string API_KEY;

		public static bool requesting;

		private static HttpClient client;

		public static string VOICE_ID;

		public static bool optimize_for_speed;

		public static float volume_boost;

		public static void Init(string api_key, string voice_id, float volumeBoost)
		{
			try
			{
				if (api_key.Length == 0)
				{
					Console.WriteLine("No Elevenlabs API key found.");
					return;
				}
				API_KEY = api_key;
				VOICE_ID = voice_id;
				client = new HttpClient();
				client.DefaultRequestHeaders.Add("xi-api-key", API_KEY);
				client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("audio/mpeg"));
				volume_boost = volumeBoost;
			}
			catch (Exception ex)
			{
				Console.WriteLine(ex.ToString());
			}
		}

		public static async Task<string> GetLatestHistoryItem(string voice_id)
		{
			dynamic val = JsonConvert.DeserializeObject(await (await client.GetAsync("https://api.elevenlabs.io/v1/history?page_size=1&voice_id=" + voice_id)).Content.ReadAsStringAsync());
			try
			{
				Console.WriteLine(val["history"][0]["history_item_id"]);
				return val["history"][0]["history_item_id"];
			}
			catch (Exception ex)
			{
				Console.WriteLine(ex.ToString());
			}
			return "";
		}

		public static async Task<AudioClip> GetLatestHistoryItemAudioClip(string history_item_id, string dir)
		{
			StringContent content = new StringContent(JsonConvert.SerializeObject((object)new { history_item_id }), Encoding.Default, "application/json");
			using (Stream stream = await (await client.PostAsync("https://api.elevenlabs.io/v1/history/" + history_item_id + "/audio", content)).Content.ReadAsStreamAsync())
			{
				using FileStream fileStream = File.Create(dir + history_item_id + ".mp3");
				await stream.CopyToAsync(fileStream);
			}
			return Plugin.LoadAudioFile(dir + history_item_id + ".mp3");
		}

		public static void ConvertMp3ToWav(string _inPath_, string _outPath_)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			Mp3FileReader val = new Mp3FileReader(_inPath_);
			try
			{
				WaveStream val2 = WaveFormatConversionStream.CreatePcmStream((WaveStream)(object)val);
				try
				{
					WaveFileWriter.CreateWaveFile(_outPath_, (IWaveProvider)(object)val2);
				}
				finally
				{
					((IDisposable)val2)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		public static void IncreaseVolume(string inputPath, string outputPath, double db)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			double num = Math.Pow(10.0, db / 10.0);
			WaveFileReader val = new WaveFileReader(inputPath);
			try
			{
				new VolumeWaveProvider16((IWaveProvider)(object)val);
				WaveFileWriter val2 = new WaveFileWriter(outputPath, ((WaveStream)val).WaveFormat);
				try
				{
					while (true)
					{
						float[] array = val.ReadNextSampleFrame();
						if (array == null)
						{
							break;
						}
						float num2 = array[0] * (float)num;
						if (num2 < -0.6f)
						{
							num2 = -0.6f;
						}
						if (num2 > 0.6f)
						{
							num2 = 0.6f;
						}
						val2.WriteSample(array[0] * (float)num);
					}
				}
				finally
				{
					((IDisposable)val2)?.Dispose();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		public static async Task<string> RequestAudio(string prompt, string voice, string fileName, string dir, int fileNum)
		{
			string requestUri = "https://api.elevenlabs.io/v1/text-to-speech/" + voice;
			StringContent content = new StringContent(JsonConvert.SerializeObject((object)new
			{
				text = prompt,
				model_id = (optimize_for_speed ? "eleven_turbo_v2" : "eleven_multilingual_v2"),
				voice_settings = new
				{
					stability = 0.5f,
					similarity_boost = 0.5f,
					style = (optimize_for_speed ? 0f : 0.3f),
					use_speaker_boost = true,
					optimize_streaming_latency = (optimize_for_speed ? 3 : 0)
				}
			}), Encoding.Default, "application/json");
			HttpResponseMessage response = await client.PostAsync(requestUri, content);
			requesting = false;
			if (response != null)
			{
				int fileNameExtension = fileNum;
				int retries = 0;
				bool fileNameValid = false;
				while (!fileNameValid)
				{
					try
					{
						using (Stream stream = await response.Content.ReadAsStreamAsync())
						{
							using FileStream fileStream = File.Create(dir + fileName + fileNameExtension + ".mp3");
							await stream.CopyToAsync(fileStream);
						}
						fileNameValid = true;
					}
					catch (Exception)
					{
						retries++;
						if (retries >= 50)
						{
							break;
						}
						fileNameExtension++;
					}
				}
				if (fileNameValid)
				{
					try
					{
						ConvertMp3ToWav(dir + fileName + fileNameExtension + ".mp3", dir + fileName + fileNameExtension + "z.wav");
						File.Delete(dir + fileName + fileNameExtension + ".mp3");
						IncreaseVolume(dir + fileName + fileNameExtension + "z.wav", dir + fileName + fileNameExtension + ".wav", volume_boost);
						File.Delete(dir + fileName + fileNameExtension + "z.wav");
					}
					catch (Exception ex2)
					{
						Console.WriteLine(ex2.ToString());
					}
					return dir + fileName + fileNameExtension + ".wav";
				}
			}
			return null;
		}
	}
	[BepInPlugin("Wendigos", "Wendigos", "1.0.9")]
	public class Plugin : BaseUnityPlugin
	{
		public class WendigosMessageHandler : NetworkBehaviour
		{
			public static string MessageName = "clipSender";

			private static Dictionary<ulong, List<byte[]>> clipFragmentBuffers = new Dictionary<ulong, List<byte[]>>();

			private static int numberOfFragments = 1;

			public static bool isEveryoneReady = false;

			public static List<ulong> ConnectedClientIDs;

			public NetworkList<FixedString128Bytes> clipNamesArr;

			public static WendigosMessageHandler Instance { get; private set; }

			public override void OnNetworkSpawn()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				((NetworkBehaviour)this).OnNetworkSpawn();
				((NetworkBehaviour)this).NetworkManager.CustomMessagingManager.RegisterNamedMessageHandler(MessageName, new HandleNamedMessageDelegate(ReceiveMessage));
				ConnectedClientIDs = new List<ulong> { 0uL };
				if (((NetworkBehaviour)this).IsServer)
				{
					((NetworkBehaviour)this).NetworkManager.OnClientConnectedCallback += OnClientConnectedCallback;
					foreach (AudioClip myClip in myClips)
					{
						clipNamesArr.Add(FixedString128Bytes.op_Implicit("0" + ((Object)myClip).name));
					}
				}
				if (!audioClips.Keys.Contains(NetworkManager.Singleton.LocalClientId))
				{
					audioClips.Add(NetworkManager.Singleton.LocalClientId, new List<AudioClip>());
				}
				foreach (AudioClip myClip2 in myClips)
				{
					audioClips[NetworkManager.Singleton.LocalClientId].Add(myClip2);
				}
				ShareVoiceIDServerRpc(NetworkManager.Singleton.LocalClientId, elevenlabs_voice_id.Value);
			}

			internal static void ClientConnectInitializer(Scene sceneName, LoadSceneMode sceneEnum)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Expected O, but got Unknown
				Scene val = sceneName;
				if (((Scene)(ref val)).name == "SampleSceneRelay")
				{
					GameObject val2 = new GameObject("WendigosMessageHandler");
					val2.AddComponent<WendigosMessageHandler>();
					val2.AddComponent<NetworkObject>();
					PropertyInfo? property = typeof(NetworkObject).GetProperty("NetworkObjectId", BindingFlags.Instance | BindingFlags.Public);
					WriteToConsole((property == null).ToString() ?? "");
					property.SetValue(val2.GetComponent<NetworkObject>(), 127uL);
					WriteToConsole("NETWORK MANAGER ID IS " + val2.GetComponent<NetworkObject>().NetworkObjectId);
					FieldInfo? field = typeof(NetworkObject).GetField("GlobalObjectIdHash", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					WriteToConsole((field == null).ToString() ?? "");
					field.SetValue(val2.GetComponent<NetworkObject>(), 127u);
				}
			}

			private void Awake()
			{
				Instance = this;
				clipNamesArr = new NetworkList<FixedString128Bytes>();
			}

			private void Update()
			{
				Action result;
				while (MainThreadInvoker._actions.TryDequeue(out result))
				{
					result();
				}
			}

			private void OnClientConnectedCallback(ulong obj)
			{
				if (((NetworkBehaviour)this).IsServer)
				{
					WriteToConsole("Server sending " + get_clips_count() + " clips");
					{
						foreach (ulong connectedClientsId in NetworkManager.Singleton.ConnectedClientsIds)
						{
							if (connectedClientsId == obj)
							{
								continue;
							}
							try
							{
								List<AudioClip> clips = new List<AudioClip>(audioClips[connectedClientsId]);
								SendClipListAsync(clips, obj, specificClient: true, shouldSync: false, connectedClientsId);
								if (!elevenlabs_enabled.Value)
								{
									continue;
								}
								foreach (ulong key in clientVoiceIDLookup.Keys)
								{
									ShareVoiceIDClientRpc(key, clientVoiceIDLookup[key]);
								}
							}
							catch
							{
							}
						}
						return;
					}
				}
				List<AudioClip> clips2 = new List<AudioClip>(audioClips[NetworkManager.Singleton.LocalClientId]);
				SendClipListAsync(clips2, obj, specificClient: false, shouldSync: true, NetworkManager.Singleton.LocalClientId);
				ShareVoiceIDServerRpc(NetworkManager.Singleton.LocalClientId, elevenlabs_voice_id.Value);
			}

			public override void OnNetworkDespawn()
			{
				foreach (List<AudioClip> value in audioClips.Values)
				{
					value.Clear();
				}
				sent_localID = false;
				ConnectedClientIDs.Clear();
				if (((NetworkBehaviour)this).IsServer)
				{
					sharedMaskedClientDict.Clear();
					serverReadyDict.Clear();
				}
			}

			private void ReceiveMessage(ulong senderId, FastBufferReader messagePayload)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				byte[] item = default(byte[]);
				((FastBufferReader)(ref messagePayload)).ReadValueSafe<byte>(ref item, default(ForPrimitives));
				if (!clipFragmentBuffers.ContainsKey(senderId))
				{
					clipFragmentBuffers.Add(senderId, new List<byte[]>());
				}
				clipFragmentBuffers[senderId].Add(item);
				if (clipFragmentBuffers[senderId].Count == numberOfFragments)
				{
					Task.Factory.StartNew(() => CombineAudioFragments(senderId));
				}
			}

			private async Task CombineAudioFragments(ulong senderId)
			{
				int num = 0;
				foreach (byte[] item in clipFragmentBuffers[senderId])
				{
					num += item.Length;
				}
				byte[] array = new byte[num];
				int num2 = 0;
				foreach (byte[] item2 in clipFragmentBuffers[senderId])
				{
					Buffer.BlockCopy(item2, 0, array, num2, item2.Length);
					num2 += item2.Length;
				}
				clipFragmentBuffers[senderId].Clear();
				array = Decompress(array);
				ulong num3 = 0uL;
				byte value = array[7];
				byte b = array[6];
				string text = Convert.ToChar(value).ToString() + b;
				WriteToConsole("ClipN is " + text);
				for (int i = 0; i < 6; i++)
				{
					num3 |= (ulong)array[i] << i * 8;
				}
				MonoBehaviour.print((object)("Sender ID is: " + senderId));
				MonoBehaviour.print((object)("Real sender ID is: " + num3));
				byte[] array2 = new byte[array.Length - 8];
				Buffer.BlockCopy(array, 8, array2, 0, array2.Length);
				AudioClip val = LoadAudioClip(array2, elevenlabs_enabled.Value ? 44100 : 24000);
				((Object)val).name = text;
				bool flag = false;
				if (!audioClips.Keys.Contains(num3))
				{
					audioClips.Add(num3, new List<AudioClip>());
				}
				if (((NetworkBehaviour)this).IsServer)
				{
					WriteToConsole($"Sever received ({array2}) from client ({num3})");
					foreach (AudioClip item3 in audioClips[num3])
					{
						if (((Object)item3).name == ((Object)val).name || senderId == 0L)
						{
							WriteToConsole(((Object)item3).name);
							WriteToConsole("We already have this clip!");
							flag = true;
							WriteToConsole("AudioClip count is now: " + get_clips_count());
						}
					}
					if (!flag)
					{
						audioClips[num3].Add(val);
						clipNamesArr.Add(FixedString128Bytes.op_Implicit(num3 + ((Object)val).name));
						WriteToConsole("Added Clip.");
						WriteToConsole("AudioClip count is now: " + get_clips_count());
					}
					return;
				}
				WriteToConsole($"Client received ({array2}) from the server.");
				foreach (AudioClip item4 in audioClips[num3])
				{
					if (((Object)item4).name == ((Object)val).name || num3 == NetworkManager.Singleton.LocalClientId)
					{
						WriteToConsole("We already have this clip!");
						flag = true;
						WriteToConsole("AudioClip count is now: " + get_clips_count());
					}
				}
				if (!flag)
				{
					audioClips[num3].Add(val);
					WriteToConsole("Added Clip.");
					WriteToConsole("AudioClip count is now: " + get_clips_count());
				}
			}

			private void SendMessage(byte[] audioClipFragment, ulong destClient = 0uL, bool specificClient = false)
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				specificClient = false;
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(audioClipFragment.Length, (Allocator)2, 512000);
				CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
				FastBufferWriter val2 = val;
				try
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<byte>(audioClipFragment, default(ForPrimitives));
					if (specificClient)
					{
						customMessagingManager.SendNamedMessage(MessageName, destClient, val, (NetworkDelivery)4);
					}
					else if (NetworkManager.Singleton.IsServer)
					{
						customMessagingManager.SendNamedMessageToAll(MessageName, val, (NetworkDelivery)4);
					}
					else
					{
						customMessagingManager.SendNamedMessage(MessageName, 0uL, val, (NetworkDelivery)4);
					}
				}
				finally
				{
					((IDisposable)(FastBufferWriter)(ref val2)).Dispose();
				}
			}

			public void SendFragmentedMessage(AudioClip audioClip, ulong destClient = 0uL, bool specificClient = false, ulong originClient = 0uL)
			{
				MonoBehaviour.print((object)"Compressing...");
				byte[] array = Compress(ConvertToByteArr(audioClip), originClient, ((Object)audioClip).name);
				WriteToConsole($"Sending message of length {array.Length}");
				if ((double)array.Length > Math.Ceiling(512000f * (float)numberOfFragments))
				{
					throw new Exception("clip is too large to send! Try increasing the number of message fragments.");
				}
				int num = (int)Math.Ceiling((float)array.Length / (float)numberOfFragments);
				List<byte[]> list = new List<byte[]>();
				for (int i = 0; i < numberOfFragments; i++)
				{
					if (i != numberOfFragments - 1)
					{
						list.Add(new byte[num]);
						Buffer.BlockCopy(array, num * i, list[i], 0, num);
					}
					else
					{
						list.Add(new byte[array.Length - (numberOfFragments - 1) * num]);
						Buffer.BlockCopy(array, num * i, list[i], 0, array.Length - (numberOfFragments - 1) * num);
					}
				}
				foreach (byte[] item in list)
				{
					SendMessage(item, destClient, specificClient);
				}
			}

			public async Task SendClipListAsync(List<AudioClip> clips, ulong destClient = 0uL, bool specificClient = false, bool shouldSync = false, ulong originClient = 0uL)
			{
				foreach (AudioClip clip in clips)
				{
					WriteToConsole("Sending " + originClient + "'s clips");
					SendFragmentedMessage(clip, destClient, specificClient, originClient);
					await Task.Delay(300);
				}
				if (((NetworkBehaviour)this).IsServer && specificClient)
				{
					ClientRpcParams val = default(ClientRpcParams);
					val.Send = new ClientRpcSendParams
					{
						TargetClientIds = new ulong[1] { destClient }
					};
					ClientRpcParams p = val;
					SendServerMyClipsClientRpc(p);
				}
				else if (!((NetworkBehaviour)this).IsServer && shouldSync)
				{
					WriteToConsole("Sent " + get_clips_count() + " Clips");
					BroadcastAllNewClipsServerRpc(originClient);
				}
			}

			[ServerRpc(RequireOwnership = false)]
			public void UpdateClientListServerRpc(ulong newClient)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
					{
						ServerRpcParams val = default(ServerRpcParams);
						FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1162019120u, val, (RpcDelivery)0);
						BytePacker.WriteValueBitPacked(val2, newClient);
						((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1162019120u, val, (RpcDelivery)0);
					}
					if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
					{
						UpdateClientListClientRpc(newClient);
					}
				}
			}

			[ClientRpc]
			public void UpdateClientListClientRpc(ulong newClient)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2868607049u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, newClient);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2868607049u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					if (!ConnectedClientIDs.Contains(newClient))
					{
						ConnectedClientIDs.Add(newClient);
					}
					WriteToConsole("New ClientID list is: [" + string.Join(",", ConnectedClientIDs.Select((ulong x) => x.ToString()).ToArray()) + "]");
				}
			}

			[ServerRpc(RequireOwnership = false)]
			public void BroadcastAllNewClipsServerRpc(ulong senderID)
			{
				//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_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0186: Unknown result type (might be due to invalid IL or missing references)
				//IL_019d: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: 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_0101: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: 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_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1706438528u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, senderID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1706438528u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					if (!audioClips.Keys.Contains(senderID))
					{
						WriteToConsole("Client " + senderID + " has not synced yet. Requesting sync...");
						ClientRpcParams val3 = default(ClientRpcParams);
						val3.Send = new ClientRpcSendParams
						{
							TargetClientIds = new ulong[1] { senderID }
						};
						ClientRpcParams p = val3;
						SendServerMyClipsClientRpc(p);
					}
					else
					{
						WriteToConsole("Broadcasting " + senderID + "'s clips - " + audioClips[senderID].Count);
						List<AudioClip> clips = new List<AudioClip>(audioClips[senderID]);
						SendClipListAsync(clips, 0uL, specificClient: false, shouldSync: false, senderID);
						ClientRpcParams val3 = default(ClientRpcParams);
						val3.Send = new ClientRpcSendParams
						{
							TargetClientIds = new ulong[1] { senderID }
						};
						ClientRpcParams param = val3;
						ValidateClipsClientRpc(param);
					}
				}
			}

			[ClientRpc]
			public void SendServerMyClipsClientRpc(ClientRpcParams p = default(ClientRpcParams))
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
					{
						FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3594351807u, p, (RpcDelivery)0);
						((NetworkBehaviour)this).__endSendClientRpc(ref val, 3594351807u, p, (RpcDelivery)0);
					}
					if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
					{
						SendClipListAsync(myClips, 0uL, specificClient: false, mod_enabled.Value, NetworkManager.Singleton.LocalClientId);
					}
				}
			}

			[ClientRpc]
			public void SetMaskedSuitClientRpc(string maskedId, int suitid)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4236159180u, val, (RpcDelivery)0);
					bool flag = maskedId != null;
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
					if (flag)
					{
						((FastBufferWriter)(ref val2)).WriteValueSafe(maskedId, false);
					}
					BytePacker.WriteValueBitPacked(val2, suitid);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4236159180u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
				{
					return;
				}
				try
				{
					maskedInstanceLookup[maskedId].SetSuit(suitid);
				}
				catch (Exception ex)
				{
					WriteToConsole(ex.Message);
				}
			}

			public async Task waitForMSeconds(int Mseconds)
			{
				await Task.Delay(Mseconds);
			}

			public async Task askServerResendList(List<(ulong COrID, FixedString128Bytes cname)> clipTuples)
			{
				foreach (var clipTuple in clipTuples)
				{
					AskServerResendClipServerRpc(clipTuple.COrID, clipTuple.cname, NetworkManager.Singleton.LocalClientId);
					await Task.Delay(200);
				}
			}

			[ClientRpc]
			public void ValidateClipsClientRpc(ClientRpcParams param = default(ClientRpcParams))
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01da: Unknown result type (might be due to invalid IL or missing references)
				//IL_024c: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3353027481u, param, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 3353027481u, param, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
				{
					return;
				}
				try
				{
					List<FixedString128Bytes> list = new List<FixedString128Bytes>();
					List<AudioClip> list2 = new List<AudioClip>();
					foreach (ulong key in audioClips.Keys)
					{
						bool flag = false;
						foreach (AudioClip item in audioClips[key])
						{
							list.Add(FixedString128Bytes.op_Implicit(key + ((Object)item).name));
							if (!clipNamesArr.Contains(FixedString128Bytes.op_Implicit(key + ((Object)item).name)))
							{
								WriteToConsole("Client resending " + key + ((Object)item).name);
								list2.Add(item);
								flag = true;
							}
						}
						if (flag)
						{
							SendClipListAsync(list2, 0uL, specificClient: false, shouldSync: true, key);
						}
					}
					List<(ulong, FixedString128Bytes)> list3 = new List<(ulong, FixedString128Bytes)>();
					foreach (FixedString128Bytes item2 in clipNamesArr)
					{
						FixedString128Bytes current3 = item2;
						if (list.Contains(current3))
						{
							continue;
						}
						ulong num = 0uL;
						string text = ((object)(FixedString128Bytes)(ref current3)).ToString();
						foreach (char c in text)
						{
							if (c >= 'a' && c <= 'z')
							{
								break;
							}
							num *= 10;
							num += (ulong)(c - 48);
						}
						list3.Add((num, FixedString128Bytes.op_Implicit(((object)(FixedString128Bytes)(ref current3)).ToString().Substring(1))));
					}
					askServerResendList(list3);
				}
				catch
				{
					WriteToConsole("SYNC ERROR");
				}
			}

			[ServerRpc(RequireOwnership = false)]
			public void AskServerResendClipServerRpc(ulong originClipId, FixedString128Bytes name, ulong senderID)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2735770731u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, originClipId);
					((FastBufferWriter)(ref val2)).WriteValueSafe<FixedString128Bytes>(ref name, default(ForFixedStrings));
					BytePacker.WriteValueBitPacked(val2, senderID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2735770731u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
				{
					return;
				}
				WriteToConsole("Resending...");
				List<AudioClip> list = new List<AudioClip>();
				foreach (AudioClip item in audioClips[originClipId])
				{
					FixedString128Bytes val3 = FixedString128Bytes.op_Implicit(((Object)item).name);
					if ((ref val3) == (ref name))
					{
						WriteToConsole("Server Resending " + originClipId + ((Object)item).name);
						list.Add(item);
					}
				}
				if (list.Count > 0)
				{
					SendClipListAsync(list, senderID, specificClient: false, shouldSync: false, originClipId);
				}
			}

			[ServerRpc(RequireOwnership = false)]
			public void TellServerReadyToSendServerRpc(string maskedID, bool ready, ServerRpcParams serverRpcParams = default(ServerRpcParams))
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2447039368u, serverRpcParams, (RpcDelivery)0);
					bool flag = maskedID != null;
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
					if (flag)
					{
						((FastBufferWriter)(ref val)).WriteValueSafe(maskedID, false);
					}
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref ready, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2447039368u, serverRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
				{
					return;
				}
				WriteToConsole("Server got ready signal");
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				WriteToConsole("Recieved " + ready + " from " + senderClientId);
				try
				{
					if (!serverReadyDict[maskedID].ContainsKey(senderClientId))
					{
						serverReadyDict[maskedID].Add(senderClientId, ready);
					}
					else
					{
						serverReadyDict[maskedID][senderClientId] = ready;
					}
				}
				catch (Exception ex)
				{
					WriteToConsole("ERROR HERE");
					WriteToConsole(ex.Message);
					foreach (string key in serverReadyDict.Keys)
					{
						WriteToConsole(key ?? "");
					}
				}
			}

			[ServerRpc(RequireOwnership = false)]
			public void AddToMaskedClientDictServerRpc(string maskedID, ulong clientID)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1290365431u, val, (RpcDelivery)0);
					bool flag = maskedID != null;
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
					if (flag)
					{
						((FastBufferWriter)(ref val2)).WriteValueSafe(maskedID, false);
					}
					BytePacker.WriteValueBitPacked(val2, clientID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1290365431u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					AddToMaskedClientDictClientRpc(maskedID, clientID);
				}
			}

			[ClientRpc]
			public void AddToMaskedClientDictClientRpc(string maskedID, ulong clientID)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3329064614u, val, (RpcDelivery)0);
					bool flag = maskedID != null;
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
					if (flag)
					{
						((FastBufferWriter)(ref val2)).WriteValueSafe(maskedID, false);
					}
					BytePacker.WriteValueBitPacked(val2, clientID);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3329064614u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					sharedMaskedClientDict[maskedID] = clientID;
					WriteToConsole("added masked " + maskedID + " to masked_client_dict");
				}
			}

			[ClientRpc]
			public void SortAudioClipsClientRpc()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
					{
						ClientRpcParams val = default(ClientRpcParams);
						FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(110445393u, val, (RpcDelivery)0);
						((NetworkBehaviour)this).__endSendClientRpc(ref val2, 110445393u, val, (RpcDelivery)0);
					}
					if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
					{
						sort_audioclips();
					}
				}
			}

			[ServerRpc(RequireOwnership = false)]
			public void TryPlayAudioServerRpc(ulong MimickingID, string maskedID, char lineType = ' ', uint talkProbability = 10u)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(104057551u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, MimickingID);
					bool flag = maskedID != null;
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
					if (flag)
					{
						((FastBufferWriter)(ref val2)).WriteValueSafe(maskedID, false);
					}
					((FastBufferWriter)(ref val2)).WriteValueSafe<char>(ref lineType, default(ForPrimitives));
					BytePacker.WriteValueBitPacked(val2, talkProbability);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 104057551u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
				{
					return;
				}
				bool flag2 = true;
				foreach (bool value in serverReadyDict[maskedID].Values)
				{
					flag2 = value && flag2;
				}
				if ((!flag2 && lineType != 'd') || (serverRand.Next() % 100 + talkProbability < 100 && lineType != 'd'))
				{
					return;
				}
				WriteToConsole("Trying to play audio");
				int num = 0;
				int num2 = -1;
				List<AudioClip> list = new List<AudioClip>();
				if (lineType != ' ')
				{
					for (int i = 0; i < audioClips[MimickingID].Count; i++)
					{
						if (((Object)audioClips[MimickingID][i]).name[0] == lineType)
						{
							list.Add(audioClips[MimickingID][i]);
							if (num2 == -1)
							{
								num2 = i;
							}
						}
					}
				}
				else
				{
					list = audioClips[MimickingID];
				}
				if (num2 == -1)
				{
					num2 = 0;
				}
				if (list.Count > 0)
				{
					num = serverRand.Next() % list.Count + num2;
					PlayAudioClientRpc(MimickingID, num, maskedID);
				}
			}

			[ClientRpc]
			public void PlayAudioClientRpc(ulong MimickingID, int indexToPlay, string maskedID)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: 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 != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1350037529u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, MimickingID);
					BytePacker.WriteValueBitPacked(val2, indexToPlay);
					bool flag = maskedID != null;
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
					if (flag)
					{
						((FastBufferWriter)(ref val2)).WriteValueSafe(maskedID, false);
					}
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1350037529u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					WriteToConsole($"Masked {maskedID} playing {MimickingID}[{indexToPlay}] - {((Object)audioClips[MimickingID][indexToPlay]).name}");
					TryToPlayAudio(audioClips[MimickingID][indexToPlay], maskedID);
				}
			}

			[ServerRpc(RequireOwnership = false)]
			public void ShareVoiceIDServerRpc(ulong clientID, string VoiceID)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3869001932u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, clientID);
					bool flag = VoiceID != null;
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
					if (flag)
					{
						((FastBufferWriter)(ref val2)).WriteValueSafe(VoiceID, false);
					}
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3869001932u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && !clientVoiceIDLookup.ContainsKey(clientID))
				{
					clientVoiceIDLookup.Add(clientID, VoiceID);
					WriteToConsole("Server adding " + clientID + " " + VoiceID);
				}
			}

			[ClientRpc]
			public void ShareVoiceIDClientRpc(ulong clientID, string VoiceID)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(783826994u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, clientID);
					bool flag = VoiceID != null;
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
					if (flag)
					{
						((FastBufferWriter)(ref val2)).WriteValueSafe(VoiceID, false);
					}
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 783826994u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !clientVoiceIDLookup.ContainsKey(clientID))
				{
					clientVoiceIDLookup.Add(clientID, VoiceID);
					WriteToConsole("Client adding " + clientID + " " + VoiceID);
				}
			}

			[ServerRpc(RequireOwnership = false)]
			public void PlaySpecificAudioClipServerRpc(string name, string MaskedID)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4050447763u, val, (RpcDelivery)0);
					bool flag = name != null;
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
					if (flag)
					{
						((FastBufferWriter)(ref val2)).WriteValueSafe(name, false);
					}
					bool flag2 = MaskedID != null;
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
					if (flag2)
					{
						((FastBufferWriter)(ref val2)).WriteValueSafe(MaskedID, false);
					}
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4050447763u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					PlaySpecificAudioClipClientRpc(name, MaskedID);
				}
			}

			[ClientRpc]
			public void PlaySpecificAudioClipClientRpc(string name, string MaskedID)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_0108: Unknown result type (might be due to invalid IL or missing references)
				//IL_0112: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3720438090u, val, (RpcDelivery)0);
					bool flag = name != null;
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
					if (flag)
					{
						((FastBufferWriter)(ref val2)).WriteValueSafe(name, false);
					}
					bool flag2 = MaskedID != null;
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
					if (flag2)
					{
						((FastBufferWriter)(ref val2)).WriteValueSafe(MaskedID, false);
					}
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3720438090u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					string name2 = name;
					string MaskedID2 = MaskedID;
					Task.Factory.StartNew(() => TryPlayClip(name2, MaskedID2));
				}
			}

			[ClientRpc]
			public void InitAzureClientRpc()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Invalid comparison between Unknown and I4
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Invalid comparison between Unknown and I4
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
				if (networkManager == null || !networkManager.IsListening)
				{
					return;
				}
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(318488603u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 318488603u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && enable_realtime_responses.Value && !AzureSTT.is_init)
				{
					AzureSTT.num_gens = 0;
					AzureSTT.Init(Azure_api_key.Value, Azure_region.Value, Azure_language.Value);
					Task.Factory.StartNew(() => AzureSTT.Main(ChatGPT_prompt.Value));
				}
			}

			private async Task TryPlayClip(string name, string MaskedID)
			{
				int checks = 0;
				while (checks < 10)
				{
					foreach (ulong key in audioClips.Keys)
					{
						foreach (AudioClip item in audioClips[key])
						{
							if (!(((Object)item).name == name))
							{
								continue;
							}
							try
							{
								if (!((EnemyAI)maskedInstanceLookup[MaskedID]).creatureVoice.isPlaying)
								{
									((EnemyAI)maskedInstanceLookup[MaskedID]).creatureVoice.minDistance = 2f;
									((EnemyAI)maskedInstanceLookup[MaskedID]).creatureVoice.PlayOneShot(item);
								}
								return;
							}
							catch
							{
								WriteToConsole("Masked not found");
								return;
							}
						}
					}
					await Task.Delay(50);
				}
				WriteToConsole("COULD NOT FIND CLIP");
			}

			protected override void __initializeVariables()
			{
				if (clipNamesArr == null)
				{
					throw new Exception("WendigosMessageHandler.clipNamesArr cannot be null. All NetworkVariableBase instances must be initialized.");
				}
				((NetworkVariableBase)clipNamesArr).Initialize((NetworkBehaviour)(object)this);
				((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)clipNamesArr, "clipNamesArr");
				base.NetworkVariableFields.Add((NetworkVariableBase)(object)clipNamesArr);
				((NetworkBehaviour)this).__initializeVariables();
			}

			[RuntimeInitializeOnLoadMethod]
			internal static void InitializeRPCS_WendigosMessageHandler()
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Expected O, but got Unknown
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Expected O, but got Unknown
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Expected O, but got Unknown
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Expected O, but got Unknown
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Expected O, but got Unknown
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Expected O, but got Unknown
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Expected O, but got Unknown
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Expected O, but got Unknown
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Expected O, but got Unknown
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Expected O, but got Unknown
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Expected O, but got Unknown
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Expected O, but got Unknown
				//IL_0170: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Expected O, but got Unknown
				//IL_018b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Expected O, but got Unknown
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b0: Expected O, but got Unknown
				//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Expected O, but got Unknown
				//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e6: Expected O, but got Unknown
				NetworkManager.__rpc_func_table.Add(1162019120u, new RpcReceiveHandler(__rpc_handler_1162019120));
				NetworkManager.__rpc_func_table.Add(2868607049u, new RpcReceiveHandler(__rpc_handler_2868607049));
				NetworkManager.__rpc_func_table.Add(1706438528u, new RpcReceiveHandler(__rpc_handler_1706438528));
				NetworkManager.__rpc_func_table.Add(3594351807u, new RpcReceiveHandler(__rpc_handler_3594351807));
				NetworkManager.__rpc_func_table.Add(4236159180u, new RpcReceiveHandler(__rpc_handler_4236159180));
				NetworkManager.__rpc_func_table.Add(3353027481u, new RpcReceiveHandler(__rpc_handler_3353027481));
				NetworkManager.__rpc_func_table.Add(2735770731u, new RpcReceiveHandler(__rpc_handler_2735770731));
				NetworkManager.__rpc_func_table.Add(2447039368u, new RpcReceiveHandler(__rpc_handler_2447039368));
				NetworkManager.__rpc_func_table.Add(1290365431u, new RpcReceiveHandler(__rpc_handler_1290365431));
				NetworkManager.__rpc_func_table.Add(3329064614u, new RpcReceiveHandler(__rpc_handler_3329064614));
				NetworkManager.__rpc_func_table.Add(110445393u, new RpcReceiveHandler(__rpc_handler_110445393));
				NetworkManager.__rpc_func_table.Add(104057551u, new RpcReceiveHandler(__rpc_handler_104057551));
				NetworkManager.__rpc_func_table.Add(1350037529u, new RpcReceiveHandler(__rpc_handler_1350037529));
				NetworkManager.__rpc_func_table.Add(3869001932u, new RpcReceiveHandler(__rpc_handler_3869001932));
				NetworkManager.__rpc_func_table.Add(783826994u, new RpcReceiveHandler(__rpc_handler_783826994));
				NetworkManager.__rpc_func_table.Add(4050447763u, new RpcReceiveHandler(__rpc_handler_4050447763));
				NetworkManager.__rpc_func_table.Add(3720438090u, new RpcReceiveHandler(__rpc_handler_3720438090));
				NetworkManager.__rpc_func_table.Add(318488603u, new RpcReceiveHandler(__rpc_handler_318488603));
			}

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

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

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

			private static void __rpc_handler_3594351807(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_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					ClientRpcParams client = rpcParams.Client;
					target.__rpc_exec_stage = (__RpcExecStage)2;
					((WendigosMessageHandler)(object)target).SendServerMyClipsClientRpc(client);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_4236159180(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					bool flag = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
					string maskedId = null;
					if (flag)
					{
						((FastBufferReader)(ref reader)).ReadValueSafe(ref maskedId, false);
					}
					int suitid = default(int);
					ByteUnpacker.ReadValueBitPacked(reader, ref suitid);
					target.__rpc_exec_stage = (__RpcExecStage)2;
					((WendigosMessageHandler)(object)target).SetMaskedSuitClientRpc(maskedId, suitid);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_3353027481(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_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					ClientRpcParams client = rpcParams.Client;
					target.__rpc_exec_stage = (__RpcExecStage)2;
					((WendigosMessageHandler)(object)target).ValidateClipsClientRpc(client);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_2735770731(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_004b: 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_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					ulong originClipId = default(ulong);
					ByteUnpacker.ReadValueBitPacked(reader, ref originClipId);
					FixedString128Bytes name = default(FixedString128Bytes);
					((FastBufferReader)(ref reader)).ReadValueSafe<FixedString128Bytes>(ref name, default(ForFixedStrings));
					ulong senderID = default(ulong);
					ByteUnpacker.ReadValueBitPacked(reader, ref senderID);
					target.__rpc_exec_stage = (__RpcExecStage)1;
					((WendigosMessageHandler)(object)target).AskServerResendClipServerRpc(originClipId, name, senderID);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_2447039368(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: 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_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: 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_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					bool flag = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
					string maskedID = null;
					if (flag)
					{
						((FastBufferReader)(ref reader)).ReadValueSafe(ref maskedID, false);
					}
					bool ready = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref ready, default(ForPrimitives));
					ServerRpcParams server = rpcParams.Server;
					target.__rpc_exec_stage = (__RpcExecStage)1;
					((WendigosMessageHandler)(object)target).TellServerReadyToSendServerRpc(maskedID, ready, server);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_1290365431(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					bool flag = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
					string maskedID = null;
					if (flag)
					{
						((FastBufferReader)(ref reader)).ReadValueSafe(ref maskedID, false);
					}
					ulong clientID = default(ulong);
					ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
					target.__rpc_exec_stage = (__RpcExecStage)1;
					((WendigosMessageHandler)(object)target).AddToMaskedClientDictServerRpc(maskedID, clientID);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_3329064614(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					bool flag = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
					string maskedID = null;
					if (flag)
					{
						((FastBufferReader)(ref reader)).ReadValueSafe(ref maskedID, false);
					}
					ulong clientID = default(ulong);
					ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
					target.__rpc_exec_stage = (__RpcExecStage)2;
					((WendigosMessageHandler)(object)target).AddToMaskedClientDictClientRpc(maskedID, clientID);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_110445393(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					target.__rpc_exec_stage = (__RpcExecStage)2;
					((WendigosMessageHandler)(object)target).SortAudioClipsClientRpc();
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_104057551(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_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					ulong mimickingID = default(ulong);
					ByteUnpacker.ReadValueBitPacked(reader, ref mimickingID);
					bool flag = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
					string maskedID = null;
					if (flag)
					{
						((FastBufferReader)(ref reader)).ReadValueSafe(ref maskedID, false);
					}
					char lineType = default(char);
					((FastBufferReader)(ref reader)).ReadValueSafe<char>(ref lineType, default(ForPrimitives));
					uint talkProbability = default(uint);
					ByteUnpacker.ReadValueBitPacked(reader, ref talkProbability);
					target.__rpc_exec_stage = (__RpcExecStage)1;
					((WendigosMessageHandler)(object)target).TryPlayAudioServerRpc(mimickingID, maskedID, lineType, talkProbability);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_1350037529(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: 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)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					ulong mimickingID = default(ulong);
					ByteUnpacker.ReadValueBitPacked(reader, ref mimickingID);
					int indexToPlay = default(int);
					ByteUnpacker.ReadValueBitPacked(reader, ref indexToPlay);
					bool flag = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
					string maskedID = null;
					if (flag)
					{
						((FastBufferReader)(ref reader)).ReadValueSafe(ref maskedID, false);
					}
					target.__rpc_exec_stage = (__RpcExecStage)2;
					((WendigosMessageHandler)(object)target).PlayAudioClientRpc(mimickingID, indexToPlay, maskedID);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_3869001932(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_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					ulong clientID = default(ulong);
					ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
					bool flag = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
					string voiceID = null;
					if (flag)
					{
						((FastBufferReader)(ref reader)).ReadValueSafe(ref voiceID, false);
					}
					target.__rpc_exec_stage = (__RpcExecStage)1;
					((WendigosMessageHandler)(object)target).ShareVoiceIDServerRpc(clientID, voiceID);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_783826994(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_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					ulong clientID = default(ulong);
					ByteUnpacker.ReadValueBitPacked(reader, ref clientID);
					bool flag = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
					string voiceID = null;
					if (flag)
					{
						((FastBufferReader)(ref reader)).ReadValueSafe(ref voiceID, false);
					}
					target.__rpc_exec_stage = (__RpcExecStage)2;
					((WendigosMessageHandler)(object)target).ShareVoiceIDClientRpc(clientID, voiceID);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_4050447763(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: 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_0099: 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)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					bool flag = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
					string name = null;
					if (flag)
					{
						((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
					}
					bool flag2 = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
					string maskedID = null;
					if (flag2)
					{
						((FastBufferReader)(ref reader)).ReadValueSafe(ref maskedID, false);
					}
					target.__rpc_exec_stage = (__RpcExecStage)1;
					((WendigosMessageHandler)(object)target).PlaySpecificAudioClipServerRpc(name, maskedID);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_3720438090(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: 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_0099: 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)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					bool flag = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
					string name = null;
					if (flag)
					{
						((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
					}
					bool flag2 = default(bool);
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
					string maskedID = null;
					if (flag2)
					{
						((FastBufferReader)(ref reader)).ReadValueSafe(ref maskedID, false);
					}
					target.__rpc_exec_stage = (__RpcExecStage)2;
					((WendigosMessageHandler)(object)target).PlaySpecificAudioClipClientRpc(name, maskedID);
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			private static void __rpc_handler_318488603(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager networkManager = target.NetworkManager;
				if (networkManager != null && networkManager.IsListening)
				{
					target.__rpc_exec_stage = (__RpcExecStage)2;
					((WendigosMessageHandler)(object)target).InitAzureClientRpc();
					target.__rpc_exec_stage = (__RpcExecStage)0;
				}
			}

			protected internal override string __getTypeName()
			{
				return "WendigosMessageHandler";
			}
		}

		public class WendigosLog
		{
			public bool generation_successful { get; set; }

			public DateTime last_successful_generation { get; set; }

			public string message { get; set; }

			public WendigosLog()
			{
				generation_successful = false;
				last_successful_generation = DateTime.MinValue;
				message = string.Empty;
			}

			public void Load()
			{
				if (File.Exists(assembly_path + "\\WendigosLog.json"))
				{
					WendigosLog wendigosLog = ReadFromJsonFile<WendigosLog>(assembly_path + "\\WendigosLog.json");
					generation_successful = wendigosLog.generation_successful;
					last_successful_generation = wendigosLog.last_successful_generation;
					message = wendigosLog.message;
				}
			}

			public void Save()
			{
				WriteToJsonFile(assembly_path + "\\WendigosLog.json", this);
			}
		}

		public class MainThreadInvoker
		{
			public static readonly ConcurrentQueue<Action> _actions = new ConcurrentQueue<Action>();

			public static void Enqueue(Action action)
			{
				if (action == null)
				{
					throw new ArgumentNullException("action");
				}
				_actions.Enqueue(action);
			}
		}

		public enum Languages
		{
			English,
			Spanish,
			French,
			German,
			Italian,
			Portuguese,
			Polish,
			Turkish,
			Russian,
			Dutch,
			Czech,
			Arabic,
			Chinese,
			Japanese,
			Hungarian,
			Korean,
			Hindi
		}

		[HarmonyPatch(typeof(StartOfRound), "OnPlayerDC")]
		private class PlayerDCPatch
		{
			private static void Prefix(int playerObjectNumber, ulong clientId)
			{
				WriteToConsole($"Clearing {clientId}'s audio clips");
				WriteToConsole($"Removed {audioClips[clientId].Count} Clips");
				audioClips[clientId].Clear();
				WriteToConsole("AudioClip count is now " + get_clips_count());
				if (!((NetworkBehaviour)WendigosMessageHandler.Instance).IsServer)
				{
					return;
				}
				WendigosMessageHandler.ConnectedClientIDs.Remove(clientId);
				foreach (string key in new Dictionary<string, ulong>(sharedMaskedClientDict).Keys)
				{
					if (sharedMaskedClientDict[key] == clientId)
					{
						sharedMaskedClientDict.Remove(key);
					}
				}
				foreach (string key2 in serverReadyDict.Keys)
				{
					serverReadyDict[key2][clientId] = true;
				}
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "OnLocalDisconnect")]
		private class DisconnectPatch
		{
			private static void Postfix()
			{
				foreach (List<AudioClip> value in audioClips.Values)
				{
					value.Clear();
				}
				sent_localID = false;
			}
		}

		[HarmonyPatch(typeof(MaskedPlayerEnemy), "DoAIInterval")]
		private class MaskedPlayerEnemyAIPatch
		{
			private static void Prefix(MaskedPlayerEnemy __instance)
			{
				if (((EnemyAI)__instance).isEnemyDead)
				{
					((EnemyAI)__instance).agent.speed = 0f;
					return;
				}
				string[] array = new string[3] { "idle", "nearby", "chasing" };
				_ = array[serverRand.Next(array.Length)];
				string id = ((Component)__instance).gameObject.GetComponent<MaskedEnemyIdentifier>().id;
				ulong num = 0uL;
				if (!sharedMaskedClientDict.Keys.Contains(id))
				{
					return;
				}
				num = sharedMaskedClientDict[id];
				switch (((EnemyAI)__instance).currentBehaviourStateIndex)
				{
				case 0:
					if ((Object)(object)((EnemyAI)__instance).CheckLineOfSightForClosestPlayer(45f, 60, -1, 0f) != (Object)null)
					{
						if (!enable_realtime_responses.Value)
						{
							WendigosMessageHandler.Instance.TryPlayAudioServerRpc(num, id, 'c', talk_probability.Value);
						}
					}
					else
					{
						WendigosMessageHandler.Instance.TryPlayAudioServerRpc(num, id, 'n', talk_probability.Value);
					}
					break;
				case 1:
				case 2:
					break;
				}
			}
		}

		[HarmonyPatch(typeof(MaskedPlayerEnemy), "SetVisibilityOfMaskedEnemy")]
		private class MaskedPlayerEnemyVisibilityPatch
		{
			public static void Postfix(MaskedPlayerEnemy __instance)
			{
				if ((bool)Traverse.Create((object)__instance).Field("enemyEnabled").GetValue())
				{
					((Component)((Component)__instance).gameObject.transform.Find("ScavengerModel/metarig/spine/spine.001/spine.002/spine.003/spine.004/HeadMaskComedy")