using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Pipes;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using BepInEx;
using BepInEx.Logging;
using CWChat;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using TMPro;
using UnityEngine;
using Zorro.Core;

[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("AeiouContent")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("DECtalk text-to-speech in Content Warning.")]
[assembly: AssemblyFileVersion("0.2.0.0")]
[assembly: AssemblyInformationalVersion("0.2.0+e9ba8a76d1a3bfd9fe4915ff982360b2ae35ab93")]
[assembly: AssemblyProduct("AeiouContent")]
[assembly: AssemblyTitle("AeiouContent")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AeiouContent
{
	internal sealed class AeiouTimeTracker : MonoBehaviour
	{
		public float speakStopTime;

		public float loudness = 1f;
	}
	[HarmonyPatch(typeof(Player))]
	internal sealed class PlayerHook
	{
		[HarmonyPatch("OnGetMic")]
		[HarmonyPostfix]
		private static void OnGetMicPostfix(ref Player __instance)
		{
			Util.UpdateMicrophoneValue(__instance);
		}
	}
	[HarmonyPatch(typeof(PlayerSyncer))]
	internal sealed class PlayerSyncerHook
	{
		private static readonly FieldInfo? PlayerField = typeof(PlayerSyncer).GetField("player", BindingFlags.Instance | BindingFlags.NonPublic);

		[HarmonyPatch("OnPhotonSerializeView")]
		[HarmonyPostfix]
		private static void OnPhotonSerializeViewPostfix(ref PlayerSyncer __instance, PhotonStream stream, PhotonMessageInfo info)
		{
			if (!stream.IsWriting)
			{
				object? obj = PlayerField?.GetValue(__instance);
				Player val = (Player)((obj is Player) ? obj : null);
				if (!((Object)(object)val == (Object)null) && val.data != null)
				{
					Util.UpdateMicrophoneValue(val);
				}
			}
		}
	}
	[BepInPlugin("AeiouContent", "AeiouContent", "0.2.0")]
	public sealed class Plugin : BaseUnityPlugin
	{
		internal const string Guid = "AeiouContent";

		internal const string Name = "AeiouContent";

		internal const string Version = "0.2.0";

		public const string TtsGameObjectName = "AeiouContentGameObject";

		public const float MaxTtsAudibleDistance = 60f;

		public const float MaxTextVisibleDistance = 45f;

		public const float TextVisibilityVerticalRangeScaling = 0.3f;

		public const float TtsVolumeBoost = 1.2f;

		private Harmony _harmony;

		internal static Plugin Instance;

		internal SpeakProcessOwner SpeakProcessOwner;

		internal ManualLogSource SelfLogger => ((BaseUnityPlugin)this).Logger;

		private void Awake()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			Instance = this;
			SpeakProcessOwner = new SpeakProcessOwner();
			SpeakProcessOwner.Init();
			_harmony = new Harmony("AeiouContent");
			_harmony.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"AeiouContent loaded!");
		}
	}
	[HarmonyPatch(typeof(RagdollHandler))]
	internal static class RagdollHandlerHook
	{
		private static readonly GameObject?[] AudioSourceGameObjects = (GameObject?[])(object)new GameObject[8];

		private static int _lastUsedAudioSource = -1;

		private const int NumSources = 8;

		private const int MaxSeconds = 40;

		private const int Frequency = 11025;

		private const int MaxSamples = 441000;

		private static readonly float[] UploadBuffer = new float[441000];

		private static GameObject GetAudioSourceGameObject()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			_lastUsedAudioSource = (_lastUsedAudioSource + 1) % AudioSourceGameObjects.Length;
			GameObject val = AudioSourceGameObjects[_lastUsedAudioSource];
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			val = new GameObject("AeiouContentGameObject");
			AudioSource obj = val.AddComponent<AudioSource>();
			val.AddComponent<AeiouTimeTracker>();
			AudioSourceGameObjects[_lastUsedAudioSource] = val;
			AudioSource val2 = obj;
			if (val2.clip == null)
			{
				AudioClip val4 = (val2.clip = AudioClip.Create("AeiouClip", 441000, 1, 11025, false));
			}
			return val;
		}

		[HarmonyPatch("FixedUpdate")]
		[HarmonyPostfix]
		private static void FixedUpdatePostfix(ref RagdollHandler __instance)
		{
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			SpeakProcessOwner.IncomingAudio result;
			GameObject val;
			GameObject sourceObject;
			AudioSource component2;
			float spatialBlend;
			for (; Plugin.Instance.SpeakProcessOwner.IncomingAudioData.TryDequeue(out result); component2.spatialBlend = spatialBlend, component2.dopplerLevel = 0f, val.transform.parent = null, val.transform.position = (((Object)(object)sourceObject != (Object)null) ? sourceObject.transform.position : Vector3.zero), val.transform.parent = (((Object)(object)sourceObject != (Object)null) ? sourceObject.transform : null), component2.Play())
			{
				val = null;
				Util.GetTtsGameObjects(result.Player, out sourceObject, out GameObject ttsObject);
				if ((Object)(object)ttsObject != (Object)null)
				{
					ttsObject.transform.parent = null;
					AudioSource component = ttsObject.GetComponent<AudioSource>();
					if ((Object)(object)component != (Object)null)
					{
						component.Stop();
					}
					val = ttsObject;
				}
				else if ((Object)(object)val == (Object)null)
				{
					val = GetAudioSourceGameObject();
				}
				Array.Clear(UploadBuffer, 0, UploadBuffer.Length);
				component2 = val.GetComponent<AudioSource>();
				AeiouTimeTracker component3 = val.GetComponent<AeiouTimeTracker>();
				component2.Stop();
				component2.clip.SetData(UploadBuffer, 0);
				for (int i = 0; i < Math.Min(result.Data.Length / 2, UploadBuffer.Length); i++)
				{
					ushort num = (ushort)(result.Data[i * 2] | (result.Data[i * 2 + 1] << 8));
					UploadBuffer[i] = Math.Clamp((float)(short)num / 32767f * 1.2f, -1f, 1f);
				}
				float num2 = (float)Math.Min(result.Data.Length / 2, UploadBuffer.Length) / 11025f;
				component3.speakStopTime = Time.unscaledTime + num2;
				component3.loudness = Mathf.Lerp(0.4f, 1f, Math.Min(1f, (float)result.MessageText.Count((char c) => c == '!' || char.IsUpper(c)) * 0.15f));
				component2.clip.SetData(UploadBuffer, 0);
				component2.outputAudioMixerGroup = SingletonAsset<MixerHolder>.Instance.voiceMixer.audioMixer.outputAudioMixerGroup;
				component2.rolloffMode = (AudioRolloffMode)1;
				component2.minDistance = 10f;
				component2.maxDistance = 60f;
				int spatialize;
				if ((Object)(object)result.Player != (Object)(object)Player.localPlayer)
				{
					Player player = result.Player;
					if (player != null)
					{
						PlayerData data = player.data;
						if (data != null)
						{
							spatialize = ((!data.dead) ? 1 : 0);
							goto IL_021d;
						}
					}
					spatialize = 0;
				}
				else
				{
					spatialize = 0;
				}
				goto IL_021d;
				IL_021d:
				component2.spatialize = (byte)spatialize != 0;
				if ((Object)(object)result.Player != (Object)(object)Player.localPlayer)
				{
					Player player = result.Player;
					if (player != null)
					{
						PlayerData data = player.data;
						if (data != null && !data.dead)
						{
							spatialBlend = 1f;
							continue;
						}
					}
				}
				spatialBlend = 0f;
			}
		}
	}
	[HarmonyPatch(typeof(ChatNet))]
	internal sealed class SimpleChatHook
	{
		private const byte ChatMessageCode = 16;

		[HarmonyPatch("OnEvent")]
		[HarmonyPrefix]
		private static bool OnEventPrefix(ref ChatNet __instance, EventData photonEvent)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			if (photonEvent.Code != 16)
			{
				return false;
			}
			if (!(photonEvent.CustomData is object[] array) || array.Length < 4 || !(array[0] is string text) || !(array[1] is string text2) || !(array[2] is bool flag) || !(array[3] is string text3))
			{
				return false;
			}
			MsgData val = default(MsgData);
			((MsgData)(ref val))..ctor(text, text2, flag, text3);
			int actorNumber = photonEvent.Sender;
			Plugin.Instance.SelfLogger.LogMessage((object)("Message from " + val.name + ": " + val.message));
			Player val2 = ((IEnumerable<Player>)PlayerHandler.instance.players).FirstOrDefault((Func<Player, bool>)((Player p) => p.refs.view.Owner.ActorNumber == actorNumber));
			if (val2 == null)
			{
				return false;
			}
			if (!Player.localPlayer.data.dead && val2.data.dead)
			{
				return false;
			}
			val.name = val2.refs.view.Controller.NickName + " ( " + ((TMP_Text)val2.refs.visor.visorFaceText).text + " )";
			Bodypart? bodypart = Util.GetBodypart(val2, (BodypartType)4);
			Vector3 val3 = ((bodypart != null) ? ((Component)bodypart).transform.position : Vector3.zero);
			Bodypart? bodypart2 = Util.GetBodypart(Player.localPlayer, (BodypartType)4);
			Vector3 val4 = ((bodypart2 != null) ? ((Component)bodypart2).transform.position : Vector3.zero);
			float num = Vector3.Distance(val3, val4);
			Plugin.Instance.SelfLogger.LogDebug((object)$"Distance from {val2.refs.view.Controller.NickName}: {num}");
			if (num <= 60f)
			{
				Plugin.Instance.SpeakProcessOwner.Speak(val.message, val2);
			}
			if (Vector3.Distance(Util.GetVerticallyScaledPosition(val3), Util.GetVerticallyScaledPosition(val4)) <= 45f)
			{
				__instance.AddNewMessage(val);
			}
			return false;
		}
	}
	internal sealed class SpeakProcessOwner
	{
		private readonly struct State
		{
			internal readonly Process Process;

			internal readonly AnonymousPipeServerStream OutPipe;

			internal readonly AnonymousPipeServerStream InPipe;

			internal readonly BinaryReader BinaryReader;

			internal readonly StreamWriter StreamWriter;

			public State(Process process, AnonymousPipeServerStream outPipe, AnonymousPipeServerStream inPipe, BinaryReader binaryReader, StreamWriter streamWriter)
			{
				Process = process;
				OutPipe = outPipe;
				InPipe = inPipe;
				BinaryReader = binaryReader;
				StreamWriter = streamWriter;
			}
		}

		private readonly struct OutgoingMsg
		{
			public readonly string Message;

			public readonly Player? Player;

			public OutgoingMsg(string message, Player? player)
			{
				Message = message;
				Player = player;
			}
		}

		public readonly struct IncomingAudio
		{
			public readonly string MessageText;

			public readonly byte[] Data;

			public readonly Player? Player;

			public IncomingAudio(string messageText, byte[] data, Player? player)
			{
				MessageText = messageText;
				Data = data;
				Player = player;
			}
		}

		private readonly ConcurrentQueue<OutgoingMsg> _outgoingMsgs = new ConcurrentQueue<OutgoingMsg>();

		private readonly object _mutex = new object();

		private State? _currentState;

		public readonly ConcurrentQueue<IncomingAudio> IncomingAudioData = new ConcurrentQueue<IncomingAudio>();

		public void Init()
		{
			lock (_mutex)
			{
				_currentState?.Process.Kill();
				string directoryName = Path.GetDirectoryName(Path.GetFullPath(typeof(Plugin).Assembly.Location));
				if (string.IsNullOrWhiteSpace(directoryName) || !Directory.Exists(directoryName))
				{
					Plugin.Instance.SelfLogger.LogError((object)("Failed to start SpeakServer: \"" + directoryName + "\" is not a valid directory"));
					return;
				}
				AnonymousPipeServerStream anonymousPipeServerStream = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable);
				AnonymousPipeServerStream anonymousPipeServerStream2 = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable);
				Process process = Process.Start(new ProcessStartInfo
				{
					FileName = Path.Combine(directoryName, "./SpeakServer.exe"),
					UseShellExecute = false,
					Arguments = anonymousPipeServerStream.GetClientHandleAsString() + " " + anonymousPipeServerStream2.GetClientHandleAsString()
				});
				if (process == null)
				{
					Plugin.Instance.SelfLogger.LogError((object)"Failed to start SpeakServer: program could not launch");
					return;
				}
				StreamWriter streamWriter = new StreamWriter(anonymousPipeServerStream);
				BinaryReader binaryReader = new BinaryReader(anonymousPipeServerStream2);
				_currentState = new State(process, anonymousPipeServerStream, anonymousPipeServerStream2, binaryReader, streamWriter);
			}
			new Thread(ServerCommunicationLoop).Start();
			Plugin.Instance.SelfLogger.LogInfo((object)"Starting up AeiouContent!");
		}

		private State? GetState()
		{
			lock (_mutex)
			{
				return _currentState;
			}
		}

		public void Speak(string message, Player? player)
		{
			_outgoingMsgs.Enqueue(new OutgoingMsg(message, player));
		}

		private void ServerCommunicationLoop()
		{
			State? state = GetState();
			if (!state.HasValue)
			{
				return;
			}
			State valueOrDefault = state.GetValueOrDefault();
			while (valueOrDefault.OutPipe.IsConnected && valueOrDefault.InPipe.IsConnected)
			{
				state = GetState();
				if (!state.HasValue || !state.GetValueOrDefault().Equals(valueOrDefault))
				{
					break;
				}
				try
				{
					OutgoingMsg result;
					while (_outgoingMsgs.TryDequeue(out result))
					{
						valueOrDefault.StreamWriter.WriteLine("msg=" + result.Message);
						valueOrDefault.StreamWriter.Flush();
						int num = valueOrDefault.BinaryReader.ReadInt32();
						if (num > 0)
						{
							byte[] data = valueOrDefault.BinaryReader.ReadBytes(num);
							IncomingAudioData.Enqueue(new IncomingAudio(result.Message, data, result.Player));
						}
					}
				}
				catch (Exception arg)
				{
					Plugin.Instance.SelfLogger.LogError((object)$"Exception in ServerCommunicationLoop: {arg}");
				}
				Thread.Sleep(32);
			}
		}
	}
	internal static class Util
	{
		private static readonly MethodInfo? GetBodypartMethodInfo = typeof(PlayerRagdoll).GetMethod("GetBodypart", BindingFlags.Instance | BindingFlags.NonPublic);

		public static Bodypart? GetBodypart(Player? player, BodypartType type)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (player == null)
			{
				return null;
			}
			if ((object)GetBodypartMethodInfo == null)
			{
				return null;
			}
			object? obj = GetBodypartMethodInfo.Invoke(player.refs.ragdoll, new object[1] { type });
			return (Bodypart?)((obj is Bodypart) ? obj : null);
		}

		public static void GetTtsGameObjects(Player? player, out GameObject? sourceObject, out GameObject? ttsObject)
		{
			object obj;
			if ((Object)(object)player != (Object)(object)Player.localPlayer && player != null)
			{
				PlayerData data = player.data;
				if (data != null && !data.dead)
				{
					obj = GetBodypart(player, (BodypartType)4);
					goto IL_0030;
				}
			}
			obj = MainCamera.instance;
			goto IL_0030;
			IL_0030:
			MonoBehaviour val = (MonoBehaviour)obj;
			sourceObject = (((Object)(object)val != (Object)null) ? ((Component)val).gameObject : null);
			ttsObject = null;
			if (!((Object)(object)sourceObject == (Object)null))
			{
				Transform val2 = sourceObject.transform.Find("AeiouContentGameObject");
				ttsObject = (((Object)(object)val2 != (Object)null) ? ((Component)val2).gameObject : null);
			}
		}

		public static void UpdateMicrophoneValue(Player player)
		{
			if (player.data.dead)
			{
				return;
			}
			GetTtsGameObjects(player, out GameObject _, out GameObject ttsObject);
			if (!((Object)(object)ttsObject == (Object)null))
			{
				AeiouTimeTracker component = ttsObject.GetComponent<AeiouTimeTracker>();
				if (!((Object)(object)component == (Object)null) && !(Time.unscaledTime > component.speakStopTime))
				{
					player.data.microphoneValue = component.loudness;
				}
			}
		}

		public static Vector3 GetVerticallyScaledPosition(Vector3 position)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(position.x, position.y / 0.3f, position.z);
		}
	}
}

using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;

[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("SharpTalk")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+e9ba8a76d1a3bfd9fe4915ff982360b2ae35ab93")]
[assembly: AssemblyProduct("SharpTalk")]
[assembly: AssemblyTitle("SharpTalk")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace SharpTalk;

public class FonixTalkEngine : IDisposable
{
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	private delegate void DtCallbackRoutine(int P_0, int P_1, uint P_2, uint P_3);

	private struct PhonemeMark
	{
		public byte ThisPhoneme;

		public byte NextPhoneme;

		public ushort Duration;
	}

	[StructLayout(LayoutKind.Explicit)]
	private struct PhonemeTag
	{
		[FieldOffset(0)]
		public PhonemeMark PMData;

		[FieldOffset(0)]
		public int DWData;
	}

	private struct InMemoryRaiiHelper : IDisposable
	{
		private readonly FonixTalkEngine _engine;

		public InMemoryRaiiHelper(FonixTalkEngine P_0)
		{
			_engine = P_0;
		}

		public void Dispose()
		{
			_engine.CloseInMemory();
		}
	}

	private struct BufferRaiiHelper : IDisposable
	{
		private readonly FonixTalkEngine _engine;

		public BufferRaiiHelper(FonixTalkEngine P_0)
		{
			_engine = P_0;
		}

		public void Dispose()
		{
			_engine.FreeBuffer();
		}
	}

	[CompilerGenerated]
	private EventHandler<PhonemeEventArgs> Phoneme;

	private static readonly uint UiIndexMsg = RegisterWindowMessage("DECtalkIndexMessage");

	private static readonly uint UiErrorMsg = RegisterWindowMessage("DECtalkErrorMessage");

	private static readonly uint UiBufferMsg = RegisterWindowMessage("DECtalkBufferMessage");

	private static readonly uint UiPhonemeMsg = RegisterWindowMessage("DECtalkVisualMessage");

	private IntPtr _handle;

	private DtCallbackRoutine _callback;

	private TtsBufferManaged _buffer;

	private Stream _bufferStream;

	[DllImport("FonixTalk.dll")]
	private static extern MMRESULT TextToSpeechStartupEx(out IntPtr P_0, uint P_1, uint P_2, DtCallbackRoutine P_3, ref IntPtr P_4);

	[DllImport("FonixTalk.dll")]
	[return: MarshalAs(UnmanagedType.Bool)]
	private static extern bool TextToSpeechSelectLang(IntPtr P_0, uint P_1);

	[DllImport("FonixTalk.dll")]
	private static extern uint TextToSpeechStartLang([MarshalAs(UnmanagedType.LPStr)] string P_0);

	[DllImport("FonixTalk.dll")]
	private static extern MMRESULT TextToSpeechSpeakA(IntPtr P_0, [MarshalAs(UnmanagedType.LPStr)] string P_1, uint P_2);

	[DllImport("FonixTalk.dll")]
	private static extern MMRESULT TextToSpeechShutdown(IntPtr P_0);

	[DllImport("FonixTalk.dll")]
	private static extern MMRESULT TextToSpeechReset(IntPtr P_0, [MarshalAs(UnmanagedType.Bool)] bool P_1);

	[DllImport("FonixTalk.dll")]
	private static extern MMRESULT TextToSpeechSync(IntPtr P_0);

	[DllImport("FonixTalk.dll")]
	private unsafe static extern MMRESULT TextToSpeechAddBuffer(IntPtr P_0, TtsBufferManaged.TTS_BUFFER_T* P_1);

	[DllImport("FonixTalk.dll")]
	private static extern MMRESULT TextToSpeechOpenInMemory(IntPtr P_0, uint P_1);

	[DllImport("FonixTalk.dll")]
	private static extern MMRESULT TextToSpeechCloseInMemory(IntPtr P_0);

	[DllImport("user32.dll")]
	private static extern uint RegisterWindowMessage([MarshalAs(UnmanagedType.LPStr)] string P_0);

	public FonixTalkEngine()
	{
		Init("US");
	}

	private void Init(string P_0)
	{
		_callback = TtsCallback;
		_buffer = null;
		_bufferStream = null;
		if (P_0 != "XX")
		{
			uint num = TextToSpeechStartLang(P_0);
			if ((num & 0x4000u) != 0)
			{
				switch (num)
				{
				case 32767u:
					throw new FonixTalkException("This version of DECtalk does not support multiple languages.");
				case 32766u:
					throw new FonixTalkException("The specified language was not found.");
				}
			}
			if (!TextToSpeechSelectLang(IntPtr.Zero, num))
			{
				throw new FonixTalkException("The specified language failed to load.");
			}
		}
		Check(TextToSpeechStartupEx(out _handle, uint.MaxValue, 0u, _callback, ref _handle));
		Speak("[:phone on]");
	}

	private unsafe void TtsCallback(int lParam1, int lParam2, uint drCallbackParameter, uint uiMsg)
	{
		if (uiMsg == UiPhonemeMsg && Phoneme != null)
		{
			PhonemeTag phonemeTag = default(PhonemeTag);
			phonemeTag.DWData = lParam2;
			PhonemeTag phonemeTag2 = phonemeTag;
			Phoneme(this, new PhonemeEventArgs((char)phonemeTag2.PMData.ThisPhoneme, phonemeTag2.PMData.Duration));
		}
		else if (uiMsg == UiBufferMsg)
		{
			_bufferStream.Write(_buffer.GetBufferBytes(), 0, (int)_buffer.Length);
			_ = _buffer.Full;
			_buffer.Reset();
			Check(TextToSpeechAddBuffer(_handle, _buffer.ValuePointer));
		}
		else if (uiMsg != UiErrorMsg)
		{
			_ = UiIndexMsg;
		}
	}

	public byte[] SpeakToMemory(string P_0)
	{
		using (_bufferStream = new MemoryStream())
		{
			using (OpenInMemory(4u))
			{
				using (ReadyBuffer())
				{
					Speak(P_0);
					Sync();
					TextToSpeechReset(_handle, false);
				}
			}
			return ((MemoryStream)_bufferStream).ToArray();
		}
	}

	public void Sync()
	{
		Check(TextToSpeechSync(_handle));
	}

	public void Speak(string P_0)
	{
		Check(TextToSpeechSpeakA(_handle, P_0, 1u));
	}

	private static void Check(MMRESULT P_0)
	{
		if (P_0 != 0)
		{
			throw new FonixTalkException(P_0);
		}
	}

	private InMemoryRaiiHelper OpenInMemory(uint P_0)
	{
		Check(TextToSpeechOpenInMemory(_handle, P_0));
		return new InMemoryRaiiHelper(this);
	}

	private void CloseInMemory()
	{
		Check(TextToSpeechCloseInMemory(_handle));
	}

	private unsafe BufferRaiiHelper ReadyBuffer()
	{
		if (_buffer != null)
		{
			throw new InvalidOperationException("Buffer already exists.");
		}
		_buffer = new TtsBufferManaged();
		Check(TextToSpeechAddBuffer(_handle, _buffer.ValuePointer));
		return new BufferRaiiHelper(this);
	}

	private void FreeBuffer()
	{
		_buffer.Dispose();
		_buffer = null;
	}

	~FonixTalkEngine()
	{
		Dispose(false);
	}

	public void Dispose()
	{
		Dispose(true);
	}

	private void Dispose(bool P_0)
	{
		TextToSpeechShutdown(_handle);
		if (_buffer != null)
		{
			_buffer.Dispose();
		}
		if (P_0)
		{
			GC.SuppressFinalize(this);
		}
	}
}
public sealed class FonixTalkException : Exception
{
	internal FonixTalkException(MMRESULT P_0)
		: base(GetMessage(P_0))
	{
	}

	internal FonixTalkException(string P_0)
		: base(P_0)
	{
	}

	private static string GetMessage(MMRESULT P_0)
	{
		return P_0 switch
		{
			MMRESULT.MMSYSERR_INVALPARAM => "An invalid parameter was passed to the function.", 
			MMRESULT.MMSYSERR_INVALHANDLE => "The associated handle is invalid. Did you dispose it?", 
			MMRESULT.MMSYSERR_ERROR => "The function returned a generic error. Please check that you are using the functions correctly.", 
			MMRESULT.MMSYSERR_NOERROR => "The function did not throw an error. If you are seeing this, Berkin was obviously high while coding.", 
			MMRESULT.MMSYSERR_NOMEM => "There was insufficnent memory available to allocate the requested resources.", 
			MMRESULT.MMSYSERR_ALLOCATED => "The requested resources are already in use somewhere else.", 
			MMRESULT.WAVERR_BADFORMAT => "Wave output device does not support request format.", 
			MMRESULT.MMSYSERR_BADDEVICEID => "Device ID out of range.", 
			MMRESULT.MMSYSERR_NODRIVER => "No wave output device present.", 
			_ => P_0.ToString(), 
		};
	}
}
internal enum MMRESULT : uint
{
	MMSYSERR_NOERROR = 0u,
	MMSYSERR_ERROR = 1u,
	MMSYSERR_BADDEVICEID = 2u,
	MMSYSERR_NOTENABLED = 3u,
	MMSYSERR_ALLOCATED = 4u,
	MMSYSERR_INVALHANDLE = 5u,
	MMSYSERR_NODRIVER = 6u,
	MMSYSERR_NOMEM = 7u,
	MMSYSERR_NOTSUPPORTED = 8u,
	MMSYSERR_BADERRNUM = 9u,
	MMSYSERR_INVALFLAG = 10u,
	MMSYSERR_INVALPARAM = 11u,
	MMSYSERR_HANDLEBUSY = 12u,
	MMSYSERR_INVALIDALIAS = 13u,
	MMSYSERR_BADDB = 14u,
	MMSYSERR_KEYNOTFOUND = 15u,
	MMSYSERR_READERROR = 16u,
	MMSYSERR_WRITEERROR = 17u,
	MMSYSERR_DELETEERROR = 18u,
	MMSYSERR_VALNOTFOUND = 19u,
	MMSYSERR_NODRIVERCB = 20u,
	WAVERR_BADFORMAT = 32u,
	WAVERR_STILLPLAYING = 33u,
	WAVERR_UNPREPARED = 34u
}
public class PhonemeEventArgs : EventArgs
{
	public readonly char Phoneme;

	public readonly uint Duration;

	internal PhonemeEventArgs(char P_0, uint P_1)
	{
		Phoneme = P_0;
		Duration = P_1;
	}
}
[StructLayout(LayoutKind.Sequential)]
internal class TtsBufferManaged : IDisposable
{
	public struct TTS_BUFFER_T
	{
		public IntPtr DataPtr;

		public unsafe TTS_PHONEME_T* PhonemeArrayPtr;

		public unsafe TTS_INDEX_T* IndexArrayPtr;

		public uint MaxBufferLength;

		public uint MaxPhonemeChanges;

		public uint MaxIndexMarks;

		public uint BufferLength;

		public uint PhonemeChangeCount;

		public uint IndexMarkCount;

		public uint _reserved;
	}

	private TTS_BUFFER_T _value;

	private GCHandle _pinHandle;

	public bool Full => _value.BufferLength == _value.MaxBufferLength;

	public uint Length => _value.BufferLength;

	public unsafe TTS_BUFFER_T* ValuePointer
	{
		get
		{
			fixed (TTS_BUFFER_T* result = &_value)
			{
				return result;
			}
		}
	}

	public TtsBufferManaged()
	{
		_value = default(TTS_BUFFER_T);
		_pinHandle = GCHandle.Alloc(this, GCHandleType.Pinned);
		_value.MaxBufferLength = 16384u;
		_value.DataPtr = Marshal.AllocHGlobal(16384);
	}

	public byte[] GetBufferBytes()
	{
		byte[] array = new byte[_value.BufferLength];
		Marshal.Copy(_value.DataPtr, array, 0, (int)_value.BufferLength);
		return array;
	}

	public void Reset()
	{
		_value.BufferLength = 0u;
		_value.PhonemeChangeCount = 0u;
		_value.IndexMarkCount = 0u;
	}

	public void Dispose()
	{
		Marshal.FreeHGlobal(_value.DataPtr);
		_pinHandle.Free();
		GC.SuppressFinalize(this);
	}
}
internal struct TTS_INDEX_T
{
	public uint IndexValue;

	public uint SampleNumber;

	private readonly uint _reserved;
}
internal struct TTS_PHONEME_T
{
	public uint Phoneme;

	public uint PhonemeSampleNumber;

	public uint PhonemeDuration;

	private readonly uint _reserved;
}

using System;
using System.Diagnostics;
using System.IO;
using System.IO.Pipes;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using SharpTalk;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName = ".NET 8.0")]
[assembly: AssemblyCompany("SpeakServer")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+e9ba8a76d1a3bfd9fe4915ff982360b2ae35ab93")]
[assembly: AssemblyProduct("SpeakServer")]
[assembly: AssemblyTitle("SpeakServer")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace SpeakServer;

internal static class Program
{
	private static void Main(string[] P_0)
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Expected O, but got Unknown
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Expected O, but got Unknown
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Expected O, but got Unknown
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Expected O, but got Unknown
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Expected O, but got Unknown
		if (P_0.Length < 2)
		{
			Console.WriteLine($"AeiouCompany SpeakServer: 2 pipes required, got {P_0.Length}, closing");
			return;
		}
		AnonymousPipeClientStream val = new AnonymousPipeClientStream((PipeDirection)1, P_0[0]);
		try
		{
			AnonymousPipeClientStream val2 = new AnonymousPipeClientStream((PipeDirection)2, P_0[1]);
			try
			{
				StreamReader val3 = new StreamReader((Stream)(object)val, Encoding.UTF8, true, 8192, true);
				try
				{
					BinaryWriter val4 = new BinaryWriter((Stream)(object)val2, Encoding.UTF8, true);
					try
					{
						FonixTalkEngine val5 = new FonixTalkEngine();
						try
						{
							Console.WriteLine("AeiouCompany SpeakServer: Connected!");
							ListenForMessages(val2, val3, val4, val5);
							val5.Sync();
						}
						finally
						{
							((global::System.IDisposable)val5)?.Dispose();
						}
					}
					finally
					{
						((global::System.IDisposable)val4)?.Dispose();
					}
				}
				finally
				{
					((global::System.IDisposable)val3)?.Dispose();
				}
			}
			finally
			{
				((global::System.IDisposable)val2)?.Dispose();
			}
		}
		finally
		{
			((global::System.IDisposable)val)?.Dispose();
		}
	}

	private static void ListenForMessages(AnonymousPipeClientStream P_0, StreamReader P_1, BinaryWriter P_2, FonixTalkEngine P_3)
	{
		//IL_00e4: Expected O, but got Unknown
		while (((PipeStream)P_0).IsConnected)
		{
			try
			{
				string text = ((TextReader)P_1).ReadLine() ?? "";
				Console.WriteLine("AeiouCompany SpeakServer: Incoming line \"" + text + "\"");
				if (string.IsNullOrWhiteSpace(text))
				{
					P_2.Write(0);
					P_2.Flush();
					continue;
				}
				if (text == "exit")
				{
					break;
				}
				if (text.StartsWith("msg=", (StringComparison)4))
				{
					string text2 = text.Substring("msg=".Length);
					byte[] array = P_3.SpeakToMemory("[:np]" + text2 + "]");
					P_2.Write(array.Length);
					P_2.Write(array);
					P_2.Flush();
					Console.WriteLine($"AeiouCompany SpeakServer: Output {array.Length} bytes of audio");
				}
			}
			catch (IOException val)
			{
				IOException val2 = val;
				Console.WriteLine("Broken: " + ((global::System.Exception)(object)val2).Message);
				break;
			}
		}
	}
}

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using FxResources.System.Collections.Immutable;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETCoreApp,Version=v8.0", FrameworkDisplayName = ".NET 8.0")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyDefaultAlias("System.Collections.Immutable")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: CLSCompliant(true)]
[assembly: AssemblyMetadata("IsTrimmable", "True")]
[assembly: DefaultDllImportSearchPaths(/*Could not decode attribute arguments.*/)]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("This package provides collections that are thread safe and guaranteed to never change their contents, also known as immutable collections. Like strings, any methods that perform modifications will not change the existing instance but instead return a new instance. For efficiency reasons, the implementation uses a sharing mechanism to ensure that newly created instances share as much data as possible with the previous instance while ensuring that operations have a predictable time complexity.\r\n\r\nThe System.Collections.Immutable library is built-in as part of the shared framework in .NET Runtime. The package can be installed when you need to use it in other target frameworks.")]
[assembly: AssemblyFileVersion("8.0.324.11423")]
[assembly: AssemblyInformationalVersion("8.0.3+9f4b1f5d664afdfc80e1508ab7ed099dff210fbd")]
[assembly: AssemblyProduct("Microsoft® .NET")]
[assembly: AssemblyTitle("System.Collections.Immutable")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/runtime")]
[assembly: AssemblyVersion("8.0.0.0")]
[module: RefSafetyRules(11)]
[module: NullablePublicOnly(true)]
[module: SkipLocalsInit]
namespace FxResources.System.Collections.Immutable
{
	internal static class SR
	{
	}
}
namespace System
{
	internal static class SR
	{
		private static readonly bool s_usingResourceKeys;

		private static ResourceManager s_resourceManager;

		internal static ResourceManager ResourceManager
		{
			get
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Expected O, but got Unknown
				object obj = s_resourceManager;
				if (obj == null)
				{
					ResourceManager val = new ResourceManager(typeof(FxResources.System.Collections.Immutable.SR));
					s_resourceManager = val;
					obj = (object)val;
				}
				return (ResourceManager)obj;
			}
		}

		internal static string CapacityMustEqualCountOnMove => GetResourceString("CapacityMustEqualCountOnMove");

		internal static string InvalidOperationOnDefaultArray => GetResourceString("InvalidOperationOnDefaultArray");

		internal static bool UsingResourceKeys()
		{
			return s_usingResourceKeys;
		}

		private static string GetResourceString(string P_0)
		{
			if (UsingResourceKeys())
			{
				return P_0;
			}
			string result = null;
			try
			{
				result = ResourceManager.GetString(P_0);
			}
			catch (MissingManifestResourceException)
			{
			}
			return result;
		}

		static SR()
		{
			System.Runtime.CompilerServices.Unsafe.SkipInit(out bool flag);
			s_usingResourceKeys = AppContext.TryGetSwitch("System.Resources.UseSystemResourceKeys", ref flag) && flag;
		}
	}
}
namespace System.Linq
{
	public static class ImmutableArrayExtensions
	{
		public static T? FirstOrDefault<T>(this ImmutableArray<T> P_0, Func<T, bool> P_1)
		{
			Requires.NotNull<Func<T, bool>>(P_1, "predicate");
			T[] array = P_0.array;
			foreach (T val in array)
			{
				if (P_1.Invoke(val))
				{
					return val;
				}
			}
			return default(T);
		}
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(/*Could not decode attribute arguments.*/)]
	internal sealed class NonVersionableAttribute : System.Attribute
	{
	}
}
namespace System.Runtime.InteropServices
{
	public static class ImmutableCollectionsMarshal
	{
		public static ImmutableArray<T> AsImmutableArray<T>(T[]? P_0)
		{
			return new ImmutableArray<T>(P_0);
		}
	}
}
namespace System.Collections.Immutable
{
	internal interface IImmutableArray
	{
		System.Array? Array { get; }
	}
	public static class ImmutableArray
	{
		public static ImmutableArray<T>.Builder CreateBuilder<T>(int P_0)
		{
			return new ImmutableArray<T>.Builder(P_0);
		}
	}
	[DefaultMember("Item")]
	[CollectionBuilder(typeof(ImmutableArray), "Create")]
	[DebuggerDisplay("{DebuggerDisplay,nq}")]
	[NonVersionable]
	public readonly struct ImmutableArray<T> : System.Collections.Generic.IReadOnlyList<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, IEquatable<ImmutableArray<T>>, System.Collections.IList, System.Collections.ICollection, IImmutableArray
	{
		[DefaultMember("Item")]
		[DebuggerDisplay("Count = {Count}")]
		[DebuggerTypeProxy(typeof(ImmutableArrayBuilderDebuggerProxy<>))]
		public sealed class Builder : System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable, System.Collections.Generic.IReadOnlyList<T>, System.Collections.Generic.IReadOnlyCollection<T>
		{
			[CompilerGenerated]
			private sealed class <GetEnumerator>d__66 : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable
			{
				private int <>1__state;

				private T <>2__current;

				public Builder <>4__this;

				private int <i>5__2;

				T System.Collections.Generic.IEnumerator<T>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

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

				[DebuggerHidden]
				public <GetEnumerator>d__66(int P_0)
				{
					<>1__state = P_0;
				}

				[DebuggerHidden]
				void System.IDisposable.Dispose()
				{
				}

				private bool MoveNext()
				{
					int num = <>1__state;
					Builder builder = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<i>5__2 = 0;
						break;
					case 1:
						<>1__state = -1;
						<i>5__2++;
						break;
					}
					if (<i>5__2 < builder.Count)
					{
						<>2__current = builder[<i>5__2];
						<>1__state = 1;
						return true;
					}
					return false;
				}

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

				[DebuggerHidden]
				void System.Collections.IEnumerator.Reset()
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					throw new NotSupportedException();
				}
			}

			private T[] _elements;

			private int _count;

			public int Capacity => _elements.Length;

			public int Count
			{
				get
				{
					return _count;
				}
				set
				{
					Requires.Range(value >= 0, "value");
					if (value < _count)
					{
						if (_count - value > 64)
						{
							System.Array.Clear((System.Array)_elements, value, _count - value);
						}
						else
						{
							for (int i = value; i < Count; i++)
							{
								_elements[i] = default(T);
							}
						}
					}
					else if (value > _count)
					{
						EnsureCapacity(value);
					}
					_count = value;
				}
			}

			public T this[int P_0]
			{
				get
				{
					if (P_0 >= Count)
					{
						ThrowIndexOutOfRangeException();
					}
					return _elements[P_0];
				}
				set
				{
					if (P_0 >= Count)
					{
						ThrowIndexOutOfRangeException();
					}
					_elements[P_0] = value;
				}
			}

			bool System.Collections.Generic.ICollection<T>.IsReadOnly => false;

			internal Builder(int P_0)
			{
				Requires.Range(P_0 >= 0, "capacity");
				_elements = new T[P_0];
				_count = 0;
			}

			private static void ThrowIndexOutOfRangeException()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new IndexOutOfRangeException();
			}

			public ImmutableArray<T> MoveToImmutable()
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				if (Capacity != Count)
				{
					throw new InvalidOperationException(SR.CapacityMustEqualCountOnMove);
				}
				T[] elements = _elements;
				_elements = ImmutableArray<T>.Empty.array;
				_count = 0;
				return new ImmutableArray<T>(elements);
			}

			public void Clear()
			{
				Count = 0;
			}

			public void Insert(int P_0, T P_1)
			{
				Requires.Range(P_0 >= 0 && P_0 <= Count, "index");
				EnsureCapacity(Count + 1);
				if (P_0 < Count)
				{
					System.Array.Copy((System.Array)_elements, P_0, (System.Array)_elements, P_0 + 1, Count - P_0);
				}
				_count++;
				_elements[P_0] = P_1;
			}

			public void Add(T P_0)
			{
				int num = _count + 1;
				EnsureCapacity(num);
				_elements[_count] = P_0;
				_count = num;
			}

			public bool Remove(T P_0)
			{
				int num = IndexOf(P_0);
				if (num >= 0)
				{
					RemoveAt(num);
					return true;
				}
				return false;
			}

			public void RemoveAt(int P_0)
			{
				Requires.Range(P_0 >= 0 && P_0 < Count, "index");
				if (P_0 < Count - 1)
				{
					System.Array.Copy((System.Array)_elements, P_0 + 1, (System.Array)_elements, P_0, Count - P_0 - 1);
				}
				Count--;
			}

			public bool Contains(T P_0)
			{
				return IndexOf(P_0) >= 0;
			}

			public T[] ToArray()
			{
				if (Count == 0)
				{
					return ImmutableArray<T>.Empty.array;
				}
				T[] array = new T[Count];
				System.Array.Copy((System.Array)_elements, (System.Array)array, Count);
				return array;
			}

			public void CopyTo(T[] P_0, int P_1)
			{
				Requires.NotNull(P_0, "array");
				Requires.Range(P_1 >= 0 && P_1 + Count <= P_0.Length, "index");
				System.Array.Copy((System.Array)_elements, 0, (System.Array)P_0, P_1, Count);
			}

			private void EnsureCapacity(int P_0)
			{
				if (_elements.Length < P_0)
				{
					int num = Math.Max(_elements.Length * 2, P_0);
					System.Array.Resize<T>(ref _elements, num);
				}
			}

			public int IndexOf(T P_0)
			{
				return IndexOf(P_0, 0, _count, (IEqualityComparer<T>?)(object)EqualityComparer<T>.Default);
			}

			public int IndexOf(T P_0, int P_1, int P_2, IEqualityComparer<T>? P_3)
			{
				if (P_2 == 0 && P_1 == 0)
				{
					return -1;
				}
				Requires.Range(P_1 >= 0 && P_1 < Count, "startIndex");
				Requires.Range(P_2 >= 0 && P_1 + P_2 <= Count, "count");
				if (P_3 == null)
				{
					P_3 = (IEqualityComparer<T>?)(object)EqualityComparer<T>.Default;
				}
				if (P_3 == EqualityComparer<T>.Default)
				{
					return System.Array.IndexOf<T>(_elements, P_0, P_1, P_2);
				}
				for (int i = P_1; i < P_1 + P_2; i++)
				{
					if (P_3.Equals(_elements[i], P_0))
					{
						return i;
					}
				}
				return -1;
			}

			[IteratorStateMachine(typeof(ImmutableArray<>.Builder.<GetEnumerator>d__66))]
			public System.Collections.Generic.IEnumerator<T> GetEnumerator()
			{
				for (int i = 0; i < Count; i++)
				{
					yield return this[i];
				}
			}

			System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator()
			{
				return GetEnumerator();
			}

			System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
			{
				return (System.Collections.IEnumerator)GetEnumerator();
			}
		}

		public struct Enumerator
		{
			private readonly T[] _array;

			private int _index;

			public T Current => _array[_index];

			internal Enumerator(T[] P_0)
			{
				_array = P_0;
				_index = -1;
			}

			public bool MoveNext()
			{
				return ++_index < _array.Length;
			}
		}

		private sealed class EnumeratorObject : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable
		{
			private static readonly System.Collections.Generic.IEnumerator<T> s_EmptyEnumerator = new EnumeratorObject(ImmutableArray<T>.Empty.array);

			private readonly T[] _array;

			private int _index;

			public T Current
			{
				get
				{
					//IL_0022: Unknown result type (might be due to invalid IL or missing references)
					if ((uint)_index < (uint)_array.Length)
					{
						return _array[_index];
					}
					throw new InvalidOperationException();
				}
			}

			object System.Collections.IEnumerator.Current => Current;

			private EnumeratorObject(T[] P_0)
			{
				_index = -1;
				_array = P_0;
			}

			public bool MoveNext()
			{
				int num = _index + 1;
				int num2 = _array.Length;
				if ((uint)num <= (uint)num2)
				{
					_index = num;
					return (uint)num < (uint)num2;
				}
				return false;
			}

			void System.Collections.IEnumerator.Reset()
			{
				_index = -1;
			}

			public void Dispose()
			{
			}

			internal static System.Collections.Generic.IEnumerator<T> Create(T[] P_0)
			{
				if (P_0.Length != 0)
				{
					return new EnumeratorObject(P_0);
				}
				return s_EmptyEnumerator;
			}
		}

		public static readonly ImmutableArray<T> Empty = new ImmutableArray<T>(new T[0]);

		[DebuggerBrowsable(/*Could not decode attribute arguments.*/)]
		internal readonly T[]? array;

		T System.Collections.Generic.IList<T>.this[int P_0]
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray[P_0];
			}
			set
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		[DebuggerBrowsable(/*Could not decode attribute arguments.*/)]
		bool System.Collections.Generic.ICollection<T>.IsReadOnly => true;

		[DebuggerBrowsable(/*Could not decode attribute arguments.*/)]
		int System.Collections.Generic.ICollection<T>.Count
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray.Length;
			}
		}

		[DebuggerBrowsable(/*Could not decode attribute arguments.*/)]
		int System.Collections.Generic.IReadOnlyCollection<T>.Count
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray.Length;
			}
		}

		T System.Collections.Generic.IReadOnlyList<T>.this[int P_0]
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray[P_0];
			}
		}

		public T this[int P_0]
		{
			[NonVersionable]
			get
			{
				return array[P_0];
			}
		}

		[DebuggerBrowsable(/*Could not decode attribute arguments.*/)]
		public int Length
		{
			[NonVersionable]
			get
			{
				return array.Length;
			}
		}

		[DebuggerBrowsable(/*Could not decode attribute arguments.*/)]
		public bool IsDefault => array == null;

		[DebuggerBrowsable(/*Could not decode attribute arguments.*/)]
		System.Array? IImmutableArray.Array => array;

		[DebuggerBrowsable(/*Could not decode attribute arguments.*/)]
		private string DebuggerDisplay
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				if (!immutableArray.IsDefault)
				{
					return $"Length = {immutableArray.Length}";
				}
				return "Uninitialized";
			}
		}

		public System.ReadOnlySpan<T> AsSpan()
		{
			return new System.ReadOnlySpan<T>(array);
		}

		public int IndexOf(T P_0)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.IndexOf(P_0, 0, immutableArray.Length, (IEqualityComparer<T>?)(object)EqualityComparer<T>.Default);
		}

		public int IndexOf(T P_0, int P_1, int P_2, IEqualityComparer<T>? P_3)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			if (P_2 == 0 && P_1 == 0)
			{
				return -1;
			}
			Requires.Range(P_1 >= 0 && P_1 < immutableArray.Length, "startIndex");
			Requires.Range(P_2 >= 0 && P_1 + P_2 <= immutableArray.Length, "count");
			if (P_3 == null)
			{
				P_3 = (IEqualityComparer<T>?)(object)EqualityComparer<T>.Default;
			}
			if (P_3 == EqualityComparer<T>.Default)
			{
				return System.Array.IndexOf<T>(immutableArray.array, P_0, P_1, P_2);
			}
			for (int i = P_1; i < P_1 + P_2; i++)
			{
				if (P_3.Equals(immutableArray.array[i], P_0))
				{
					return i;
				}
			}
			return -1;
		}

		public bool Contains(T P_0)
		{
			return IndexOf(P_0) >= 0;
		}

		void System.Collections.Generic.IList<T>.Insert(int P_0, T P_1)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			throw new NotSupportedException();
		}

		void System.Collections.Generic.IList<T>.RemoveAt(int P_0)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			throw new NotSupportedException();
		}

		void System.Collections.Generic.ICollection<T>.Add(T P_0)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			throw new NotSupportedException();
		}

		void System.Collections.Generic.ICollection<T>.Clear()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			throw new NotSupportedException();
		}

		bool System.Collections.Generic.ICollection<T>.Remove(T P_0)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			throw new NotSupportedException();
		}

		internal ImmutableArray(T[]? P_0)
		{
			array = P_0;
		}

		public void CopyTo(T[] P_0, int P_1)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			System.Array.Copy((System.Array)immutableArray.array, 0, (System.Array)P_0, P_1, immutableArray.Length);
		}

		[MethodImpl(256)]
		public Enumerator GetEnumerator()
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			return new Enumerator(immutableArray.array);
		}

		public override int GetHashCode()
		{
			ImmutableArray<T> immutableArray = this;
			if (immutableArray.array != null)
			{
				return ((object)immutableArray.array).GetHashCode();
			}
			return 0;
		}

		public override bool Equals([NotNullWhen(true)] object? P_0)
		{
			if (P_0 is IImmutableArray immutableArray)
			{
				return array == immutableArray.Array;
			}
			return false;
		}

		[NonVersionable]
		public bool Equals(ImmutableArray<T> P_0)
		{
			return array == P_0.array;
		}

		System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator()
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return EnumeratorObject.Create(immutableArray.array);
		}

		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return (System.Collections.IEnumerator)EnumeratorObject.Create(immutableArray.array);
		}

		internal void ThrowNullRefIfNotInitialized()
		{
			_ = array.Length;
		}

		private void ThrowInvalidOperationIfNotInitialized()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (IsDefault)
			{
				throw new InvalidOperationException(SR.InvalidOperationOnDefaultArray);
			}
		}
	}
	internal sealed class ImmutableArrayBuilderDebuggerProxy<T>
	{
		private readonly ImmutableArray<T>.Builder _builder;

		[DebuggerBrowsable(/*Could not decode attribute arguments.*/)]
		public T[] A => _builder.ToArray();

		public ImmutableArrayBuilderDebuggerProxy(ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			_builder = builder;
		}
	}
	internal static class Requires
	{
		[DebuggerStepThrough]
		public static void NotNull<T>([NotNull] T P_0, string? P_1) where T : class
		{
			if (P_0 == null)
			{
				FailArgumentNullException(P_1);
			}
		}

		[DoesNotReturn]
		[DebuggerStepThrough]
		public static void FailArgumentNullException(string? P_0)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			throw new ArgumentNullException(P_0);
		}

		[DebuggerStepThrough]
		public static void Range([DoesNotReturnIf(false)] bool P_0, string? P_1, string? P_2 = null)
		{
			if (!P_0)
			{
				FailRange(P_1, P_2);
			}
		}

		[DoesNotReturn]
		[DebuggerStepThrough]
		public static void FailRange(string? P_0, string? P_1 = null)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(P_1))
			{
				throw new ArgumentOutOfRangeException(P_0);
			}
			throw new ArgumentOutOfRangeException(P_0, P_1);
		}
	}
}