using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Concentus.Celt;
using Concentus.Celt.Structs;
using Concentus.Common;
using Concentus.Common.CPlusPlus;
using Concentus.Enums;
using Concentus.Silk;
using Concentus.Silk.Enums;
using Concentus.Silk.Structs;
using Concentus.Structs;
using HarmonyLib;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using ProximityVoiceChat.UI;
using ProximityVoiceChat.Voice;
using ProximityVoiceChat.Voice.Audio;
using ServerSync;
using Splatform;
using Steamworks;
using TMPro;
using UIManager;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.U2D;
using UnityEngine.UI;
using UserManagement;
using Valheim.SettingsGui;
using Valheim.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.ObjectPool;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
using YamlDotNet.Serialization.Callbacks;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ProximityVoiceChat")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Azumatt")]
[assembly: AssemblyProduct("ProximityVoiceChat")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("E0E2F92E-557C-4A05-9D89-AA92A0BD75C4")]
[assembly: AssemblyFileVersion("1.0.2")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class ExtensionMarkerAttribute : Attribute
	{
		public ExtensionMarkerAttribute(string name)
		{
		}
	}
}
namespace ProximityVoiceChat
{
	[BepInPlugin("Azumatt.ProximityVoiceChat", "ProximityVoiceChat", "1.0.2")]
	public class ProximityVoiceChatPlugin : BaseUnityPlugin
	{
		public enum Toggle
		{
			On = 1,
			Off = 0
		}

		public enum Bone
		{
			X,
			Y,
			Z
		}

		private class AcceptableShortcuts : AcceptableValueBase
		{
			public AcceptableShortcuts()
				: base(typeof(KeyboardShortcut))
			{
			}

			public override object Clamp(object value)
			{
				return value;
			}

			public override bool IsValid(object value)
			{
				return true;
			}

			public override string ToDescriptionString()
			{
				return "# Acceptable values: " + string.Join(", ", UnityInput.Current.SupportedKeyCodes);
			}
		}

		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public int? Order;

			[UsedImplicitly]
			public bool? Browsable;

			[UsedImplicitly]
			public string? Category;

			[UsedImplicitly]
			public Action<ConfigEntryBase>? CustomDrawer;
		}

		internal const string ModName = "ProximityVoiceChat";

		internal const string ModVersion = "1.0.2";

		internal const string Author = "Azumatt";

		private const string ModGUID = "Azumatt.ProximityVoiceChat";

		private static readonly string ConfigFileName = "Azumatt.ProximityVoiceChat.cfg";

		private static readonly string ConfigFileFullPath = Paths.ConfigPath + Path.DirectorySeparatorChar + ConfigFileName;

		private readonly Harmony _harmony = new Harmony("Azumatt.ProximityVoiceChat");

		private static GameObject _runtimeObject = null;

		internal static ProximityVoiceChatPlugin? Instance;

		public static readonly ManualLogSource Log = Logger.CreateLogSource("ProximityVoiceChat");

		private static readonly ConfigSync ConfigSync = new ConfigSync("Azumatt.ProximityVoiceChat")
		{
			DisplayName = "ProximityVoiceChat",
			CurrentVersion = "1.0.2",
			MinimumRequiredVersion = "1.0.2",
			IsLocked = false
		};

		private static ConfigEntry<Toggle> _serverConfigLocked = null;

		internal static ConfigEntry<float> MaxRange = null;

		internal static ConfigEntry<float> RangeHysteresis = null;

		internal static ConfigEntry<float> FullVolumeRange = null;

		internal static ConfigEntry<Toggle> EnableVoice = null;

		internal static ConfigEntry<string> InputDevice = null;

		internal static ConfigEntry<Toggle> MuteSelf = null;

		internal static ConfigEntry<KeyboardShortcut> MuteSelfKey = null;

		internal static ConfigEntry<Toggle> UseVoiceActivation = null;

		internal static ConfigEntry<KeyboardShortcut> PushToTalkKey = null;

		internal static ConfigEntry<float> ActivationThreshold = null;

		internal static ConfigEntry<float> MicGain = null;

		internal static ConfigEntry<Toggle> AutoGain = null;

		internal static ConfigEntry<float> AutoGainTarget = null;

		internal static ConfigEntry<int> Bitrate = null;

		internal static ConfigEntry<int> ExpectedPacketLoss = null;

		internal static ConfigEntry<Toggle> UseDtx = null;

		internal static ConfigEntry<Toggle> AdaptiveFec = null;

		internal static ConfigEntry<float> VoiceVolume = null;

		internal static ConfigEntry<Toggle> Deafen = null;

		internal static ConfigEntry<KeyboardShortcut> DeafenKey = null;

		internal static ConfigEntry<float> MonitorVolume = null;

		internal static ConfigEntry<int> JitterTargetMs = null;

		internal static ConfigEntry<int> JitterMaxMs = null;

		internal static ConfigEntry<Toggle> AdaptiveJitter = null;

		internal static ConfigEntry<Toggle> DuckMusic = null;

		internal static ConfigEntry<float> DuckMusicAmount = null;

		internal static ConfigEntry<Toggle> Occlusion = null;

		internal static ConfigEntry<float> OccludedCutoff = null;

		internal static ConfigEntry<float> OccludedVolume = null;

		internal static ConfigEntry<Toggle> UnderwaterMuffle = null;

		internal static ConfigEntry<float> UnderwaterCutoff = null;

		internal static ConfigEntry<Toggle> VoiceReverb = null;

		internal static ConfigEntry<float> ReverbMix = null;

		internal static ConfigEntry<Toggle> ShowSpeakingIndicator = null;

		internal static ConfigEntry<float> SpeakingIndicatorHeight = null;

		internal static ConfigEntry<Toggle> PeerIndicators = null;

		internal static ConfigEntry<float> PeerIndicatorHeight = null;

		internal static ConfigEntry<float> PeerIndicatorScale = null;

		internal static ConfigEntry<Toggle> PeerIndicatorThroughWalls = null;

		internal static ConfigEntry<Toggle> JawMovement = null;

		internal static ConfigEntry<float> JawMaxAngle = null;

		internal static ConfigEntry<float> JawSensitivity = null;

		internal static ConfigEntry<Bone> JawAxis = null;

		internal static ConfigEntry<Toggle> HotkeyMessages = null;

		internal static ConfigEntry<Toggle> TestTone = null;

		internal static ConfigEntry<Toggle> LoopbackTest = null;

		internal static ConfigEntry<string> PerPlayerSettings = null;

		public void Awake()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Expected O, but got Unknown
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Expected O, but got Unknown
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Expected O, but got Unknown
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Expected O, but got Unknown
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Expected O, but got Unknown
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Expected O, but got Unknown
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Expected O, but got Unknown
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Expected O, but got Unknown
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Expected O, but got Unknown
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0466: Expected O, but got Unknown
			//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d7: Expected O, but got Unknown
			//IL_0521: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Expected O, but got Unknown
			//IL_055a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0565: Expected O, but got Unknown
			//IL_05af: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ba: Expected O, but got Unknown
			//IL_0604: Unknown result type (might be due to invalid IL or missing references)
			//IL_060f: Expected O, but got Unknown
			//IL_0659: Unknown result type (might be due to invalid IL or missing references)
			//IL_0664: Expected O, but got Unknown
			//IL_06ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b9: Expected O, but got Unknown
			//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f2: Expected O, but got Unknown
			//IL_0758: Unknown result type (might be due to invalid IL or missing references)
			//IL_0763: Expected O, but got Unknown
			//IL_0791: Unknown result type (might be due to invalid IL or missing references)
			//IL_079c: Expected O, but got Unknown
			//IL_0841: Unknown result type (might be due to invalid IL or missing references)
			//IL_084c: Expected O, but got Unknown
			//IL_088b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0895: Expected O, but got Unknown
			Instance = this;
			Localizer.Load();
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			_serverConfigLocked = config("1 - General", "Lock Configuration", Toggle.On, "If on, only server admins can change the synced settings.");
			ConfigSync.AddLockingConfigEntry<Toggle>(_serverConfigLocked);
			MaxRange = config("2 - Proximity", "Max Range", 45f, new ConfigDescription("Max distance you can hear other players", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 200f), Array.Empty<object>()));
			RangeHysteresis = config("2 - Proximity", "Range Buffer", 8f, new ConfigDescription("Extra distance before a player disconnects from voice. Helps prevent audio cutting in and out near max range.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 50f), Array.Empty<object>()));
			FullVolumeRange = config("2 - Proximity", "Full Volume Range", 4f, new ConfigDescription("Players within this distance are heard at full volume. Beyond it, volume fades with distance.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 40f), Array.Empty<object>()));
			EnableVoice = config("3 - Microphone", "Enable Voice", Toggle.On, "Turn microphone capture off entirely.", synchronizedSetting: false);
			InputDevice = config("3 - Microphone", "Input Device", "", "Microphone to use. Leave blank to use your system default.", synchronizedSetting: false);
			MuteSelf = config("3 - Microphone", "Mute Self", Toggle.Off, "Stops sending your voice without turning off the microphone.", synchronizedSetting: false);
			MuteSelfKey = config<KeyboardShortcut>("3 - Microphone", "Mute Self Key", new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>()), new ConfigDescription("Toggles your microphone mute. Unbound by default to avoid conflicts with other mods.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), synchronizedSetting: false);
			UseVoiceActivation = config("3 - Microphone", "Use Voice Activation", Toggle.Off, "Automatically transmits when you speak. Turn this off to use push-to-talk.", synchronizedSetting: false);
			PushToTalkKey = config<KeyboardShortcut>("3 - Microphone", "Push To Talk", new KeyboardShortcut((KeyCode)98, Array.Empty<KeyCode>()), new ConfigDescription("Hold this key to talk when Voice Activation is off.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), synchronizedSetting: false);
			ActivationThreshold = config("3 - Microphone", "Activation Threshold", 0.02f, new ConfigDescription("How loud you need to speak before voice activation starts transmitting. Lower values are more sensitive.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.001f, 0.3f), Array.Empty<object>()), synchronizedSetting: false);
			MicGain = config("3 - Microphone", "Microphone Gain", 1f, new ConfigDescription("Boosts or lowers your microphone volume before it is sent. Checked before encoding", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 8f), Array.Empty<object>()), synchronizedSetting: false);
			AutoGain = config("3 - Microphone", "Auto Gain", Toggle.On, "Chases a steady speaking level so you do not have to hunt for a gain number. Microphone Gain still multiplies on top.", synchronizedSetting: false);
			AutoGainTarget = config("3 - Microphone", "Auto Gain Target", 0.12f, new ConfigDescription("Target speaking volume used by Automatic Gain. Higher values make your voice louder.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.02f, 0.4f), Array.Empty<object>()), synchronizedSetting: false);
			Bitrate = config("4 - Codec", "Bitrate", 24000, new ConfigDescription("Opus target bitrate in bits per second. Voice quality and bandwidth usage. Higher is better but uses more bandwidth.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(6000, 64000), Array.Empty<object>()));
			ExpectedPacketLoss = config("4 - Codec", "Expected Packet Loss", 5, new ConfigDescription("How much packet loss Opus should expect. Higher values use more error correction.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 40), Array.Empty<object>()));
			UseDtx = config("4 - Codec", "Use DTX", Toggle.Off, "Stops sending audio while you are silent. Saves bandwidth, but very quiet words may get cut off.");
			AdaptiveFec = config("4 - Codec", "Adaptive FEC", Toggle.On, "Adds more error correction when other players report lost audio packets.", synchronizedSetting: false);
			VoiceVolume = config("5 - Playback", "Voice Volume", 1f, new ConfigDescription("Overall volume of voice chat.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()), synchronizedSetting: false);
			Deafen = config("5 - Playback", "Deafen", Toggle.Off, "Stops all incoming voice and stops you transmitting.", synchronizedSetting: false);
			DeafenKey = config<KeyboardShortcut>("5 - Playback", "Deafen Key", new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>()), new ConfigDescription("Toggles Deafen. Unbound by default to avoid conflicts with other mods.", (AcceptableValueBase)(object)new AcceptableShortcuts(), Array.Empty<object>()), synchronizedSetting: false);
			MonitorVolume = config("5 - Playback", "Monitor Volume", 0.7f, new ConfigDescription("How loudly you hear yourself while Hear Myself While I Talk is enabled.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()), synchronizedSetting: false);
			JitterTargetMs = config("5 - Playback", "Jitter Buffer Target", 60, new ConfigDescription("Audio buffered to smooth out network hiccups. Lower means less delay; higher is more stable.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(20, 300), Array.Empty<object>()), synchronizedSetting: false);
			JitterMaxMs = config("5 - Playback", "Jitter Buffer Max", 200, new ConfigDescription("Maximum buffer size allowed when Automatic Voice Buffer is enabled.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(40, 600), Array.Empty<object>()), synchronizedSetting: false);
			AdaptiveJitter = config("5 - Playback", "Adaptive Jitter", Toggle.On, "Automatically adjusts each player's audio buffer based on their connection.", synchronizedSetting: false);
			DuckMusic = config("5 - Playback", "Duck Music", Toggle.On, "Lowers Valheim's music while a nearby player is speaking.", synchronizedSetting: false);
			DuckMusicAmount = config("5 - Playback", "Duck Music Amount", 0.35f, new ConfigDescription("Music volume while someone is speaking. 0 is silent, 1 is unchanged.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), synchronizedSetting: false);
			Occlusion = config("5 - Playback", "Occlusion", Toggle.On, "Makes voices quieter and muffled when something solid is between you.", synchronizedSetting: false);
			OccludedCutoff = config("5 - Playback", "Occluded Cutoff", 900f, new ConfigDescription("How muffled voices sound through walls. Lower values sound more muffled.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(200f, 8000f), Array.Empty<object>()), synchronizedSetting: false);
			OccludedVolume = config("5 - Playback", "Occluded Volume", 0.7f, new ConfigDescription("Volume of voices heard through walls. 1 is full volume.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1f), Array.Empty<object>()), synchronizedSetting: false);
			UnderwaterMuffle = config("5 - Playback", "Underwater Muffle", Toggle.On, "Muffles voice chat while you are swimming.", synchronizedSetting: false);
			UnderwaterCutoff = config("5 - Playback", "Underwater Cutoff", 500f, new ConfigDescription("How muffled voices sound underwater. Lower values sound more muffled.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(150f, 4000f), Array.Empty<object>()), synchronizedSetting: false);
			VoiceReverb = config("5 - Playback", "Voice Reverb", Toggle.Off, "Let the game's reverb zones colour voices, so caves and halls sound like caves and halls.", synchronizedSetting: false);
			ReverbMix = config("5 - Playback", "Reverb Mix", 0.3f, new ConfigDescription("How much of the game's reverb a voice picks up. A full send drowns speech in echo.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()), synchronizedSetting: false);
			ShowSpeakingIndicator = config("6 - UI", "Speaking Indicator", Toggle.On, "Shows a speaker icon above your character while you are transmitting.", synchronizedSetting: false);
			SpeakingIndicatorHeight = config("6 - UI", "Speaking Indicator Height", 0.5f, new ConfigDescription("How high the speaker icon sits above your head.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()), synchronizedSetting: false);
			PeerIndicators = config("6 - UI", "Peer Speaking Indicators", Toggle.Off, "Shows a speaker icon above other players while they are talking.", synchronizedSetting: false);
			PeerIndicatorHeight = config("6 - UI", "Peer Indicator Height", 0.9f, new ConfigDescription("How high speaker icons sit above other players.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()), synchronizedSetting: false);
			PeerIndicatorScale = config("6 - UI", "Peer Indicator Scale", 1f, new ConfigDescription("Size of the speaker icons shown above other players.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 3f), Array.Empty<object>()), synchronizedSetting: false);
			PeerIndicatorThroughWalls = config("6 - UI", "Peer Indicator Through Walls", Toggle.Off, "Keeps speaking indicators visible even when a wall is between you.", synchronizedSetting: false);
			JawMovement = config("6 - UI", "Jaw Movement", Toggle.On, "Moves player jaws while they are speaking. Yours and others.", synchronizedSetting: false);
			JawMaxAngle = config("6 - UI", "Jaw Max Angle", 14f, new ConfigDescription("Maximum amount the jaw opens while speaking.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 40f), Array.Empty<object>()), synchronizedSetting: false);
			JawSensitivity = config("6 - UI", "Jaw Sensitivity", 12f, new ConfigDescription("How strongly voice volume moves the jaw. Raise this if mouths barely move.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 60f), Array.Empty<object>()), synchronizedSetting: false);
			JawAxis = config("6 - UI", "Jaw Axis", Bone.X, "Change this if the head twists instead of the mouth opening. Default is good for Valheim model, but might not be for VRMs", synchronizedSetting: false);
			HotkeyMessages = config("6 - UI", "Hotkey Messages", Toggle.On, "Shows a short message when you mute or deafen yourself with a hotkey.", synchronizedSetting: false);
			TestTone = config("6 - UI", "Test Tone", Toggle.Off, "Sends a test tone instead of microphone audio. Useful for testing without a working microphone.", synchronizedSetting: false);
			LoopbackTest = config("6 - UI", "Loopback Test", Toggle.Off, "Plays your outgoing voice back to you so you can hear what other players hear.", synchronizedSetting: false);
			PerPlayerSettings = config("6 - UI", "Per Player Settings", "", new ConfigDescription("Saved data. Don't write here manually, unless you know what you're doing. Written by the player list. steamid:volume:muted, semicolon separated.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes
				{
					Browsable = false
				}
			}), synchronizedSetting: false);
			TestTone.Value = Toggle.Off;
			LoopbackTest.Value = Toggle.Off;
			PeerPreferences.Load(PerPlayerSettings.Value);
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			_runtimeObject = new GameObject("ProximityVoiceChat_Runtime");
			Object.DontDestroyOnLoad((Object)(object)_runtimeObject);
			((Object)_runtimeObject).hideFlags = (HideFlags)61;
			_runtimeObject.AddComponent<VoiceRuntime>();
			_runtimeObject.AddComponent<SpeakingIndicator>();
			_runtimeObject.AddComponent<JawAnimator>();
			_runtimeObject.AddComponent<VoiceHotkeys>();
			UIRoot.Init(Log, _harmony);
			SetupWatcher();
			((BaseUnityPlugin)this).Config.Save();
			if (saveOnConfigSet)
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = saveOnConfigSet;
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)_runtimeObject != (Object)null)
			{
				Object.Destroy((Object)(object)_runtimeObject);
			}
			if (PeerPreferences.TryFlush(out string serialized))
			{
				PerPlayerSettings.Value = serialized;
			}
			((BaseUnityPlugin)this).Config.Save();
		}

		internal static void SaveConfig()
		{
			if (PeerPreferences.TryFlush(out string serialized))
			{
				PerPlayerSettings.Value = serialized;
			}
			ProximityVoiceChatPlugin? instance = Instance;
			if (instance != null)
			{
				((BaseUnityPlugin)instance).Config.Save();
			}
		}

		private void SetupWatcher()
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(ConfigFileFullPath))
			{
				return;
			}
			try
			{
				Log.LogDebug((object)"ReadConfigValues called");
				((BaseUnityPlugin)this).Config.Reload();
			}
			catch
			{
				Log.LogError((object)("There was an issue loading your " + ConfigFileName));
				Log.LogError((object)"Please check your config entries for spelling and format!");
			}
		}

		private ConfigEntry<T> config<T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			ConfigDescription val = new ConfigDescription(description.Description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]"), description.AcceptableValues, description.Tags);
			ConfigEntry<T> val2 = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, val);
			ConfigSync.AddConfigEntry<T>(val2).SynchronizedConfig = synchronizedSetting;
			return val2;
		}

		private ConfigEntry<T> config<T>(string group, string name, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}
	}
	public static class KeyboardExtensions
	{
		[SpecialName]
		public sealed class <G>$8D1D3E80A18AA9715780B6CB7003B2F1
		{
			[SpecialName]
			public static class <M>$895AB635D4D087636CF1C26BA650BA11
			{
			}

			[ExtensionMarker("<M>$895AB635D4D087636CF1C26BA650BA11")]
			public bool IsKeyDown()
			{
				throw null;
			}

			[ExtensionMarker("<M>$895AB635D4D087636CF1C26BA650BA11")]
			public bool IsKeyHeld()
			{
				throw null;
			}
		}

		public static bool IsKeyDown(this KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey))
			{
				return ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
			}
			return false;
		}

		public static bool IsKeyHeld(this KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey != 0 && Input.GetKey(((KeyboardShortcut)(ref shortcut)).MainKey))
			{
				return ((KeyboardShortcut)(ref shortcut)).Modifiers.All((Func<KeyCode, bool>)Input.GetKey);
			}
			return false;
		}
	}
	public static class ToggleExtensions
	{
		[SpecialName]
		public sealed class <G>$BDF3EF541E575CBEE3FDDD5BBDE7E281
		{
			[SpecialName]
			public static class <M>$E3FDBDD135D264042C5DDA2535FB9962
			{
			}

			[ExtensionMarker("<M>$E3FDBDD135D264042C5DDA2535FB9962")]
			public bool IsOn()
			{
				throw null;
			}

			[ExtensionMarker("<M>$E3FDBDD135D264042C5DDA2535FB9962")]
			public bool IsOff()
			{
				throw null;
			}
		}

		public static bool IsOn(this ProximityVoiceChatPlugin.Toggle toggle)
		{
			return toggle == ProximityVoiceChatPlugin.Toggle.On;
		}

		public static bool IsOff(this ProximityVoiceChatPlugin.Toggle toggle)
		{
			return toggle == ProximityVoiceChatPlugin.Toggle.Off;
		}
	}
}
namespace ProximityVoiceChat.UI
{
	internal static class SettingsTabInjector
	{
		internal const string TabLabel = "Voice";

		internal static void Inject(Settings? settings)
		{
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Expected O, but got Unknown
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Expected O, but got Unknown
			//IL_0298: Expected O, but got Unknown
			if ((Object)(object)settings == (Object)null)
			{
				return;
			}
			TabHandler val = (((Object)(object)settings.m_tabHandler != (Object)null) ? settings.m_tabHandler : ((Component)settings).GetComponentInChildren<TabHandler>());
			if ((Object)(object)val == (Object)null)
			{
				ProximityVoiceChatPlugin.Log.LogWarning((object)"Voice tab: no TabHandler in the settings prefab");
				return;
			}
			if (val.m_tabs.Count == 0)
			{
				ProximityVoiceChatPlugin.Log.LogWarning((object)"Voice tab: settings prefab has no tabs");
				return;
			}
			foreach (Tab tab in val.m_tabs)
			{
				if ((Object)(object)tab.m_button != (Object)null && ((Object)tab.m_button).name == "Voice")
				{
					return;
				}
			}
			Button val2 = null;
			RectTransform val3 = null;
			foreach (Tab tab2 in val.m_tabs)
			{
				if ((Object)(object)tab2.m_button != (Object)null)
				{
					val2 = tab2.m_button;
				}
				if ((Object)(object)tab2.m_page != (Object)null && (Object)(object)val3 == (Object)null)
				{
					val3 = tab2.m_page;
				}
			}
			if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
			{
				ProximityVoiceChatPlugin.Log.LogWarning((object)$"Voice tab: no usable template, button {(Object)(object)val2 != (Object)null}, page {(Object)(object)val3 != (Object)null}");
				return;
			}
			Button val4 = Object.Instantiate<Button>(val2, ((Component)val2).transform.parent);
			((Object)val4).name = "Voice";
			((Component)val4).transform.SetAsLastSibling();
			((UnityEventBase)val4.onClick).RemoveAllListeners();
			SetLabel(((Component)val4).gameObject, "Voice");
			Transform val5 = ((Component)val4).transform.Find("KeyHint");
			if ((Object)(object)val5 != (Object)null)
			{
				((Component)val5).gameObject.SetActive(false);
			}
			GameObject val6 = new GameObject("VoicePage", new Type[1] { typeof(RectTransform) });
			val6.transform.SetParent(((Transform)val3).parent, false);
			RectTransform val7 = (RectTransform)val6.transform;
			val7.anchorMin = val3.anchorMin;
			val7.anchorMax = val3.anchorMax;
			val7.pivot = val3.pivot;
			val7.offsetMin = val3.offsetMin;
			val7.offsetMax = val3.offsetMax;
			((Transform)val7).localScale = Vector3.one;
			val6.AddComponent<VoiceSettingsTab>();
			val6.SetActive(false);
			val.m_tabs.Add(new Tab
			{
				m_button = val4,
				m_page = val7,
				m_default = false,
				m_onClick = new UnityEvent()
			});
			ProximityVoiceChatPlugin.Log.LogInfo((object)$"Added the Voice tab to the settings menu, {val.m_tabs.Count} tabs now");
		}

		private static void SetLabel(GameObject button, string text)
		{
			TMP_Text[] componentsInChildren = button.GetComponentsInChildren<TMP_Text>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].text = text;
			}
			Text[] componentsInChildren2 = button.GetComponentsInChildren<Text>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				componentsInChildren2[i].text = text;
			}
			Localize[] componentsInChildren3 = button.GetComponentsInChildren<Localize>(true);
			for (int j = 0; j < componentsInChildren3.Length; j++)
			{
				Object.Destroy((Object)(object)componentsInChildren3[j]);
			}
		}
	}
	[HarmonyPatch(typeof(Settings), "SetAvailableTabs")]
	internal static class Settings_SetAvailableTabs_Patch
	{
		private static void Prefix(Settings __instance)
		{
			try
			{
				SettingsTabInjector.Inject(__instance);
			}
			catch (Exception arg)
			{
				ProximityVoiceChatPlugin.Log.LogError((object)$"Could not add the Voice settings tab: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(SessionPlayerListEntry), "SetValues")]
	internal static class SessionPlayerListEntry_SetValues_Patch
	{
		private static void Postfix(SessionPlayerListEntry __instance)
		{
			VoiceEntryUI voiceEntryUI = ((Component)__instance).gameObject.GetComponent<VoiceEntryUI>();
			if ((Object)(object)voiceEntryUI == (Object)null)
			{
				voiceEntryUI = ((Component)__instance).gameObject.AddComponent<VoiceEntryUI>();
			}
			voiceEntryUI.Bind(__instance, __instance.IsOwnPlayer);
		}
	}
	internal sealed class SliderRow
	{
		internal Slider Slider;

		internal Text Value;

		internal string Format = "0.00";

		internal void Set(float value)
		{
			Slider.SetValueWithoutNotify(value);
			Value.text = value.ToString(Format);
		}
	}
	internal sealed class KeyRow
	{
		internal Button Button;

		internal Text Label;

		internal ConfigEntry<KeyboardShortcut> Entry;

		internal void Refresh()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Label.text = (KeyBinder.IsListening(Entry) ? UIBuild.Localize("$pvc_key_press") : KeyBinder.Describe(Entry.Value));
		}
	}
	internal sealed class CycleRow<T> where T : struct, Enum
	{
		internal Button Button;

		internal Text Label;

		internal ConfigEntry<T> Entry;

		internal void Step()
		{
			T[] array = (T[])Enum.GetValues(typeof(T));
			int num = Array.IndexOf(array, Entry.Value);
			Entry.Value = array[(num + 1 + array.Length) % array.Length];
			Refresh();
		}

		internal void Refresh()
		{
			Label.text = Entry.Value.ToString();
		}
	}
	internal static class UIBuild
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__42_0;

			public static UnityAction <>9__42_1;

			internal void <DevicePicker>b__42_0()
			{
				StepDevice(-1);
			}

			internal void <DevicePicker>b__42_1()
			{
				StepDevice(1);
			}
		}

		internal const float RowHeight = 26f;

		internal const float LabelWidth = 210f;

		internal const float ValueWidth = 56f;

		private const float RowSpacing = 10f;

		private const float HeadingHeight = 28f;

		private const float NoteHeight = 20f;

		private const float ControlHeight = 24f;

		private const float ToggleHeight = 22f;

		private const float SliderHeight = 18f;

		private const float SliderWidth = 200f;

		private const float ButtonWidth = 160f;

		internal const float TallRowHeight = 28f;

		private const float ArrowWidth = 28f;

		private const float ArrowCell = 32f;

		private const float MeterRowHeight = 20f;

		private const float MeterLabelWidth = 70f;

		private const float MeterTrackWidth = 200f;

		private const float MeterTrackHeight = 12f;

		private const int BodyFontSize = 16;

		private const int TitleFontSize = 18;

		private const int NoteFontSize = 15;

		private const int SmallFontSize = 14;

		internal const float MeterFloorDb = -60f;

		private const float MeterSilence = 0.0001f;

		private const float AmplitudeToDb = 20f;

		internal static string Localize(string key)
		{
			if (Localization.instance == null)
			{
				return key;
			}
			return Localization.instance.Localize(key);
		}

		internal static string Localize(string key, params object[] args)
		{
			return string.Format(Localize(key), args);
		}

		internal static GameObject Row(Transform parent, float height)
		{
			//IL_0018: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			GameObject val = new GameObject("Row", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			HorizontalLayoutGroup obj = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 10f;
			((LayoutGroup)obj).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			LayoutElement obj2 = val.AddComponent<LayoutElement>();
			obj2.minHeight = height;
			obj2.preferredHeight = height;
			return val;
		}

		internal static LayoutElement Element(Component component)
		{
			LayoutElement component2 = component.gameObject.GetComponent<LayoutElement>();
			if (!((Object)(object)component2 != (Object)null))
			{
				return component.gameObject.AddComponent<LayoutElement>();
			}
			return component2;
		}

		internal static T Fixed<T>(T component, float width, float height = 0f) where T : Component
		{
			LayoutElement val = Element((Component)(object)component);
			val.minWidth = width;
			val.preferredWidth = width;
			if (height > 0f)
			{
				val.minHeight = height;
				val.preferredHeight = height;
			}
			return component;
		}

		internal static T Flex<T>(T component) where T : Component
		{
			Element((Component)(object)component).flexibleWidth = 1f;
			return component;
		}

		internal static Text Label(Transform parent, string text)
		{
			return UIFactory.Text("Label", parent, text, TextRole.Body, 16, (TextAnchor)3);
		}

		internal static Text Heading(Transform parent, string text)
		{
			Text obj = UIFactory.Text("Heading", parent, text, TextRole.Title, 18, (TextAnchor)3);
			Element((Component)(object)obj).preferredHeight = 28f;
			return obj;
		}

		internal static Text Note(Transform parent, string text)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			Text obj = UIFactory.Text("Note", parent, text, TextRole.Body, 15, (TextAnchor)3);
			((Graphic)obj).color = GameColors.Beige;
			Element((Component)(object)obj).preferredHeight = 20f;
			return obj;
		}

		internal static float MeterScale(float amplitude)
		{
			if (amplitude <= 0.0001f)
			{
				return 0f;
			}
			return Mathf.Clamp01((20f * Mathf.Log10(amplitude) - -60f) / 60f);
		}

		internal static RectTransform Meter(Transform parent, string label)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00c3: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: 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_0124: Expected O, but got Unknown
			GameObject val = Row(parent, 20f);
			UIBuild.Fixed<Text>(UIFactory.Text("Label", val.transform, label, TextRole.Body, 14, (TextAnchor)3), 70f, 0f);
			GameObject val2 = UIFactory.Panel("Track", val.transform, new Vector2(200f, 12f), window: false);
			UIBuild.Flex<Transform>(val2.transform);
			Element((Component)(object)val2.transform).preferredHeight = 12f;
			GameObject val3 = new GameObject("Fill", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val3.transform.SetParent(val2.transform, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = new Vector2(0f, 1f);
			val4.pivot = new Vector2(0f, 0.5f);
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = Vector2.zero;
			((Graphic)val3.GetComponent<Image>()).color = GameColors.Beige;
			return val4;
		}

		internal static SliderRow SliderControl(Transform parent, string label, float min, float max, float value, UnityAction<float> onChanged, string format = "0.00")
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Row(parent, 26f);
			UIBuild.Fixed<Text>(Label(val.transform, label), 210f, 0f);
			SliderRow control = new SliderRow
			{
				Format = format
			};
			control.Slider = UIFactory.Slider(label, val.transform, new Vector2(200f, 18f), min, max, value, delegate(float v)
			{
				onChanged.Invoke(v);
				control.Value.text = v.ToString(control.Format);
			});
			UIBuild.Flex<Slider>(control.Slider);
			Element((Component)(object)control.Slider).preferredHeight = 18f;
			control.Value = UIBuild.Fixed<Text>(UIFactory.Text("Value", val.transform, value.ToString(format), TextRole.Body, 16, (TextAnchor)5), 56f, 0f);
			return control;
		}

		internal static SliderRow SliderFor(Transform parent, string label, ConfigEntry<float> entry, string format = "0.00")
		{
			AcceptableValueRange<float> val = (AcceptableValueRange<float>)(object)((ConfigEntryBase)entry).Description.AcceptableValues;
			return SliderControl(parent, label, val.MinValue, val.MaxValue, entry.Value, delegate(float v)
			{
				if (!Mathf.Approximately(entry.Value, v))
				{
					entry.Value = v;
				}
			}, format);
		}

		internal static Toggle ToggleFor(Transform parent, string label, ConfigEntry<ProximityVoiceChatPlugin.Toggle> entry)
		{
			return RawToggle(parent, label, entry.Value.IsOn(), delegate(bool on)
			{
				entry.Value = (on ? ProximityVoiceChatPlugin.Toggle.On : ProximityVoiceChatPlugin.Toggle.Off);
			});
		}

		internal static Toggle RawToggle(Transform parent, string label, bool value, UnityAction<bool> onChanged)
		{
			GameObject val = Row(parent, 26f);
			Toggle obj = UIFactory.Toggle(label, val.transform, label, value, onChanged);
			UIBuild.Flex<Toggle>(obj);
			Element((Component)(object)obj).preferredHeight = 22f;
			return obj;
		}

		internal static KeyRow KeyBinding(Transform parent, string label, ConfigEntry<KeyboardShortcut> entry)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			GameObject val = Row(parent, 26f);
			UIBuild.Fixed<Text>(Label(val.transform, label), 210f, 0f);
			KeyRow obj = new KeyRow
			{
				Entry = entry,
				Button = UIBuild.Flex<Button>(UIFactory.Button("Bind", val.transform, KeyBinder.Describe(entry.Value), new Vector2(160f, 24f), (UnityAction)delegate
				{
					KeyBinder.Begin(entry);
				}))
			};
			Element((Component)(object)obj.Button).preferredHeight = 24f;
			obj.Label = ((Component)obj.Button).GetComponentInChildren<Text>();
			return obj;
		}

		internal static CycleRow<T> Cycle<T>(Transform parent, string label, ConfigEntry<T> entry) where T : struct, Enum
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			GameObject val = Row(parent, 26f);
			UIBuild.Fixed<Text>(Label(val.transform, label), 210f, 0f);
			CycleRow<T> cycleRow = new CycleRow<T>
			{
				Entry = entry
			};
			cycleRow.Button = UIBuild.Flex<Button>(UIFactory.Button("Cycle", val.transform, entry.Value.ToString(), new Vector2(160f, 24f), new UnityAction(cycleRow.Step)));
			Element((Component)(object)cycleRow.Button).preferredHeight = 24f;
			cycleRow.Label = ((Component)cycleRow.Button).GetComponentInChildren<Text>();
			return cycleRow;
		}

		internal static Text DevicePicker(Transform parent, string label)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			GameObject val = Row(parent, 28f);
			UIBuild.Fixed<Text>(Label(val.transform, label), 210f, 0f);
			Transform transform = val.transform;
			Vector2 size = new Vector2(28f, 24f);
			object obj = <>c.<>9__42_0;
			if (obj == null)
			{
				UnityAction val2 = delegate
				{
					StepDevice(-1);
				};
				<>c.<>9__42_0 = val2;
				obj = (object)val2;
			}
			UIBuild.Fixed<Button>(UIFactory.Button("Prev", transform, "<", size, (UnityAction)obj), 32f, 24f);
			Text result = UIBuild.Flex<Text>(UIFactory.Text("Device", val.transform, "", TextRole.Body, 16, (TextAnchor)4));
			Transform transform2 = val.transform;
			Vector2 size2 = new Vector2(28f, 24f);
			object obj2 = <>c.<>9__42_1;
			if (obj2 == null)
			{
				UnityAction val3 = delegate
				{
					StepDevice(1);
				};
				<>c.<>9__42_1 = val3;
				obj2 = (object)val3;
			}
			UIBuild.Fixed<Button>(UIFactory.Button("Next", transform2, ">", size2, (UnityAction)obj2), 32f, 24f);
			return result;
		}

		internal static void StepDevice(int direction)
		{
			string[] devices = MicrophoneCapture.Devices;
			if (devices.Length != 0)
			{
				int num = Array.IndexOf(devices, ProximityVoiceChatPlugin.InputDevice.Value);
				if (num < 0)
				{
					num = 0;
				}
				num = (num + direction + devices.Length) % devices.Length;
				ProximityVoiceChatPlugin.InputDevice.Value = devices[num];
			}
		}

		internal static string CurrentDeviceName()
		{
			string value = ProximityVoiceChatPlugin.InputDevice.Value;
			if (!string.IsNullOrEmpty(value))
			{
				return value;
			}
			string[] devices = MicrophoneCapture.Devices;
			if (devices.Length == 0)
			{
				return Localize("$pvc_device_none");
			}
			return devices[0];
		}
	}
	internal sealed class VoiceSettingsTab : MonoBehaviour, ISettingsTab
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction<bool> <>9__45_0;

			public static UnityAction <>9__45_1;

			internal void <Build>b__45_0(bool on)
			{
				ProximityVoiceChatPlugin.LoopbackTest.Value = (on ? ProximityVoiceChatPlugin.Toggle.On : ProximityVoiceChatPlugin.Toggle.Off);
			}

			internal void <Build>b__45_1()
			{
				VoiceRuntime.Instance?.Capture?.ProbeRaw();
			}
		}

		private Text? _device;

		private Text? _status;

		private RectTransform? _inFill;

		private RectTransform? _rmsFill;

		private RectTransform? _outFill;

		private Text? _numbers;

		private Text? _stats;

		private SliderRow? _gain;

		private SliderRow? _gate;

		private SliderRow? _incoming;

		private SliderRow? _monitor;

		private Toggle? _enableVoice;

		private Toggle? _activation;

		private Toggle? _muteSelf;

		private Toggle? _deafen;

		private Toggle? _monitorOn;

		private Toggle? _autoGain;

		private Toggle? _duckMusic;

		private Toggle? _adaptiveJitter;

		private Toggle? _testTone;

		private Toggle? _speakingIndicator;

		private Toggle? _peerIndicators;

		private Toggle? _peerThroughWalls;

		private Toggle? _jawMovement;

		private Toggle? _occlusion;

		private Toggle? _underwater;

		private Toggle? _reverb;

		private SliderRow? _selfHeight;

		private SliderRow? _peerHeight;

		private SliderRow? _peerScale;

		private SliderRow? _jawAngle;

		private SliderRow? _jawSensitivity;

		private CycleRow<ProximityVoiceChatPlugin.Bone>? _jawAxis;

		private readonly List<KeyRow> _keyRows = new List<KeyRow>();

		private const float TextInterval = 0.15f;

		private const int ClipWarningFrames = 50;

		private const int ContentPadding = 24;

		private const float ContentSpacing = 6f;

		private const float ProbeButtonWidth = 220f;

		private const float ProbeButtonHeight = 26f;

		private float _textTimer;

		public event Action<string, int>? SharedSettingChanged;

		public void Initialize()
		{
			try
			{
				Build();
			}
			catch (Exception arg)
			{
				ProximityVoiceChatPlugin.Log.LogError((object)$"Voice settings tab failed to build: {arg}");
			}
		}

		private void Build()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_0077: Expected O, but got Unknown
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0536: Unknown result type (might be due to invalid IL or missing references)
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0541: Expected O, but got Unknown
			RectTransform content;
			RectTransform val = (RectTransform)((Component)UIFactory.ScrollView("VoiceScroll", ((Component)this).transform, new Vector2(100f, 100f), out content)).transform;
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.offsetMin = Vector2.zero;
			val.offsetMax = Vector2.zero;
			Transform parent = (Transform)(object)content;
			VerticalLayoutGroup component = ((Component)content).GetComponent<VerticalLayoutGroup>();
			if (component != null)
			{
				((LayoutGroup)component).padding = new RectOffset(24, 24, 24, 24);
				((HorizontalOrVerticalLayoutGroup)component).spacing = 6f;
				((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = true;
				((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
				((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			}
			UIBuild.Heading(parent, UIBuild.Localize("$pvc_heading_microphone"));
			_enableVoice = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_enable_voice"), ProximityVoiceChatPlugin.EnableVoice);
			_status = UIBuild.Note(parent, "");
			_device = UIBuild.DevicePicker(parent, UIBuild.Localize("$pvc_input_device"));
			_inFill = UIBuild.Meter(parent, UIBuild.Localize("$pvc_meter_input"));
			_rmsFill = UIBuild.Meter(parent, UIBuild.Localize("$pvc_meter_sent"));
			_outFill = UIBuild.Meter(parent, UIBuild.Localize("$pvc_meter_heard"));
			_numbers = UIBuild.Note(parent, "");
			_gain = UIBuild.SliderFor(parent, UIBuild.Localize("$pvc_mic_gain"), ProximityVoiceChatPlugin.MicGain);
			_gate = UIBuild.SliderFor(parent, UIBuild.Localize("$pvc_gate_threshold"), ProximityVoiceChatPlugin.ActivationThreshold, "0.000");
			_activation = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_voice_activation"), ProximityVoiceChatPlugin.UseVoiceActivation);
			_autoGain = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_auto_gain"), ProximityVoiceChatPlugin.AutoGain);
			_muteSelf = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_mute_self"), ProximityVoiceChatPlugin.MuteSelf);
			UIBuild.Heading(parent, UIBuild.Localize("$pvc_heading_listening"));
			_incoming = UIBuild.SliderFor(parent, UIBuild.Localize("$pvc_incoming_volume"), ProximityVoiceChatPlugin.VoiceVolume);
			_deafen = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_deafen"), ProximityVoiceChatPlugin.Deafen);
			_duckMusic = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_duck_music"), ProximityVoiceChatPlugin.DuckMusic);
			_adaptiveJitter = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_adaptive_jitter"), ProximityVoiceChatPlugin.AdaptiveJitter);
			_occlusion = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_occlusion"), ProximityVoiceChatPlugin.Occlusion);
			_underwater = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_underwater"), ProximityVoiceChatPlugin.UnderwaterMuffle);
			_reverb = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_reverb"), ProximityVoiceChatPlugin.VoiceReverb);
			UIBuild.Heading(parent, UIBuild.Localize("$pvc_heading_keys"));
			_keyRows.Add(UIBuild.KeyBinding(parent, UIBuild.Localize("$pvc_key_ptt"), ProximityVoiceChatPlugin.PushToTalkKey));
			_keyRows.Add(UIBuild.KeyBinding(parent, UIBuild.Localize("$pvc_key_mute"), ProximityVoiceChatPlugin.MuteSelfKey));
			_keyRows.Add(UIBuild.KeyBinding(parent, UIBuild.Localize("$pvc_key_deafen"), ProximityVoiceChatPlugin.DeafenKey));
			UIBuild.Note(parent, UIBuild.Localize("$pvc_note_binding"));
			UIBuild.Heading(parent, UIBuild.Localize("$pvc_heading_interface"));
			_speakingIndicator = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_speaking_indicator"), ProximityVoiceChatPlugin.ShowSpeakingIndicator);
			_selfHeight = UIBuild.SliderFor(parent, UIBuild.Localize("$pvc_indicator_height"), ProximityVoiceChatPlugin.SpeakingIndicatorHeight);
			_peerIndicators = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_peer_indicators"), ProximityVoiceChatPlugin.PeerIndicators);
			_peerHeight = UIBuild.SliderFor(parent, UIBuild.Localize("$pvc_peer_indicator_height"), ProximityVoiceChatPlugin.PeerIndicatorHeight);
			_peerScale = UIBuild.SliderFor(parent, UIBuild.Localize("$pvc_peer_indicator_scale"), ProximityVoiceChatPlugin.PeerIndicatorScale);
			_peerThroughWalls = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_peer_through_walls"), ProximityVoiceChatPlugin.PeerIndicatorThroughWalls);
			_jawMovement = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_jaw_movement"), ProximityVoiceChatPlugin.JawMovement);
			_jawAngle = UIBuild.SliderFor(parent, UIBuild.Localize("$pvc_jaw_angle"), ProximityVoiceChatPlugin.JawMaxAngle, "0");
			_jawSensitivity = UIBuild.SliderFor(parent, UIBuild.Localize("$pvc_jaw_sensitivity"), ProximityVoiceChatPlugin.JawSensitivity, "0");
			_jawAxis = UIBuild.Cycle<ProximityVoiceChatPlugin.Bone>(parent, UIBuild.Localize("$pvc_jaw_axis"), ProximityVoiceChatPlugin.JawAxis);
			UIBuild.Heading(parent, UIBuild.Localize("$pvc_heading_test"));
			_monitor = UIBuild.SliderFor(parent, UIBuild.Localize("$pvc_monitor_volume"), ProximityVoiceChatPlugin.MonitorVolume);
			_monitorOn = UIBuild.RawToggle(parent, UIBuild.Localize("$pvc_hear_myself"), ProximityVoiceChatPlugin.LoopbackTest.Value.IsOn(), delegate(bool on)
			{
				ProximityVoiceChatPlugin.LoopbackTest.Value = (on ? ProximityVoiceChatPlugin.Toggle.On : ProximityVoiceChatPlugin.Toggle.Off);
			});
			_testTone = UIBuild.ToggleFor(parent, UIBuild.Localize("$pvc_test_tone"), ProximityVoiceChatPlugin.TestTone);
			GameObject val2 = UIBuild.Row(parent, 28f);
			Transform transform = val2.transform;
			string label = UIBuild.Localize("$pvc_probe_button");
			Vector2 size = new Vector2(220f, 26f);
			object obj = <>c.<>9__45_1;
			if (obj == null)
			{
				UnityAction val3 = delegate
				{
					VoiceRuntime.Instance?.Capture?.ProbeRaw();
				};
				<>c.<>9__45_1 = val3;
				obj = (object)val3;
			}
			UIBuild.Flex<Button>(UIFactory.Button("Probe", transform, label, size, (UnityAction)obj));
			_stats = UIBuild.Note(parent, "");
			UIBuild.Note(parent, UIBuild.Localize("$pvc_note_perplayer"));
			UIBuild.Note(parent, UIBuild.Localize("$pvc_note_menu_mic"));
		}

		public void OnTabOpen(Button backButton, Button okButton)
		{
		}

		private void OnEnable()
		{
			VoiceRuntime.LocalTestRequested = true;
		}

		private void OnDisable()
		{
			VoiceRuntime.LocalTestRequested = false;
			KeyBinder.Cancel();
		}

		public void OnOkAsync(OkActionCompletedHandler okActionCompletedCallback)
		{
			ProximityVoiceChatPlugin.SaveConfig();
			if (okActionCompletedCallback != null)
			{
				okActionCompletedCallback.Invoke();
			}
		}

		private void Update()
		{
			KeyBinder.Tick();
			for (int i = 0; i < _keyRows.Count; i++)
			{
				_keyRows[i].Refresh();
			}
			VoiceRuntime instance = VoiceRuntime.Instance;
			MicrophoneCapture microphoneCapture = instance?.Capture;
			VoiceEncoder voiceEncoder = instance?.Encoder;
			float num = 0f;
			if (instance?.Playback != null && instance.Playback.Streams.TryGetValue(1uL, out PeerVoiceStream value))
			{
				num = value.OutputRms;
			}
			SetFill(_inFill, microphoneCapture?.PeakLevel ?? 0f);
			SetFill(_rmsFill, voiceEncoder?.LastRms ?? 0f);
			SetFill(_outFill, num);
			_textTimer += Time.unscaledDeltaTime;
			if (_textTimer >= 0.15f)
			{
				_textTimer = 0f;
				RefreshText(microphoneCapture, voiceEncoder, instance, num);
			}
			_gain?.Set(ProximityVoiceChatPlugin.MicGain.Value);
			_gate?.Set(ProximityVoiceChatPlugin.ActivationThreshold.Value);
			_incoming?.Set(ProximityVoiceChatPlugin.VoiceVolume.Value);
			_monitor?.Set(ProximityVoiceChatPlugin.MonitorVolume.Value);
			_selfHeight?.Set(ProximityVoiceChatPlugin.SpeakingIndicatorHeight.Value);
			_peerHeight?.Set(ProximityVoiceChatPlugin.PeerIndicatorHeight.Value);
			_peerScale?.Set(ProximityVoiceChatPlugin.PeerIndicatorScale.Value);
			_jawAngle?.Set(ProximityVoiceChatPlugin.JawMaxAngle.Value);
			_jawSensitivity?.Set(ProximityVoiceChatPlugin.JawSensitivity.Value);
			_jawAxis?.Refresh();
			SetToggle(_enableVoice, ProximityVoiceChatPlugin.EnableVoice);
			SetToggle(_activation, ProximityVoiceChatPlugin.UseVoiceActivation);
			SetToggle(_muteSelf, ProximityVoiceChatPlugin.MuteSelf);
			SetToggle(_deafen, ProximityVoiceChatPlugin.Deafen);
			SetToggle(_monitorOn, ProximityVoiceChatPlugin.LoopbackTest);
			SetToggle(_autoGain, ProximityVoiceChatPlugin.AutoGain);
			SetToggle(_duckMusic, ProximityVoiceChatPlugin.DuckMusic);
			SetToggle(_adaptiveJitter, ProximityVoiceChatPlugin.AdaptiveJitter);
			SetToggle(_testTone, ProximityVoiceChatPlugin.TestTone);
			SetToggle(_speakingIndicator, ProximityVoiceChatPlugin.ShowSpeakingIndicator);
			SetToggle(_peerIndicators, ProximityVoiceChatPlugin.PeerIndicators);
			SetToggle(_peerThroughWalls, ProximityVoiceChatPlugin.PeerIndicatorThroughWalls);
			SetToggle(_jawMovement, ProximityVoiceChatPlugin.JawMovement);
			SetToggle(_occlusion, ProximityVoiceChatPlugin.Occlusion);
			SetToggle(_underwater, ProximityVoiceChatPlugin.UnderwaterMuffle);
			SetToggle(_reverb, ProximityVoiceChatPlugin.VoiceReverb);
		}

		private void RefreshText(MicrophoneCapture? capture, VoiceEncoder? encoder, VoiceRuntime? runtime, float heard)
		{
			if ((Object)(object)_device != (Object)null)
			{
				_device.text = UIBuild.CurrentDeviceName();
			}
			if ((Object)(object)_status != (Object)null)
			{
				_status.text = ((capture == null) ? UIBuild.Localize("$pvc_no_microphone") : UIBuild.Localize("$pvc_status_device", capture.Device ?? "", capture.DeviceRate, capture.Channels));
			}
			if ((Object)(object)_stats != (Object)null)
			{
				SteamVoiceTransport steamVoiceTransport = runtime?.Transport;
				_stats.text = ((steamVoiceTransport == null) ? UIBuild.Localize("$pvc_not_connected") : UIBuild.Localize("$pvc_stats", steamVoiceTransport.PacketsSent, steamVoiceTransport.PacketsReceived, steamVoiceTransport.PacketsDropped));
			}
			if (!((Object)(object)_numbers == (Object)null))
			{
				string text = ((encoder != null && encoder.FramesSinceClip < 50) ? ("   <color=#ff8080>" + UIBuild.Localize("$pvc_too_loud") + "</color>") : "");
				_numbers.text = UIBuild.Localize("$pvc_numbers", (capture?.PeakLevel ?? 0f).ToString("0.000"), (encoder?.LastRms ?? 0f).ToString("0.000"), heard.ToString("0.000"), (-60f).ToString("0")) + text;
			}
		}

		private static void SetFill(RectTransform? fill, float value)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)fill != (Object)null)
			{
				fill.anchorMax = new Vector2(UIBuild.MeterScale(value), 1f);
			}
		}

		private static void SetToggle(Toggle? toggle, ConfigEntry<ProximityVoiceChatPlugin.Toggle> entry)
		{
			if ((Object)(object)toggle != (Object)null)
			{
				toggle.SetIsOnWithoutNotify(entry.Value.IsOn());
			}
		}
	}
	internal sealed class VoiceEntryUI : MonoBehaviour
	{
		private static readonly Color Speaking = new Color(0.45f, 1f, 0.45f, 1f);

		private static readonly Color Silent = new Color(1f, 1f, 1f, 0.55f);

		private static readonly Color Blocked = new Color(1f, 0.45f, 0.45f, 1f);

		private const float FallbackSpacing = -60f;

		private const float IconSize = 48f;

		private const float Gap = 12f;

		private const float RefreshInterval = 0.1f;

		private const float ExtraHeight = 40f;

		private const float LabelWidth = 64f;

		private const float SliderWidth = 296f;

		private const float SliderHeight = 14f;

		private const float ValueWidth = 46f;

		private const float TextHeight = 20f;

		private const int FontSize = 14;

		private const float DefaultNameLeft = 76f;

		private const float DefaultNameBottom = -28f;

		private static bool _warned;

		private Image? _icon;

		private Slider? _volume;

		private Text? _volumeText;

		private ulong _steamId;

		private bool _own;

		private bool _suppress;

		private float _timer;

		internal void Bind(SessionPlayerListEntry entry, bool isOwnPlayer)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			_own = isOwnPlayer;
			if (PeerPreferences.TryGetSteamId(entry.User, out _steamId))
			{
				VoiceSprites.Resolve();
				GrowRow((RectTransform)((Component)entry).transform);
				BuildMute(entry);
				BuildVolume(entry);
				Refresh();
			}
		}

		private void BuildMute(SessionPlayerListEntry entry)
		{
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Expected O, but got Unknown
			if ((Object)(object)_icon != (Object)null)
			{
				return;
			}
			Transform val = ((Component)entry).transform.Find("PVC_MuteImage");
			if ((Object)(object)val != (Object)null)
			{
				_icon = ((Component)val).GetComponent<Image>();
				Wire((val.childCount > 0) ? ((Component)val.GetChild(0)).GetComponent<Button>() : null);
				return;
			}
			Transform val2 = ((Component)entry).transform.Find("MuteImage");
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).gameObject.SetActive(true);
				_icon = ((Component)val2).GetComponent<Image>();
				Transform obj = val2.Find("Mute");
				Wire((obj != null) ? ((Component)obj).GetComponent<Button>() : null);
				return;
			}
			Transform obj2 = ((Component)entry).transform.Find("BlockImage");
			RectTransform val3 = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
			Transform obj3 = ((Component)entry).transform.Find("KickImage");
			RectTransform val4 = (RectTransform)(object)((obj3 is RectTransform) ? obj3 : null);
			if ((Object)(object)val3 == (Object)null)
			{
				if (!_warned)
				{
					_warned = true;
					ProximityVoiceChatPlugin.Log.LogWarning((object)"No BlockImage on the player list row, so there is nothing to clone a mute button from. Player list voice controls are off.");
				}
				return;
			}
			float num = (((Object)(object)val4 != (Object)null) ? (val3.anchoredPosition.x - val4.anchoredPosition.x) : (-60f));
			GameObject val5 = Object.Instantiate<GameObject>(((Component)val3).gameObject, ((Component)entry).transform);
			((Object)val5).name = "PVC_MuteImage";
			val5.SetActive(true);
			Pin((RectTransform)val5.transform, val3.anchoredPosition.x + num, 48f, 48f);
			_icon = val5.GetComponent<Image>();
			Transform val6 = ((val5.transform.childCount > 0) ? val5.transform.GetChild(0) : null);
			if ((Object)(object)val6 != (Object)null)
			{
				((Object)val6).name = "PVC_Mute";
				Wire(((Component)val6).GetComponent<Button>());
			}
		}

		private void Wire(Button? button)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			if (!((Object)(object)button == (Object)null))
			{
				for (int i = 0; i < ((UnityEventBase)button.onClick).GetPersistentEventCount(); i++)
				{
					((UnityEventBase)button.onClick).SetPersistentListenerState(i, (UnityEventCallState)0);
				}
				((UnityEventBase)button.onClick).RemoveAllListeners();
				((UnityEvent)button.onClick).AddListener(new UnityAction(OnClick));
			}
		}

		private void BuildVolume(SessionPlayerListEntry entry)
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			//IL_00da: 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_0130: Expected O, but got Unknown
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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_01a9: Expected O, but got Unknown
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Expected O, but got Unknown
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			if (_own || (Object)(object)_volume != (Object)null)
			{
				return;
			}
			Slider val = ((IEnumerable<Slider>)((Component)entry).GetComponentsInChildren<Slider>(true)).FirstOrDefault((Func<Slider, bool>)((Slider x) => ((Object)x).name == "PVC_Volume"));
			if ((Object)(object)val != (Object)null)
			{
				_volume = val;
				Transform obj = ((Component)val).transform.parent.Find("PVC_VolumeValue");
				_volumeText = ((obj != null) ? ((Component)obj).GetComponent<Text>() : null);
				((UnityEventBase)_volume.onValueChanged).RemoveAllListeners();
				((UnityEvent<float>)(object)_volume.onValueChanged).AddListener((UnityAction<float>)OnVolumeChanged);
				return;
			}
			RectTransform val2 = (RectTransform)((Component)entry).transform;
			Transform obj2 = ((Component)entry).transform.Find("Background");
			RectTransform val3 = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
			if (!((Object)(object)val3 == (Object)null))
			{
				float y = (NameBottomEdge(val2) - val2.sizeDelta.y * 0.5f) * 0.5f;
				float num = NameLeftEdge(val2);
				Text obj3 = UIFactory.Text("PVC_VolumeLabel", (Transform)(object)val3, UIBuild.Localize("$pvc_volume_label"), TextRole.Body, 14, (TextAnchor)3);
				PinLeft((RectTransform)((Component)obj3).transform, num, y, 64f, 20f);
				((Graphic)obj3).color = GameColors.Muted;
				_volume = UIFactory.Slider("PVC_Volume", (Transform)(object)val3, new Vector2(296f, 14f), 0f, 2f, PeerPreferences.GetVolume(_steamId), OnVolumeChanged);
				PinLeft((RectTransform)((Component)_volume).transform, num + 64f + 12f, y, 296f, 14f);
				_volumeText = UIFactory.Text("PVC_VolumeValue", (Transform)(object)val3, "", TextRole.Body, 14, (TextAnchor)3);
				PinLeft((RectTransform)((Component)_volumeText).transform, num + 64f + 12f + 296f + 12f, y, 46f, 20f);
				((Graphic)_volumeText).color = GameColors.Beige;
			}
		}

		private static void GrowRow(RectTransform row)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)((Transform)row).Find("PVC_Tall") != (Object)null))
			{
				GameObject val = new GameObject("PVC_Tall", new Type[1] { typeof(RectTransform) });
				val.transform.SetParent((Transform)(object)row, false);
				val.SetActive(false);
				row.sizeDelta = new Vector2(row.sizeDelta.x, row.sizeDelta.y + 40f);
				LayoutRebuilder.MarkLayoutForRebuild(row);
			}
		}

		private static float NameLeftEdge(RectTransform row)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			RectTransform[] componentsInChildren = ((Component)row).GetComponentsInChildren<RectTransform>(true);
			foreach (RectTransform val in componentsInChildren)
			{
				if (((Object)val).name == "CharacterName" && Mathf.Approximately(val.anchorMin.x, 0f))
				{
					float x = val.anchoredPosition.x;
					float x2 = val.pivot.x;
					Rect rect = val.rect;
					return x - x2 * ((Rect)(ref rect)).width;
				}
			}
			return 76f;
		}

		private static float NameBottomEdge(RectTransform row)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			float num = float.PositiveInfinity;
			RectTransform[] componentsInChildren = ((Component)row).GetComponentsInChildren<RectTransform>(true);
			foreach (RectTransform val in componentsInChildren)
			{
				if (!(((Object)val).name != "CharacterName") || !(((Object)val).name != "Gamertag"))
				{
					float num2 = num;
					float y = val.anchoredPosition.y;
					float num3 = 1f - val.pivot.y;
					Rect rect = val.rect;
					num = Mathf.Min(num2, y - num3 * ((Rect)(ref rect)).height);
				}
			}
			if (!float.IsPositiveInfinity(num))
			{
				return num;
			}
			return -28f;
		}

		private static void Pin(RectTransform rect, float x, float width, float height)
		{
			//IL_000b: 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)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(1f, 0.5f);
			rect.anchorMax = new Vector2(1f, 0.5f);
			rect.pivot = new Vector2(0.5f, 0.5f);
			((Transform)rect).localScale = Vector3.one;
			rect.sizeDelta = new Vector2(width, height);
			rect.anchoredPosition = new Vector2(x, 0f);
		}

		private static void PinLeft(RectTransform rect, float x, float y, float width, float height)
		{
			//IL_000b: 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)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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)
			rect.anchorMin = new Vector2(0f, 0.5f);
			rect.anchorMax = new Vector2(0f, 0.5f);
			rect.pivot = new Vector2(0f, 0.5f);
			((Transform)rect).localScale = Vector3.one;
			rect.sizeDelta = new Vector2(width, height);
			rect.anchoredPosition = new Vector2(x, y);
		}

		private void OnVolumeChanged(float value)
		{
			if (!_suppress)
			{
				PeerPreferences.SetVolume(_steamId, value);
				ProximityVoiceChatPlugin.SaveConfig();
			}
		}

		private void OnClick()
		{
			if (_own)
			{
				ProximityVoiceChatPlugin.MuteSelf.Value = ((!ProximityVoiceChatPlugin.MuteSelf.Value.IsOn()) ? ProximityVoiceChatPlugin.Toggle.On : ProximityVoiceChatPlugin.Toggle.Off);
			}
			else
			{
				PeerPreferences.ToggleMuted(_steamId);
				VoiceRuntime.Instance?.Playback?.Remove(_steamId);
				ProximityVoiceChatPlugin.SaveConfig();
			}
			Refresh();
		}

		private void Update()
		{
			if (!((Object)(object)_icon == (Object)null))
			{
				_timer += Time.unscaledDeltaTime;
				if (!(_timer < 0.1f))
				{
					_timer = 0f;
					Refresh();
				}
			}
		}

		private void Refresh()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_icon == (Object)null))
			{
				bool flag = (_own ? ProximityVoiceChatPlugin.MuteSelf.Value.IsOn() : PeerPreferences.IsSilenced(_steamId));
				if ((Object)(object)VoiceSprites.Speaker != (Object)null && (Object)(object)VoiceSprites.Muted != (Object)null)
				{
					_icon.sprite = (flag ? VoiceSprites.Muted : VoiceSprites.Speaker);
				}
				((Graphic)_icon).color = (flag ? Blocked : (IsTalking() ? Speaking : Silent));
				RefreshVolume(flag);
			}
		}

		private void RefreshVolume(bool muted)
		{
			if (!((Object)(object)_volume == (Object)null) && !((Object)(object)_volumeText == (Object)null))
			{
				float volume = PeerPreferences.GetVolume(_steamId);
				_suppress = true;
				_volume.SetValueWithoutNotify(volume);
				_suppress = false;
				((Selectable)_volume).interactable = !PeerPreferences.IsBlockedByGame(_steamId);
				_volumeText.text = (muted ? UIBuild.Localize("$pvc_mute") : volume.ToString("0.00"));
			}
		}

		private bool IsTalking()
		{
			VoiceRuntime instance = VoiceRuntime.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			if (_own)
			{
				return instance.Encoder?.IsTransmitting ?? false;
			}
			if (instance.Playback != null && instance.Playback.Streams.TryGetValue(_steamId, out PeerVoiceStream value))
			{
				return value.Speaking;
			}
			return false;
		}
	}
	internal static class VoiceSprites
	{
		private const int Size = 128;

		private const int Samples = 3;

		private const int MaxAlpha = 255;

		private const float PixelsPerUnit = 100f;

		private const int QuietWaves = 1;

		private const int TalkingWaves = 3;

		private const float Middle = 0.5f;

		private const float ConeMouth = 0.5f;

		private const float BodyLeft = 0.16f;

		private const float BodyRight = 0.3f;

		private const float BodyHalfHeight = 0.11f;

		private const float ConeFlare = 0.2f;

		private const float SlashHalfWidth = 0.035f;

		private const float SlashGap = 0.075f;

		private const float WaveArcDegrees = 52f;

		private const float WaveInner = 0.1f;

		private const float WaveSpacing = 0.1f;

		private const float WaveThickness = 0.045f;

		private static readonly Vector2 SlashStart = new Vector2(0.17f, 0.2f);

		private static readonly Vector2 SlashEnd = new Vector2(0.83f, 0.8f);

		private static bool _built;

		internal static Sprite? Speaker { get; private set; }

		internal static Sprite? SpeakerTalking { get; private set; }

		internal static Sprite? Muted { get; private set; }

		internal static void Resolve()
		{
			if (!_built)
			{
				_built = true;
				Speaker = Build(1, slash: false);
				SpeakerTalking = Build(3, slash: false);
				Muted = Build(0, slash: true);
			}
		}

		private static Sprite Build(int waves, bool slash)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(128, 128, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1,
				hideFlags = (HideFlags)61
			};
			Color32[] array = (Color32[])(object)new Color32[16384];
			for (int i = 0; i < 128; i++)
			{
				for (int j = 0; j < 128; j++)
				{
					float num = 0f;
					for (int k = 0; k < 3; k++)
					{
						for (int l = 0; l < 3; l++)
						{
							float u = ((float)j + ((float)l + 0.5f) / 3f) / 128f;
							float v = ((float)i + ((float)k + 0.5f) / 3f) / 128f;
							if (Inside(u, v, waves, slash))
							{
								num += 1f;
							}
						}
					}
					num /= 9f;
					byte b = (byte)Mathf.Clamp(Mathf.RoundToInt(num * 255f), 0, 255);
					array[i * 128 + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, b);
				}
			}
			val.SetPixels32(array);
			val.Apply(false, false);
			Sprite obj = Sprite.Create(val, new Rect(0f, 0f, 128f, 128f), new Vector2(0.5f, 0.5f), 100f);
			((Object)obj).hideFlags = (HideFlags)61;
			return obj;
		}

		private static bool Inside(float u, float v, int waves, bool slash)
		{
			if (slash)
			{
				float num = DistanceToSlash(u, v);
				if (num <= 0.035f)
				{
					return true;
				}
				if (num <= 0.075f)
				{
					return false;
				}
			}
			float num2 = Mathf.Abs(v - 0.5f);
			if (u >= 0.16f && u <= 0.3f && num2 <= 0.11f)
			{
				return true;
			}
			if (u > 0.3f && u <= 0.5f && num2 <= 0.11f + (u - 0.3f) / 0.19999999f * 0.2f)
			{
				return true;
			}
			if (waves <= 0)
			{
				return false;
			}
			float num3 = u - 0.5f;
			float num4 = v - 0.5f;
			float num5 = Mathf.Sqrt(num3 * num3 + num4 * num4);
			if (num3 <= 0f)
			{
				return false;
			}
			if (Mathf.Abs(Mathf.Atan2(num4, num3)) * 57.29578f > 52f)
			{
				return false;
			}
			for (int i = 0; i < waves; i++)
			{
				float num6 = 0.1f + (float)i * 0.1f;
				if (num5 >= num6 && num5 <= num6 + 0.045f)
				{
					return true;
				}
			}
			return false;
		}

		private static float DistanceToSlash(float u, float v)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = new Vector2(u, v);
			Vector2 val2 = SlashEnd - SlashStart;
			float num = Mathf.Clamp01(Vector2.Dot(val - SlashStart, val2) / Vector2.Dot(val2, val2));
			return Vector2.Distance(val, SlashStart + val2 * num);
		}
	}
	internal sealed class SpeakingIndicator : MonoBehaviour
	{
		private sealed class Marker
		{
			internal GameObject Root;

			internal Image Icon;

			internal RectTransform Rect;

			internal float Shown;
		}

		private const float FadeRate = 6f;

		private const float IconSize = 34f;

		private const float PeerHeadHeight = 1.5f;

		private const float FadeBandFraction = 0.25f;

		private const float BounceBase = 0.9f;

		private const float BounceDepth = 0.25f;

		private const float Invisible = 0.001f;

		private static readonly List<RosterEntry> NoPeers = new List<RosterEntry>();

		private readonly List<Marker> _peers = new List<Marker>();

		private Marker? _self;

		private Hud? _hud;

		private void OnDestroy()
		{
			Teardown();
		}

		private void LateUpdate()
		{
			bool flag = ProximityVoiceChatPlugin.ShowSpeakingIndicator.Value.IsOn();
			bool flag2 = ProximityVoiceChatPlugin.PeerIndicators.Value.IsOn();
			if (!flag && !flag2)
			{
				Teardown();
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			Hud instance = Hud.instance;
			Camera mainCamera = Utils.GetMainCamera();
			if ((Object)(object)localPlayer == (Object)null || !Object.op_Implicit((Object)(object)localPlayer) || (Object)(object)instance == (Object)null || !Object.op_Implicit((Object)(object)instance) || (Object)(object)mainCamera == (Object)null || Hud.IsUserHidden())
			{
				HideAll();
				return;
			}
			if ((Object)(object)_hud != (Object)(object)instance)
			{
				Teardown();
				_hud = instance;
			}
			if (flag)
			{
				DrawSelf(instance, mainCamera, localPlayer);
			}
			else
			{
				Fade(_self);
			}
			DrawPeers(instance, mainCamera, flag2);
		}

		private void DrawSelf(Hud hud, Camera camera, Player player)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_00d5: 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)
			if (_self == null)
			{
				_self = Build(hud, "PVC_Speaking");
			}
			VoiceEncoder voiceEncoder = VoiceRuntime.Instance?.Encoder;
			bool flag = ProximityVoiceChatPlugin.MuteSelf.Value.IsOn() || ProximityVoiceChatPlugin.Deafen.Value.IsOn();
			bool flag2 = !flag && voiceEncoder != null && voiceEncoder.IsSpeaking && VoiceRuntime.GateOpen();
			float level = ((!flag && voiceEncoder != null) ? UIBuild.MeterScale(voiceEncoder.LastRms) : 0f);
			_self.Icon.sprite = (flag ? VoiceSprites.Muted : VoiceSprites.SpeakerTalking);
			Vector3 world = ((Character)player).GetHeadPoint() + Vector3.up * ProximityVoiceChatPlugin.SpeakingIndicatorHeight.Value;
			Place(_self, camera, world, flag2 || flag, flag ? GameColors.Danger : GameColors.Beige, level, 1f, 1f);
		}

		private void DrawPeers(Hud hud, Camera camera, bool wantPeers)
		{
			//IL_01c3: 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_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			VoiceRuntime instance = VoiceRuntime.Instance;
			IReadOnlyList<RosterEntry> readOnlyList;
			if (!((Object)(object)instance != (Object)null && wantPeers))
			{
				IReadOnlyList<RosterEntry> noPeers = NoPeers;
				readOnlyList = noPeers;
			}
			else
			{
				readOnlyList = instance.Roster.Entries;
			}
			IReadOnlyList<RosterEntry> readOnlyList2 = readOnlyList;
			float value = ProximityVoiceChatPlugin.PeerIndicatorScale.Value;
			bool flag = ProximityVoiceChatPlugin.PeerIndicatorThroughWalls.Value.IsOn();
			float value2 = ProximityVoiceChatPlugin.MaxRange.Value;
			while (_peers.Count < readOnlyList2.Count)
			{
				_peers.Add(Build(hud, "PVC_PeerSpeaking"));
			}
			for (int i = 0; i < _peers.Count; i++)
			{
				Marker marker = _peers[i];
				if (i >= readOnlyList2.Count)
				{
					Fade(marker);
					continue;
				}
				RosterEntry rosterEntry = readOnlyList2[i];
				instance.Links.TryGetValue(rosterEntry.SteamId, out PeerLink value3);
				bool flag2 = PeerPreferences.IsSilenced(rosterEntry.SteamId);
				PeerVoiceStream peerVoiceStream = null;
				if (instance.Playback != null && instance.Playback.Streams.TryGetValue(rosterEntry.SteamId, out PeerVoiceStream value4))
				{
					peerVoiceStream = value4;
				}
				bool num = ((!flag2) ? (peerVoiceStream?.Speaking ?? false) : (value3?.Transmitting ?? false));
				bool flag3 = !flag && (peerVoiceStream?.Occluded ?? false);
				bool wanted = num && !flag3 && rosterEntry.HasPosition && (value3?.InRange ?? false);
				marker.Icon.sprite = (flag2 ? VoiceSprites.Muted : VoiceSprites.SpeakerTalking);
				float level = ((!flag2 && peerVoiceStream != null) ? UIBuild.MeterScale(peerVoiceStream.OutputRms) : 0f);
				float num2 = value3?.Distance ?? value2;
				float fade = Mathf.Clamp01((value2 - num2) / Mathf.Max(1f, value2 * 0.25f));
				Vector3 world = HeadOf(rosterEntry) + Vector3.up * ProximityVoiceChatPlugin.PeerIndicatorHeight.Value;
				Place(marker, camera, world, wanted, flag2 ? GameColors.Danger : GameColors.Beige, level, value, fade);
			}
		}

		private static Vector3 HeadOf(RosterEntry entry)
		{
			//IL_001c: 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_002b: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)entry.Player != (Object)null) || !Object.op_Implicit((Object)(object)entry.Player))
			{
				return entry.LastKnownPosition + Vector3.up * 1.5f;
			}
			return ((Character)entry.Player).GetHeadPoint();
		}

		private static void Place(Marker marker, Camera camera, Vector3 world, bool wanted, Color color, float level, float scale, float fade)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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)
			marker.Shown = Mathf.MoveTowards(marker.Shown, wanted ? 1f : 0f, 6f * Time.unscaledDeltaTime);
			float num = marker.Shown * fade;
			if (num <= 0.001f)
			{
				Hide(marker);
				return;
			}
			Vector3 val = Utils.WorldToScreenPointScaled(camera, world);
			if (val.z <= 0f)
			{
				Hide(marker);
				return;
			}
			marker.Root.SetActive(true);
			((Transform)marker.Rect).position = val;
			((Transform)marker.Rect).localScale = Vector3.one * scale * (0.9f + 0.25f * level) * marker.Shown;
			color.a = num;
			((Graphic)marker.Icon).color = color;
		}

		private static Marker Build(Hud hud, string name)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			VoiceSprites.Resolve();
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(((Component)hud).transform, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.sizeDelta = new Vector2(34f, 34f);
			Image component = val.GetComponent<Image>();
			component.sprite = VoiceSprites.SpeakerTalking;
			((Graphic)component).raycastTarget = false;
			component.preserveAspect = true;
			val.SetActive(false);
			return new Marker
			{
				Root = val,
				Icon = component,
				Rect = val2
			};
		}

		private static void Fade(Marker? marker)
		{
			if (marker != null)
			{
				marker.Shown = Mathf.MoveTowards(marker.Shown, 0f, 6f * Time.unscaledDeltaTime);
				if (marker.Shown <= 0.001f)
				{
					Hide(marker);
				}
			}
		}

		private static void Hide(Marker marker)
		{
			if ((Object)(object)marker.Root != (Object)null && marker.Root.activeSelf)
			{
				marker.Root.SetActive(false);
			}
		}

		private void HideAll()
		{
			if (_self != null)
			{
				Hide(_self);
			}
			for (int i = 0; i < _peers.Count; i++)
			{
				Hide(_peers[i]);
			}
		}

		private void Teardown()
		{
			if (_self != null)
			{
				Object.Destroy((Object)(object)_self.Root);
				_self = null;
			}
			for (int i = 0; i < _peers.Count; i++)
			{
				Object.Destroy((Object)(object)_peers[i].Root);
			}
			_peers.Clear();
			_hud = null;
		}
	}
	internal static class KeyBinder
	{
		private static readonly KeyCode[] Modifiers;

		private static KeyCode[]? _candidates;

		private static int _startedFrame;

		private static readonly List<KeyCode> Held;

		internal static ConfigEntry<KeyboardShortcut>? Target;

		internal static bool Listening => Target != null;

		internal static bool IsListening(ConfigEntry<KeyboardShortcut> entry)
		{
			return Target == entry;
		}

		internal static void Begin(ConfigEntry<KeyboardShortcut> entry)
		{
			Target = entry;
			_startedFrame = Time.frameCount;
		}

		internal static void Cancel()
		{
			Target = null;
		}

		internal static void Tick()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Invalid comparison between I4 and Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<KeyboardShortcut> target = Target;
			if (target == null || !Input.anyKeyDown || Time.frameCount == _startedFrame)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				Target = null;
				return;
			}
			if (Input.GetKeyDown((KeyCode)8) || Input.GetKeyDown((KeyCode)127))
			{
				target.Value = new KeyboardShortcut((KeyCode)0, Array.Empty<KeyCode>());
				Target = null;
				return;
			}
			if (_candidates == null)
			{
				_candidates = BuildCandidates();
			}
			for (int i = 0; i < _candidates.Length; i++)
			{
				KeyCode val = _candidates[i];
				if (!Input.GetKeyDown(val))
				{
					continue;
				}
				Held.Clear();
				for (int j = 0; j < Modifiers.Length; j++)
				{
					if ((int)Modifiers[j] != (int)val && Input.GetKey(Modifiers[j]))
					{
						Held.Add(Modifiers[j]);
					}
				}
				target.Value = new KeyboardShortcut(val, Held.ToArray());
				Target = null;
				break;
			}
		}

		internal static string Describe(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((KeyboardShortcut)(ref shortcut)).MainKey == 0)
			{
				return UIBuild.Localize("$pvc_key_unbound");
			}
			string text = "";
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				text = text + ((object)modifier/*cast due to .constrained prefix*/).ToString() + " + ";
			}
			return text + ((object)((KeyboardShortcut)(ref shortcut)).MainKey/*cast due to .constrained prefix*/).ToString();
		}

		private static KeyCode[] BuildCandidates()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			List<KeyCode> list = new List<KeyCode>();
			foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
			{
				if ((int)value != 0 && (int)value != 323 && !((object)value/*cast due to .constrained prefix*/).ToString().StartsWith("Joystick", StringComparison.Ordinal))
				{
					list.Add(value);
				}
			}
			return list.ToArray();
		}

		static KeyBinder()
		{
			KeyCode[] array = new KeyCode[6];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			Modifiers = (KeyCode[])(object)array;
			Held = new List<KeyCode>();
		}
	}
}
namespace ProximityVoiceChat.Voice
{
	internal static class MusicDucking
	{
		[HarmonyPatch(typeof(MusicMan), "UpdateMusic")]
		private static class MusicMan_UpdateMusic_Patch
		{
			private static void Postfix(MusicMan __instance)
			{
				if (!(_duck >= 0.999f) && !((Object)(object)__instance.m_musicSource == (Object)null))
				{
					AudioSource musicSource = __instance.m_musicSource;
					musicSource.volume *= _duck;
				}
			}
		}

		private const float FadeRate = 3f;

		private static float _duck = 1f;

		internal static void Tick(float deltaTime, bool someoneSpeaking)
		{
			float num = 1f;
			if (someoneSpeaking && ProximityVoiceChatPlugin.DuckMusic.Value.IsOn())
			{
				num = Mathf.Clamp01(ProximityVoiceChatPlugin.DuckMusicAmount.Value);
			}
			_duck = Mathf.MoveTowards(_duck, num, 3f * deltaTime);
		}

		internal static void Reset()
		{
			_duck = 1f;
		}
	}
	internal sealed class JawAnimator : MonoBehaviour
	{
		private sealed class Mouth
		{
			internal Transform? Jaw;

			internal Quaternion Rest;

			internal float Open;

			internal float Seed;

			internal bool Missing;
		}

		private const string JawBone = "Jaw";

		private const float AttackPerSecond = 14f;

		private const float ReleasePerSecond = 7f;

		private const float Floor = 0.012f;

		private const float Closed = 0.0005f;

		private const float WobbleBase = 0.85f;

		private const float WobbleDepth = 0.15f;

		private const float WobbleHz = 9f;

		private const float SeedRange = 10f;

		private readonly Dictionary<Player, Mouth> _mouths = new Dictionary<Player, Mouth>();

		private readonly List<Player> _stale = new List<Player>();

		private void LateUpdate()
		{
			if (ProximityVoiceChatPlugin.JawMovement.Value == ProximityVoiceChatPlugin.Toggle.Off || (Object)(object)ZNet.instance == (Object)null)
			{
				if (_mouths.Count > 0)
				{
					ReleaseAll();
				}
				return;
			}
			VoiceRuntime instance = VoiceRuntime.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			float deltaTime = Time.deltaTime;
			VoiceEncoder encoder = instance.Encoder;
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null && Object.op_Implicit((Object)(object)localPlayer))
			{
				float level = ((encoder != null && encoder.IsSpeaking && VoiceRuntime.GateOpen()) ? encoder.LastRms : 0f);
				if (ProximityVoiceChatPlugin.LoopbackTest.Value.IsOn() && instance.Playback != null && instance.Playback.Streams.TryGetValue(1uL, out PeerVoiceStream value))
				{
					level = (value.Speaking ? value.OutputRms : 0f);
				}
				Drive(localPlayer, level, deltaTime);
			}
			if (instance.Playback != null)
			{
				IReadOnlyList<RosterEntry> entries = instance.Roster.Entries;
				for (int i = 0; i < entries.Count; i++)
				{
					RosterEntry rosterEntry = entries[i];
					if (!((Object)(object)rosterEntry.Player == (Object)null) && Object.op_Implicit((Object)(object)rosterEntry.Player))
					{
						PeerVoiceStream value2;
						float level2 = ((instance.Playback.Streams.TryGetValue(rosterEntry.SteamId, out value2) && value2.Speaking) ? value2.OutputRms : 0f);
						Drive(rosterEntry.Player, level2, deltaTime);
					}
				}
			}
			Sweep();
		}

		private void Drive(Player player, float level, float deltaTime)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			if (!_mouths.TryGetValue(player, out Mouth value))
			{
				value = new Mouth
				{
					Seed = Random.Range(0f, 10f)
				};
				_mouths[player] = value;
			}
			if (value.Missing)
			{
				return;
			}
			if ((Object)(object)value.Jaw == (Object)null)
			{
				value.Jaw = FindJaw(player);
				if ((Object)(object)value.Jaw == (Object)null)
				{
					value.Missing = true;
					return;
				}
				value.Rest = value.Jaw.localRotation;
			}
			float num = ((level <= 0.012f) ? 0f : Mathf.Clamp01(Mathf.Sqrt(level * ProximityVoiceChatPlugin.JawSensitivity.Value)));
			if (num > 0f)
			{
				num *= 0.85f + 0.15f * Mathf.PerlinNoise(value.Seed, Time.time * 9f);
			}
			float num2 = ((num > value.Open) ? 14f : 7f);
			value.Open = Mathf.MoveTowards(value.Open, num, num2 * deltaTime);
			if (value.Open <= 0.0005f)
			{
				value.Jaw.localRotation = value.Rest;
				return;
			}
			float num3 = value.Open * ProximityVoiceChatPlugin.JawMaxAngle.Value;
			value.Jaw.localRotation = value.Rest * Quaternion.AngleAxis(num3, Axis());
		}

		private static Vector3 Axis()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			return (Vector3)(ProximityVoiceChatPlugin.JawAxis.Value switch
			{
				ProximityVoiceChatPlugin.Bone.Y => Vector3.up, 
				ProximityVoiceChatPlugin.Bone.Z => Vector3.forward, 
				_ => Vector3.right, 
			});
		}

		private static Transform? FindJaw(Player player)
		{
			Transform[] componentsInChildren = ((Component)player).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name == "Jaw")
				{
					return val;
				}
			}
			return null;
		}

		private void Sweep()
		{
			_stale.Clear();
			foreach (KeyValuePair<Player, Mouth> mouth in _mouths)
			{
				if ((Object)(object)mouth.Key == (Object)null || !Object.op_Implicit((Object)(object)mouth.Key))
				{
					_stale.Add(mouth.Key);
				}
			}
			for (int i = 0; i < _stale.Count; i++)
			{
				_mouths.Remove(_stale[i]);
			}
		}

		private void ReleaseAll()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<Player, Mouth> mouth in _mouths)
			{
				Mouth value = mouth.Value;
				if ((Object)(object)value.Jaw != (Object)null)
				{
					value.Jaw.localRotation = value.Rest;
				}
			}
			_mouths.Clear();
		}

		private void OnDestroy()
		{
			ReleaseAll();
		}
	}
	internal sealed class VoiceHotkeys : MonoBehaviour
	{
		private void Update()
		{
			//IL_0014: 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)
			if (Typing() || KeyBinder.Listening)
			{
				return;
			}
			if (ProximityVoiceChatPlugin.MuteSelfKey.Value.IsKeyDown())
			{
				Say(Flip(ProximityVoiceChatPlugin.MuteSelf) ? "$pvc_msg_muted" : "$pvc_msg_unmuted");
			}
			if (ProximityVoiceChatPlugin.DeafenKey.Value.IsKeyDown())
			{
				bool num = Flip(ProximityVoiceChatPlugin.Deafen);
				Say(num ? "$pvc_msg_deafened" : "$pvc_msg_undeafened");
				if (num)
				{
					VoiceRuntime.Instance?.Playback?.Clear();
				}
			}
		}

		private static bool Flip(ConfigEntry<ProximityVoiceChatPlugin.Toggle> entry)
		{
			bool flag = entry.Value == ProximityVoiceChatPlugin.Toggle.Off;
			entry.Value = (flag ? ProximityVoiceChatPlugin.Toggle.On : ProximityVoiceChatPlugin.Toggle.Off);
			return flag;
		}

		private static void Say(string key)
		{
			if (ProximityVoiceChatPlugin.HotkeyMessages.Value != ProximityVoiceChatPlugin.Toggle.Off && (Object)(object)MessageHud.instance != (Object)null)
			{
				MessageHud.instance.ShowMessage((MessageType)1, UIBuild.Localize(key), 0, (Sprite)null, false, true);
			}
		}

		private static bool Typing()
		{
			if ((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus())
			{
				return true;
			}
			if ((Object)(object)Settings.instance != (Object)null || Menu.IsVisible())
			{
				return true;
			}
			if (!Console.IsVisible())
			{
				return TextInput.IsVisible();
			}
			return true;
		}
	}
	internal static class PeerPreferences
	{
		internal const float MaxVolume = 2f;

		private const char RecordSeparator = ';';

		private const char FieldSeparator = ':';

		private const string MutedFlag = "1";

		private const string VolumeFormat = "0.##";

		private const int Fields = 3;

		private static readonly Dictionary<ulong, float> Volumes = new Dictionary<ulong, float>();

		private static readonly HashSet<ulong> Muted = new HashSet<ulong>();

		private static bool _dirty;

		internal static bool IsMutedByUs(ulong steamId)
		{
			return Muted.Contains(steamId);
		}

		internal static bool IsBlockedByGame(ulong steamId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			PlatformUserID val = ToUserId(steamId);
			if (!((PlatformUserID)(ref val)).IsValid)
			{
				return false;
			}
			if (!((PlayerListManagement)MuteList.Instance).Contains(val))
			{
				return RelationsManager.IsBlocked(val);
			}
			return true;
		}

		internal static bool IsSilenced(ulong steamId)
		{
			if (!IsMutedByUs(steamId))
			{
				return IsBlockedByGame(steamId);
			}
			return true;
		}

		internal static void SetMuted(ulong steamId, bool muted)
		{
			if (!(muted ? (!Muted.Add(steamId)) : (!Muted.Remove(steamId))))
			{
				_dirty = true;
			}
		}

		internal static void ToggleMuted(ulong steamId)
		{
			SetMuted(steamId, !IsMutedByUs(steamId));
		}

		internal static float GetVolume(ulong steamId)
		{
			if (!Volumes.TryGetValue(steamId, out var value))
			{
				return 1f;
			}
			return value;
		}

		internal static void SetVolume(ulong steamId, float volume)
		{
			volume = Mathf.Clamp(volume, 0f, 2f);
			if (!Mathf.Approximately(GetVolume(steamId), volume))
			{
				if (Mathf.Approximately(volume, 1f))
				{
					Volumes.Remove(steamId);
				}
				else
				{
					Volumes[steamId] = volume;
				}
				_dirty = true;
			}
		}

		internal static PlatformUserID ToUserId(ulong steamId)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (steamId == 0L || PlatformManager.DistributionPlatform == null)
			{
				return PlatformUserID.None;
			}
			return new PlatformUserID(PlatformManager.DistributionPlatform.Platform, steamId, true);
		}

		internal static bool TryGetSteamId(PlatformUserID user, out ulong steamId)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			steamId = 0uL;
			if (((PlatformUserID)(ref user)).IsValid && user.m_platform == "Steam" && ((PlatformUserID)(ref user)).TryParseAsUInt64(ref steamId))
			{
				return steamId != 0;
			}
			return false;
		}

		internal static void Load(string serialized)
		{
			Volumes.Clear();
			Muted.Clear();
			if (string.IsNullOrEmpty(serialized))
			{
				return;
			}
			string[] array = serialized.Split(';');
			foreach (string text in array)
			{
				if (text.Length == 0)
				{
					continue;
				}
				string[] array2 = text.Split(':');
				if (array2.Length >= 3 && ulong.TryParse(array2[0], out var result))
				{
					if (float.TryParse(array2[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && !Mathf.Approximately(result2, 1f))
					{
						Volumes[result] = Mathf.Clamp(result2, 0f, 2f);
					}
					if (array2[2] == "1")
					{
						Muted.Add(result);
					}
				}
			}
			_dirty = false;
		}

		internal static bool TryFlush(out string serialized)
		{
			serialized = "";
			if (!_dirty)
			{
				return false;
			}
			HashSet<ulong> hashSet = new HashSet<ulong>(Muted);
			foreach (ulong key in Volumes.Keys)
			{
				hashSet.Add(key);
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (ulong item in hashSet)
			{
				stringBuilder.Append(item).Append(':');
				stringBuilder.Append(GetVolume(item).ToString("0.##", CultureInfo.InvariantCulture)).Append(':');
				stringBuilder.Append(Muted.Contains(item) ? "1" : "0").Append(';');
			}
			serialized = stringBuilder.ToString();
			_dirty = false;
			return true;
		}
	}
	internal delegate void VoicePacketHandler(ulong senderSteamId, in VoiceHeader header, byte[] buffer, int offset, int length);
	internal sealed class SteamVoiceTransport : IDisposable
	{
		internal const int Channel = 24051;

		private const int RecvBatch = 32;

		private const int MaxPacketsPerSenderPerSecond = 120;

		private const float RateLimitWindow = 1f;

		private readonly IntPtr[] _recvPtrs = new IntPtr[32];

		private readonly byte[] _recvScratch = new byte[1112];

		private readonly byte[] _sendScratch = new byte[1112];

		private readonly Dictionary<ulong, int> _packetsThisWindow = new Dictionary<ulong, int>();

		private readonly HashSet<ulong> _openSessions = new HashSet<ulong>();

		private readonly Func<ulong, bool> _isKnownPeer;

		private Callback<SteamNetworkingMessagesSessionRequest_t>? _sessionRequest;

		private Callback<SteamNetworkingMessagesSessionFailed_t>? _sessionFailed;

		private IntPtr _sendBuffer;

		private float _windowTimer;

		private bool _broken;

		private ushort _frameSequence;

		private ushort _controlSequence;

		private bool _disposed;

		internal int PacketsSent;

		internal int PacketsReceived;

		internal int PacketsDropped;

		internal ushort FrameSequence => _frameSequence;

		internal bool Broken => _broken;

		internal SteamVoiceTransport(Func<ulong, bool> isKnownPeer)
		{
			_isKnownPeer = isKnownPeer;
			_sendBuffer = Marshal.AllocHGlobal(1112);
			_sessionRequest = Callback<SteamNetworkingMessagesSessionRequest_t>.Create((DispatchDelegate<SteamNetworkingMessagesSessionRequest_t>)OnSessionRequest);
			_sessionFailed = Callback<SteamNetworkingMessagesSessionFailed_t>.Create((DispatchDelegate<SteamNetworkingMessagesSessionFailed_t>)OnSessionFailed);
		}

		private void OnSessionRequest(SteamNetworkingMessagesSessionRequest_t data)
		{
			//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_0006: Unknown result type (might be due to invalid IL or missing references)
			SteamNetworkingIdentity identityRemote = data.m_identityRemote;
			ulong steamID = ((SteamNetworkingIdentity)(ref identityRemote)).GetSteamID64();
			if (!_isKnownPeer(steamID))
			{
				ProximityVoiceChatPlugin.Log.LogInfo((object)$"Rejecting voice session from unknown user {steamID}");
				SteamNetworkingMessages.CloseSessionWithUser(ref identityRemote);
			}
			else if (SteamNetworkingMessages.AcceptSessionWithUser(ref identityRemote))
			{
				_openSessions.Add(steamID);
				ProximityVoiceChatPlugin.Log.LogInfo((object)$"Accepted voice session from {steamID}");
			}
		}

		private void OnSessionFailed(SteamNetworkingMessagesSessionFailed_t data)
		{
			//IL_002f: 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)
			ulong steamID = ((SteamNetworkingIdentity)(ref data.m_info.m_identityRemote)).GetSteamID64();
			_openSessions.Remove(steamID);
			ProximityVoiceChatPlugin.Log.LogWarning((object)$"Voice session with {steamID} failed: {data.m_info.m_eEndReason} {((SteamNetConnectionInfo_t)(ref data.m_info)).m_szEndDebug}");
		}

		internal bool Send(ulong steamId, VoicePacketType type, VoiceFlags flags, uint timestampMs, byte[] payload, int payloadOffset, int payloadLength)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			if (_disposed || _broken || payloadLength > 1100)
			{
				return false;
			}
			ushort seq = ((type == VoicePacketType.Frame) ? _frameSequence : _controlSequence);
			VoiceWireFormat.WriteHeader(_sendScratch, type, flags, seq, timestampMs, (ushort)payloadLength);
			if (payloadLength > 0)
			{
				Buffer.BlockCopy(payload, payloadOffset, _sendScratch, 12, payloadLength);
			}
			int num = 12 + payloadLength;
			Marshal.Copy(_sendScratch, 0, _sendBuffer, num);
			SteamNetworkingIdentity val = default(SteamNetworkingIdentity);
			((SteamNetworkingIdentity)(ref val)).SetSteamID64(steamId);
			EResult val2;
			try
			{
				val2 = SteamNetworkingMessages.SendMessageToUser(ref val, _sendBuffer, (uint)num, 37, 24051);
			}
			catch (Exception ex)
			{
				Break("send", ex);
				return false;
			}
			if ((int)val2 != 1)
			{
				return false;
			}
			PacketsSent++;
			return true;
		}

		internal void AdvanceFrameSequence()
		{
			_frameSequence++;
		}

		internal void AdvanceControlSequence()
		{
			_controlSequence++;
		}

		private void Break(string stage, Exception ex)
		{
			if (!_broken)
			{
				_broken = true;
				ProximityVoiceChatPlugin.Log.LogError((object)("SteamNetworkingMessages " + stage + " failed, voice transport is off for this session: " + ex.Message));
			}
		}

		internal void Pump(float deltaTime, VoicePacketHandler handler)
		{
			if (_disposed || _broken)
			{
				return;
			}
			_windowTimer += deltaTime;
			if (_windowTimer >= 1f)
			{
				_windowTimer = 0f;
				_packetsThisWindow.Clear();
			}
			int num;
			do
			{
				try
				{
					num = SteamNetworkingMessages.ReceiveMessagesOnChannel(24051, _recvPtrs, 32);
				}
				catch (Exception ex)
				{
					Break("receive", ex);
					break;
				}
				for (int i = 0; i < num; i++)
				{
					IntPtr intPtr = _recvPtrs[i];
					try
					{
						Dispatch(intPtr, handler);
					}
					finally
					{
						SteamNetworkingMessage_t.Release(intPtr);
					}
				}
			}
			while (num == 32);
		}

		private void Dispatch(IntPtr ptr, VoicePacketHandler handler)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			SteamNetworkingMessage_t val = SteamNetworkingMessage_t.FromIntPtr(ptr);
			ulong steamID = ((SteamNetworkingIdentity)(ref val.m_identityPeer)).GetSteamID64();
			if (val.m_cbSize < 12 || val.m_cbSize > 1112)
			{
				PacketsDropped++;
				return;
			}
			if (!_isKnownPeer(steamID))
			{
				PacketsDropped++;
				return;
			}
			_packetsThisWindow.TryGetValue(steamID, out var value);
			if (value >= 120)
			{
				PacketsDropped++;
				return;
			}
			_packetsThisWindow[steamID] = value + 1;
			Marshal.Copy(val.m_pData, _recvScratch, 0, val.m_cbSize);
			if (!VoiceWireFormat.TryReadHeader(_recvScratch, val.m_cbSize, out var header))
			{
				PacketsDropped++;
				return;
			}
			PacketsReceived++;
			_openSessions.Add(steamID);
			handler(steamID, in header, _recvScratch, 12, header.PayloadLength);
		}

		internal void CloseSession(ulong steamId)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (_broken || !_openSessions.Remove(steamId))
			{
				return;
			}
			SteamNetworkingIdentity val = default(SteamNetworkingIdentity);
			((SteamNetworkingIdentity)(ref val)).SetSteamID64(steamId);
			try
			{
				SteamNetworkingMessages.CloseSessionWithUser(ref val);
			}
			catch (Exception ex)
			{
				Break("close", ex);
			}
		}

		public void Dispose()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (_disposed)
			{
				return;
			}
			_disposed = true;
			try
			{
				foreach (ulong item in new List<ulong>(_openSessions))
				{
					SteamNetworkingIdentity val = default(SteamNetworkingIdentity);
					((SteamNetworkingIdentity)(ref val)).SetSteamID64(item);
					SteamNetworkingMessages.CloseSessionWithUser(ref val);
				}
			}
			catch (Exception ex)
			{
				ProximityVoiceChatPlugin.Log.LogWarning((object)("Could not close voice sessions cleanly: " + ex.Message));
			}
			_openSessions.Clear();
			_sessionRequest?.Dispose();
			_sessionRequest = null;
			_sessionFailed?.Dispose();
			_sessionFailed = null;
			if (_sendBuffer != IntPtr.Zero)
			{
				Marshal.FreeHGlobal(_sendBuffer);
				_sendBuffer = IntPtr.Zero;
			}
		}
	}
	internal enum VoicePacketType : byte
	{
		Frame,
		Hello,
		Bye,
		Ping,
		Pong
	}
	[Flags]
	internal enum VoiceFlags : byte
	{
		None = 0,
		EndOfTalkspurt = 1,
		Whisper = 2,
		Shout = 4
	}
	internal struct VoiceHeader
	{
		public VoicePacketType Type;

		public VoiceFlags Flags;

		public ushort Sequence;

		public uint TimestampMs;

		public ushort PayloadLength;
	}
	internal static class VoiceWireFormat
	{
		internal const byte Magic = 86;

		internal const byte Protocol = 1;

		internal const int HeaderSize = 12;

		internal const int MaxPayload = 1100;

		internal const int MaxPacketSize = 1112;

		internal static int WriteHeader(byte[] buf, VoicePacketType type, VoiceFlags flags, ushort seq, uint timestampMs, ushort payloadLength)
		{
			buf[0] = 86;
			buf[1] = 1;
			buf[2] = (byte)type;
			buf[3] = (byte)flags;
			buf[4] = (byte)(seq & 0xFF);
			buf[5] = (byte)(seq >> 8);
			buf[6] = (byte)(timestampMs & 0xFF);
			buf[7] = (byte)((timestampMs >> 8) & 0xFF);
			buf[8] = (byte)((timestampMs >> 16) & 0xFF);
			buf[9] = (byte)((timestampMs >> 24) & 0xFF);
			buf[10] = (byte)(payloadLength & 0xFF);
			buf[11] = (byte)(payloadLength >> 8);
			return 12;
		}

		internal static bool TryReadHeader(byte[] buf, int length, out VoiceHeader header)
		{
			header = default(VoiceHeader);
			if (length < 12 || buf[0] != 86 || buf[1] != 1)
			{
				return false;
			}
			ushort num = (ushort)(buf[10] | (buf[11] << 8));
			if (num > 1100 || 12 + num != length)
			{
				return false;
			}
			header.Type = (VoicePacketType)buf[2];
			header.Flags = (VoiceFlags)buf[3];
			header.Sequence = (ushort)(buf[4] | (buf[5] << 8));
			header.TimestampMs = (uint)(buf[6] | (buf[7] << 8) | (buf[8] << 16) | (buf[9] << 24));
			header.PayloadLength = num;
			return true;
		}

		internal static int SequenceDelta(ushort a, ushort b)
		{
			return (short)(a - b);
		}
	}
	internal sealed class RosterEntry
	{
		internal ulong SteamId;

		internal ZDOID CharacterId;

		internal string Name = "";

		internal Player? Player;

		internal Vector3 LastKnownPosition;

		internal bool HasPosition;
	}
	internal sealed class VoiceRoster
	{
		private const float RefreshInterval = 1f;

		private const string SteamPlatform = "Steam";

		private readonly Dictionary<ulong, RosterEntry> _bySteamId = new Dictionary<ulong, RosterEntry>();

		private readonly List<RosterEntry> _entries = new List<RosterEntry>();

		private readonly List<ulong> _removed = new List<ulong>();

		private float _refreshTimer;

		internal ulong LocalSteamId { get; private set; }

		internal IReadOnlyList<RosterEntry> Entries => _entries;

		internal static bool BackendSupported
		{
			get
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				if (SteamManager.Initialized && PlatformManager.DistributionPlatform != null)
				{
					return PlatformManager.DistributionPlatform.Platform == "Steam";
				}
				return false;
			}
		}

		internal bool IsKnownPeer(ulong steamId)
		{
			return _bySteamId.ContainsKey(steamId);
		}

		internal bool TryGet(ulong steamId, out RosterEntry entry)
		{
			return _bySteamId.TryGetValue(steamId, out entry);
		}

		internal void Reset()
		{
			_bySteamId.Clear();
			_entries.Clear();
			LocalSteamId = 0uL;
		}

		internal void Refresh(float deltaTime, List<ulong>? departed = null)
		{
			_refreshTimer += deltaTime;
			if (_refreshTimer < 1f)
			{
				ResolvePlayers();
				return;
			}
			_refreshTimer = 0f;
			Rebuild(departed);
			ResolvePlayers();
		}

		private void Rebuild(List<ulong>? departed)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: 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_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || !BackendSupported)
			{
				departed?.AddRange(_bySteamId.Keys);
				Reset();
				return;
			}
			if (LocalSteamId == 0L)
			{
				PlatformUserID platformUserID = ((IUser)PlatformManager.DistributionPlatform.LocalUser).PlatformUserID;
				ulong localSteamId = default(ulong);
				if (platformUserID.m_platform == "Steam" && ((PlatformUserID)(ref platformUserID)).TryParseAsUInt64(ref localSteamId))
				{
					LocalSteamId = localSteamId;
				}
			}
			_removed.Clear();
			_removed.AddRange(_bySteamId.Keys);
			List<PlayerInfo> playerList = ZNet.instance.GetPlayerList();
			ulong num = default(ulong);
			for (int i = 0; i < playerList.Count; i++)
			{
				PlayerInfo val = playerList[i];
				if (!(val.m_userInfo.m_id.m_platform != "Steam") && ((PlatformUserID)(ref val.m_userInfo.m_id)).TryParseAsUInt64(ref num) && num != 0L && num != LocalSteamId)
				{
					_removed.Remove(num);
					if (!_bySteamId.TryGetValue(num, out RosterEntry value))
					{
						value = new RosterEntry
						{
							SteamId = num
						};
						_bySteamId[num] = value;
						_entries.Add(value);
					}
					value.Name = val.m_name;
					if (value.CharacterId != val.m_characterID)
					{
						value.CharacterId = val.m_characterID;
						value.Player = null;
					}
					if (val.m_publicPosition)
					{
						value.LastKnownPosition = val.m_position;
						value.HasPosition = true;
					}
				}
			}
			for (int j = 0; j < _removed.Count; j++)
			{
				ulong num2 = _removed[j];
				if (_bySteamId.TryGetValue(num2, out RosterEntry value2))
				{
					_bySteamId.Remove(num2);
					_entries.Remove(value2);
					departed?.Add(num2);
				}
			}
		}

		private void ResolvePlayers()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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)
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			for (int i = 0; i < _entries.Count; i++)
			{
				RosterEntry rosterEntry = _entries[i];
				if ((Object)(object)rosterEntry.Player != (Object)null && !Object.op_Implicit((Object)(object)rosterEntry.Player))
				{
					rosterEntry.Player = null;
				}
				if ((Object)(object)rosterEntry.Player == (Object)null && !((ZDOID)(ref rosterEntry.CharacterId)).IsNone())
				{
					GameObject val = ZNetScene.instance.FindInstance(rosterEntry.CharacterId);
					if ((Object)(object)val != (Object)null)
					{
						rosterEntry.Player = val.GetComponent<Player>();
					}
				}
				if ((Object)(object)rosterEntry.Player != (Object)null && Object.op_Implicit((Object)(object)rosterEntry.Player))
				{
					rosterEntry.LastKnownPosition = ((Component)rosterEntry.Player).transform.position;
					rosterEntry.HasPosition = true;
				}
			}
		}
	}
	internal sealed class PeerLink
	{
		private const float TransmitHold = 0.3f;

		internal ushort LastSequence;

		internal int Lost;

		internal int Received;

		internal byte ReportedLossPercent;

		internal bool InRange;

		internal float Distance;

		internal float LastFrameTime;

		internal bool Transmitting
		{
			get
			{
				if (LastFrameTime > 0f)
				{
					return Time.unscaledTime - LastFrameTime < 0.3f;
				}
				return false;
			}
		}
	}
	internal sealed class VoiceRuntime : MonoBehaviour
	{
		private const float LinkCheckInterval = 1f;

		private const int PcmBufferSeconds = 2;

		private const int EncodedFrameSlots = 32;

		private const int LossReportWindow = 20;

		private const int PercentFull = 100;

		internal const ulong LoopbackId = 1uL;

		internal static VoiceRuntime? Instance;

		internal static bool LocalTestRequested;

		private readonly VoiceRoster _roster = new VoiceRoster();

		private readonly Dictionary<ulong, PeerLink> _links = new Dictionary<ulong, PeerLink>();

		private readonly List<ulong> _departed = new List<ulong>();

		private readonly byte[] _lossPayload = new byte[1];

		private readonly PcmRingBuffer _pcm = new PcmRingBuffer(96000);

		private readonly EncodedFrameRing _encoded = new EncodedFrameRing(32);

		private SteamVoiceTransport? _transport;

		private SpatialPlayback? _playback;

		private MicrophoneCapture? _capture;

		private VoiceEncoder? _encoder;

		private string _activeDevice = "";

		private float _linkTimer;

		private uint _startTicks;

		private ushort _loopbackSequence;

		private bool _loggedLoopback;

		internal VoiceRoster Roster => _roster;

		internal IReadOnlyDictionary<ulong, PeerLink> Links => _links;

		internal SteamVoiceTransport? Transport => _transport;

		internal MicrophoneCapture? Capture => _capture;

		internal SpatialPlayback? Playback => _playback;

		internal VoiceEncoder? Encoder => _encoder;

		private uint NowMs => (uint)(Environment.TickCount - _startTicks);

		private void Awake()
		{
			Instance = this;
			_startTicks = (uint)Environment.TickCount;
		}

		private void OnDestroy()
		{
			Shutdown();
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		private void OnApplicationQuit()
		{
			Shutdown();
		}

		internal void Shutdown()
		{
			StopAudio();
			MusicDucking.Reset();
			_playback?.Dispose();
			_playback = null;
			VoiceMixer.Reset();
			_transport?.Dispose();
			_transport = null;
			_roster.Reset();
			_links.Clear();
			_loggedLoopback = false;
		}

		private void StopAudio()
		{
			_encoder?.Dispose();
			_encoder = null;
			_capture?.Dispose();
			_capture = null;
			_pcm.Clear();
			_encoded.Clear();
			_activeDevice = "";
		}

		private void Update()
		{
			float unscaledDeltaTime = Time.unscaledDeltaTime;
			if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsDedicated() || !VoiceRoster.BackendSupported)
			{
				if (_transport != null)
				{
					Shutdown();
				}
				if (LocalTestRequested)
				{
					TickLocalTest(unscaledDeltaTime);
				}
				else if (_capture != null || _playback != null)
				{
					Shutdown();
				}
				return;
			}
			if (_transport == null)
			{
				_transport = new SteamVoiceTransport(_roster.IsKnownPeer);
			}
			if (_playback == null)
			{
				_playback = new SpatialPlayback(((Component)this).transform);
			}
			_departed.Clear();
			_roster.Refresh(unscaledDeltaTime, _departed);
			for (int i = 0; i < _departed.Count; i++)
			{
				_transport.CloseSession(_departed[i]);
				_links.Remove(_departed[i]);
				_playback.Remove(_departed[i]);
			}
			UpdateRanges();
			UpdateAudio(unscaledDeltaTime);
			_transport.Pump(unscaledDeltaTime, OnPacket);
			_playback.Tick(unscaledDeltaTime, _roster);
			MusicDucking.Tick(unscaledDeltaTime, _playback.AnyoneSpeaking);
			_linkTimer += unscaledDeltaTime;
			if (_linkTimer >= 1f)
			{
				_linkTimer = 0f;
				SendLinkChecks();
			}
		}

		private void TickLocalTest(float deltaTime)
		{
			if (_playback == null)
			{
				_playback = new SpatialPlayback(((Component)this).transform);
			}
			UpdateAudio(deltaTime);
			_playback.Tick(deltaTime, _roster);
		}

		private void UpdateAudio(float deltaTime)
		{
			if (ProximityVoiceChatPlugin.EnableVoice.Value == ProximityVoiceChatPlugin.Toggle.Off)
			{
				if (_capture != null)
				{
					StopAudio();
				}
				return;
			}
			string value = ProximityVoiceChatPlugin.InputDevice.Value;
			if (_capture != null && value != _activeDevice)
			{
				StopAudio();
			}
			if (_capture == null)
			{
				MicrophoneCapture microphoneCapture = new MicrophoneCapture(_pcm);
				if (!microphoneCapture.Start(value))
				{
					microphoneCapture.Dispose();
					return;
				}
				VoiceEncoder voiceEncoder = new VoiceEncoder(_pcm, _encoded);
				try
				{
					voiceEncoder.Start();
				}
				catch (Exception ex)
				{
					ProximityVoiceChatPlugin.Log.LogError((object)("Could not start the Opus encoder: " + ex.Message));
					voiceEncoder.Dispose();
					microphoneCapture.Dispose();
					return;
				}
				_capture = microphoneCapture;
				_encoder = voiceEncoder;
				_activeDevice = value;
			}
			_capture.Poll(deltaTime);
			if (_capture.Dead)
			{
				StopAudio();
			}
			else if (_encoder != null)
			{
				VoiceEncoder? encoder = _encoder;
				encoder.SetGateOpen(GateOpen());
				int num = ProximityVoiceChatPlugin.ExpectedPacketLoss.Value;
				if (ProximityVoiceChatPlugin.AdaptiveFec.Value.IsOn())
				{
					num = Math.Max(num, WorstReportedLoss());
				}
				encoder.SetAutoGain(ProximityVoiceChatPlugin.AutoGain.Value.IsOn(), ProximityVoiceChatPlugin.AutoGainTarget.Value);
				encoder.SetTuning(ProximityVoiceChatPlugin.MicGain.Value, ProximityVoiceChatPlugin.ActivationThreshold.Value, ProximityVoiceChatPlugin.Bitrate.Value, num, ProximityVoiceChatPlugin.UseDtx.Value.IsOn());
				DrainEncodedFrames();
			}
		}

		internal static bool GateOpen()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (ProximityVoiceChatPlugin.MuteSelf.Value.IsOn())
			{
				return false;
			}
			if (ProximityVoiceChatPlugin.Deafen.Value.IsOn())
			{
				return false;
			}
			if ((Object)(object)Chat.instance != (Object)null && Chat.instance.HasFocus())
			{
				return false;
			}
			if (ProximityVoiceChatPlugin.UseVoiceActivation.Value.IsOn())
			{
				return true;
			}
			return ProximityVoiceChatPlugin.PushToTalkKey.Value.IsKeyHeld();
		}

		private void DrainEncodedFrames()
		{
			bool flag = ProximityVoiceChatPlugin.LoopbackTest.Value.IsOn();
			EncodedFrame encodedFrame;
			while ((encodedFrame = _encoded.BeginRead()) != null)
			{
				ushort sequence;
				if (_transport != null)
				{
					_transport.AdvanceFrameSequence();
					sequence = _transport.FrameSequence;
				}
				else
				{
					sequence = _loopbackSequence++;
				}
				if (flag)
				{
					PushLoopback(encodedFrame, sequence);
				}
				if (_transport != null)
				{
					IReadOnlyList<RosterEntry> entries = _roster.Entries;
					for (int i = 0; i < entries.Count; i++)
					{
						RosterEntry rosterEntry = entries[i];
						if (_links.TryGetValue(rosterEntry.SteamId, out PeerLink value) && value.InRange)
						{
							_transport.Send(rosterEntry.SteamId, VoicePacketType.Frame, encodedFrame.Flags, encodedFrame.TimestampMs, encodedFrame.Data, 0, encodedFrame.Length);
						}
					}
				}
				_encoded.CommitRead();
			}
		}

		private void PushLoopback(EncodedFrame frame, ushort sequence)
		{
			if (_playback != null)
			{
				VoiceHeader header = new VoiceHeader
				{
					Type = VoicePacketType.Frame,
					Flags = frame.Flags,
					Sequence = sequence,
					TimestampMs = frame.TimestampMs,
					PayloadLength = (ushort)frame.Length
				};
				if (!_loggedLoopback)
				{
					_loggedLoopback = true;
					ProximityVoiceChatPlugin.Log.LogInfo((object)$"Loopback got its first frame, {frame.Length} bytes");
				}
				_playback.Push(1uL, in header, frame.Data, 0, frame.Length);
			}
		}

		private void UpdateRanges()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !Object.op_Implicit((Object)(object)localPlayer))
			{
				return;
			}
			Vector3 position = ((Component)localPlayer).transform.position;
			float value = ProximityVoiceChatPlugin.MaxRange.Value;
			float num = value + ProximityVoiceChatPlugin.RangeHysteresis.Value;
			IReadOnlyList<RosterEntry> entries = _roster.Entries;
			for (int i = 0; i < entries.Count; i++)
			{
				RosterEntry rosterEntry = entries[i];
				PeerLink link = GetLink(rosterEntry.SteamId);
				if (!rosterEntry.HasPosition)
				{
					link.InRange = false;
					link.Distance = float.PositiveInfinity;
				}
				else
				{
					link.Distance = Vector3.Distance(position, rosterEntry.LastKnownPosition);
					link.InRange = link.Distance <= (link.InRange ? num : value);
				}
			}
		}

		private PeerLink GetLink(ulong steamId)
		{
			if (!_links.TryGetValue(steamId, out PeerLink value))
			{
				value = new PeerLink();
				_links[steamId] = value;
			}
			return value;
		}

		private static byte TakeLossPercent(PeerLink link)
		{
			int num = link.Lost + link.Received;
			if (num < 20)
			{
				return 0;
			}
			byte result = (byte)Mathf.Clamp(Mathf.RoundToInt(100f * (float)link.Lost / (float)num), 0, 100);
			link.Lost = 0;
			link.Received = 0;
			return result;
		}

		private int WorstReportedLoss()
		{
			int num = 0;
			foreach (KeyValuePair<ulong, PeerLink> link in _links)
			{
				if (link.Value.InRange && link.Value.ReportedLossPercent > num)
				{
					num = link.Value.ReportedLossPercent;
				}
			}
			return num;
		}

		private void SendLinkChecks()
		{
			if (_transport == null)
			{
				return;
			}
			uint nowMs = NowMs;
			_transport.AdvanceControlSequence();
			IReadOnlyList<RosterEntry> entries = _roster.Entries;
			for (int i = 0; i < entries.Count; i++)
			{
				RosterEntry rosterEntry = entries[i];
				if (!_links.TryGetValue(rosterEntry.SteamId, out PeerLink value) || value.InRange)
				{
					_transport.Send(rosterEntry.SteamId, VoicePacketType.Ping, VoiceFlags.None, nowMs, _lossPayload, 0, 0);
				}
			}
		}

		private void OnPacket(ulong senderSteamId, in VoiceHeader header, byte[] buffer, int offset, int length)
		{
			if (_transport == null)
			{
				return;
			}
			PeerLink link = GetLink(senderSteamId);
			if (header.Type == VoicePacketType.Frame)
			{
				link.Received++;
				if (length > 0 && (header.Flags & VoiceFlags.EndOfTalkspurt) == 0)
				{
					link.LastFrameTime = Time.unscaledTime;
				}
				int num = VoiceWireFormat.SequenceDelta(header.Sequence, link.LastSequence);
				if (num > 1)
				{
					link.Lost += num - 1;
				}
				if (num > 0)
				{
					link.LastSequence = header.Sequence;
				}
			}
			switch (header.Type)
			{
			case VoicePacketType.Ping:
				_lossPayload[0] = TakeLossPercent(link);
				_transport.Send(senderSteamId, VoicePacketType.Pong, VoiceFlags.None, NowMs, _lossPayload, 0, 1);
				break;
			case VoicePacketType.Pong:
				if (length >= 1)
				{
					link.ReportedLossPercent = buffer[offset];
				}
				break;
			case VoicePacketType.Frame:
				_playback?.Push(senderSteamId, in header, buffer, offset, length);
				break;
			case VoicePacketType.Hello:
			case VoicePacketType.Bye:
				break;
			}
		}
	}
}
namespace ProximityVoiceChat.Voice.Audio
{
	internal sealed class JitterEstimator
	{
		private const int OffsetWindow = 100;

		private const float TimeWindow = 0.25f;

		private const int Capacity = 64;

		private readonly double[] _offsets = new double[100];

		private int _offsetCount;

		private int _offsetHead;

		private double _offsetSum;

		private readonly double[] _deviation = new double[64];

		private readonly double[] _arrived = new double[64];

		private int _count;

		private int _head;

		internal float JitterSeconds { get; private set; }

		internal void Reset()
		{
			_offsetCount = 0;
			_offsetHead = 0;
			_offsetSum = 0.0;
			_count = 0;
			_head = 0;
			JitterSeconds = 0f;
		}

		internal void Sample(double remoteSeconds, double localSeconds)
		{
			double num = localSeconds - remoteSeconds;
			if (_offsetCount == 100)
			{
				_offsetSum -= _offsets[_offsetHead];
				_offsets[_offsetHead] = num;
				_offsetHead = (_offsetHead + 1) % 100;
			}
			else
			{
				_offsets[(_offsetHead + _offsetCount) % 100] = num;
				_offsetCount++;
			}
			_offsetSum += num;
			double num2 = _offsetSum / (double)_offsetCount;
			int num3 = (_head + _count) % 64;
			if (_count == 64)
			{
				_head = (_head + 1) % 64;
				num3 = (_head + _count - 1) % 64;
			}
			else
			{
				_count++;
			}
			_deviation[num3] = num - num2;
			_arrived[num3] = localSeconds;
			double num4 = 0.0;
			int num5 = 0;
			for (int i = 0; i < _count; i++)
			{
				int num6 = (_head + i) % 64;
				if (!(localSeconds - _arrived[num6] > 0.25))
				{
					num4 += _deviation[num6] * _deviation[num6];
					num5++;
				}
			}
			JitterSeconds = ((num5 > 0) ? ((float)Math.Sqrt(num4 / (double)num5)) : 0f);
		}
	}
	internal static class AudioFormat
	{
		internal const int SampleRate = 48000;

		internal const int Channels = 1;

		internal const int FrameMs = 20;

		internal const int FrameSamples = 960;

		private const float SoftClipKnee = 0.6f;

		private const float SoftClipRange = 0.39999998f;

		internal static bool IsOpusRate(int rate)
		{
			if (rate != 8000 && rate != 12000 && rate != 16000 && rate != 24000)
			{
				return rate == 48000;
			}
			return true;
		}

		internal static float SoftClip(float sample)
		{
			float num = ((sample < 0f) ? (0f - sample) : sample);
			if (num <= 0.6f)
			{
				return sample;
			}
			float num2 = (num - 0.6f) / 0.39999998f;
			float num3 = 0.6f + 0.39999998f * (float)Math.Tanh(num2);
			if (!(sample < 0f))
			{
				return num3;
			}
			return 0f - num3;
		}
	}
	internal sealed class EncodedFrame
	{
		internal readonly byte[] Data = new byte[1100];

		internal int Length;

		internal uint TimestampMs;

		internal VoiceFlags Flags;
	}
	internal sealed class EncodedFrameRing
	{
		private readonly EncodedFrame[] _slots;

		private readonly int _capacity;

		private int _write;

		private int _read;

		internal int Overruns;

		internal EncodedFrameRing(int capacity)
		{
			_capacity = capacity;
			_slots = new EncodedFrame[capacity];
			for (int i = 0; i < capacity; i++)
			{
				_slots[i] = new EncodedFrame();
			}
		}

		internal EncodedFrame? BeginWrite()
		{
			int write = _write;
			if ((write + 1) % _capacity == Volatile.Read(in _read))
			{
				Overruns++;
				return null;
			}
			return _slots[write];
		}

		internal void CommitWrite()
		{
			Volatile.Write(ref _write, (_write + 1) % _capacity);
		}

		internal EncodedFrame? BeginRead()
		{
			int read = _read;
			if (read == Volatile.Read(in _write))
			{
				return null;
			}
			return _slots[read];
		}

		internal void CommitRead()
		{
			Volatile.Write(ref _read, (_read + 1) % _capacity);
		}

		internal void Clear()
		{
			Volatile.Write(ref _read, 0);
			Volatile.Write(ref _write, 0);
		}
	}
	internal sealed class MicrophoneCapture : IDisposable
	{
		private const int ClipSeconds = 1;

		private const int ChunksPerSecond = 100;

		private const float RecoveryInterval = 2f;

		private const float DeviceScanInterval = 1f;

		private const float ToneHz = 200f;

		private const float ToneAmplitude = 0.2f;

		private const float PeakDecayPerChunk = 0.02f;

		private const int ResampleSlack = 4;

		private const int ResampleGrowth = 2;

		private readonly PcmRingBuffer _ring;

		private float[] _chunk = Array.Empty<float>();

		private float[] _mono = Array.Empty<float>();

		private float[] _resampled = Array.Empty<float>();

		private AudioClip? _clip;

		private string? _device;

		private int _frames;

		private int _chunkFrames;

		private int _channels = 1;

		private int _deviceRate;

		private int _readPos;

		private float _resamplePos;

		private float _recoveryTimer;

		private float _deviceScanTimer;

		private string[] _knownDevices = Array.Empty<string>();

		private float _tonePhase;

		private float _toneCarry;

		private readonly float[] _toneChunk = new float[960];

		private bool _disposed;

		internal float PeakLevel { get; private set; }

		internal bool Dead
		{
			get
			{
				if (!((Object)(object)_clip == (Object)null))
				{
					return _device == null;
				}
				return true;
			}
		}

		internal bool IsCapturing
		{
			get
			{
				if ((Object)(object)_clip != (Object)null && _device != null)
				{
					return Microphone.IsRecording(_device);
				}
				return false;
			}
		}

		internal string? Device => _device;

		internal int DeviceRate => _deviceRate;

		internal int Channels => _channels;

		internal static string[] Devices => Microphone.devices;

		internal MicrophoneCapture(PcmRingBuffer ring)
		{
			_ring = ring;
		}

		internal bool Start(string requestedDevice)
		{
			if (_disposed)
			{
				return false;
			}
			Stop();
			string[] devices = Microphone.devices;
			if (devices.Length == 0)
			{
				ProximityVoiceChatPlugin.Log.LogWarning((object)"No microphone devices, voice capture stays off");
				return false;
			}
			string text = requestedDevice;
			if (string.IsNullOrEmpty(text) || Array.IndexOf(devices, text) < 0)
			{
				text = devices[0];
			}
			_deviceRate = ResolveRate(text);
			AudioClip val = Microphone.Start(text, true, 1, _deviceRate);
			if ((Object)(object)val == (Object)null)
			{
				ProximityVoiceChatPlugin.Log.LogError((object)("Microphone.Start failed for \"" + text + "\""));
				return false;
			}
			_clip = val;
			_device = text;
			_channels = Mathf.Max(1, val.channels);
			_frames = val.samples;
			_chunkFrames = Math.Max(1, _frames / 100);
			if (_chunk.Length != _chunkFrames * _channels)
			{
				_chunk = new float[_chunkFrames * _channels];
			}
			if (_mono.Length != _chunkFrames)
			{
				_mono = new float[_chunkFrames];
			}
			_readPos = 0;
			_resamplePos = 0f;
			_recoveryTimer = 0f;
			_ring.Clear();
			ProximityVoiceChatPlugin.Log.LogInfo((object)$"Capturing from \"{text}\" at {_deviceRate} Hz, {_channels} ch, {_chunkFrames} frame chunks");
			return true;
		}

		private static int ResolveRate(string device)
		{
			int num = default(int);
			int num2 = default(int);
			Microphone.GetDeviceCaps(device, ref num, ref num2);
			if (num == 0 && num2 == 0)
			{
				return 48000;
			}
			if (48000 >= num && 48000 <= num2)
			{
				return 48000;
			}
			return Mathf.Clamp(48000, num, num2);
		}

		internal void Stop()
		{
			if (_device != null && Microphone.IsRecording(_device))
			{
				Microphone.End(_device);
			}
			if ((Object)(object)_clip != (Object)null)
			{
				Object.Destroy((Object)(object)_clip);
				_clip = null;
			}
			_device = null;
			_frames = 0;
			_chunkFrames = 0;
			_channels = 1;
			_readPos = 0;
			PeakLevel = 0f;
		}

		internal void Poll(float deltaTime)
		{
			if (_disposed || (Object)(object)_clip == (Object)null || _device == null)
			{
				return;
			}
			ScanDevices(deltaTime);
			if (ProximityVoiceChatPlugin.TestTone.Value.IsOn())
			{
				PushTone(deltaTime);
				return;
			}
			if (!Microphone.IsRecording(_device))
			{
				Recover(deltaTime);
				return;
			}
			_recoveryTimer = 0f;
			int position = Microphone.GetPosition(_device);
			if (position < 0 || position > _frames)
			{
				return;
			}
			int num = 101;
			while (num-- > 0 && Pending(position) >= _chunkFrames)
			{
				if (_readPos + _chunkFrames > _frames)
				{
					_readPos = 0;
					continue;
				}
				if (!_clip.GetData(_chunk, _readPos))
				{
					break;
				}
				_readPos += _chunkFrames;
				if (_readPos >= _frames)
				{
					_readPos = 0;
				}
				Downmix();
				TrackPeak(_mono, _chunkFrames);
				if (_deviceRate == 48000)
				{
					_ring.Write(_mono, 0, _chunkFrames);
					continue;
				}
				int count = Resample();
				_ring.Write(_resampled, 0, count);
			}
		}

		private void ScanDevices(float deltaTime)
		{
			_deviceScanTimer += deltaTime;
			if (_deviceScanTimer < 1f)
			{
				return;
			}
			_deviceScanTimer = 0f;
			string[] devices = Microphone.devices;
			bool flag = devices.Length != _knownDevices.Length;
			if (!flag)
			{
				for (int i = 0; i < devices.Length; i++)
				{
					if (Array.IndexOf(_knownDevices, devices[i]) < 0)
					{
						flag = true;
						break;
					}
				}
			}
			if (flag)
			{
				_knownDevices = devices;
				if (_device != null && Array.IndexOf<string>(devices, _device) < 0)
				{
					ProximityVoiceChatPlugin.Log.LogWarning((object)("Microphone \"" + _device + "\" went away, dropping capture"));
					Stop();
				}
				else
				{
					ProximityVoiceChatPlugin.Log.LogInfo((object)$"Microphone list changed, {devices.Length} device(s) now");
				}
			}
		}

		private void PushTone(float deltaTime)
		{
			_toneCarry += deltaTime * 48000f;
			int num = (int)_toneCarry;
			if (num <= 0)
			{
				return;
			}
			_toneCarry -= num;
			float num2 = (float)Math.PI / 120f;
			while (num > 0)
			{
				int num3 = Math.Min(num, _toneChunk.Length);
				for (int i = 0; i < num3; i++)
				{
					_toneChunk[i] = Mathf.Sin(_tonePhase) * 0.2f;
					_tonePhase += num2;
					if (_tonePhase > (float)Math.PI * 2f)
					{
						_tonePhase -= (float)Math.PI * 2f;
					}
				}
				_ring.Write(_toneChunk, 0, num3);
				num -= num3;
			}
			PeakLevel = 0.2f;
		}

		internal void ProbeRaw()
		{
			if ((Object)(object)_clip == (Object)null || _device == null)
			{
				ProximityVoiceChatPlugin.Log.LogWarning((object)"Mic probe: not capturing");
				return;
			}
			float[] array = new float[_frames * _channels];
			if (!_clip.GetData(array, 0))
			{
				ProximityVoiceChatPlugin.Log.LogWarning((object)"Mic probe: GetData refused");
				return;
			}
			float num = 0f;
			double num2 = 0.0;
			int num3 = 0;
			foreach (float num4 in array)
			{
				if (num4 == 0f)
				{
					num3++;
				}
				float num5 = ((num4 < 0f) ? (0f - num4) : num4);
				if (num5 > num)
				{
					num = num5;
				}
				num2 += (double)num4 * (double)num4;
			}
			float num6 = (float)Math.Sqrt(num2 / (double)array.Length);
			float num7 = 100f * (float)num3 / (float)array.Length;
			int position = Microphone.GetPosition(_device);
			ProximityVoiceChatPlugin.Log.LogInfo((object)($"Mic probe on \"{_device}\": peak {num:0.0000} rms {num6:0.0000} exact zeros {num7:0.0}% " + $"over {_frames} frames x {_channels} ch, writePos {position}, myReadPos {_readPos}"));
		}

		private void Downmix()
		{
			if (_channels == 1)
			{
				Array.Copy(_chunk, _mono, _chunkFrames);
				return;
			}
			float num = 1f / (float)_channels;
			int num2 = 0;
			for (int i = 0; i < _chunkFrames; i++)
			{
				float num3 = 0f;
				for (int j = 0; j < _channels; j++)
				{
					num3 += _chunk[num2++];
				}
				_mono[i] = num3 * num;
			}
		}

		private int Pending(int writePos)
		{
			int num = writePos - _readPos;
			if (num >= 0)
			{
				return num;
			}
			return num + _frames;
		}

		private void Recover(float deltaTime)
		{
			_recoveryTimer += deltaTime;
			if (!(_recoveryTimer < 2f))
			{
				_recoveryTimer = 0f;
				string text = _device ?? string.Empty;
				ProximityVoiceChatPlugin.Log.LogWarning((object)("Microphone \"" + text + "\" stopped recording, restarting it"));
				Start(text);
			}
		}

		private int Resample()
		{
			float num = (float)_deviceRate / 48000f;
			int num2 = (int)((float)_chunkFrames / num) + 4;
			if (_resampled.Length < num2)
			{
				_resampled = new float[num2 * 2];
			}
			int num3 = 0;
			while (_resamplePos < (float)_chunkFrames && num3 < _resampled.Length)
			{
				int num4 = (int)_resamplePos;
				float num5 = _resamplePos - (float)num4;
				float num6 = _mono[num4];
				float num7 = ((num4 + 1 < _chunkFrames) ? _mono[num4 + 1] : num6);
				_resampled[num3++] = Mathf.Lerp(num6, num7, num5);
				_resamplePos += num;
			}
			_resamplePos -= _chunkFrames;
			if (_resamplePos < 0f)
			{
				_resamplePos = 0f;
			}
			return num3;
		}

		private void TrackPeak(float[] samples, int count)
		{
			float num = 0f;
			for (int i = 0; i < count; i++)
			{
				float num2 = ((samples[i] < 0f) ? (0f - samples[i]) : samples[i]);
				if (num2 > num)
				{
					num = num2;
				}
			}
			PeakLevel = Mathf.Max(num, PeakLevel - 0.02f);
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				_disposed = true;
				Stop();
			}
		}
	}
	internal sealed class PeerVoiceStream : IDisposable
	{
		private const int FramesPerClip = 50;

		private const float SecondsPerFrame = 0.02f;

		private const float ClipSeconds = 1f;

		private const float FrameLifetime = 0.5f;

		private const int GuardFrames = 25;

		private const int EndOfTalkspurtClear = 25;

		private const float MaxNegativeLatency = 0.25f;

		private const float PitchGain = 0.4f;

		private const float PitchMaxCorrection = 0.03f;

		private const float ResyncError = 0.25f;

		private const float IdleTimeout = 8f;

		private const float SpeakingHold = 0.2f;

		private const float StallFrames = 2f;

		private const float DrainMargin = 4f;

		private const float JitterSigma = 2f;

		private const float MinTargetLatency = 0.02f;

		internal const float OpenCutoff = 22000f;

		private const float CutoffPerSecond = 26000f;

		private const float OcclusionInterval = 0.2f;

		private const float MuffleVolumePerSecond = 2f;

		private const int SourcePriority = 64;

		private const float SourceSpread = 35f;

		private const float RolloffKnee = 0.45f;

		private const float RolloffKneeVolume = 0.6f;

		private const float RolloffSmoothing = 0.6f;

		private readonly ulong _steamId;

		private readonly bool _spatial;

		private readonly int[] _slotFrame = new int[50];

		private readonly float[] _decodedFrame = new float[960];

		private readonly float[] _emptyFrame = new float[960];

		private readonly float[] _emptyClip = new float[48000];

		private readonly Stopwatch _sinceFrame = new Stopwatch();

		private readonly Stopwatch _sinceOpen = Stopwatch.StartNew();

		private readonly JitterEstimator _jitter = new JitterEstimator();

		private OpusDecoder? _decoder;

		private GameObject? _object;

		private AudioSource? _source;

		private AudioLowPassFilter? _lowPass;

		private float _cutoff = 22000f;

		private float _muffleVolume = 1f;

		private float _occlusionTimer;

		private bool _occluded;

		private static int _viewBlockMask;

		private AudioClip? _clip;

		private int _firstFrame = -1;

		private int _greatestFrame = -1;

		private int _absolute;

		private ushort _lastSequence;

		private bool _haveSequence;

		private bool _playing;

		private float _lastPacketTime;

		private float _minDistance = -1f;

		private float _maxDistance = -1f;

		private bool _disposed;

		private bool _loggedFirstDecode;

		private volatile float _gain = 1f;

		internal float OutputRms;

		internal ulong SteamId => _steamId;

		internal bool Speaking
		{
			get
			{
				if (_playing)
				{
					return _sinceFrame.Elapsed.TotalSeconds < 0.20000000298023224;
				}
				return false;
			}
		}

		internal bool Occluded => _occluded;

		internal float IdleFor => Time.unscaledTime - _lastPacketTime;

		internal bool Expired => IdleFor > 8f;

		internal PeerVoiceStream(ulong steamId, Transform parent, bool spatial)
		{
			_steamId = steamId;
			_spatial = spatial;
			_lastPacketTime = Time.unscaledTime;
			for (int i = 0; i < _slotFrame.Length; i++)
			{
				_slotFrame[i] = -1;
			}
			_decoder = new OpusDecoder(48000, 1);
			BuildSource(parent);
		}

		private void BuildSource(Transform parent)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			_object = new GameObject($"PVC_Voice_{_steamId}");
			_object.transform.SetParent(parent, false);
			_clip = AudioClip.Create($"PVC_{_steamId}", 48000, 1, 48000, false);
			_source = _object.AddComponent<AudioSource>();
			_source.clip = _clip;
			_source.loop = true;
			_source.playOnAwake = false;
			_source.dopplerLevel = 0f;
			_source.priority = 64;
			_source.bypassReverbZones = true;
			_source.spatialBlend = (_spatial ? 1f : 0f);
			if (_spatial)
			{
				_source.spread = 35f;
				_source.minDistance = ProximityVoiceChatPlugin.FullVolumeRange.Value;
				_source.maxDistance = ProximityVoiceChatPlugin.MaxRange.Value;
				bool flag = ProximityVoiceChatPlugin.VoiceReverb.Value.IsOn();
				_source.bypassReverbZones = !flag;
				_source.reverbZoneMix = (flag ? ProximityVoiceChatPlugin.ReverbMix.Value : 0f);
				ApplyRolloff();
				_lowPass = _object.AddComponent<AudioLowPassFilter>();
				_lowPass.cutoffFrequency = 22000f;
				_lowPass.lowpassResonanceQ = 1f;
			}
			_source.outputAudioMixerGroup = VoiceMixer.Group;
			_source.Stop();
		}

		internal void Push(in VoiceHeader header, byte[] buffer, int offset, int length)
		{
			if (_disposed || _decoder == null || (Object)(object)_clip == (Object)null)
			{
				return;
			}
			_lastPacketTime = Time.unscaledTime;
			_jitter.Sample((double)header.TimestampMs / 1000.0, _sinceOpen.Elapsed.TotalSeconds);
			if ((header.Flags & VoiceFlags.EndOfTalkspurt) != VoiceFlags.None || length == 0)
			{
				if (_greatestFrame >= 0)
				{
					ClearAhead(_greatestFrame, 25);
				}
				return;
			}
			int num = Unwrap(header.Sequence);
			if (_greatestFrame >= 0 && num <= _greatestFrame - 50)
			{
				return;
			}
			int num2;
			try
			{
				num2 = _decoder.Decode(buffer, offset, length, _decodedFrame, 0, 960);
			}
			catch (Exception ex)
			{
				ProximityVoiceChatPlugin.Log.LogWarning((object)$"Opus decode failed for {_steamId}: {ex.Message}");
				return;
			}
			if (num2 > 0)
			{
				float gain = _gain;
				double num3 = 0.0;
				for (int i = 0; i < num2; i++)
				{
					float num4 = AudioFormat.SoftClip(_decodedFrame[i] * gain);
					_decodedFrame[i] = num4;
					num3 += (double)num4 * (double)num4;
				}
				OutputRms = (float)Math.Sqrt(num3 / (double)num2);
				int num5 = Mod(num, 50);
				_clip.SetData(_decodedFrame, num5 * 960);
				_slotFrame[num5] = num;
				ClearAhead(num, 25);
				if (_firstFrame < 0)
				{
					_firstFrame = num;
				}
				if (num > _greatestFrame)
				{
					_greatestFrame = num;
				}
				_sinceFrame.Restart();
				if (!_loggedFirstDecode)
				{
					_loggedFirstDecode = true;
					ProximityVoiceChatPlugin.Log.LogInfo((object)$"Decoding audio from {_steamId}, {num2} samples per frame");
				}
			}
		}

		internal void Tick(float deltaTime)
		{
			if (_disposed || (Object)(object)_source == (Object)null || (Object)(object)_clip == (Object)null)
			{
				return;
			}
			float num = (float)_sinceFrame.Elapsed.TotalSeconds;
			if (_playing && num > TargetLatency() + 0.08f)
			{
				Reset();
				return;
			}
			if (!_playing)
			{
				if (_greatestFrame < 0 || (float)(_greatestFrame - _firstFrame + 1) * 0.02f + num < TargetLatency())
				{
					return;
				}
				_source.time = WrapTime((float)Mod(_firstFrame, 50) * 0.02f);
				_source.Play();
				_playing = true;
			}
			if (num > 0.04f)
			{
				_source.pitch = 1f;
				ClearOldFrames();
				return;
			}
			float num2 = Latency() - TargetLatency();
			if (Mathf.Abs(num2) > 0.25f)
			{
				_source.time = WrapTime((float)Mod(_greatestFrame, 50) * 0.02f - TargetLatency());
				_source.pitch = 1f;
			}
			else
			{
				_source.pitch = 1f + Mathf.Clamp(num2 * 0.4f, -0.03f, 0.03f);
			}
			ClearOldFrames();
		}

		private float TargetLatency()
		{
			float num = Mathf.Max(0.02f, (float)ProximityVoiceChatPlugin.JitterTargetMs.Value / 1000f);
			if (ProximityVoiceChatPlugin.AdaptiveJitter.Value.IsOn())
			{
				num += 2f * _jitter.JitterSeconds;
			}
			return Mathf.Min(num, (float)ProximityVoiceChatPlugin.JitterMaxMs.Value / 1000f);
		}

		private float Latency()
		{
			if ((Object)(object)_source == (Object)null || _greatestFrame < 0)
			{
				return 0f;
			}
			float num = (float)Mod(_greatestFrame, 50) * 0.02f - _source.time;
			if (num < 0f)
			{
				num += 1f;
			}
			if (0.75f < num)
			{
				num -= 1f;
			}
			return num + (float)_sinceFrame.Elapsed.TotalSeconds;
		}

		private void ClearAhead(int index, int count)
		{
			if ((Object)(object)_clip == (Object)null)
			{
				return;
			}
			for (int i = 1; i <= count; i++)
			{
				int num = Mod(index + i, 50);
				if (_slotFrame[num] >= 0 && _slotFrame[num] < index)
				{
					_clip.SetData(_emptyFrame, num * 960);
					_slotFrame[num] = -1;
				}
			}
		}

		private void ClearOldFrames()
		{
			if ((Object)(object)_clip == (Object)null)
			{
				return;
			}
			for (int i = 0; i < _slotFrame.Length; i++)
			{
				int num = _slotFrame[i];
				if (num >= 0 && !((float)(_greatestFrame - num) * 0.02f <= 0.5f))
				{
					_clip.SetData(_emptyFrame, i * 960);
					_slotFrame[i] = -1;
				}
			}
		}

		private void Reset()
		{
			AudioSource? source = _source;
			if (source != null)
			{
				source.Stop();
			}
			AudioClip? clip = _clip;
			if (clip != null)
			{
				clip.SetData(_emptyClip, 0);
			}
			for (int i = 0; i < _slotFrame.Length; i++)
			{
				_slotFrame[i] = -1;
			}
			_playing = false;
			_firstFrame = -1;
			_greatestFrame = -1;
			_sinceFrame.Reset();
			_jitter.Reset();
		}

		private int Unwrap(ushort sequence)
		{
			if (!_haveSequence)
			{
				_haveSequence = true;
				_absolute = sequence;
			}
			else
			{
				_absolute += VoiceWireFormat.SequenceDelta(sequence, _lastSequence);
			}
			_lastSequence = sequence;
			return _absolute;
		}

		private static float WrapTime(float time)
		{
			time %= 1f;
			if (time < 0f)
			{
				time += 1f;
			}
			return Mathf.Min(time, 0.98f);
		}

		private static int Mod(int value, int modulus)
		{
			int num = value % modulus;
			if (num >= 0)
			{
				return num;
			}
			return num + modulus;
		}

		internal bool CheckOccluded(Vector3 from, Vector3 to, float deltaTime)
		{
			//IL_007d: 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)
			_occlusionTimer -= deltaTime;
			if (_occlusionTimer > 0f)
			{
				return _occluded;
			}
			_occlusionTimer = 0.2f;
			if (_viewBlockMask == 0)
			{
				_viewBlockMask = LayerMask.GetMask(new string[7] { "Default", "static_solid", "Default_small", "piece", "terrain", "viewblock", "vehicle" });
			}
			_occluded = Physics.Linecast(from, to, _viewBlockMask);
			return _occluded;
		}

		internal void SetMuffle(float targetCutoff, float targetVolume, float deltaTime)
		{
			_muffleVolume = Mathf.MoveTowards(_muffleVolume, targetVolume, 2f * deltaTime);
			if (!((Object)(object)_lowPass == (Object)null))
			{
				_cutoff = Mathf.MoveTowards(_cutoff, targetCutoff, 26000f * deltaTime);
				_lowPass.cutoffFrequency = _cutoff;
			}
		}

		internal void UpdateSpatial(Vector3 position, float volume)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (_disposed || (Object)(object)_object == (Object)null || (Object)(object)_source == (Object)null)
			{
				return;
			}
			volume *= _muffleVolume;
			_source.volume = ((volume > 1f) ? 1f : volume);
			_gain = ((volume > 1f) ? volume : 1f);
			if (_spatial)
			{
				_object.transform.position = position;
				float value = ProximityVoiceChatPlugin.FullVolumeRange.Value;
				float value2 = ProximityVoiceChatPlugin.MaxRange.Value;
				if (value != _minDistance || value2 != _maxDistance)
				{
					_minDistance = value;
					_maxDistance = value2;
					_source.minDistance = value;
					_source.maxDistance = value2;
					ApplyRolloff();
				}
			}
		}

		private void ApplyRolloff()
		{
			//IL_0048: 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)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			if (!((Object)(object)_source == (Object)null))
			{
				float num = Mathf.Clamp01(_source.minDistance / Mathf.Max(1f, _source.maxDistance));
				AnimationCurve val = new AnimationCurve((Keyframe[])(object)new Keyframe[4]
				{
					new Keyframe(0f, 1f),
					new Keyframe(num, 1f),
					new Keyframe(num + (1f - num) * 0.45f, 0.6f),
					new Keyframe(1f, 0f)
				});
				for (int i = 0; i < val.length; i++)
				{
					val.SmoothTangents(i, 0.6f);
				}
				_source.rolloffMode = (AudioRolloffMode)2;
				_source.SetCustomCurve((AudioSourceCurveType)0, val);
			}
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				_disposed = true;
				if ((Object)(object)_source != (Object)null)
				{
					_source.Stop();
					_source.clip = null;
					_source = null;
				}
				if ((Object)(object)_clip != (Object)null)
				{
					Object.Destroy((Object)(object)_clip);
					_clip = null;
				}
				if ((Object)(object)_object != (Object)null)
				{
					Object.Destroy((Object)(object)_object);
					_object = null;
				}
				_decoder = null;
			}
		}
	}
	internal static class VoiceMixer
	{
		private static AudioMixerGroup? _group;

		private static bool _resolved;

		internal static AudioMixerGroup? Group
		{
			get
			{
				if (_resolved)
				{
					return _group;
				}
				AudioMan instance = AudioMan.instance;
				if ((Object)(object)instance == (Object)null || (Object)(object)instance.m_masterMixer == (Object)null)
				{
					return null;
				}
				string[] array = new string[4] { "GUI", "SFX", "Sfx", "Master" };
				foreach (string text in array)
				{
					AudioMixerGroup[] array2 = instance.m_masterMixer.FindMatchingGroups(text);
					if (array2.Length != 0)
					{
						_group = array2[0];
						break;
					}
				}
				if (_group == null)
				{
					_group = instance.m_ambientMixer;
				}
				_resolved = true;
				ProximityVoiceChatPlugin.Log.LogInfo((object)(((Object)(object)_group != (Object)null) ? ("Voice routed through mixer group \"" + ((Object)_group).name + "\"") : "No mixer group found, voice goes straight to the master output"));
				return _group;
			}
		}

		internal static void Reset()
		{
			_group = null;
			_resolved = false;
		}
	}
	internal sealed class SpatialPlayback : IDisposable
	{
		private const float HeadHeight = 1.5f;

		private const float MonitorDistance = 3f;

		private readonly Dictionary<ulong, PeerVoiceStream> _streams = new Dictionary<ulong, PeerVoiceStream>();

		private readonly List<ulong> _reap = new List<ulong>();

		private GameObject? _root;

		private bool _disposed;

		internal IReadOnlyDictionary<ulong, PeerVoiceStream> Streams => _streams;

		internal bool AnyoneSpeaking
		{
			get
			{
				foreach (KeyValuePair<ulong, PeerVoiceStream> stream in _streams)
				{
					if (stream.Value.Speaking)
					{
						return true;
					}
				}
				return false;
			}
		}

		internal SpatialPlayback(Transform parent)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			_root = new GameObject("PVC_Voices");
			_root.transform.SetParent(parent, false);
		}

		internal void Push(ulong steamId, in VoiceHeader header, byte[] buffer, int offset, int length)
		{
			if (!_disposed && !((Object)(object)_root == (Object)null) && !PeerPreferences.IsSilenced(steamId) && !ProximityVoiceChatPlugin.Deafen.Value.IsOn())
			{
				if (!_streams.TryGetValue(steamId, out PeerVoiceStream value))
				{
					value = new PeerVoiceStream(steamId, _root.transform, steamId != 1);
					_streams[steamId] = value;
					ProximityVoiceChatPlugin.Log.LogInfo((object)$"Opened a voice stream for {steamId}");
				}
				value.Push(in header, buffer, offset, length);
			}
		}

		internal void Tick(float deltaTime, VoiceRoster roster)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			if (_disposed)
			{
				return;
			}
			float value = ProximityVoiceChatPlugin.VoiceVolume.Value;
			_reap.Clear();
			foreach (KeyValuePair<ulong, PeerVoiceStream> stream in _streams)
			{
				PeerVoiceStream value2 = stream.Value;
				if (value2.Expired)
				{
					_reap.Add(stream.Key);
					continue;
				}
				value2.Tick(deltaTime);
				float volume = ((stream.Key == 1) ? ProximityVoiceChatPlugin.MonitorVolume.Value : (value * PeerPreferences.GetVolume(stream.Key)));
				Vector3 position = ResolvePosition(roster, stream.Key);
				if (stream.Key != 1)
				{
					Muffle(value2, position, deltaTime);
				}
				value2.UpdateSpatial(position, volume);
			}
			for (int i = 0; i < _reap.Count; i++)
			{
				Remove(_reap[i]);
			}
		}

		private static void Muffle(PeerVoiceStream stream, Vector3 position, float deltaTime)
		{
			//IL_0079: 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)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !Object.op_Implicit((Object)(object)localPlayer))
			{
				stream.SetMuffle(22000f, 1f, deltaTime);
				return;
			}
			if (ProximityVoiceChatPlugin.UnderwaterMuffle.Value.IsOn() && ((Character)localPlayer).IsSwimming())
			{
				stream.SetMuffle(ProximityVoiceChatPlugin.UnderwaterCutoff.Value, 1f, deltaTime);
				return;
			}
			if (ProximityVoiceChatPlugin.Occlusion.Value == ProximityVoiceChatPlugin.Toggle.Off)
			{
				stream.SetMuffle(22000f, 1f, deltaTime);
				return;
			}
			bool flag = stream.CheckOccluded(((Character)localPlayer).GetHeadPoint(), position, deltaTime);
			stream.SetMuffle(flag ? ProximityVoiceChatPlugin.OccludedCutoff.Value : 22000f, flag ? ProximityVoiceChatPlugin.OccludedVolume.Value : 1f, deltaTime);
		}

		private static Vector3 ResolvePosition(VoiceRoster roster, ulong steamId)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_0094: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			bool flag = (Object)(object)localPlayer != (Object)null && Object.op_Implicit((Object)(object)localPlayer);
			if (steamId == 1)
			{
				if (!flag)
				{
					return Vector3.zero;
				}
				return ((Component)localPlayer).transform.position + ((Component)localPlayer).transform.forward * 3f + Vector3.up;
			}
			if (roster.TryGet(steamId, out RosterEntry entry) && entry.HasPosition)
			{
				return entry.LastKnownPosition + Vector3.up * 1.5f;
			}
			if (!flag)
			{
				return Vector3.zero;
			}
			return ((Component)localPlayer).transform.position;
		}

		internal void Clear()
		{
			foreach (KeyValuePair<ulong, PeerVoiceStream> stream in _streams)
			{
				stream.Value.Dispose();
			}
			_streams.Clear();
		}

		internal void Remove(ulong steamId)
		{
			if (_streams.TryGetValue(steamId, out PeerVoiceStream value))
			{
				value.Dispose();
				_streams.Remove(steamId);
			}
		}

		public void Dispose()
		{
			if (_disposed)
			{
				return;
			}
			_disposed = true;
			foreach (KeyValuePair<ulong, PeerVoiceStream> stream in _streams)
			{
				stream.Value.Dispose();
			}
			_streams.Clear();
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
				_root = null;
			}
		}
	}
	internal sealed class PcmRingBuffer
	{
		private readonly float[] _buffer;

		private readonly int _capacity;

		private int _write;

		private int _read;

		internal int Dropped;

		internal int Starved;

		internal int Available
		{
			get
			{
				int num = Volatile.Read(in _write) - Volatile.Read(in _read);
				if (num >= 0)
				{
					return num;
				}
				return num + _capacity;
			}
		}

		internal PcmRingBuffer(int capacity)
		{
			_capacity = capacity;
			_buffer = new float[capacity];
		}

		internal void Clear()
		{
			Volatile.Write(ref _read, 0);
			Volatile.Write(ref _write, 0);
			Dropped = 0;
			Starved = 0;
		}

		internal void Write(float[] source, int offset, int count)
		{
			if (count <= 0)
			{
				return;
			}
			int num = _capacity - Available - 1;
			if (count > num)
			{
				Dropped += count - num;
				count = num;
				if (count <= 0)
				{
					return;
				}
			}
			int write = _write;
			int num2 = Math.Min(count, _capacity - write);
			Array.Copy(source, offset, _buffer, write, num2);
			int num3 = count - num2;
			if (num3 > 0)
			{
				Array.Copy(source, offset + num2, _buffer, 0, num3);
			}
			Volatile.Write(ref _write, (write + count) % _capacity);
		}

		internal int ReadOrSilence(float[] destination, int count)
		{
			int num = Math.Min(Available, count);
			if (num > 0)
			{
				TryRead(destination, num);
			}
			for (int i = num; i < count; i++)
			{
				destination[i] = 0f;
			}
			if (num < count)
			{
				Starved += count - num;
			}
			return num;
		}

		internal bool TryRead(float[] destination, int count)
		{
			if (Available < count)
			{
				return false;
			}
			int read = _read;
			int num = Math.Min(count, _capacity - read);
			Array.Copy(_buffer, read, destination, 0, num);
			int num2 = count - num;
			if (num2 > 0)
			{
				Array.Copy(_buffer, 0, destination, num, num2);
			}
			Volatile.Write(ref _read, (read + count) % _capacity);
			return true;
		}
	}
	internal sealed class VoiceEncoder : IDisposable
	{
		private const int IdleWaitMs = 5;

		private const int JoinTimeoutMs = 1500;

		private const int HangoverFrames = 12;

		private const int OpusComplexity = 10;

		private const int OpusLsbDepth = 16;

		private const int DtxFrameBytes = 2;

		private const float MinAutoGain = 0.25f;

		private const float MaxAutoGain = 12f;

		private const float AutoGainRise = 0.02f;

		private const float AutoGainFall = 0.25f;

		private const float AutoGainFloor = 0.004f;

		private const float DefaultThreshold = 0.02f;

		private const int DefaultBitrate = 24000;

		private const int DefaultPacketLoss = 5;

		private const float DefaultAutoGainTarget = 0.12f;

		private readonly PcmRingBuffer _pcm;

		private readonly EncodedFrameRing _output;

		private readonly float[] _frame = new float[960];

		private readonly AutoResetEvent _wake = new AutoResetEvent(initialState: false);

		private OpusEncoder? _encoder;

		private Thread? _thread;

		private volatile bool _running;

		private volatile bool _disposed;

		private int _hangover;

		private bool _wasSpeaking;

		private bool _loggedFirstFrame;

		private uint _startTicks;

		private volatile bool _transmitting;

		private volatile bool _gateOpen;

		private volatile float _gain = 1f;

		private volatile float _threshold = 0.02f;

		private volatile int _bitrate = 24000;

		private volatile int _packetLossPercent = 5;

		private volatile bool _useDtx;

		private volatile bool _autoGain;

		private volatile float _autoGainTarget = 0.12f;

		private volatile float _autoGainFactor = 1f;

		internal int FramesEncoded;

		internal int FramesSuppressed;

		internal int ClippedFrames;

		internal int FramesSinceClip = int.MaxValue;

		internal float LastRms { get; private set; }

		internal bool IsSpeaking => _wasSpeaking;

		internal bool IsTransmitting => _transmitting;

		internal float LastRawRms { get; private set; }

		internal float AutoGainFactor => _autoGainFactor;

		internal VoiceEncoder(PcmRingBuffer pcm, EncodedFrameRing output)
		{
			_pcm = pcm;
			_output = output;
		}

		internal void SetGateOpen(bool open)
		{
			_gateOpen = open;
		}

		internal void SetAutoGain(bool enabled, float target)
		{
			_autoGain = enabled;
			_autoGainTarget = target;
			if (!enabled)
			{
				_autoGainFactor = 1f;
			}
		}

		internal void SetTuning(float gain, float threshold, int bitrate, int packetLossPercent, bool useDtx)
		{
			_gain = gain;
			_threshold = threshold;
			_useDtx = useDtx;
			if (_bitrate != bitrate)
			{
				_bitrate = bitrate;
				ApplyBitrate();
			}
			if (_packetLossPercent != packetLossPercent)
			{
				_packetLossPercent = packetLossPercent;
				ApplyPacketLoss();
			}
		}

		internal void Start()
		{
			if (!_disposed && !_running)
			{
				_encoder = new OpusEncoder(48000, 1, OpusApplication.OPUS_APPLICATION_VOIP)
				{
					Bitrate = _bitrate,
					SignalType = OpusSignal.OPUS_SIGNAL_VOICE,
					Complexity = 10,
					ForceMode = OpusMode.MODE_SILK_ONLY,
					Bandwidth = OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND,
					MaxBandwidth = OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND,
					LSBDepth = 16,
					UseVBR = true,
					UseDTX = _useDtx,
					UseInbandFEC = true,
					PacketLossPercent = _packetLossPercent
				};
				_startTicks = (uint)Environment.TickCount;
				_hangover = 0;
				_wasSpeaking = false;
				_running = true;
				_thread = new Thread(Run)
				{
					Name = "PVC Opus Encoder",
					IsBackground = true,
					Priority = ThreadPriority.AboveNormal
				};
				_thread.Start();
			}
		}

		internal bool Stop()
		{
			if (!_running)
			{
				return true;
			}
			_running = false;
			_wake.Set();
			Thread thread = _thread;
			_thread = null;
			int num;
			if (thread != null)
			{
				num = (thread.Join(1500) ? 1 : 0);
				if (num == 0)
				{
					ProximityVoiceChatPlugin.Log.LogWarning((object)"Encoder thread did not stop in time, leaving it to the background flag");
				}
			}
			else
			{
				num = 1;
			}
			_encoder = null;
			_transmitting = false;
			if (num != 0)
			{
				_output.Clear();
			}
			return (byte)num != 0;
		}

		private void ApplyBitrate()
		{
			OpusEncoder encoder = _encoder;
			if (encoder != null)
			{
				encoder.Bitrate = _bitrate;
			}
		}

		private void ApplyPacketLoss()
		{
			OpusEncoder encoder = _encoder;
			if (encoder != null)
			{
				encoder.PacketLossPercent = _packetLossPercent;
			}
		}

		private void Run()
		{
			while (_running)
			{
				bool flag = false;
				while (_running && _pcm.TryRead(_frame, 960))
				{
					flag = true;
					EncodeFrame();
				}
				if (!flag)
				{
					_wake.WaitOne(5);
				}
			}
		}

		private float UpdateAutoGain()
		{
			if (!_autoGain)
			{
				return 1f;
			}
			double num = 0.0;
			for (int i = 0; i < 960; i++)
			{
				num += (double)_frame[i] * (double)_frame[i];
			}
			float num2 = (LastRawRms = (float)Math.Sqrt(num / 960.0));
			if (num2 < 0.004f)
			{
				return _autoGainFactor;
			}
			float num4 = Math.Min(_autoGainTarget / num2, 12f);
			float autoGainFactor = _autoGainFactor;
			float num5 = ((num4 < autoGainFactor) ? 0.25f : 0.02f);
			autoGainFactor += (num4 - autoGainFactor) * num5;
			_autoGainFactor = Math.Max(0.25f, Math.Min(12f, autoGainFactor));
			return _autoGainFactor;
		}

		private void EncodeFrame()
		{
			OpusEncoder encoder = _encoder;
			if (encoder == null)
			{
				return;
			}
			float num = _gain * UpdateAutoGain();
			double num2 = 0.0;
			float num3 = 0f;
			bool flag = false;
			for (int i = 0; i < 960; i++)
			{
				float num4 = _frame[i] * num;
				float num5 = ((num4 < 0f) ? (0f - num4) : num4);
				if (num5 > num3)
				{
					num3 = num5;
				}
				if (num5 > 1f)
				{
					flag = true;
				}
				num4 = AudioFormat.SoftClip(num4);
				_frame[i] = num4;
				num2 += (double)(num4 * num4);
			}
			float num6 = (LastRms = (float)Math.Sqrt(num2 / 960.0));
			if (flag)
			{
				ClippedFrames++;
				FramesSinceClip = 0;
			}
			else if (FramesSinceClip < int.MaxValue)
			{
				FramesSinceClip++;
			}
			if (!DecideSpeaking(num6))
			{
				if (_wasSpeaking)
				{
					EmitEndOfTalkspurt();
				}
				_wasSpeaking = false;
				_transmitting = false;
				FramesSuppressed++;
				return;
			}
			EncodedFrame encodedFrame = _output.BeginWrite();
			if (encodedFrame == null)
			{
				return;
			}
			int num8;
			try
			{
				num8 = encoder.Encode(_frame, 0, 960, encodedFrame.Data, 0, encodedFrame.Data.Length);
			}
			catch (Exception ex)
			{
				ProximityVoiceChatPlugin.Log.LogError((object)("Opus encode failed: " + ex.Message));
				return;
			}
			if (_useDtx && num8 <= 2)
			{
				_transmitting = false;
				FramesSuppressed++;
				return;
			}
			encodedFrame.Length = num8;
			encodedFrame.TimestampMs = (uint)(Environment.TickCount - _startTicks);
			encodedFrame.Flags = VoiceFlags.None;
			_output.CommitWrite();
			FramesEncoded++;
			_wasSpeaking = true;
			_transmitting = true;
			if (!_loggedFirstFrame)
			{
				_loggedFirstFrame = true;
				ProximityVoiceChatPlugin.Log.LogInfo((object)$"First Opus frame encoded, {num8} bytes at rms {num6:0.000}");
			}
		}

		private bool DecideSpeaking(float rms)
		{
			if (!_gateOpen)
			{
				_hangover = 0;
				return false;
			}
			if (rms >= _threshold)
			{
				_hangover = 12;
				return true;
			}
			if (_hangover > 0)
			{
				_hangover--;
				return true;
			}
			return false;
		}

		private void EmitEndOfTalkspurt()
		{
			EncodedFrame encodedFrame = _output.BeginWrite();
			if (encodedFrame != null)
			{
				encodedFrame.Length = 0;
				encodedFrame.TimestampMs = (uint)(Environment.TickCount - _startTicks);
				encodedFrame.Flags = VoiceFlags.EndOfTalkspurt;
				_output.CommitWrite();
			}
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				_disposed = true;
				if (Stop())
				{
					_wake.Close();
				}
			}
		}
	}
}
namespace LocalizationManager
{
	[PublicAPI]
	public class Localizer
	{
		private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;

		private static readonly Dictionary<string, Dictionary<string, string>> loadedTexts;

		private static readonly ConditionalWeakTable<Localization, string> localizationLanguage;

		private static readonly List<WeakReference<Localization>> localizationObjects;

		private static BaseUnityPlugin? _plugin;

		private static readonly List<string> fileExtensions;

		private static BaseUnityPlugin plugin
		{
			get
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				if (_plugin == null)
				{
					IEnumerable<TypeInfo> source;
					try
					{
						source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
					}
					catch (ReflectionTypeLoadException ex)
					{
						source = from t in ex.Types
							where t != null
							select t.GetTypeInfo();
					}
					_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First((TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
				}
				return _plugin;
			}
		}

		public static event Action? OnLocalizationComplete;

		private static void UpdatePlaceholderText(Localization localization, string key)
		{
			localizationLanguage.TryGetValue(localization, out string value);
			string text = loadedTexts[value][key];
			if (PlaceholderProcessors.TryGetValue(key, out Dictionary<string, Func<string>> value2))
			{
				text = value2.Aggregate(text, (string current, KeyValuePair<string, Func<string>> kv) => current.Replace("{" + kv.Key + "}", kv.Value()));
			}
			localization.AddWord(key, text);
		}

		public static void AddPlaceholder<T>(string key, string placeholder, ConfigEntry<T> config, Func<T, string>? convertConfigValue = null) where T : notnull
		{
			if (convertConfigValue == null)
			{
				convertConfigValue = (T val) => val.ToString();
			}
			if (!PlaceholderProcessors.ContainsKey(key))
			{
				PlaceholderProcessors[key] = new Dictionary<string, Func<string>>();
			}
			config.SettingChanged += delegate
			{
				UpdatePlaceholder();
			};
			if (loadedTexts.ContainsKey(Localization.instance.GetSelectedLanguage()))
			{
				UpdatePlaceholder();
			}
			void UpdatePlaceholder()
			{
				PlaceholderProcessors[key][placeholder] = () => convertConfigValue(config.Value);
				UpdatePlaceholderText(Localization.instance, key);
			}
		}

		public static void AddText(string key, string text)
		{
			List<WeakReference<Localization>> list = new List<WeakReference<Localization>>();
			foreach (WeakReference<Localization> localizationObject in localizationObjects)
			{
				if (localizationObject.TryGetTarget(out var target))
				{
					Dictionary<string, string> dictionary = loadedTexts[localizationLanguage.GetOrCreateValue(target)];
					if (!target.m_translations.ContainsKey(key))
					{
						dictionary[key] = text;
						target.AddWord(key, text);
					}
				}
				else
				{
					list.Add(localizationObject);
				}
			}
			foreach (WeakReference<Localization> item in list)
			{
				localizationObjects.Remove(item);
			}
		}

		public static void Load()
		{
			_ = plugin;
		}

		public static void LoadLocalizationLater(Localization __instance)
		{
			LoadLocalization(Localization.instance, __instance.GetSelectedLanguage());
		}

		public static void SafeCallLocalizeComplete()
		{
			Localizer.OnLocalizationComplete?.Invoke();
		}

		private static void LoadLocalization(Localization __instance, string language)
		{
			if (!localizationLanguage.Remove(__instance))
			{
				localizationObjects.Add(new WeakReference<Localization>(__instance));
			}
			localizationLanguage.Add(__instance, language);
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (string item in from f in Directory.GetFiles(Path.GetDirectoryName(Paths.PluginPath), plugin.Info.Metadata.Name + ".*", SearchOption.AllDirectories)
				where fileExtensions.IndexOf(Path.GetExtension(f)) >= 0
				select f)
			{
				string[] array = Path.GetFileNameWithoutExtension(item).Split('.');
				if (array.Length >= 2)
				{
					string text = array[1];
					if (dictionary.ContainsKey(text))
					{
						Debug.LogWarning((object)("Duplicate key " + text + " found for " + plugin.Info.Metadata.Name + ". The duplicate file found at " + item + " will be skipped."));
					}
					else
					{
						dictionary[text] = item;
					}
				}
			}
			byte[] array2 = LoadTranslationFromAssembly("English");
			if (array2 == null)
			{
				throw new Exception("Found no English localizations in mod " + plugin.Info.Metadata.Name + ". Expected an embedded resource translations/English.json or translations/English.yml.");
			}
			Dictionary<string, string> dictionary2 = new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(Encoding.UTF8.GetString(array2));
			if (dictionary2 == null)
			{
				throw new Exception("Localization for mod " + plugin.Info.Metadata.Name + " failed: Localization file was empty.");
			}
			string text2 = null;
			if (language != "English")
			{
				if (dictionary.TryGetValue(language, out var value))
				{
					text2 = File.ReadAllText(value);
				}
				else
				{
					byte[] array3 = LoadTranslationFromAssembly(language);
					if (array3 != null)
					{
						text2 = Encoding.UTF8.GetString(array3);
					}
				}
			}
			if (text2 == null && dictionary.TryGetValue("English", out var value2))
			{
				text2 = File.ReadAllText(value2);
			}
			if (text2 != null)
			{
				foreach (KeyValuePair<string, string> item2 in new DeserializerBuilder().IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text2) ?? new Dictionary<string, string>())
				{
					dictionary2[item2.Key] = item2.Value;
				}
			}
			loadedTexts[language] = dictionary2;
			foreach (KeyValuePair<string, string> item3 in dictionary2)
			{
				UpdatePlaceholderText(__instance, item3.Key);
			}
		}

		static Localizer()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			PlaceholderProcessors = new Dictionary<string, Dictionary<string, Func<string>>>();
			loadedTexts = new Dictionary<string, Dictionary<string, string>>();
			localizationLanguage = new ConditionalWeakTable<Localization, string>();
			localizationObjects = new List<WeakReference<Localization>>();
			fileExtensions = new List<string>(2) { ".json", ".yml" };
			Harmony val = new Harmony("org.bepinex.helpers.LocalizationManager");
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "SetupLanguage", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalization", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "SetupGui", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalizationLater", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Start", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "SafeCallLocalizeComplete", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static byte[]? LoadTranslationFromAssembly(string language)
		{
			foreach (string fileExtension in fileExtensions)
			{
				byte[] array = ReadEmbeddedFileBytes("translations." + language + fileExtension);
				if (array != null)
				{
					return array;
				}
			}
			return null;
		}

		public static byte[]? ReadEmbeddedFileBytes(string resourceFileName, Assembly? containingAssembly = null)
		{
			using MemoryStream memoryStream = new MemoryStream();
			if ((object)containingAssembly == null)
			{
				containingAssembly = Assembly.GetCallingAssembly();
			}
			string text = containingAssembly.GetManifestResourceNames().FirstOrDefault((string str) => str.EndsWith(resourceFileName, StringComparison.Ordinal));
			if (text != null)
			{
				containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
			}
			return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
		}
	}
	public static class LocalizationManagerVersion
	{
		public const string Version = "1.4.1";
	}
}
[CompilerGenerated]
internal sealed class <1f0b1d75-e10c-4d8b-b252-7e4e0b261763><PrivateImplementationDetails>
{
	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 24)]
	internal struct __StaticArrayInitTypeSize=24
	{
	}

	internal static readonly __StaticArrayInitTypeSize=24 38219780559D657075AD2D3AA3B81B553629ACF7EACA0297D3BB56C21092ADED/* Not supported: data(32 01 00 00 31 01 00 00 30 01 00 00 2F 01 00 00 34 01 00 00 33 01 00 00) */;
}
namespace ServerSync
{
	[PublicAPI]
	internal abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	internal class SyncedConfigEntry<T>(ConfigEntry<T> sourceConfig) : OwnConfigEntryBase()
	{
		public readonly ConfigEntry<T> SourceConfig = sourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object? BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	internal sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	internal class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, isAdmin: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend > 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZNetPeer peer;
				if (__instance.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0052;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag == true;
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0052:
				result = 0;
				goto IL_0053;
				IL_0053:
				return (byte)result != 0;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; } = false;

		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(0L, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority));
			customValue.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(0L, customValue);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int num2 = 0; num2 < num; num2++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config.SynchronizedConfig || config.LocalBaseValue == null || (!configSync.IsLocked && (config != configSync.lockedConfig || lockExempt));
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer.m_socket.IsConnected())
					{
						ZPackage fragmentedPackage = new ZPackage();
						fragmentedPackage.Write((byte)2);
						fragmentedPackage.Write(packageIdentifier);
						fragmentedPackage.Write(fragment);
						fragmentedPackage.Write(fragments);
						fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(fragmentedPackage);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer.m_uid} after 30 seconds config sending timeout");
						peer.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != 0)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write((byte)4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from p in peers
				where p.IsReady()
				select distributeConfigToPeers(p, package)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, object? value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	internal class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		private ConfigSync? ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool flag = new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new System.Version(ReceivedCurrentVersion) >= new System.Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error(ZRpc? rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			foreach (VersionCheck versionCheck in array2)
			{
				Debug.LogWarning((object)versionCheck.Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
namespace YamlDotNet
{
	internal sealed class CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

		public CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
			: base(baseCulture.Name)
		{
			this.provider = provider;
		}

		public override object? GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	internal static class Polyfills
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool Contains(this string source, char c)
		{
			return source.IndexOf(c) != -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool EndsWith(this string source, char c)
		{
			if (source.Length > 0)
			{
				return source[source.Length - 1] == c;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool StartsWith(this string source, char c)
		{
			if (source.Length > 0)
			{
				return source[0] == c;
			}
			return false;
		}
	}
	internal static class PropertyInfoExtensions
	{
		public static object? ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class ReflectionExtensions
	{
		private static readonly Func<PropertyInfo, bool> IsInstance = (PropertyInfo property) => !(property.GetMethod ?? property.SetMethod).IsStatic;

		private static readonly Func<PropertyInfo, bool> IsInstancePublic = (PropertyInfo property) => IsInstance(property) && (property.GetMethod ?? property.SetMethod).IsPublic;

		public static Type? BaseType(this Type type)
		{
			return type.GetTypeInfo().BaseType;
		}

		public static bool IsValueType(this Type type)
		{
			return type.GetTypeInfo().IsValueType;
		}

		public static bool IsGenericType(this Type type)
		{
			return type.GetTypeInfo().IsGenericType;
		}

		public static bool IsGenericTypeDefinition(this Type type)
		{
			return type.GetTypeInfo().IsGenericTypeDefinition;
		}

		public static Type? GetImplementationOfOpenGenericInterface(this Type type, Type openGenericType)
		{
			if (!openGenericType.IsGenericType || !openGenericType.IsInterface)
			{
				throw new ArgumentException("The type must be a generic type definition and an interface", "openGenericType");
			}
			if (IsGenericDefinitionOfType(type, openGenericType))
			{
				return type;
			}
			return type.FindInterfaces((Type t, object context) => IsGenericDefinitionOfType(t, context), openGenericType).FirstOrDefault();
			static bool IsGenericDefinitionOfType(Type t, object? context)
			{
				if (t.IsGenericType)
				{
					return t.GetGenericTypeDefinition() == (Type)context;
				}
				return false;
			}
		}

		public static bool IsInterface(this Type type)
		{
			return type.GetTypeInfo().IsInterface;
		}

		public static bool IsEnum(this Type type)
		{
			return type.GetTypeInfo().IsEnum;
		}

		public static bool IsRequired(this MemberInfo member)
		{
			return member.GetCustomAttributes(inherit: true).Any((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.RequiredMemberAttribute");
		}

		public static bool HasDefaultConstructor(this Type type, bool allowPrivateConstructors)
		{
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
			if (allowPrivateConstructors)
			{
				bindingFlags |= BindingFlags.NonPublic;
			}
			if (!type.IsValueType)
			{
				return type.GetConstructor(bindingFlags, null, Type.EmptyTypes, null) != null;
			}
			return true;
		}

		public static bool IsAssignableFrom(this Type type, Type source)
		{
			return type.IsAssignableFrom(source.GetTypeInfo());
		}

		public static bool IsAssignableFrom(this Type type, TypeInfo source)
		{
			return type.GetTypeInfo().IsAssignableFrom(source);
		}

		public static TypeCode GetTypeCode(this Type type)
		{
			if (type.IsEnum())
			{
				type = Enum.GetUnderlyingType(type);
			}
			if (type == typeof(bool))
			{
				return TypeCode.Boolean;
			}
			if (type == typeof(char))
			{
				return TypeCode.Char;
			}
			if (type == typeof(sbyte))
			{
				return TypeCode.SByte;
			}
			if (type == typeof(byte))
			{
				return TypeCode.Byte;
			}
			if (type == typeof(short))
			{
				return TypeCode.Int16;
			}
			if (type == typeof(ushort))
			{
				return TypeCode.UInt16;
			}
			if (type == typeof(int))
			{
				return TypeCode.Int32;
			}
			if (type == typeof(uint))
			{
				return TypeCode.UInt32;
			}
			if (type == typeof(long))
			{
				return TypeCode.Int64;
			}
			if (type == typeof(ulong))
			{
				return TypeCode.UInt64;
			}
			if (type == typeof(float))
			{
				return TypeCode.Single;
			}
			if (type == typeof(double))
			{
				return TypeCode.Double;
			}
			if (type == typeof(decimal))
			{
				return TypeCode.Decimal;
			}
			if (type == typeof(DateTime))
			{
				return TypeCode.DateTime;
			}
			if (type == typeof(string))
			{
				return TypeCode.String;
			}
			return TypeCode.Object;
		}

		public static bool IsDbNull(this object value)
		{
			return value?.GetType()?.FullName == "System.DBNull";
		}

		public static Type[] GetGenericArguments(this Type type)
		{
			return type.GetTypeInfo().GenericTypeArguments;
		}

		public static PropertyInfo? GetPublicProperty(this Type type, string name)
		{
			return type.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public).FirstOrDefault((PropertyInfo p) => p.Name == name);
		}

		public static FieldInfo? GetPublicStaticField(this Type type, string name)
		{
			return type.GetRuntimeField(name);
		}

		public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
		{
			Func<PropertyInfo, bool> predicate = (includeNonPublic ? IsInstance : IsInstancePublic);
			if (!type.IsInterface())
			{
				return type.GetRuntimeProperties().Where(predicate);
			}
			return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany((Type i) => i.GetRuntimeProperties().Where(predicate));
		}

		public static IEnumerable<PropertyInfo> GetPublicProperties(this Type type)
		{
			return type.GetProperties(includeNonPublic: false);
		}

		public static IEnumerable<FieldInfo> GetPublicFields(this Type type)
		{
			return from f in type.GetRuntimeFields()
				where !f.IsStatic && f.IsPublic
				select f;
		}

		public static IEnumerable<MethodInfo> GetPublicStaticMethods(this Type type)
		{
			return from m in type.GetRuntimeMethods()
				where m.IsPublic && m.IsStatic
				select m;
		}

		public static MethodInfo GetPrivateStaticMethod(this Type type, string name)
		{
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => !m.IsPublic && m.IsStatic && m.Name.Equals(name)) ?? throw new MissingMethodException("Expected to find a method named '" + name + "' in '" + type.FullName + "'.");
		}

		public static MethodInfo? GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			return type.GetRuntimeMethods().FirstOrDefault(delegate(MethodInfo m)
			{
				if (m.IsPublic && m.IsStatic && m.Name.Equals(name))
				{
					ParameterInfo[] parameters = m.GetParameters();
					if (parameters.Length == parameterTypes.Length)
					{
						return parameters.Zip(parameterTypes, (ParameterInfo pi, Type pt) => pi.ParameterType == pt).All((bool r) => r);
					}
					return false;
				}
				return false;
			});
		}

		public static MethodInfo? GetPublicInstanceMethod(this Type type, string name)
		{
			return type.GetRuntimeMethods().FirstOrDefault((MethodInfo m) => m.IsPublic && !m.IsStatic && m.Name.Equals(name));
		}

		public static MethodInfo? GetGetMethod(this PropertyInfo property, bool nonPublic)
		{
			MethodInfo methodInfo = property.GetMethod;
			if (!nonPublic && !methodInfo.IsPublic)
			{
				methodInfo = null;
			}
			return methodInfo;
		}

		public static MethodInfo? GetSetMethod(this PropertyInfo property)
		{
			return property.SetMethod;
		}

		public static IEnumerable<Type> GetInterfaces(this Type type)
		{
			return type.GetTypeInfo().ImplementedInterfaces;
		}

		public static bool IsInstanceOf(this Type type, object o)
		{
			if (!(o.GetType() == type))
			{
				return o.GetType().GetTypeInfo().IsSubclassOf(type);
			}
			return true;
		}

		public static Attribute[] GetAllCustomAttributes<TAttribute>(this PropertyInfo member)
		{
			return Attribute.GetCustomAttributes(member, typeof(TAttribute), inherit: true);
		}

		public static bool AcceptsNull(this MemberInfo member)
		{
			object[] customAttributes = member.DeclaringType.GetCustomAttributes(inherit: true);
			object obj = customAttributes.FirstOrDefault((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.NullableContextAttribute");
			int num = 0;
			if (obj != null)
			{
				Type type = obj.GetType();
				PropertyInfo property = type.GetProperty("Flag");
				num = (byte)property.GetValue(obj);
			}
			object[] customAttributes2 = member.GetCustomAttributes(inherit: true);
			object obj2 = customAttributes2.FirstOrDefault((object x) => x.GetType().FullName == "System.Runtime.CompilerServices.NullableAttribute");
			PropertyInfo propertyInfo = (obj2?.GetType())?.GetProperty("NullableFlags");
			byte[] source = (byte[])propertyInfo.GetValue(obj2);
			return source.Any((byte x) => x == 2) || num == 2;
		}
	}
	internal static class StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	internal abstract class BuilderSkeleton<TBuilder> where TBuilder : BuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal INamingConvention enumNamingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly YamlAttributeOverrides overrides;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		internal bool ignoreFields;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal YamlFormatter yamlFormatter = YamlFormatter.Default;

		protected abstract TBuilder Self { get; }

		internal BuilderSkeleton(ITypeResolver typeResolver)
		{
			overrides = new YamlAttributeOverrides();
			typeConverterFactories = new LazyComponentRegistrationList<Nothing, IYamlTypeConverter>
			{
				{
					typeof(YamlDotNet.Serialization.Converters.GuidConverter),
					(Nothing _) => new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: false)
				},
				{
					typeof(SystemTypeConverter),
					(Nothing _) => new SystemTypeConverter()
				}
			};
			typeInspectorFactories = new LazyComponentRegistrationList<ITypeInspector, ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			settings = new Settings();
		}

		public TBuilder IgnoreFields()
		{
			ignoreFields = true;
			return Self;
		}

		public TBuilder IncludeNonPublicProperties()
		{
			includeNonPublicProperties = true;
			return Self;
		}

		public TBuilder EnablePrivateConstructors()
		{
			settings.AllowPrivateConstructors = true;
			return Self;
		}

		public TBuilder WithNamingConvention(INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithEnumNamingConvention(INamingConvention enumNamingConvention)
		{
			this.enumNamingConvention = enumNamingConvention;
			return Self;
		}

		public TBuilder WithTypeResolver(ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(TagName tag, Type type);

		public TBuilder WithAttributeOverride<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			overrides.Add(propertyAccessor, attribute);
			return Self;
		}

		public TBuilder WithAttributeOverride(Type type, string member, Attribute attribute)
		{
			overrides.Add(type, member, attribute);
			return Self;
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter, Action<IRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where)
		{
			if (typeConverter == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (Nothing _) => typeConverter));
			return Self;
		}

		public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			if (typeConverterFactory == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
		{
			return WithoutTypeConverter(typeof(TYamlTypeConverter));
		}

		public TBuilder WithoutTypeConverter(Type converterType)
		{
			if (converterType == null)
			{
				throw new ArgumentNullException("converterType");
			}
			typeConverterFactories.Remove(converterType);
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

		public TBuilder WithoutTypeInspector(Type inspectorType)
		{
			if (inspectorType == null)
			{
				throw new ArgumentNullException("inspectorType");
			}
			typeInspectorFactories.Remove(inspectorType);
			return Self;
		}

		public TBuilder WithYamlFormatter(YamlFormatter formatter)
		{
			yamlFormatter = formatter ?? throw new ArgumentNullException("formatter");
			return Self;
		}

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent WrapperFactory<TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent WrapperFactory<TArgument, TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	internal sealed class Deserializer : IDeserializer
	{
		private readonly IValueDeserializer valueDeserializer;

		public Deserializer()
			: this(new DeserializerBuilder().BuildValueDeserializer())
		{
		}

		private Deserializer(IValueDeserializer valueDeserializer)
		{
			this.valueDeserializer = valueDeserializer ?? throw new ArgumentNullException("valueDeserializer");
		}

		public static Deserializer FromValueDeserializer(IValueDeserializer valueDeserializer)
		{
			return new Deserializer(valueDeserializer);
		}

		public T Deserialize<T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<T>(TextReader input)
		{
			return Deserialize<T>(new Parser(input));
		}

		public T Deserialize<T>(IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		public object? Deserialize(string input)
		{
			return Deserialize<object>(input);
		}

		public object? Deserialize(TextReader input)
		{
			return Deserialize<object>(input);
		}

		public object? Deserialize(IParser parser)
		{
			return Deserialize<object>(parser);
		}

		public object? Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		public object? Deserialize(TextReader input, Type type)
		{
			return Deserialize(new Parser(input), type);
		}

		public object? Deserialize(IParser parser, Type type)
		{
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			YamlDotNet.Core.Events.StreamStart @event;
			bool flag = parser.TryConsume<YamlDotNet.Core.Events.StreamStart>(out @event);
			YamlDotNet.Core.Events.DocumentStart event2;
			bool flag2 = parser.TryConsume<YamlDotNet.Core.Events.DocumentStart>(out event2);
			object result = null;
			if (!parser.Accept<YamlDotNet.Core.Events.DocumentEnd>(out var _) && !parser.Accept<YamlDotNet.Core.Events.StreamEnd>(out var _))
			{
				using SerializerState serializerState = new SerializerState();
				result = valueDeserializer.DeserializeValue(parser, type, serializerState, valueDeserializer);
				serializerState.OnDeserialization();
			}
			if (flag2)
			{
				parser.Consume<YamlDotNet.Core.Events.DocumentEnd>();
			}
			if (flag)
			{
				parser.Consume<YamlDotNet.Core.Events.StreamEnd>();
			}
			return result;
		}
	}
	internal sealed class DeserializerBuilder : BuilderSkeleton<DeserializerBuilder>
	{
		private Lazy<IObjectFactory> objectFactory;

		private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

		private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<TagName, Type> tagMappings;

		private readonly Dictionary<Type, Type> typeMappings;

		private readonly ITypeConverter typeConverter;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		private bool enforceRequiredProperties;

		protected override DeserializerBuilder Self => this;

		public DeserializerBuilder()
			: base((ITypeResolver)new StaticTypeResolver())
		{
			typeMappings = new Dictionary<Type, Type>();
			objectFactory = new Lazy<IObjectFactory>(() => new DefaultObjectFactory(typeMappings, settings), isThreadSafe: true);
			tagMappings = new Dictionary<TagName, Type>
			{
				{
					FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(YamlAttributeOverridesInspector), (ITypeInspector inner) => (overrides == null) ? inner : new YamlAttributeOverridesInspector(inner, overrides.Clone()));
			typeInspectorFactories.Add(typeof(ReadableAndWritablePropertiesTypeInspector), (ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner));
			nodeDeserializerFactories = new LazyComponentRegistrationList<Nothing, INodeDeserializer>
			{
				{
					typeof(YamlConvertibleNodeDeserializer),
					(Nothing _) => new YamlConvertibleNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(YamlSerializableNodeDeserializer),
					(Nothing _) => new YamlSerializableNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(TypeConverterNodeDeserializer),
					(Nothing _) => new TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(NullNodeDeserializer),
					(Nothing _) => new NullNodeDeserializer()
				},
				{
					typeof(ScalarNodeDeserializer),
					(Nothing _) => new ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter, BuildTypeInspector(), yamlFormatter, enumNamingConvention)
				},
				{
					typeof(ArrayNodeDeserializer),
					(Nothing _) => new ArrayNodeDeserializer(enumNamingConvention, BuildTypeInspector())
				},
				{
					typeof(DictionaryNodeDeserializer),
					(Nothing _) => new DictionaryNodeDeserializer(objectFactory.Value, duplicateKeyChecking)
				},
				{
					typeof(CollectionNodeDeserializer),
					(Nothing _) => new CollectionNodeDeserializer(objectFactory.Value, enumNamingConvention, BuildTypeInspector())
				},
				{
					typeof(EnumerableNodeDeserializer),
					(Nothing _) => new EnumerableNodeDeserializer()
				},
				{
					typeof(ObjectNodeDeserializer),
					(Nothing _) => new ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter, enumNamingConvention, enforceNullability, caseInsensitivePropertyMatching, enforceRequiredProperties, BuildTypeConverters())
				},
				{
					typeof(FsharpListNodeDeserializer),
					(Nothing _) => new FsharpListNodeDeserializer(BuildTypeInspector(), enumNamingConvention)
				}
			};
			nodeTypeResolverFactories = new LazyComponentRegistrationList<Nothing, INodeTypeResolver>
			{
				{
					typeof(MappingNodeTypeResolver),
					(Nothing _) => new MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(YamlConvertibleTypeResolver),
					(Nothing _) => new YamlConvertibleTypeResolver()
				},
				{
					typeof(YamlSerializableTypeResolver),
					(Nothing _) => new YamlSerializableTypeResolver()
				},
				{
					typeof(TagNodeTypeResolver),
					(Nothing _) => new TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(PreventUnknownTagsNodeTypeResolver),
					(Nothing _) => new PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(DefaultContainersNodeTypeResolver),
					(Nothing _) => new DefaultContainersNodeTypeResolver()
				}
			};
			typeConverter = new ReflectionTypeConverter();
		}

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = new WritablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
			}
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}

		public DeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
		{
			attemptUnknownTypeDeserialization = true;
			return this;
		}

		public DeserializerBuilder WithObjectFactory(IObjectFactory objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory, isThreadSafe: true);
			return this;
		}

		public DeserializerBuilder WithObjectFactory(Func<Type, object> objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			return WithObjectFactory(new LambdaObjectFactory(objectFactory));
		}

		public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer, Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>> where)
		{
			if (nodeDeserializer == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (Nothing _) => nodeDeserializer));
			return this;
		}

		public DeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			if (nodeDeserializerFactory == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory(wrapped)));
			return this;
		}

		public DeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public DeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public DeserializerBuilder WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
		{
			TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
			configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
			TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
			{
				s.Before<DictionaryNodeDeserializer>();
			});
		}

		public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
		{
			if (nodeTypeResolver == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (Nothing _) => nodeTypeResolver));
			return this;
		}

		public DeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			if (nodeTypeResolverFactory == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory(wrapped)));
			return this;
		}

		public DeserializerBuilder WithCaseInsensitivePropertyMatching()
		{
			caseInsensitivePropertyMatching = true;
			return this;
		}

		public DeserializerBuilder WithEnforceNullability()
		{
			enforceNullability = true;
			return this;
		}

		public DeserializerBuilder WithEnforceRequiredMembers()
		{
			enforceRequiredProperties = true;
			return this;
		}

		public DeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public DeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override DeserializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(tag, out Type value))
			{
				throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
			}
			tagMappings.Add(tag, type);
			return this;
		}

		public DeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			if (!DictionaryExtensions.TryAdd(typeMappings, typeFromHandle, typeFromHandle2))
			{
				typeMappings[typeFromHandle] = typeFromHandle2;
			}
			return this;
		}

		public DeserializerBuilder WithoutTagMapping(TagName tag)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (!tagMappings.Remove(tag))
			{
				throw new KeyNotFoundException($"Tag '{tag}' is not registered");
			}
			return this;
		}

		public DeserializerBuilder IgnoreUnmatchedProperties()
		{
			ignoreUnmatched = true;
			return this;
		}

		public DeserializerBuilder WithDuplicateKeyChecking()
		{
			duplicateKeyChecking = true;
			return this;
		}

		public IDeserializer Build()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			return Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public IValueDeserializer BuildValueDeserializer()
		{
			return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter, enumNamingConvention, BuildTypeInspector()));
		}
	}
	internal sealed class EmissionPhaseObjectGraphVisitorArgs
	{
		private readonly IEnumerable<IObjectGraphVisitor<Nothing>> preProcessingPhaseVisitors;

		public IObjectGraphVisitor<IEmitter> InnerVisitor { get; private set; }

		public IEventEmitter EventEmitter { get; private set; }

		public ObjectSerializer NestedObjectSerializer { get; private set; }

		public IEnumerable<IYamlTypeConverter> TypeConverters { get; private set; }

		public EmissionPhaseObjectGraphVisitorArgs(IObjectGraphVisitor<IEmitter> innerVisitor, IEventEmitter eventEmitter, IEnumerable<IObjectGraphVisitor<Nothing>> preProcessingPhaseVisitors, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
		{
			InnerVisitor = innerVisitor ?? throw new ArgumentNullException("innerVisitor");
			EventEmitter = eventEmitter ?? throw new ArgumentNullException("eventEmitter");
			this.preProcessingPhaseVisitors = preProcessingPhaseVisitors ?? throw new ArgumentNullException("preProcessingPhaseVisitors");
			TypeConverters = typeConverters ?? throw new ArgumentNullException("typeConverters");
			NestedObjectSerializer = nestedObjectSerializer ?? throw new ArgumentNullException("nestedObjectSerializer");
		}

		public T GetPreProcessingPhaseObjectGraphVisitor<T>() where T : IObjectGraphVisitor<Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	internal abstract class EventInfo
	{
		public IObjectDescriptor Source { get; }

		protected EventInfo(IObjectDescriptor source)
		{
			Source = source ?? throw new ArgumentNullException("source");
		}
	}
	internal class AliasEventInfo : EventInfo
	{
		public AnchorName Alias { get; }

		public bool NeedsExpansion { get; set; }

		public AliasEventInfo(IObjectDescriptor source, AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	internal class ObjectEventInfo : EventInfo
	{
		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		protected ObjectEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class ScalarEventInfo : ObjectEventInfo
	{
		public string RenderedValue { get; set; }

		public ScalarStyle Style { get; set; }

		public bool IsPlainImplicit { get; set; }

		public bool IsQuotedImplicit { get; set; }

		public ScalarEventInfo(IObjectDescriptor source)
			: base(source)
		{
			Style = source.ScalarStyle;
			RenderedValue = string.Empty;
		}
	}
	internal sealed class MappingStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public MappingStyle Style { get; set; }

		public MappingStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class MappingEndEventInfo : EventInfo
	{
		public MappingEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public SequenceStyle Style { get; set; }

		public SequenceStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceEndEventInfo : EventInfo
	{
		public SequenceEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal interface IAliasProvider
	{
		AnchorName GetAlias(object target);
	}
	internal interface IDeserializer
	{
		T Deserialize<T>(string input);

		T Deserialize<T>(TextReader input);

		T Deserialize<T>(IParser parser);

		object? Deserialize(string input);

		object? Deserialize(TextReader input);

		object? Deserialize(IParser parser);

		object? Deserialize(string input, Type type);

		object? Deserialize(TextReader input, Type type);

		object? Deserialize(IParser parser, Type type);
	}
	internal interface IEventEmitter
	{
		void Emit(AliasEventInfo eventInfo, IEmitter emitter);

		void Emit(ScalarEventInfo eventInfo, IEmitter emitter);

		void Emit(MappingStartEventInfo eventInfo, IEmitter emitter);

		void Emit(MappingEndEventInfo eventInfo, IEmitter emitter);

		void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter);

		void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter);
	}
	internal interface INamingConvention
	{
		string Apply(string value);

		string Reverse(string value);
	}
	internal interface INodeDeserializer
	{
		bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer);
	}
	internal interface INodeTypeResolver
	{
		bool Resolve(NodeEvent? nodeEvent, ref Type currentType);
	}
	internal interface IObjectAccessor
	{
		void Set(string name, object target, object value);

		object? Read(string name, object target);
	}
	internal interface IObjectDescriptor
	{
		object? Value { get; }

		Type Type { get; }

		Type StaticType { get; }

		ScalarStyle ScalarStyle { get; }
	}
	internal static class ObjectDescriptorExtensions
	{
		public static object NonNullValue(this IObjectDescriptor objectDescriptor)
		{
			return objectDescriptor.Value ?? throw new InvalidOperationException("Attempted to use a IObjectDescriptor of type '" + objectDescriptor.Type.FullName + "' whose Value is null at a point whete it is invalid to do so. This may indicate a bug in YamlDotNet.");
		}
	}
	internal interface IObjectFactory
	{
		object Create(Type type);

		object? CreatePrimitive(Type type);

		bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments);

		Type GetValueType(Type type);

		void ExecuteOnDeserializing(object value);

		void ExecuteOnDeserialized(object value);

		void ExecuteOnSerializing(object value);

		void ExecuteOnSerialized(object value);
	}
	internal interface IObjectGraphTraversalStrategy
	{
		void Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context, ObjectSerializer serializer);
	}
	internal interface IObjectGraphVisitor<TContext>
	{
		bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, TContext context, ObjectSerializer serializer);

		bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, TContext context, ObjectSerializer serializer);

		bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, TContext context, ObjectSerializer serializer);

		void VisitScalar(IObjectDescriptor scalar, TContext context, ObjectSerializer serializer);

		void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, TContext context, ObjectSerializer serializer);

		void VisitMappingEnd(IObjectDescriptor mapping, TContext context, ObjectSerializer serializer);

		void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, TContext context, ObjectSerializer serializer);

		void VisitSequenceEnd(IObjectDescriptor sequence, TContext context, ObjectSerializer serializer);
	}
	internal interface IPropertyDescriptor
	{
		string Name { get; }

		bool AllowNulls { get; }

		bool CanWrite { get; }

		Type Type { get; }

		Type? TypeOverride { get; set; }

		int Order { get; set; }

		ScalarStyle ScalarStyle { get; set; }

		bool Required { get; }

		Type? ConverterType { get; }

		T? GetCustomAttribute<T>() where T : Attribute;

		IObjectDescriptor Read(object target);

		void Write(object target, object? value);
	}
	internal interface IRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void Before<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void After<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void OnTop();

		void OnBottom();
	}
	internal interface ITrackingRegistrationLocationSelectionSyntax<TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	internal interface ISerializer
	{
		string Serialize(object? graph);

		string Serialize(object? graph, Type type);

		void Serialize(TextWriter writer, object? graph);

		void Serialize(TextWriter writer, object? graph, Type type);

		void Serialize(IEmitter emitter, object? graph);

		void Serialize(IEmitter emitter, object? graph, Type type);
	}
	internal interface ITypeInspector
	{
		IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

		IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched, bool caseInsensitivePropertyMatching);

		string GetEnumName(Type enumType, string name);

		string GetEnumValue(object enumValue);
	}
	internal interface ITypeResolver
	{
		Type Resolve(Type staticType, object? actualValue);
	}
	internal interface IValueDeserializer
	{
		object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
	}
	internal interface IValuePromise
	{
		event Action<object?> ValueAvailable;
	}
	internal interface IValueSerializer
	{
		void SerializeValue(IEmitter emitter, object? value, Type? type);
	}
	internal interface IYamlConvertible
	{
		void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);

		void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
	}
	internal delegate object? ObjectDeserializer(Type type);
	internal delegate void ObjectSerializer(object? value, Type? type = null);
	[Obsolete("Please use IYamlConvertible instead")]
	internal interface IYamlSerializable
	{
		void ReadYaml(IParser parser);

		void WriteYaml(IEmitter emitter);
	}
	internal interface IYamlTypeConverter
	{
		bool Accepts(Type type);

		object? ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer);

		void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer);
	}
	internal sealed class LazyComponentRegistrationList<TArgument, TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		public sealed class LazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TArgument, TComponent> Factory;

			public LazyComponentRegistration(Type componentType, Func<TArgument, TComponent> factory)
			{
				ComponentType = componentType;
				Factory = factory;
			}
		}

		public sealed class TrackingLazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TComponent, TArgument, TComponent> Factory;

			public TrackingLazyComponentRegistration(Type componentType, Func<TComponent, TArgument, TComponent> factory)
			{
				ComponentType = componentType;
				Factory = factory;
			}
		}

		private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly LazyComponentRegistration newRegistration;

			public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, LazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries[index] = newRegistration;
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.After<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int num = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(num + 1, newRegistration);
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.Before<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(index, newRegistration);
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.OnBottom()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Add(newRegistration);
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.OnTop()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Insert(0, newRegistration);
			}
		}

		private class TrackingRegistrationLocationSelector : ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			private readonly TrackingLazyComponentRegistration newRegistration;

			public TrackingRegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, TrackingLazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void ITrackingRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				Func<TArgument, TComponent> innerComponentFactory = registrations.entries[index].Factory;
				registrations.entries[index] = new LazyComponentRegistration(newRegistration.ComponentType, (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		private readonly List<LazyComponentRegistration> entries = new List<LazyComponentRegistration>();

		public int Count => entries.Count;

		public IEnumerable<Func<TArgument, TComponent>> InReverseOrder
		{
			get
			{
				int i = entries.Count - 1;
				while (i >= 0)
				{
					yield return entries[i].Factory;
					int num = i - 1;
					i = num;
				}
			}
		}

		public LazyComponentRegistrationList<TArgument, TComponent> Clone()
		{
			LazyComponentRegistrationList<TArgument, TComponent> lazyComponentRegistrationList = new LazyComponentRegistrationList<TArgument, TComponent>();
			foreach (LazyComponentRegistration entry in entries)
			{
				lazyComponentRegistrationList.entries.Add(entry);
			}
			return lazyComponentRegistrationList;
		}

		public void Clear()
		{
			entries.Clear();
		}

		public void Add(Type componentType, Func<TArgument, TComponent> factory)
		{
			entries.Add(new LazyComponentRegistration(componentType, factory));
		}

		public void Remove(Type componentType)
		{
			for (int i = 0; i < entries.Count; i++)
			{
				if (entries[i].ComponentType == componentType)
				{
					entries.RemoveAt(i);
					return;
				}
			}
			throw new KeyNotFoundException("A component registration of type '" + componentType.FullName + "' was not found.");
		}

		public IRegistrationLocationSelectionSyntax<TComponent> CreateRegistrationLocationSelector(Type componentType, Func<TArgument, TComponent> factory)
		{
			return new RegistrationLocationSelector(this, new LazyComponentRegistration(componentType, factory));
		}

		public ITrackingRegistrationLocationSelectionSyntax<TComponent> CreateTrackingRegistrationLocationSelector(Type componentType, Func<TComponent, TArgument, TComponent> factory)
		{
			return new TrackingRegistrationLocationSelector(this, new TrackingLazyComponentRegistration(componentType, factory));
		}

		public IEnumerator<Func<TArgument, TComponent>> GetEnumerator()
		{
			return entries.Select((LazyComponentRegistration e) => e.Factory).GetEnumerator();
		}

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

		private int IndexOfRegistration(Type registrationType)
		{
			for (int i = 0; i < entries.Count; i++)
			{
				if (registrationType == entries[i].ComponentType)
				{
					return i;
				}
			}
			return -1;
		}

		private void EnsureNoDuplicateRegistrationType(Type componentType)
		{
			if (IndexOfRegistration(componentType) != -1)
			{
				throw new InvalidOperationException("A component of type '" + componentType.FullName + "' has already been registered.");
			}
		}

		private int EnsureRegistrationExists<TRegistrationType>()
		{
			int num = IndexOfRegistration(typeof(TRegistrationType));
			if (num == -1)
			{
				throw new InvalidOperationException("A component of type '" + typeof(TRegistrationType).FullName + "' has not been registered.");
			}
			return num;
		}
	}
	internal static class LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder(inner)));
		}

		public static List<TComponent> BuildComponentList<TComponent>(this LazyComponentRegistrationList<Nothing, TComponent> registrations)
		{
			return registrations.Select((Func<Nothing, TComponent> factory) => factory(default(Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<TArgument, TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			return registrations.Select((Func<TArgument, TComponent> factory) => factory(argument)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct Nothing
	{
	}
	internal sealed class ObjectDescriptor : IObjectDescriptor
	{
		public object? Value { get; private set; }

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public ScalarStyle ScalarStyle { get; private set; }

		public ObjectDescriptor(object? value, Type type, Type staticType)
			: this(value, type, staticType, ScalarStyle.Any)
		{
		}

		public ObjectDescriptor(object? value, Type type, Type staticType, ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	internal delegate IObjectGraphTraversalStrategy ObjectGraphTraversalStrategyFactory(ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion);
	internal sealed class PropertyDescriptor : IPropertyDescriptor
	{
		private readonly IPropertyDescriptor baseDescriptor;

		public bool AllowNulls => baseDescriptor.AllowNulls;

		public string Name { get; set; }

		public bool Required => baseDescriptor.Required;

		public Type Type => baseDescriptor.Type;

		public Type? TypeOverride
		{
			get
			{
				return baseDescriptor.TypeOverride;
			}
			set
			{
				baseDescriptor.TypeOverride = value;
			}
		}

		public Type? ConverterType => baseDescriptor.ConverterType;

		public int Order { get; set; }

		public ScalarStyle ScalarStyle
		{
			get
			{
				return baseDescriptor.ScalarStyle;
			}
			set
			{
				baseDescriptor.ScalarStyle = value;
			}
		}

		public bool CanWrite => baseDescriptor.CanWrite;

		public PropertyDescriptor(IPropertyDescriptor baseDescriptor)
		{
			this.baseDescriptor = baseDescriptor;
			Name = baseDescriptor.Name;
		}

		public void Write(object target, object? value)
		{
			baseDescriptor.Write(target, value);
		}

		public T? GetCustomAttribute<T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	internal sealed class Serializer : ISerializer
	{
		private readonly IValueSerializer valueSerializer;

		private readonly EmitterSettings emitterSettings;

		public Serializer()
			: this(new SerializerBuilder().BuildValueSerializer(), EmitterSettings.Default)
		{
		}

		private Serializer(IValueSerializer valueSerializer, EmitterSettings emitterSettings)
		{
			this.valueSerializer = valueSerializer ?? throw new ArgumentNullException("valueSerializer");
			this.emitterSettings = emitterSettings ?? throw new ArgumentNullException("emitterSettings");
		}

		public static Serializer FromValueSerializer(IValueSerializer valueSerializer, EmitterSettings emitterSettings)
		{
			return new Serializer(valueSerializer, emitterSettings);
		}

		public string Serialize(object? graph)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph);
			return stringWriter.ToString();
		}

		public string Serialize(object? graph, Type type)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph, type);
			return stringWriter.ToString();
		}

		public void Serialize(TextWriter writer, object? graph)
		{
			Serialize(new Emitter(writer, emitterSettings), graph);
		}

		public void Serialize(TextWriter writer, object? graph, Type type)
		{
			Serialize(new Emitter(writer, emitterSettings), graph, type);
		}

		public void Serialize(IEmitter emitter, object? graph)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			EmitDocument(emitter, graph, null);
		}

		public void Serialize(IEmitter emitter, object? graph, Type type)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			EmitDocument(emitter, graph, type);
		}

		private void EmitDocument(IEmitter emitter, object? graph, Type? type)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			valueSerializer.SerializeValue(emitter, graph, type);
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: true));
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}
	}
	internal sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
	{
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

			private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(IObjectGraphTraversalStrategy traversalStrategy, IEventEmitter eventEmitter, IEnumerable<IYamlTypeConverter> typeConverters, LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories, LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			public void SerializeValue(IEmitter emitter, object? value, Type? type)
			{
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				ObjectDescriptor graph = new ObjectDescriptor(value, type2, staticType);
				List<IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(Nothing), NestedObjectSerializer);
				}
				traversalStrategy.Traverse(graph, visitor, emitter, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter, v, t);
				}
			}
		}

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

		private readonly Dictionary<Type, TagName> tagMappings = new Dictionary<Type, TagName>();

		private readonly IObjectFactory objectFactory;

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		private ScalarStyle defaultScalarStyle;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		protected override SerializerBuilder Self => this;

		public SerializerBuilder()
			: base((ITypeResolver)new DynamicTypeResolver())
		{
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(YamlAttributeOverridesInspector), (ITypeInspector inner) => (overrides == null) ? inner : new YamlAttributeOverridesInspector(inner, overrides.Clone()));
			preProcessingPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> { 
			{
				typeof(AnchorAssigner),
				(IEnumerable<IYamlTypeConverter> typeConverters) => new AnchorAssigner(typeConverters)
			} };
			emissionPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>
			{
				{
					typeof(CustomSerializationObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CustomSerializationObjectGraphVisitor(args.InnerVisitor, args.TypeConverters, args.NestedObjectSerializer)
				},
				{
					typeof(AnchorAssigningObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new AnchorAssigningObjectGraphVisitor(args.InnerVisitor, args.EventEmitter, args.GetPreProcessingPhaseObjectGraphVisitor<AnchorAssigner>())
				},
				{
					typeof(DefaultValuesObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new DefaultValuesObjectGraphVisitor(defaultValuesHandlingConfiguration, args.InnerVisitor, new DefaultObjectFactory())
				},
				{
					typeof(CommentsObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CommentsObjectGraphVisitor(args.InnerVisitor)
				}
			};
			eventEmitterFactories = new LazyComponentRegistrationList<IEventEmitter, IEventEmitter> { 
			{
				typeof(TypeAssigningEventEmitter),
				(IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector())
			} };
			objectFactory = new DefaultObjectFactory();
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, objectFactory);
		}

		public SerializerBuilder WithQuotingNecessaryStrings(bool quoteYaml1_1Strings = false)
		{
			quoteNecessaryStrings = true;
			this.quoteYaml1_1Strings = quoteYaml1_1Strings;
			return this;
		}

		public SerializerBuilder WithDefaultScalarStyle(ScalarStyle style)
		{
			defaultScalarStyle = style;
			return this;
		}

		public SerializerBuilder WithMaximumRecursion(int maximumRecursion)
		{
			if (maximumRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maximumRecursion", $"The maximum recursion specified ({maximumRecursion}) is invalid. It should be a positive integer.");
			}
			this.maximumRecursion = maximumRecursion;
			return this;
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory(e), where);
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory(inner, BuildTypeInspector())));
			return Self;
		}

		public SerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
			return Self;
		}

		public SerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

		public SerializerBuilder WithoutEventEmitter(Type eventEmitterType)
		{
			if (eventEmitterType == null)
			{
				throw new ArgumentNullException("eventEmitterType");
			}
			eventEmitterFactories.Remove(eventEmitterType);
			return this;
		}

		public override SerializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(type, out var value))
			{
				throw new ArgumentException($"Type already has a registered tag '{value}' for type '{type.FullName}'", "type");
			}
			tagMappings.Add(type, tag);
			return this;
		}

		public SerializerBuilder WithoutTagMapping(Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!tagMappings.Remove(type))
			{
				throw new KeyNotFoundException("Tag for type '" + type.FullName + "' is not registered");
			}
			return this;
		}

		public SerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, objectFactory);
			WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

		public SerializerBuilder DisableAliases()
		{
			preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigner));
			emissionPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigningObjectGraphVisitor));
			return this;
		}

		[Obsolete("The default behavior is now to always emit default values, thefore calling this method has no effect. This behavior is now controlled by ConfigureDefaultValuesHandling.", true)]
		public SerializerBuilder EmitDefaults()
		{
			return ConfigureDefaultValuesHandling(DefaultValuesHandling.Preserve);
		}

		public SerializerBuilder ConfigureDefaultValuesHandling(DefaultValuesHandling configuration)
		{
			defaultValuesHandlingConfiguration = configuration;
			return this;
		}

		public SerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName().WithUtf16SurrogatePairs();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(ScalarStyle.DoubleQuoted)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

		public SerializerBuilder WithNewLine(string newLine)
		{
			emitterSettings = emitterSettings.WithNewLine(newLine);
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitor == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory(typeConverters)));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory(wrapped)));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory(wrapped, typeConverters)));
			return this;
		}

		public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			preProcessingPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public SerializerBuilder WithObjectGraphTraversalStrategyFactory(ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
		{
			this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
			return this;
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
			return this;
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(wrapped, args)));
			return this;
		}

		public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			emissionPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public SerializerBuilder WithIndentedSequences()
		{
			emitterSettings = emitterSettings.WithIndentedSequences();
			return this;
		}

		public ISerializer Build()
		{
			if (FsharpHelper.Instance == null)
			{
				FsharpHelper.Instance = new DefaultFsharpHelper();
			}
			return Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

		public IValueSerializer BuildValueSerializer()
		{
			IEnumerable<IYamlTypeConverter> typeConverters = BuildTypeConverters();
			ITypeInspector typeInspector = BuildTypeInspector();
			IObjectGraphTraversalStrategy traversalStrategy = objectGraphTraversalStrategyFactory(typeInspector, typeResolver, typeConverters, maximumRecursion);
			IEventEmitter eventEmitter = eventEmitterFactories.BuildComponentChain(new WriterEventEmitter());
			return new ValueSerializer(traversalStrategy, eventEmitter, typeConverters, preProcessingPhaseObjectGraphVisitorFactories.Clone(), emissionPhaseObjectGraphVisitorFactories.Clone());
		}

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = new ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
			}
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	internal class Settings
	{
		public bool AllowPrivateConstructors { get; set; }
	}
	internal abstract class StaticBuilderSkeleton<TBuilder> where TBuilder : StaticBuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal INamingConvention enumNamingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal YamlFormatter yamlFormatter = YamlFormatter.Default;

		protected abstract TBuilder Self { get; }

		internal StaticBuilderSkeleton(ITypeResolver typeResolver)
		{
			typeConverterFactories = new LazyComponentRegistrationList<Nothing, IYamlTypeConverter> { 
			{
				typeof(YamlDotNet.Serialization.Converters.GuidConverter),
				(Nothing _) => new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: false)
			} };
			typeInspectorFactories = new LazyComponentRegistrationList<ITypeInspector, ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			settings = new Settings();
		}

		public TBuilder WithNamingConvention(INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithEnumNamingConvention(INamingConvention enumNamingConvention)
		{
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			return Self;
		}

		public TBuilder WithTypeResolver(ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(TagName tag, Type type);

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter, Action<IRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where)
		{
			if (typeConverter == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (Nothing _) => typeConverter));
			return Self;
		}

		public TBuilder WithTypeConverter<TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			if (typeConverterFactory == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
		{
			return WithoutTypeConverter(typeof(TYamlTypeConverter));
		}

		public TBuilder WithoutTypeConverter(Type converterType)
		{
			if (converterType == null)
			{
				throw new ArgumentNullException("converterType");
			}
			typeConverterFactories.Remove(converterType);
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

		public TBuilder WithoutTypeInspector(Type inspectorType)
		{
			if (inspectorType == null)
			{
				throw new ArgumentNullException("inspectorType");
			}
			typeInspectorFactories.Remove(inspectorType);
			return Self;
		}

		public TBuilder WithYamlFormatter(YamlFormatter formatter)
		{
			yamlFormatter = formatter ?? throw new ArgumentNullException("formatter");
			return Self;
		}

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal abstract class StaticContext
	{
		public virtual bool IsKnownType(Type type)
		{
			throw new NotImplementedException();
		}

		public virtual ITypeResolver GetTypeResolver()
		{
			throw new NotImplementedException();
		}

		public virtual StaticObjectFactory GetFactory()
		{
			throw new NotImplementedException();
		}

		public virtual ITypeInspector GetTypeInspector()
		{
			throw new NotImplementedException();
		}
	}
	internal sealed class StaticDeserializerBuilder : StaticBuilderSkeleton<StaticDeserializerBuilder>
	{
		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

		private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<TagName, Type> tagMappings;

		private readonly ITypeConverter typeConverter;

		private readonly Dictionary<Type, Type> typeMappings;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		private bool enforceNullability;

		private bool caseInsensitivePropertyMatching;

		protected override StaticDeserializerBuilder Self => this;

		public StaticDeserializerBuilder(StaticContext context)
			: base(context.GetTypeResolver())
		{
			this.context = context;
			factory = context.GetFactory();
			typeMappings = new Dictionary<Type, Type>();
			tagMappings = new Dictionary<TagName, Type>
			{
				{
					FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			nodeDeserializerFactories = new LazyComponentRegistrationList<Nothing, INodeDeserializer>
			{
				{
					typeof(YamlConvertibleNodeDeserializer),
					(Nothing _) => new YamlConvertibleNodeDeserializer(factory)
				},
				{
					typeof(YamlSerializableNodeDeserializer),
					(Nothing _) => new YamlSerializableNodeDeserializer(factory)
				},
				{
					typeof(TypeConverterNodeDeserializer),
					(Nothing _) => new TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(NullNodeDeserializer),
					(Nothing _) => new NullNodeDeserializer()
				},
				{
					typeof(ScalarNodeDeserializer),
					(Nothing _) => new ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter, BuildTypeInspector(), yamlFormatter, enumNamingConvention)
				},
				{
					typeof(StaticArrayNodeDeserializer),
					(Nothing _) => new StaticArrayNodeDeserializer(factory)
				},
				{
					typeof(StaticDictionaryNodeDeserializer),
					(Nothing _) => new StaticDictionaryNodeDeserializer(factory, duplicateKeyChecking)
				},
				{
					typeof(StaticCollectionNodeDeserializer),
					(Nothing _) => new StaticCollectionNodeDeserializer(factory)
				},
				{
					typeof(ObjectNodeDeserializer),
					(Nothing _) => new ObjectNodeDeserializer(factory, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter, enumNamingConvention, enforceNullability, caseInsensitivePropertyMatching, enforceRequiredProperties: false, BuildTypeConverters())
				}
			};
			nodeTypeResolverFactories = new LazyComponentRegistrationList<Nothing, INodeTypeResolver>
			{
				{
					typeof(MappingNodeTypeResolver),
					(Nothing _) => new MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(YamlConvertibleTypeResolver),
					(Nothing _) => new YamlConvertibleTypeResolver()
				},
				{
					typeof(YamlSerializableTypeResolver),
					(Nothing _) => new YamlSerializableTypeResolver()
				},
				{
					typeof(TagNodeTypeResolver),
					(Nothing _) => new TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(PreventUnknownTagsNodeTypeResolver),
					(Nothing _) => new PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(DefaultContainersNodeTypeResolver),
					(Nothing _) => new DefaultContainersNodeTypeResolver()
				}
			};
			typeConverter = new NullTypeConverter();
		}

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}

		public StaticDeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
		{
			attemptUnknownTypeDeserialization = true;
			return this;
		}

		public StaticDeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public StaticDeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer, Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>> where)
		{
			if (nodeDeserializer == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (Nothing _) => nodeDeserializer));
			return this;
		}

		public StaticDeserializerBuilder WithNodeDeserializer<TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			if (nodeDeserializerFactory == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithCaseInsensitivePropertyMatching()
		{
			caseInsensitivePropertyMatching = true;
			return this;
		}

		public StaticDeserializerBuilder WithEnforceNullability()
		{
			enforceNullability = true;
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeDeserializer<TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public StaticDeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public StaticDeserializerBuilder WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
		{
			TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
			configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
			TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
			{
				s.Before<DictionaryNodeDeserializer>();
			});
		}

		public StaticDeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public StaticDeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
		{
			if (nodeTypeResolver == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (Nothing _) => nodeTypeResolver));
			return this;
		}

		public StaticDeserializerBuilder WithNodeTypeResolver<TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			if (nodeTypeResolverFactory == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeTypeResolver<TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public StaticDeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override StaticDeserializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(tag, out Type value))
			{
				throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
			}
			tagMappings.Add(tag, type);
			return this;
		}

		public StaticDeserializerBuilder WithTypeMapping<TInterface, TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			typeMappings[typeFromHandle] = typeFromHandle2;
			return this;
		}

		public StaticDeserializerBuilder WithoutTagMapping(TagName tag)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (!tagMappings.Remove(tag))
			{
				throw new KeyNotFoundException($"Tag '{tag}' is not registered");
			}
			return this;
		}

		public StaticDeserializerBuilder IgnoreUnmatchedProperties()
		{
			ignoreUnmatched = true;
			return this;
		}

		public StaticDeserializerBuilder WithDuplicateKeyChecking()
		{
			duplicateKeyChecking = true;
			return this;
		}

		public IDeserializer Build()
		{
			return Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public IValueDeserializer BuildValueDeserializer()
		{
			return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter, enumNamingConvention, BuildTypeInspector()));
		}
	}
	internal sealed class StaticSerializerBuilder : StaticBuilderSkeleton<StaticSerializerBuilder>
	{
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

			private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(IObjectGraphTraversalStrategy traversalStrategy, IEventEmitter eventEmitter, IEnumerable<IYamlTypeConverter> typeConverters, LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories, LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			public void SerializeValue(IEmitter emitter, object? value, Type? type)
			{
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				ObjectDescriptor graph = new ObjectDescriptor(value, type2, staticType);
				List<IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(Nothing), NestedObjectSerializer);
				}
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>(new EmittingObjectGraphVisitor(eventEmitter), (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter, NestedObjectSerializer);
				void NestedObjectSerializer(object? v, Type? t)
				{
					SerializeValue(emitter, v, t);
				}
			}
		}

		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

		private readonly Dictionary<Type, TagName> tagMappings = new Dictionary<Type, TagName>();

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		private ScalarStyle defaultScalarStyle;

		protected override StaticSerializerBuilder Self => this;

		public StaticSerializerBuilder(StaticContext context)
			: base((ITypeResolver)new DynamicTypeResolver())
		{
			this.context = context;
			factory = context.GetFactory();
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			preProcessingPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> { 
			{
				typeof(AnchorAssigner),
				(IEnumerable<IYamlTypeConverter> typeConverters) => new AnchorAssigner(typeConverters)
			} };
			emissionPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>
			{
				{
					typeof(CustomSerializationObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CustomSerializationObjectGraphVisitor(args.InnerVisitor, args.TypeConverters, args.NestedObjectSerializer)
				},
				{
					typeof(AnchorAssigningObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new AnchorAssigningObjectGraphVisitor(args.InnerVisitor, args.EventEmitter, args.GetPreProcessingPhaseObjectGraphVisitor<AnchorAssigner>())
				},
				{
					typeof(DefaultValuesObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new DefaultValuesObjectGraphVisitor(defaultValuesHandlingConfiguration, args.InnerVisitor, factory)
				},
				{
					typeof(CommentsObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CommentsObjectGraphVisitor(args.InnerVisitor)
				}
			};
			eventEmitterFactories = new LazyComponentRegistrationList<IEventEmitter, IEventEmitter> { 
			{
				typeof(TypeAssigningEventEmitter),
				(IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter, enumNamingConvention, BuildTypeInspector())
			} };
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, factory);
		}

		public StaticSerializerBuilder WithQuotingNecessaryStrings(bool quoteYaml1_1Strings = false)
		{
			quoteNecessaryStrings = true;
			this.quoteYaml1_1Strings = quoteYaml1_1Strings;
			return this;
		}

		public StaticSerializerBuilder WithQuotingNecessaryStrings()
		{
			quoteNecessaryStrings = true;
			return this;
		}

		public StaticSerializerBuilder WithDefaultScalarStyle(ScalarStyle style)
		{
			defaultScalarStyle = style;
			return this;
		}

		public StaticSerializerBuilder WithMaximumRecursion(int maximumRecursion)
		{
			if (maximumRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maximumRecursion", $"The maximum recursion specified ({maximumRecursion}) is invalid. It should be a positive integer.");
			}
			this.maximumRecursion = maximumRecursion;
			return this;
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter((IEventEmitter e, ITypeInspector _) => eventEmitterFactory(e), where);
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(Func<IEventEmitter, ITypeInspector, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory(inner, BuildTypeInspector())));
			return Self;
		}

		public StaticSerializerBuilder WithEventEmitter<TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
			return Self;
		}

		public StaticSerializerBuilder WithoutEventEmitter<TEventEmitter>() where TEventEmitter : IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

		public StaticSerializerBuilder WithoutEventEmitter(Type eventEmitterType)
		{
			if (eventEmitterType == null)
			{
				throw new ArgumentNullException("eventEmitterType");
			}
			eventEmitterFactories.Remove(eventEmitterType);
			return this;
		}

		public override StaticSerializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(type, out var value))
			{
				throw new ArgumentException($"Type already has a registered tag '{value}' for type '{type.FullName}'", "type");
			}
			tagMappings.Add(type, tag);
			return this;
		}

		public StaticSerializerBuilder WithoutTagMapping(Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!tagMappings.Remove(type))
			{
				throw new KeyNotFoundException("Tag for type '" + type.FullName + "' is not registered");
			}
			return this;
		}

		public StaticSerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, factory);
			WithEventEmitter((IEventEmitter inner) => new TypeAssigningEventEmitter(inner, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings: false, ScalarStyle.Plain, YamlFormatter.Default, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector((ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

		public StaticSerializerBuilder DisableAliases()
		{
			preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigner));
			emissionPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigningObjectGraphVisitor));
			return this;
		}

		[Obsolete("The default behavior is now to always emit default values, thefore calling this method has no effect. This behavior is now controlled by ConfigureDefaultValuesHandling.", true)]
		public StaticSerializerBuilder EmitDefaults()
		{
			return ConfigureDefaultValuesHandling(DefaultValuesHandling.Preserve);
		}

		public StaticSerializerBuilder ConfigureDefaultValuesHandling(DefaultValuesHandling configuration)
		{
			defaultValuesHandlingConfiguration = configuration;
			return this;
		}

		public StaticSerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName().WithUtf16SurrogatePairs();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new DateTime8601Converter(ScalarStyle.DoubleQuoted)).WithEventEmitter((IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter, enumNamingConvention, BuildTypeInspector()), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

		public StaticSerializerBuilder WithNewLine(string newLine)
		{
			emitterSettings = emitterSettings.WithNewLine(newLine);
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitor == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<IEnumerable<IYamlTypeConverter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory(typeConverters)));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory(wrapped)));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> typeConverters) => objectGraphVisitorFactory(wrapped, typeConverters)));
			return this;
		}

		public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			preProcessingPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public StaticSerializerBuilder WithObjectGraphTraversalStrategyFactory(ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
		{
			this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(wrapped, args)));
			return this;
		}

		public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			emissionPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public StaticSerializerBuilder WithIndentedSequences()
		{
			emitterSettings = emitterSettings.WithIndentedSequences();
			return this;
		}

		public ISerializer Build()
		{
			return Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

		public IValueSerializer BuildValueSerializer()
		{
			IEnumerable<IYamlTypeConverter> typeConverters = BuildTypeConverters();
			ITypeInspector typeInspector = BuildTypeInspector();
			IObjectGraphTraversalStrategy traversalStrategy = objectGraphTraversalStrategyFactory(typeInspector, typeResolver, typeConverters, maximumRecursion);
			IEventEmitter eventEmitter = eventEmitterFactories.BuildComponentChain(new WriterEventEmitter());
			return new ValueSerializer(traversalStrategy, eventEmitter, typeConverters, preProcessingPhaseObjectGraphVisitorFactories.Clone(), emissionPhaseObjectGraphVisitorFactories.Clone());
		}

		public ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	internal sealed class StreamFragment : IYamlConvertible
	{
		private readonly List<ParsingEvent> events = new List<ParsingEvent>();

		public IList<ParsingEvent> Events => events;

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			events.Clear();
			int num = 0;
			do
			{
				if (!parser.MoveNext())
				{
					throw new InvalidOperationException("The parser has reached the end before deserialization completed.");
				}
				ParsingEvent current = parser.Current;
				events.Add(current);
				num += current.NestingIncrease;
			}
			while (num > 0);
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			foreach (ParsingEvent @event in events)
			{
				emitter.Emit(@event);
			}
		}
	}
	internal sealed class TagMappings
	{
		private readonly Dictionary<string, Type> mappings;

		public TagMappings()
		{
			mappings = new Dictionary<string, Type>();
		}

		public TagMappings(IDictionary<string, Type> mappings)
		{
			this.mappings = new Dictionary<string, Type>(mappings);
		}

		public void Add(string tag, Type mapping)
		{
			mappings.Add(tag, mapping);
		}

		internal Type? GetMapping(string tag)
		{
			if (!mappings.TryGetValue(tag, out Type value))
			{
				return null;
			}
			return value;
		}
	}
	internal sealed class YamlAttributeOverrides
	{
		private readonly struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

			public AttributeKey(Type attributeType, string propertyName)
			{
				AttributeType = attributeType;
				PropertyName = propertyName;
			}

			public override bool Equals(object? obj)
			{
				if (obj is AttributeKey attributeKey && AttributeType.Equals(attributeKey.AttributeType))
				{
					return PropertyName.Equals(attributeKey.PropertyName);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return YamlDotNet.Core.HashCode.CombineHashCodes(AttributeType.GetHashCode(), PropertyName.GetHashCode());
			}
		}

		private sealed class AttributeMapping
		{
			public readonly Type RegisteredType;

			public readonly Attribute Attribute;

			public AttributeMapping(Type registeredType, Attribute attribute)
			{
				RegisteredType = registeredType;
				Attribute = attribute;
			}

			public override bool Equals(object? obj)
			{
				if (obj is AttributeMapping attributeMapping && RegisteredType.Equals(attributeMapping.RegisteredType))
				{
					return Attribute.Equals(attributeMapping.Attribute);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return YamlDotNet.Core.HashCode.CombineHashCodes(RegisteredType.GetHashCode(), Attribute.GetHashCode());
			}

			public int Matches(Type matchType)
			{
				int num = 0;
				Type type = matchType;
				while (type != null)
				{
					num++;
					if (type == RegisteredType)
					{
						return num;
					}
					type = type.BaseType();
				}
				if (matchType.GetInterfaces().Contains(RegisteredType))
				{
					return num;
				}
				return 0;
			}
		}

		private readonly Dictionary<AttributeKey, List<AttributeMapping>> overrides = new Dictionary<AttributeKey, List<AttributeMapping>>();

		[return: MaybeNull]
		public T GetAttribute<T>(Type type, string member) where T : Attribute
		{
			if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out List<AttributeMapping> value))
			{
				int num = 0;
				AttributeMapping attributeMapping = null;
				foreach (AttributeMapping item in value)
				{
					int num2 = item.Matches(type);
					if (num2 > num)
					{
						num = num2;
						attributeMapping = item;
					}
				}
				if (num > 0)
				{
					return (T)attributeMapping.Attribute;
				}
			}
			return null;
		}

		public void Add(Type type, string member, Attribute attribute)
		{
			AttributeMapping item = new AttributeMapping(type, attribute);
			AttributeKey key = new AttributeKey(attribute.GetType(), member);
			if (!overrides.TryGetValue(key, out List<AttributeMapping> value))
			{
				value = new List<AttributeMapping>();
				overrides.Add(key, value);
			}
			else if (value.Contains(item))
			{
				throw new InvalidOperationException($"Attribute ({attribute}) already set for Type {type.FullName}, Member {member}");
			}
			value.Add(item);
		}

		public YamlAttributeOverrides Clone()
		{
			YamlAttributeOverrides yamlAttributeOverrides = new YamlAttributeOverrides();
			foreach (KeyValuePair<AttributeKey, List<AttributeMapping>> @override in overrides)
			{
				foreach (AttributeMapping item in @override.Value)
				{
					yamlAttributeOverrides.Add(item.RegisteredType, @override.Key.PropertyName, item.Attribute);
				}
			}
			return yamlAttributeOverrides;
		}

		public void Add<TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			PropertyInfo propertyInfo = propertyAccessor.AsProperty();
			Add(typeof(TClass), propertyInfo.Name, attribute);
		}
	}
	internal sealed class YamlAttributeOverridesInspector : ReflectionTypeInspector
	{
		public sealed class OverridePropertyDescriptor : IPropertyDescriptor
		{
			private readonly IPropertyDescriptor baseDescriptor;

			private readonly YamlAttributeOverrides overrides;

			private readonly Type classType;

			public string Name => baseDescriptor.Name;

			public bool Required => baseDescriptor.Required;

			public bool AllowNulls => baseDescriptor.AllowNulls;

			public bool CanWrite => baseDescriptor.CanWrite;

			public Type Type => baseDescriptor.Type;

			public Type? TypeOverride
			{
				get
				{
					return baseDescriptor.TypeOverride;
				}
				set
				{
					baseDescriptor.TypeOverride = value;
				}
			}

			public Type? ConverterType => GetCustomAttribute<YamlConverterAttribute>()?.ConverterType ?? baseDescriptor.ConverterType;

			public int Order
			{
				get
				{
					return baseDescriptor.Order;
				}
				set
				{
					baseDescriptor.Order = value;
				}
			}

			public ScalarStyle ScalarStyle
			{
				get
				{
					return baseDescriptor.ScalarStyle;
				}
				set
				{
					baseDescriptor.ScalarStyle = value;
				}
			}

			public OverridePropertyDescriptor(IPropertyDescriptor baseDescriptor, YamlAttributeOverrides overrides, Type classType)
			{
				this.baseDescriptor = baseDescriptor;
				this.overrides = overrides;
				this.classType = classType;
			}

			public void Write(object target, object? value)
			{
				baseDescriptor.Write(target, value);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				T attribute = overrides.GetAttribute<T>(classType, Name);
				return attribute ?? baseDescriptor.GetCustomAttribute<T>();
			}

			public IObjectDescriptor Read(object target)
			{
				return baseDescriptor.Read(target);
			}
		}

		private readonly ITypeInspector innerTypeDescriptor;

		private readonly YamlAttributeOverrides overrides;

		public YamlAttributeOverridesInspector(ITypeInspector innerTypeDescriptor, YamlAttributeOverrides overrides)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
			this.overrides = overrides;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			IEnumerable<IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<IPropertyDescriptor, IPropertyDescriptor>)((IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type)));
			}
			return enumerable;
		}
	}
	internal sealed class YamlAttributesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		public YamlAttributesTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
					where p.GetCustomAttribute<YamlIgnoreAttribute>() == null
					select p).Select((Func<IPropertyDescriptor, IPropertyDescriptor>)delegate(IPropertyDescriptor p)
				{
					PropertyDescriptor propertyDescriptor = new PropertyDescriptor(p);
					YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
					if (customAttribute != null)
					{
						if (customAttribute.SerializeAs != null)
						{
							propertyDescriptor.TypeOverride = customAttribute.SerializeAs;
						}
						propertyDescriptor.Order = customAttribute.Order;
						propertyDescriptor.ScalarStyle = customAttribute.ScalarStyle;
						if (customAttribute.Alias != null)
						{
							propertyDescriptor.Name = customAttribute.Alias;
						}
					}
					return propertyDescriptor;
				})
				orderby p.Order
				select p;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
	internal sealed class YamlConverterAttribute : Attribute
	{
		public Type ConverterType { get; }

		public YamlConverterAttribute(Type converterType)
		{
			ConverterType = converterType;
		}
	}
	internal class YamlFormatter
	{
		public static YamlFormatter Default { get; } = new YamlFormatter();

		public NumberFormatInfo NumberFormat { get; set; } = new NumberFormatInfo
		{
			CurrencyDecimalSeparator = ".",
			CurrencyGroupSeparator = "_",
			CurrencyGroupSizes = new int[1] { 3 },
			CurrencySymbol = string.Empty,
			CurrencyDecimalDigits = 99,
			NumberDecimalSeparator = ".",
			NumberGroupSeparator = "_",
			NumberGroupSizes = new int[1] { 3 },
			NumberDecimalDigits = 99,
			NaNSymbol = ".nan",
			PositiveInfinitySymbol = ".inf",
			NegativeInfinitySymbol = "-.inf"
		};

		public virtual Func<object, ITypeInspector, INamingConvention, string> FormatEnum { get; set; } = delegate(object value, ITypeInspector typeInspector, INamingConvention enumNamingConvention)
		{
			string empty = string.Empty;
			empty = ((value != null) ? typeInspector.GetEnumValue(value) : string.Empty);
			return enumNamingConvention.Apply(empty);
		};

		public virtual Func<object, bool> PotentiallyQuoteEnums { get; set; } = (object _) => true;

		public string FormatNumber(object number)
		{
			return Convert.ToString(number, NumberFormat);
		}

		public string FormatNumber(double number)
		{
			return number.ToString("G", NumberFormat);
		}

		public string FormatNumber(float number)
		{
			return number.ToString("G", NumberFormat);
		}

		public string FormatBoolean(object boolean)
		{
			if (!boolean.Equals(true))
			{
				return "false";
			}
			return "true";
		}

		public string FormatDateTime(object dateTime)
		{
			return ((DateTime)dateTime).ToString("o", CultureInfo.InvariantCulture);
		}

		public string FormatTimeSpan(object timeSpan)
		{
			return ((TimeSpan)timeSpan/*cast due to .constrained prefix*/).ToString();
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class YamlIgnoreAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class YamlMemberAttribute : Attribute
	{
		private DefaultValuesHandling? defaultValuesHandling;

		public string? Description { get; set; }

		public Type? SerializeAs { get; set; }

		public int Order { get; set; }

		public string? Alias { get; set; }

		public bool ApplyNamingConventions { get; set; }

		public ScalarStyle ScalarStyle { get; set; }

		public DefaultValuesHandling DefaultValuesHandling
		{
			get
			{
				return defaultValuesHandling.GetValueOrDefault();
			}
			set
			{
				defaultValuesHandling = value;
			}
		}

		public bool IsDefaultValuesHandlingSpecified => defaultValuesHandling.HasValue;

		public YamlMemberAttribute()
		{
			ScalarStyle = ScalarStyle.Any;
			ApplyNamingConventions = true;
		}

		public YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum, Inherited = false, AllowMultiple = true)]
	internal sealed class YamlSerializableAttribute : Attribute
	{
		public YamlSerializableAttribute()
		{
		}

		public YamlSerializableAttribute(Type serializableType)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	internal sealed class YamlStaticContextAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.ValueDeserializers
{
	internal sealed class AliasValueDeserializer : IValueDeserializer
	{
		private sealed class AliasState : Dictionary<AnchorName, ValuePromise>, IPostDeserializationCallback
		{
			public void OnDeserialization()
			{
				foreach (ValuePromise value in base.Values)
				{
					if (!value.HasValue)
					{
						YamlDotNet.Core.Events.AnchorAlias alias = value.Alias;
						throw new AnchorNotFoundException(alias.Start, alias.End, $"Anchor '{alias.Value}' not found");
					}
				}
			}
		}

		private sealed class ValuePromise : IValuePromise
		{
			private object? value;

			public readonly YamlDotNet.Core.Events.AnchorAlias? Alias;

			public bool HasValue { get; private set; }

			public object? Value
			{
				get
				{
					if (!HasValue)
					{
						throw new InvalidOperationException("Value not set");
					}
					return value;
				}
				set
				{
					if (HasValue)
					{
						throw new InvalidOperationException("Value already set");
					}
					HasValue = true;
					this.value = value;
					this.ValueAvailable?.Invoke(value);
				}
			}

			public event Action<object?>? ValueAvailable;

			public ValuePromise(YamlDotNet.Core.Events.AnchorAlias alias)
			{
				Alias = alias;
			}

			public ValuePromise(object? value)
			{
				HasValue = true;
				this.value = value;
			}
		}

		private readonly IValueDeserializer innerDeserializer;

		public AliasValueDeserializer(IValueDeserializer innerDeserializer)
		{
			this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
		}

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var @event))
			{
				AliasState aliasState = state.Get<AliasState>();
				if (!aliasState.TryGetValue(@event.Value, out ValuePromise value))
				{
					throw new AnchorNotFoundException(@event.Start, @event.End, $"Alias ${@event.Value} cannot precede anchor declaration");
				}
				if (!value.HasValue)
				{
					return value;
				}
				return value.Value;
			}
			AnchorName anchorName = AnchorName.Empty;
			if (parser.Accept<NodeEvent>(out var event2) && !event2.Anchor.IsEmpty)
			{
				anchorName = event2.Anchor;
				AliasState aliasState2 = state.Get<AliasState>();
				if (!aliasState2.ContainsKey(anchorName))
				{
					aliasState2[anchorName] = new ValuePromise(new YamlDotNet.Core.Events.AnchorAlias(anchorName));
				}
			}
			object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
			if (!anchorName.IsEmpty)
			{
				AliasState aliasState3 = state.Get<AliasState>();
				if (!aliasState3.TryGetValue(anchorName, out ValuePromise value2))
				{
					aliasState3.Add(anchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState3[anchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	internal sealed class NodeValueDeserializer : IValueDeserializer
	{
		private readonly IList<INodeDeserializer> deserializers;

		private readonly IList<INodeTypeResolver> typeResolvers;

		private readonly ITypeConverter typeConverter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public NodeValueDeserializer(IList<INodeDeserializer> deserializers, IList<INodeTypeResolver> typeResolvers, ITypeConverter typeConverter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.deserializers = deserializers ?? throw new ArgumentNullException("deserializers");
			this.typeResolvers = typeResolvers ?? throw new ArgumentNullException("typeResolvers");
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.typeInspector = typeInspector;
		}

		public object? DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			parser.Accept<NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			ObjectDeserializer rootDeserializer = (Type x) => DeserializeValue(parser, x, state, nestedObjectDeserializer);
			try
			{
				foreach (INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser, typeFromEvent, (IParser r, Type t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out object value, rootDeserializer))
					{
						return typeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
					}
				}
			}
			catch (YamlException)
			{
				throw;
			}
			catch (Exception innerException)
			{
				throw new YamlException(@event?.Start ?? Mark.Empty, @event?.End ?? Mark.Empty, "Exception during deserialization", innerException);
			}
			throw new YamlException(@event?.Start ?? Mark.Empty, @event?.End ?? Mark.Empty, "No node deserializer was able to deserialize the node into type " + expectedType.AssemblyQualifiedName);
		}

		private Type GetTypeFromEvent(NodeEvent? nodeEvent, Type currentType)
		{
			foreach (INodeTypeResolver typeResolver in typeResolvers)
			{
				if (typeResolver.Resolve(nodeEvent, ref currentType))
				{
					break;
				}
			}
			return currentType;
		}
	}
}
namespace YamlDotNet.Serialization.Utilities
{
	internal interface IPostDeserializationCallback
	{
		void OnDeserialization();
	}
	internal interface ITypeConverter
	{
		object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector);
	}
	internal class NullTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return value;
		}
	}
	internal sealed class ObjectAnchorCollection
	{
		private readonly Dictionary<string, object> objectsByAnchor = new Dictionary<string, object>();

		private readonly Dictionary<object, string> anchorsByObject = new Dictionary<object, string>();

		public object this[string anchor]
		{
			get
			{
				if (objectsByAnchor.TryGetValue(anchor, out object value))
				{
					return value;
				}
				throw new AnchorNotFoundException("The anchor '" + anchor + "' does not exists");
			}
		}

		public void Add(string anchor, object @object)
		{
			objectsByAnchor.Add(anchor, @object);
			if (@object != null)
			{
				anchorsByObject.Add(@object, anchor);
			}
		}

		public bool TryGetAnchor(object @object, [MaybeNullWhen(false)] out string? anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	internal class ReflectionTypeConverter : ITypeConverter
	{
		public object? ChangeType(object? value, Type expectedType, ITypeInspector typeInspector)
		{
			return ChangeType(value, expectedType, NullNamingConvention.Instance, typeInspector);
		}

		public object? ChangeType(object? value, Type expectedType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return TypeConverter.ChangeType(value, expectedType, enumNamingConvention, typeInspector);
		}
	}
	internal sealed class SerializerState : IDisposable
	{
		private readonly Dictionary<Type, object> items = new Dictionary<Type, object>();

		public T Get<T>() where T : class, new()
		{
			if (!items.TryGetValue(typeof(T), out object value))
			{
				value = new T();
				items.Add(typeof(T), value);
			}
			return (T)value;
		}

		public void OnDeserialization()
		{
			foreach (IPostDeserializationCallback item in items.Values.OfType<IPostDeserializationCallback>())
			{
				item.OnDeserialization();
			}
		}

		public void Dispose()
		{
			foreach (IDisposable item in items.Values.OfType<IDisposable>())
			{
				item.Dispose();
			}
		}
	}
	internal static class StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", (Match match) => match.Groups["char"].Value.ToUpperInvariant(), RegexOptions.IgnoreCase);
			return firstLetterTransform(text[0]) + text.Substring(1);
		}

		public static string ToCamelCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToLowerInvariant);
		}

		public static string ToPascalCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToUpperInvariant);
		}

		public static string FromCamelCase(this string str, string separator)
		{
			str = char.ToLower(str[0], CultureInfo.InvariantCulture) + str.Substring(1);
			str = Regex.Replace(str.ToCamelCase(), "(?<char>[A-Z])", (Match match) => separator + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	internal static class TypeConverter
	{
		public static T ChangeType<T>(object? value, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return (T)ChangeType(value, typeof(T), enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return ChangeType(value, destinationType, CultureInfo.InvariantCulture, enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, IFormatProvider provider, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			return ChangeType(value, destinationType, new CultureInfoAdapter(CultureInfo.CurrentCulture, provider), enumNamingConvention, typeInspector);
		}

		public static object? ChangeType(object? value, Type destinationType, CultureInfo culture, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			if (value == null || value.IsDbNull())
			{
				if (!destinationType.IsValueType())
				{
					return null;
				}
				return Activator.CreateInstance(destinationType);
			}
			Type type = value.GetType();
			if (destinationType == type || destinationType.IsAssignableFrom(type))
			{
				return value;
			}
			if (destinationType.IsGenericType())
			{
				Type genericTypeDefinition = destinationType.GetGenericTypeDefinition();
				if (genericTypeDefinition == typeof(Nullable<>) || FsharpHelper.IsOptionType(genericTypeDefinition))
				{
					Type destinationType2 = destinationType.GetGenericArguments()[0];
					object obj = ChangeType(value, destinationType2, culture, enumNamingConvention, typeInspector);
					return Activator.CreateInstance(destinationType, obj);
				}
			}
			if (destinationType.IsEnum())
			{
				object result = value;
				if (value is string value2)
				{
					string name = enumNamingConvention.Reverse(value2);
					name = typeInspector.GetEnumName(destinationType, name);
					result = Enum.Parse(destinationType, name, ignoreCase: true);
				}
				return result;
			}
			if (destinationType == typeof(bool))
			{
				if ("0".Equals(value))
				{
					return false;
				}
				if ("1".Equals(value))
				{
					return true;
				}
			}
			System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
			if (converter != null && converter.CanConvertTo(destinationType))
			{
				return converter.ConvertTo(null, culture, value, destinationType);
			}
			System.ComponentModel.TypeConverter converter2 = TypeDescriptor.GetConverter(destinationType);
			if (converter2 != null && converter2.CanConvertFrom(type))
			{
				return converter2.ConvertFrom(null, culture, value);
			}
			Type[] array = new Type[2] { type, destinationType };
			foreach (Type type2 in array)
			{
				foreach (MethodInfo publicStaticMethod2 in type2.GetPublicStaticMethods())
				{
					if (!publicStaticMethod2.IsSpecialName || (!(publicStaticMethod2.Name == "op_Implicit") && !(publicStaticMethod2.Name == "op_Explicit")) || !destinationType.IsAssignableFrom(publicStaticMethod2.ReturnParameter.ParameterType))
					{
						continue;
					}
					ParameterInfo[] parameters = publicStaticMethod2.GetParameters();
					if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(type))
					{
						try
						{
							return publicStaticMethod2.Invoke(null, new object[1] { value });
						}
						catch (TargetInvocationException ex)
						{
							throw ex.InnerException;
						}
					}
				}
			}
			if (type == typeof(string))
			{
				try
				{
					MethodInfo publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string), typeof(IFormatProvider));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[2] { value, culture });
					}
					publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[1] { value });
					}
				}
				catch (TargetInvocationException ex2)
				{
					throw ex2.InnerException;
				}
			}
			if (destinationType == typeof(TimeSpan))
			{
				return TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture, enumNamingConvention, typeInspector), CultureInfo.InvariantCulture);
			}
			return Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		public static void RegisterTypeConverter<TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any((TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
	internal sealed class TypeConverterCache
	{
		private readonly IYamlTypeConverter[] typeConverters;

		private readonly ConcurrentDictionary<Type, (bool HasMatch, IYamlTypeConverter? TypeConverter)> cache = new ConcurrentDictionary<Type, (bool, IYamlTypeConverter)>();

		public TypeConverterCache(IEnumerable<IYamlTypeConverter>? typeConverters)
			: this(typeConverters?.ToArray() ?? Array.Empty<IYamlTypeConverter>())
		{
		}

		public TypeConverterCache(IYamlTypeConverter[] typeConverters)
		{
			this.typeConverters = typeConverters;
		}

		public bool TryGetConverterForType(Type type, [NotNullWhen(true)] out IYamlTypeConverter? typeConverter)
		{
			(bool, IYamlTypeConverter) orAdd = DictionaryExtensions.GetOrAdd(cache, type, (Type t, IYamlTypeConverter[] tc) => LookupTypeConverter(t, tc), typeConverters);
			typeConverter = orAdd.Item2;
			return orAdd.Item1;
		}

		public IYamlTypeConverter GetConverterByType(Type converter)
		{
			IYamlTypeConverter[] array = typeConverters;
			foreach (IYamlTypeConverter yamlTypeConverter in array)
			{
				if (yamlTypeConverter.GetType() == converter)
				{
					return yamlTypeConverter;
				}
			}
			throw new ArgumentException("IYamlTypeConverter of type " + converter.FullName + " not found", "converter");
		}

		private static (bool HasMatch, IYamlTypeConverter? TypeConverter) LookupTypeConverter(Type type, IYamlTypeConverter[] typeConverters)
		{
			foreach (IYamlTypeConverter yamlTypeConverter in typeConverters)
			{
				if (yamlTypeConverter.Accepts(type))
				{
					return (HasMatch: true, TypeConverter: yamlTypeConverter);
				}
			}
			return (HasMatch: false, TypeConverter: null);
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	internal sealed class DynamicTypeResolver : ITypeResolver
	{
		public Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	internal class StaticTypeResolver : ITypeResolver
	{
		public virtual Type Resolve(Type staticType, object? actualValue)
		{
			if (actualValue != null)
			{
				if (actualValue.GetType().IsEnum)
				{
					return staticType;
				}
				switch (actualValue.GetType().GetTypeCode())
				{
				case TypeCode.Boolean:
					return typeof(bool);
				case TypeCode.Char:
					return typeof(char);
				case TypeCode.SByte:
					return typeof(sbyte);
				case TypeCode.Byte:
					return typeof(byte);
				case TypeCode.Int16:
					return typeof(short);
				case TypeCode.UInt16:
					return typeof(ushort);
				case TypeCode.Int32:
					return typeof(int);
				case TypeCode.UInt32:
					return typeof(uint);
				case TypeCode.Int64:
					return typeof(long);
				case TypeCode.UInt64:
					return typeof(ulong);
				case TypeCode.Single:
					return typeof(float);
				case TypeCode.Double:
					return typeof(double);
				case TypeCode.Decimal:
					return typeof(decimal);
				case TypeCode.String:
					return typeof(string);
				case TypeCode.DateTime:
					return typeof(DateTime);
				}
			}
			return staticType;
		}
	}
}
namespace YamlDotNet.Serialization.TypeInspectors
{
	internal class CachedTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		private readonly ConcurrentDictionary<Type, List<IPropertyDescriptor>> cache = new ConcurrentDictionary<Type, List<IPropertyDescriptor>>();

		private readonly ConcurrentDictionary<Type, ConcurrentDictionary<string, string>> enumNameCache = new ConcurrentDictionary<Type, ConcurrentDictionary<string, string>>();

		private readonly ConcurrentDictionary<object, string> enumValueCache = new ConcurrentDictionary<object, string>();

		public CachedTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			ConcurrentDictionary<string, string> orAdd = enumNameCache.GetOrAdd(enumType, (Type _) => new ConcurrentDictionary<string, string>());
			return DictionaryExtensions.GetOrAdd(orAdd, name, delegate(string n, (Type enumType, ITypeInspector innerTypeDescriptor) context)
			{
				var (enumType2, typeInspector) = context;
				return typeInspector.GetEnumName(enumType2, n);
			}, (enumType, innerTypeDescriptor));
		}

		public override string GetEnumValue(object enumValue)
		{
			return DictionaryExtensions.GetOrAdd(enumValueCache, enumValue, delegate(object _, (object enumValue, ITypeInspector innerTypeDescriptor) context)
			{
				var (enumValue2, typeInspector) = context;
				return typeInspector.GetEnumValue(enumValue2);
			}, (enumValue, innerTypeDescriptor));
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return DictionaryExtensions.GetOrAdd(cache, type, delegate(Type t, (object container, ITypeInspector innerTypeDescriptor) context)
			{
				var (container2, typeInspector) = context;
				return typeInspector.GetProperties(t, container2).ToList();
			}, (container, innerTypeDescriptor));
		}
	}
	internal class CompositeTypeInspector : TypeInspectorSkeleton
	{
		private readonly IEnumerable<ITypeInspector> typeInspectors;

		public CompositeTypeInspector(params ITypeInspector[] typeInspectors)
			: this((IEnumerable<ITypeInspector>)typeInspectors)
		{
		}

		public CompositeTypeInspector(IEnumerable<ITypeInspector> typeInspectors)
		{
			this.typeInspectors = typeInspectors?.ToList() ?? throw new ArgumentNullException("typeInspectors");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			foreach (ITypeInspector typeInspector in typeInspectors)
			{
				try
				{
					return typeInspector.GetEnumName(enumType, name);
				}
				catch
				{
				}
			}
			throw new ArgumentOutOfRangeException("enumType,name", "Name not found on enum type");
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				throw new ArgumentNullException("enumValue");
			}
			foreach (ITypeInspector typeInspector in typeInspectors)
			{
				try
				{
					return typeInspector.GetEnumValue(enumValue);
				}
				catch
				{
				}
			}
			throw new ArgumentOutOfRangeException("enumValue", $"Value not found for ({enumValue})");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return typeInspectors.SelectMany((ITypeInspector i) => i.GetProperties(type, container));
		}
	}
	internal class NamingConventionTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		private readonly INamingConvention namingConvention;

		public NamingConventionTypeInspector(ITypeInspector innerTypeDescriptor, INamingConvention namingConvention)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return innerTypeDescriptor.GetProperties(type, container).Select(delegate(IPropertyDescriptor p)
			{
				YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
				return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new PropertyDescriptor(p)
				{
					Name = namingConvention.Apply(p.Name)
				};
			});
		}
	}
	internal class ReadableAndWritablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		public ReadableAndWritablePropertiesTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override string GetEnumName(Type enumType, string name)
		{
			return innerTypeDescriptor.GetEnumName(enumType, name);
		}

		public override string GetEnumValue(object enumValue)
		{
			return innerTypeDescriptor.GetEnumValue(enumValue);
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	internal class ReadableFieldsTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionFieldDescriptor : IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public bool Required => fieldInfo.IsRequired();

			public Type Type => fieldInfo.FieldType;

			public Type? ConverterType { get; }

			public Type? TypeOverride { get; set; }

			public bool AllowNulls => fieldInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => !fieldInfo.IsInitOnly;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionFieldDescriptor(FieldInfo fieldInfo, ITypeResolver typeResolver)
			{
				this.fieldInfo = fieldInfo;
				this.typeResolver = typeResolver;
				YamlConverterAttribute customAttribute = fieldInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
				ScalarStyle = ScalarStyle.Any;
			}

			public void Write(object target, object? value)
			{
				fieldInfo.SetValue(target, value);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				object[] customAttributes = fieldInfo.GetCustomAttributes(typeof(T), inherit: true);
				return (T)customAttributes.FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object value = fieldInfo.GetValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, value);
				return new ObjectDescriptor(value, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		public ReadableFieldsTypeInspector(ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetPublicFields().Select((Func<FieldInfo, IPropertyDescriptor>)((FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	internal class ReadablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = ScalarStyle.Any;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

			public void Write(object target, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				Attribute[] allCustomAttributes = propertyInfo.GetAllCustomAttributes<T>();
				return (T)allCustomAttributes.FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object obj = propertyInfo.ReadValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public ReadablePropertiesTypeInspector(ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public ReadablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.includeNonPublicProperties = includeNonPublicProperties;
		}

		private static bool IsValidProperty(PropertyInfo property)
		{
			if (property.CanRead)
			{
				return property.GetGetMethod(nonPublic: true).GetParameters().Length == 0;
			}
			return false;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	internal abstract class ReflectionTypeInspector : TypeInspectorSkeleton
	{
		public override string GetEnumName(Type enumType, string name)
		{
			return name;
		}

		public override string GetEnumValue(object enumValue)
		{
			if (enumValue == null)
			{
				return string.Empty;
			}
			return enumValue.ToString();
		}
	}
	internal abstract class TypeInspectorSkeleton : ITypeInspector
	{
		public abstract string GetEnumName(Type enumType, string name);

		public abstract string GetEnumValue(object enumValue);

		public abstract IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container);

		public IPropertyDescriptor GetProperty(Type type, object? container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched, bool caseInsensitivePropertyMatching)
		{
			IEnumerable<IPropertyDescriptor> enumerable = ((!caseInsensitivePropertyMatching) ? (from p in GetProperties(type, container)
				where p.Name == name
				select p) : (from p in GetProperties(type, container)
				where p.Name.Equals(name, StringComparison.OrdinalIgnoreCase)
				select p));
			using IEnumerator<IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				if (ignoreUnmatched)
				{
					return null;
				}
				throw new SerializationException("Property '" + name + "' not found on type '" + type.FullName + "'.");
			}
			IPropertyDescriptor current = enumerator.Current;
			if (enumerator.MoveNext())
			{
				throw new SerializationException("Multiple properties with the name/alias '" + name + "' already exists on type '" + type.FullName + "', maybe you're misusing YamlAlias or maybe you are using the wrong naming convention? The matching properties are: " + string.Join(", ", enumerable.Select((IPropertyDescriptor p) => p.Name).ToArray()));
			}
			return current;
		}
	}
	internal class WritablePropertiesTypeInspector : ReflectionTypeInspector
	{
		protected class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public bool Required => propertyInfo.IsRequired();

			public Type Type => propertyInfo.PropertyType;

			public Type? TypeOverride { get; set; }

			public Type? ConverterType { get; set; }

			public bool AllowNulls => propertyInfo.AcceptsNull();

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = ScalarStyle.Any;
				YamlConverterAttribute customAttribute = propertyInfo.GetCustomAttribute<YamlConverterAttribute>();
				if (customAttribute != null)
				{
					ConverterType = customAttribute.ConverterType;
				}
			}

			public void Write(object target, object? value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			public T? GetCustomAttribute<T>() where T : Attribute
			{
				Attribute[] allCustomAttributes = propertyInfo.GetAllCustomAttributes<T>();
				return (T)allCustomAttributes.FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object obj = propertyInfo.ReadValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public WritablePropertiesTypeInspector(ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public WritablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.includeNonPublicProperties = includeNonPublicProperties;
		}

		private static bool IsValidProperty(PropertyInfo property)
		{
			if (property.CanWrite)
			{
				return property.GetSetMethod(nonPublic: true).GetParameters().Length == 1;
			}
			return false;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, object? container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)((PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)))
				.ToArray();
		}
	}
}
namespace YamlDotNet.Serialization.Schemas
{
	internal sealed class FailsafeSchema
	{
		public static class Tags
		{
			public static readonly TagName Map = new TagName("tag:yaml.org,2002:map");

			public static readonly TagName Seq = new TagName("tag:yaml.org,2002:seq");

			public static readonly TagName Str = new TagName("tag:yaml.org,2002:str");
		}
	}
	internal sealed class JsonSchema
	{
		public static class Tags
		{
			public static readonly TagName Null = new TagName("tag:yaml.org,2002:null");

			public static readonly TagName Bool = new TagName("tag:yaml.org,2002:bool");

			public static readonly TagName Int = new TagName("tag:yaml.org,2002:int");

			public static readonly TagName Float = new TagName("tag:yaml.org,2002:float");
		}
	}
	internal sealed class CoreSchema
	{
		public static class Tags
		{
		}
	}
	internal sealed class DefaultSchema
	{
		public static class Tags
		{
			public static readonly TagName Timestamp = new TagName("tag:yaml.org,2002:timestamp");
		}
	}
}
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
	internal sealed class AnchorAssigner : PreProcessingPhaseObjectGraphVisitorSkeleton, IAliasProvider
	{
		private class AnchorAssignment
		{
			public AnchorName Anchor;
		}

		private readonly Dictionary<object, AnchorAssignment> assignments = new Dictionary<object, AnchorAssignment>();

		private uint nextId;

		public AnchorAssigner(IEnumerable<IYamlTypeConverter> typeConverters)
			: base(typeConverters)
		{
		}

		protected override bool Enter(IObjectDescriptor value, ObjectSerializer serializer)
		{
			if (value.Value != null && assignments.TryGetValue(value.Value, out AnchorAssignment value2))
			{
				if (value2.Anchor.IsEmpty)
				{
					value2.Anchor = new AnchorName("o" + nextId.ToString(CultureInfo.InvariantCulture));
					nextId++;
				}
				return false;
			}
			return true;
		}

		protected override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, ObjectSerializer serializer)
		{
			return true;
		}

		protected override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, ObjectSerializer serializer)
		{
			return true;
		}

		protected override void VisitScalar(IObjectDescriptor scalar, ObjectSerializer serializer)
		{
		}

		protected override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, ObjectSerializer serializer)
		{
			VisitObject(mapping);
		}

		protected override void VisitMappingEnd(IObjectDescriptor mapping, ObjectSerializer serializer)
		{
		}

		protected override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, ObjectSerializer serializer)
		{
			VisitObject(sequence);
		}

		protected override void VisitSequenceEnd(IObjectDescriptor sequence, ObjectSerializer serializer)
		{
		}

		private void VisitObject(IObjectDescriptor value)
		{
			if (value.Value != null)
			{
				assignments.Add(value.Value, new AnchorAssignment());
			}
		}

		AnchorName IAliasProvider.GetAlias(object target)
		{
			if (target != null && assignments.TryGetValue(target, out AnchorAssignment value))
			{
				return value.Anchor;
			}
			return AnchorName.Empty;
		}
	}
	internal sealed class AnchorAssigningObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly IEventEmitter eventEmitter;

		private readonly IAliasProvider aliasProvider;

		private readonly HashSet<AnchorName> emittedAliases = new HashSet<AnchorName>();

		public AnchorAssigningObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEventEmitter eventEmitter, IAliasProvider aliasProvider)
			: base(nextVisitor)
		{
			this.eventEmitter = eventEmitter;
			this.aliasProvider = aliasProvider;
		}

		public override bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (value.Value != null)
			{
				AnchorName alias = aliasProvider.GetAlias(value.Value);
				if (!alias.IsEmpty && !emittedAliases.Add(alias))
				{
					AliasEventInfo aliasEventInfo = new AliasEventInfo(value, alias);
					eventEmitter.Emit(aliasEventInfo, context);
					return aliasEventInfo.NeedsExpansion;
				}
			}
			return base.Enter(propertyDescriptor, value, context, serializer);
		}

		public override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			AnchorName alias = aliasProvider.GetAlias(mapping.NonNullValue());
			eventEmitter.Emit(new MappingStartEventInfo(mapping)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			AnchorName alias = aliasProvider.GetAlias(sequence.NonNullValue());
			eventEmitter.Emit(new SequenceStartEventInfo(sequence)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			ScalarEventInfo scalarEventInfo = new ScalarEventInfo(scalar);
			if (scalar.Value != null)
			{
				scalarEventInfo.Anchor = aliasProvider.GetAlias(scalar.Value);
			}
			eventEmitter.Emit(scalarEventInfo, context);
		}
	}
	internal abstract class ChainedObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IObjectGraphVisitor<IEmitter> nextVisitor;

		protected ChainedObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
		{
			this.nextVisitor = nextVisitor;
		}

		public virtual bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.Enter(propertyDescriptor, value, context, serializer);
		}

		public virtual bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return nextVisitor.EnterMapping(key, value, context, serializer);
		}

		public virtual void VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitScalar(scalar, context, serializer);
		}

		public virtual void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingStart(mapping, keyType, valueType, context, serializer);
		}

		public virtual void VisitMappingEnd(IObjectDescriptor mapping, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitMappingEnd(mapping, context, serializer);
		}

		public virtual void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceStart(sequence, elementType, context, serializer);
		}

		public virtual void VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context, ObjectSerializer serializer)
		{
			nextVisitor.VisitSequenceEnd(sequence, context, serializer);
		}
	}
	internal sealed class CommentsObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public CommentsObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.Description != null)
			{
				context.Emit(new YamlDotNet.Core.Events.Comment(customAttribute.Description, isInline: false));
			}
			return base.EnterMapping(key, value, context, serializer);
		}
	}
	internal sealed class CustomSerializationObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly TypeConverterCache typeConverters;

		private readonly ObjectSerializer nestedObjectSerializer;

		public CustomSerializationObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
			: base(nextVisitor)
		{
			this.typeConverters = new TypeConverterCache(typeConverters);
			this.nestedObjectSerializer = nestedObjectSerializer;
		}

		public override bool Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (propertyDescriptor?.ConverterType != null)
			{
				IYamlTypeConverter converterByType = typeConverters.GetConverterByType(propertyDescriptor.ConverterType);
				converterByType.WriteYaml(context, value.Value, value.Type, serializer);
				return false;
			}
			if (typeConverters.TryGetConverterForType(value.Type, out IYamlTypeConverter typeConverter))
			{
				typeConverter.WriteYaml(context, value.Value, value.Type, serializer);
				return false;
			}
			if (value.Value is IYamlConvertible yamlConvertible)
			{
				yamlConvertible.Write(context, nestedObjectSerializer);
				return false;
			}
			if (value.Value is IYamlSerializable yamlSerializable)
			{
				yamlSerializable.WriteYaml(context);
				return false;
			}
			return base.Enter(propertyDescriptor, value, context, serializer);
		}
	}
	internal sealed class DefaultExclusiveObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public DefaultExclusiveObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		private static object? GetDefault(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			if (!object.Equals(value.Value, GetDefault(value.Type)))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			DefaultValueAttribute customAttribute = key.GetCustomAttribute<DefaultValueAttribute>();
			object objB = ((customAttribute != null) ? customAttribute.Value : GetDefault(key.Type));
			if (!object.Equals(value.Value, objB))
			{
				return base.EnterMapping(key, value, context, serializer);
			}
			return false;
		}
	}
	internal sealed class DefaultValuesObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly DefaultValuesHandling handling;

		private readonly IObjectFactory factory;

		public DefaultValuesObjectGraphVisitor(DefaultValuesHandling handling, IObjectGraphVisitor<IEmitter> nextVisitor, IObjectFactory factory)
			: base(nextVisitor)
		{
			this.handling = handling;
			this.factory = factory;
		}

		private object? GetDefault(Type type)
		{
			return factory.CreatePrimitive(type);
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			DefaultValuesHandling defaultValuesHandling = handling;
			YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.IsDefaultValuesHandlingSpecified)
			{
				defaultValuesHandling = customAttribute.DefaultValuesHandling;
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitNull) != DefaultValuesHandling.Preserve && value.Value == null)
			{
				return false;
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitEmptyCollections) != DefaultValuesHandling.Preserve && value.Value is IEnumerable enumerable)
			{
				IEnumerator enumerator = enumerable.GetEnumerator();
				bool flag = enumerator.MoveNext();
				if (enumerator is IDisposable disposable)
				{
					disposable.Dispose();
				}
				if (!flag)
				{
					return false;
				}
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitDefaults) != DefaultValuesHandling.Preserve)
			{
				object objB = key.GetCustomAttribute<DefaultValueAttribute>()?.Value ?? GetDefault(key.Type);
				if (object.Equals(value.Value, objB))
				{
					return false;
				}
			}
			return base.EnterMapping(key, value, context, serializer);
		}
	}
	internal sealed class EmittingObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IEventEmitter eventEmitter;

		public EmittingObjectGraphVisitor(IEventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}

		bool IObjectGraphVisitor<IEmitter>.Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context, ObjectSerializer serializer)
		{
			return true;
		}

		void IObjectGraphVisitor<IEmitter>.VisitScalar(IObjectDescriptor scalar, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new ScalarEventInfo(scalar), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new MappingStartEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingEnd(IObjectDescriptor mapping, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new MappingEndEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new SequenceStartEventInfo(sequence), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context, ObjectSerializer serializer)
		{
			eventEmitter.Emit(new SequenceEndEventInfo(sequence), context);
		}
	}
	internal abstract class PreProcessingPhaseObjectGraphVisitorSkeleton : IObjectGraphVisitor<Nothing>
	{
		protected readonly IEnumerable<IYamlTypeConverter> typeConverters;

		private readonly TypeConverterCache typeConverterCache;

		public PreProcessingPhaseObjectGraphVisitorSkeleton(IEnumerable<IYamlTypeConverter> typeConverters)
		{
			typeConverterCache = new TypeConverterCache((IYamlTypeConverter[])(this.typeConverters = typeConverters?.ToArray() ?? Array.Empty<IYamlTypeConverter>()));
		}

		bool IObjectGraphVisitor<Nothing>.Enter(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			if (typeConverterCache.TryGetConverterForType(value.Type, out IYamlTypeConverter _))
			{
				return false;
			}
			if (value.Value is IYamlConvertible)
			{
				return false;
			}
			if (value.Value is IYamlSerializable)
			{
				return false;
			}
			return Enter(value, serializer);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, Nothing context, ObjectSerializer serializer)
		{
			return EnterMapping(key, value, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingEnd(IObjectDescriptor mapping, Nothing context, ObjectSerializer serializer)
		{
			VisitMappingEnd(mapping, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, Nothing context, ObjectSerializer serializer)
		{
			VisitMappingStart(mapping, keyType, valueType, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitScalar(IObjectDescriptor scalar, Nothing context, ObjectSerializer serializer)
		{
			VisitScalar(scalar, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceEnd(IObjectDescriptor sequence, Nothing context, ObjectSerializer serializer)
		{
			VisitSequenceEnd(sequence, serializer);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, Nothing context, ObjectSerializer serializer)
		{
			VisitSequenceStart(sequence, elementType, serializer);
		}

		protected abstract bool Enter(IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, ObjectSerializer serializer);

		protected abstract void VisitMappingEnd(IObjectDescriptor mapping, ObjectSerializer serializer);

		protected abstract void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, ObjectSerializer serializer);

		protected abstract void VisitScalar(IObjectDescriptor scalar, ObjectSerializer serializer);

		protected abstract void VisitSequenceEnd(IObjectDescriptor sequence, ObjectSerializer serializer);

		protected abstract void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, ObjectSerializer serializer);
	}
}
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
	internal class FullObjectGraphTraversalStrategy : IObjectGraphTraversalStrategy
	{
		protected readonly struct ObjectPathSegment
		{
			public readonly object Name;

			public readonly IObjectDescriptor Value;

			public ObjectPathSegment(object name, IObjectDescriptor value)
			{
				Name = name;
				Value = value;
			}
		}

		private readonly int maxRecursion;

		private readonly ITypeInspector typeDescriptor;

		private readonly ITypeResolver typeResolver;

		private readonly INamingConvention namingConvention;

		private readonly IObjectFactory objectFactory;

		public FullObjectGraphTraversalStrategy(ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention, IObjectFactory objectFactory)
		{
			if (maxRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maxRecursion", maxRecursion, "maxRecursion must be greater than 1");
			}
			this.typeDescriptor = typeDescriptor ?? throw new ArgumentNullException("typeDescriptor");
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.maxRecursion = maxRecursion;
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		void IObjectGraphTraversalStrategy.Traverse<TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context, ObjectSerializer serializer)
		{
			Traverse(null, "<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion), serializer);
		}

		protected virtual void Traverse<TContext>(IPropertyDescriptor? propertyDescriptor, object name, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (path.Count >= maxRecursion)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Too much recursion when traversing the object graph.");
				stringBuilder.AppendLine("The path to reach this recursion was:");
				Stack<KeyValuePair<string, string>> stack = new Stack<KeyValuePair<string, string>>(path.Count);
				int num = 0;
				foreach (ObjectPathSegment item in path)
				{
					string text = item.Name?.ToString() ?? string.Empty;
					num = Math.Max(num, text.Length);
					stack.Push(new KeyValuePair<string, string>(text, item.Value.Type.FullName));
				}
				foreach (KeyValuePair<string, string> item2 in stack)
				{
					stringBuilder.Append(" -> ").Append(item2.Key.PadRight(num)).Append("  [")
						.Append(item2.Value)
						.AppendLine("]");
				}
				throw new MaximumRecursionLevelReachedException(stringBuilder.ToString());
			}
			if (!visitor.Enter(propertyDescriptor, value, context, serializer))
			{
				return;
			}
			path.Push(new ObjectPathSegment(name, value));
			try
			{
				TypeCode typeCode = value.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
				case TypeCode.Char:
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
				case TypeCode.Single:
				case TypeCode.Double:
				case TypeCode.Decimal:
				case TypeCode.DateTime:
				case TypeCode.String:
					visitor.VisitScalar(value, context, serializer);
					return;
				case TypeCode.Empty:
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
				if (value.IsDbNull())
				{
					visitor.VisitScalar(new ObjectDescriptor(null, typeof(object), typeof(object)), context, serializer);
				}
				if (value.Value == null || value.Type == typeof(TimeSpan))
				{
					visitor.VisitScalar(value, context, serializer);
					return;
				}
				Type underlyingType = Nullable.GetUnderlyingType(value.Type);
				Type type = underlyingType ?? FsharpHelper.GetOptionUnderlyingType(value.Type);
				object obj = ((type != null) ? FsharpHelper.GetValue(value) : null);
				if (underlyingType != null)
				{
					Traverse(propertyDescriptor, "Value", new ObjectDescriptor(value.Value, underlyingType, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else if (type != null && obj != null)
				{
					Traverse(propertyDescriptor, "Value", new ObjectDescriptor(FsharpHelper.GetValue(value), type, value.Type, value.ScalarStyle), visitor, context, path, serializer);
				}
				else
				{
					TraverseObject(propertyDescriptor, value, visitor, context, path, serializer);
				}
			}
			finally
			{
				path.Pop();
			}
		}

		protected virtual void TraverseObject<TContext>(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			IDictionary dictionary;
			Type[] genericArguments;
			if (typeof(IDictionary).IsAssignableFrom(value.Type))
			{
				TraverseDictionary(propertyDescriptor, value, visitor, typeof(object), typeof(object), context, path, serializer);
			}
			else if (objectFactory.GetDictionary(value, out dictionary, out genericArguments))
			{
				TraverseDictionary(propertyDescriptor, new ObjectDescriptor(dictionary, value.Type, value.StaticType, value.ScalarStyle), visitor, genericArguments[0], genericArguments[1], context, path, serializer);
			}
			else if (typeof(IEnumerable).IsAssignableFrom(value.Type))
			{
				TraverseList(propertyDescriptor, value, visitor, context, path, serializer);
			}
			else
			{
				TraverseProperties(value, visitor, context, path, serializer);
			}
		}

		protected virtual void TraverseDictionary<TContext>(IPropertyDescriptor? propertyDescriptor, IObjectDescriptor dictionary, IObjectGraphVisitor<TContext> visitor, Type keyType, Type valueType, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			visitor.VisitMappingStart(dictionary, keyType, valueType, context, serializer);
			bool flag = dictionary.Type.FullName.Equals("System.Dynamic.ExpandoObject");
			foreach (DictionaryEntry? item in (IDictionary)dictionary.NonNullValue())
			{
				DictionaryEntry value = item.Value;
				object obj = (flag ? namingConvention.Apply(value.Key.ToString()) : value.Key);
				ObjectDescriptor objectDescriptor = GetObjectDescriptor(obj, keyType);
				ObjectDescriptor objectDescriptor2 = GetObjectDescriptor(value.Value, valueType);
				if (visitor.EnterMapping(objectDescriptor, objectDescriptor2, context, serializer))
				{
					Traverse(propertyDescriptor, obj, objectDescriptor, visitor, context, path, serializer);
					Traverse(propertyDescriptor, obj, objectDescriptor2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(dictionary, context, serializer);
		}

		private void TraverseList<TContext>(IPropertyDescriptor propertyDescriptor, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			Type valueType = objectFactory.GetValueType(value.Type);
			visitor.VisitSequenceStart(value, valueType, context, serializer);
			int num = 0;
			foreach (object item in (IEnumerable)value.NonNullValue())
			{
				Traverse(propertyDescriptor, num, GetObjectDescriptor(item, valueType), visitor, context, path, serializer);
				num++;
			}
			visitor.VisitSequenceEnd(value, context, serializer);
		}

		protected virtual void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerializing(value.Value);
			}
			visitor.VisitMappingStart(value, typeof(string), typeof(object), context, serializer);
			object obj = value.NonNullValue();
			foreach (IPropertyDescriptor property in typeDescriptor.GetProperties(value.Type, obj))
			{
				IObjectDescriptor value2 = property.Read(obj);
				if (visitor.EnterMapping(property, value2, context, serializer))
				{
					Traverse(null, property.Name, new ObjectDescriptor(property.Name, typeof(string), typeof(string), ScalarStyle.Plain), visitor, context, path, serializer);
					Traverse(property, property.Name, value2, visitor, context, path, serializer);
				}
			}
			visitor.VisitMappingEnd(value, context, serializer);
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerialized(value.Value);
			}
		}

		private ObjectDescriptor GetObjectDescriptor(object? value, Type staticType)
		{
			return new ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	internal class RoundtripObjectGraphTraversalStrategy : FullObjectGraphTraversalStrategy
	{
		private readonly TypeConverterCache converters;

		private readonly Settings settings;

		public RoundtripObjectGraphTraversalStrategy(IEnumerable<IYamlTypeConverter> converters, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention, Settings settings, IObjectFactory factory)
			: base(typeDescriptor, typeResolver, maxRecursion, namingConvention, factory)
		{
			this.converters = new TypeConverterCache(converters);
			this.settings = settings;
		}

		protected override void TraverseProperties<TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path, ObjectSerializer serializer)
		{
			if (!value.Type.HasDefaultConstructor(settings.AllowPrivateConstructors) && !converters.TryGetConverterForType(value.Type, out IYamlTypeConverter _))
			{
				throw new InvalidOperationException($"Type '{value.Type}' cannot be deserialized because it does not have a default constructor or a type converter.");
			}
			base.TraverseProperties(value, visitor, context, path, serializer);
		}
	}
}
namespace YamlDotNet.Serialization.ObjectFactories
{
	internal class DefaultObjectFactory : ObjectFactoryBase
	{
		private readonly Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>> stateMethods = new Dictionary<Type, ConcurrentDictionary<Type, MethodInfo[]>>
		{
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute),
				new ConcurrentDictionary<Type, MethodInfo[]>()
			}
		};

		private readonly Dictionary<Type, Type> defaultGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable<>),
				typeof(List<>)
			},
			{
				typeof(ICollection<>),
				typeof(List<>)
			},
			{
				typeof(IList<>),
				typeof(List<>)
			},
			{
				typeof(IDictionary<, >),
				typeof(Dictionary<, >)
			}
		};

		private readonly Dictionary<Type, Type> defaultNonGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable),
				typeof(List<object>)
			},
			{
				typeof(ICollection),
				typeof(List<object>)
			},
			{
				typeof(IList),
				typeof(List<object>)
			},
			{
				typeof(IDictionary),
				typeof(Dictionary<object, object>)
			}
		};

		private readonly Settings settings;

		public DefaultObjectFactory()
			: this(new Dictionary<Type, Type>(), new Settings())
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> mappings)
			: this(mappings, new Settings())
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> mappings, Settings settings)
		{
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
				defaultNonGenericInterfaceImplementations.Add(mapping.Key, mapping.Value);
			}
			this.settings = settings;
		}

		public override object Create(Type type)
		{
			if (type.IsInterface())
			{
				Type value2;
				if (type.IsGenericType())
				{
					if (defaultGenericInterfaceImplementations.TryGetValue(type.GetGenericTypeDefinition(), out Type value))
					{
						type = value.MakeGenericType(type.GetGenericArguments());
					}
				}
				else if (defaultNonGenericInterfaceImplementations.TryGetValue(type, out value2))
				{
					type = value2;
				}
			}
			try
			{
				return Activator.CreateInstance(type, settings.AllowPrivateConstructors);
			}
			catch (Exception innerException)
			{
				string message = "Failed to create an instance of type '" + type.FullName + "'.";
				throw new InvalidOperationException(message, innerException);
			}
		}

		public override void ExecuteOnDeserialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute), value);
		}

		public override void ExecuteOnDeserializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute), value);
		}

		public override void ExecuteOnSerialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute), value);
		}

		public override void ExecuteOnSerializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute), value);
		}

		private void ExecuteState(Type attributeType, object value)
		{
			if (value != null)
			{
				Type type = value.GetType();
				MethodInfo[] array = GetStateMethods(attributeType, type);
				MethodInfo[] array2 = array;
				foreach (MethodInfo methodInfo in array2)
				{
					methodInfo.Invoke(value, null);
				}
			}
		}

		private MethodInfo[] GetStateMethods(Type attributeType, Type valueType)
		{
			ConcurrentDictionary<Type, MethodInfo[]> concurrentDictionary = stateMethods[attributeType];
			return concurrentDictionary.GetOrAdd(valueType, delegate(Type type)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				return methods.Where((MethodInfo x) => x.GetCustomAttributes(attributeType, inherit: true).Length != 0).ToArray();
			});
		}
	}
	internal sealed class LambdaObjectFactory : ObjectFactoryBase
	{
		private readonly Func<Type, object> factory;

		public LambdaObjectFactory(Func<Type, object> factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public override object Create(Type type)
		{
			return factory(type);
		}
	}
	internal abstract class ObjectFactoryBase : IObjectFactory
	{
		public abstract object Create(Type type);

		public virtual object? CreatePrimitive(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public virtual void ExecuteOnDeserialized(object value)
		{
		}

		public virtual void ExecuteOnDeserializing(object value)
		{
		}

		public virtual void ExecuteOnSerialized(object value)
		{
		}

		public virtual void ExecuteOnSerializing(object value)
		{
		}

		public virtual bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			Type implementationOfOpenGenericInterface = descriptor.Type.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			if (implementationOfOpenGenericInterface != null)
			{
				genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				object obj = Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(genericArguments), descriptor.Value);
				dictionary = obj as IDictionary;
				return true;
			}
			genericArguments = null;
			dictionary = null;
			return false;
		}

		public virtual Type GetValueType(Type type)
		{
			Type implementationOfOpenGenericInterface = type.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
			return (implementationOfOpenGenericInterface != null) ? implementationOfOpenGenericInterface.GetGenericArguments()[0] : typeof(object);
		}
	}
	internal abstract class StaticObjectFactory : IObjectFactory
	{
		public abstract object Create(Type type);

		public abstract Array CreateArray(Type type, int count);

		public abstract bool IsDictionary(Type type);

		public abstract bool IsArray(Type type);

		public abstract bool IsList(Type type);

		public abstract Type GetKeyType(Type type);

		public abstract Type GetValueType(Type type);

		public virtual object? CreatePrimitive(Type type)
		{
			return Type.GetTypeCode(type) switch
			{
				TypeCode.Boolean => false, 
				TypeCode.Byte => (byte)0, 
				TypeCode.Int16 => (short)0, 
				TypeCode.Int32 => 0, 
				TypeCode.Int64 => 0L, 
				TypeCode.SByte => (sbyte)0, 
				TypeCode.UInt16 => (ushort)0, 
				TypeCode.UInt32 => 0u, 
				TypeCode.UInt64 => 0uL, 
				TypeCode.Single => 0f, 
				TypeCode.Double => 0.0, 
				TypeCode.Decimal => 0m, 
				TypeCode.Char => '\0', 
				TypeCode.DateTime => default(DateTime), 
				_ => null, 
			};
		}

		public bool GetDictionary(IObjectDescriptor descriptor, out IDictionary? dictionary, out Type[]? genericArguments)
		{
			dictionary = null;
			genericArguments = null;
			return false;
		}

		public abstract void ExecuteOnDeserializing(object value);

		public abstract void ExecuteOnDeserialized(object value);

		public abstract void ExecuteOnSerializing(object value);

		public abstract void ExecuteOnSerialized(object value);
	}
}
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
	internal sealed class DefaultContainersNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (currentType == typeof(object))
			{
				if (nodeEvent is SequenceStart)
				{
					currentType = typeof(List<object>);
					return true;
				}
				if (nodeEvent is MappingStart)
				{
					currentType = typeof(Dictionary<object, object>);
					return true;
				}
			}
			return false;
		}
	}
	internal class MappingNodeTypeResolver : INodeTypeResolver
	{
		private readonly IDictionary<Type, Type> mappings;

		public MappingNodeTypeResolver(IDictionary<Type, Type> mappings)
		{
			if (mappings == null)
			{
				throw new ArgumentNullException("mappings");
			}
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
			}
			this.mappings = mappings;
		}

		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (mappings.TryGetValue(currentType, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	internal class PreventUnknownTagsNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				throw new YamlException(nodeEvent.Start, nodeEvent.End, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
			}
			return false;
		}
	}
	internal sealed class TagNodeTypeResolver : INodeTypeResolver
	{
		private readonly IDictionary<TagName, Type> tagMappings;

		public TagNodeTypeResolver(IDictionary<TagName, Type> tagMappings)
		{
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
		}

		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty && tagMappings.TryGetValue(nodeEvent.Tag, out Type value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	[Obsolete("The mechanism that this class uses to specify type names is non-standard. Register the tags explicitly instead of using this convention.")]
	internal sealed class TypeNameInTagNodeTypeResolver : INodeTypeResolver
	{
		bool INodeTypeResolver.Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Type type = Type.GetType(nodeEvent.Tag.Value.Substring(1), throwOnError: false);
				if (type != null)
				{
					currentType = type;
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class YamlConvertibleTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	internal sealed class YamlSerializableTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent? nodeEvent, ref Type currentType)
		{
			return typeof(IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	internal sealed class ArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public ArrayNodeDeserializer(INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!expectedType.IsArray)
			{
				value = false;
				return false;
			}
			Type itemType = expectedType.GetElementType();
			ArrayList arrayList = new ArrayList();
			Array array = null;
			CollectionNodeDeserializer.DeserializeHelper(itemType, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector, PromiseResolvedHandler);
			array = Array.CreateInstance(itemType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
			void PromiseResolvedHandler(int index, object? value2)
			{
				if (array == null)
				{
					throw new InvalidOperationException("Destination array is still null");
				}
				array.SetValue(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(value2, itemType, enumNamingConvention, typeInspector), index);
			}
		}
	}
	internal abstract class CollectionDeserializer
	{
		protected static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, IObjectFactory objectFactory)
		{
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						throw new ForwardAnchorNotSupportedException(current?.Start ?? Mark.Empty, current?.End ?? Mark.Empty, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(objectFactory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result[index] = v;
					};
				}
				else
				{
					result.Add(obj);
				}
			}
		}
	}
	internal sealed class CollectionNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public CollectionNodeDeserializer(IObjectFactory objectFactory, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			bool canUpdate = true;
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(ICollection<>));
			Type type;
			IList list;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				value = objectFactory.Create(expectedType);
				list = value as IList;
				if (list == null)
				{
					Type implementationOfOpenGenericInterface2 = expectedType.GetImplementationOfOpenGenericInterface(typeof(IList<>));
					canUpdate = implementationOfOpenGenericInterface2 != null;
					list = (IList)Activator.CreateInstance(typeof(GenericCollectionToNonGenericAdapter<>).MakeGenericType(type), value);
				}
			}
			else
			{
				if (!typeof(IList).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				value = objectFactory.Create(expectedType);
				list = (IList)value;
			}
			DeserializeHelper(type, parser, nestedObjectDeserializer, list, canUpdate, enumNamingConvention, typeInspector);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, bool canUpdate, INamingConvention enumNamingConvention, ITypeInspector typeInspector, Action<int, object?>? promiseResolvedHandler = null)
		{
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						throw new ForwardAnchorNotSupportedException(current?.Start ?? Mark.Empty, current?.End ?? Mark.Empty, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(tItem.IsValueType() ? Activator.CreateInstance(tItem) : null);
					if (promiseResolvedHandler != null)
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							promiseResolvedHandler(index, v);
						};
					}
					else
					{
						valuePromise.ValueAvailable += delegate(object? v)
						{
							result[index] = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(v, tItem, enumNamingConvention, typeInspector);
						};
					}
				}
				else
				{
					result.Add(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(obj, tItem, enumNamingConvention, typeInspector));
				}
			}
		}
	}
	internal abstract class DictionaryDeserializer
	{
		private readonly bool duplicateKeyChecking;

		public DictionaryDeserializer(bool duplicateKeyChecking)
		{
			this.duplicateKeyChecking = duplicateKeyChecking;
		}

		private void TryAssign(IDictionary result, object key, object value, MappingStart propertyName)
		{
			if (duplicateKeyChecking && result.Contains(key))
			{
				throw new YamlException(propertyName.Start, propertyName.End, $"Encountered duplicate key {key}");
			}
			result[key] = value;
		}

		protected virtual void Deserialize(Type tKey, Type tValue, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IDictionary result, ObjectDeserializer rootDeserializer)
		{
			MappingStart property = parser.Consume<MappingStart>();
			MappingEnd @event;
			while (!parser.TryConsume<MappingEnd>(out @event))
			{
				object key = nestedObjectDeserializer(parser, tKey);
				object value = nestedObjectDeserializer(parser, tValue);
				IValuePromise valuePromise = value as IValuePromise;
				if (key is IValuePromise valuePromise2)
				{
					if (valuePromise == null)
					{
						valuePromise2.ValueAvailable += delegate(object? v)
						{
							result[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					valuePromise2.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result, v, value, property);
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					valuePromise.ValueAvailable += delegate(object? v)
					{
						if (hasFirstPart)
						{
							TryAssign(result, key, v, property);
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
					continue;
				}
				if (key == null)
				{
					throw new ArgumentException("Empty key names are not supported yet.", "tKey");
				}
				if (valuePromise == null)
				{
					TryAssign(result, key, value, property);
					continue;
				}
				valuePromise.ValueAvailable += delegate(object? v)
				{
					result[key] = v;
				};
			}
		}
	}
	internal class DictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public DictionaryNodeDeserializer(IObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IDictionary<, >));
			Type type;
			Type type2;
			IDictionary dictionary;
			if (implementationOfOpenGenericInterface != null)
			{
				Type[] genericArguments = implementationOfOpenGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				type2 = genericArguments[1];
				value = objectFactory.Create(expectedType);
				dictionary = value as IDictionary;
				if (dictionary == null)
				{
					dictionary = (IDictionary)Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(type, type2), value);
				}
			}
			else
			{
				if (!typeof(IDictionary).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				type2 = typeof(object);
				value = objectFactory.Create(expectedType);
				dictionary = (IDictionary)value;
			}
			Deserialize(type, type2, parser, nestedObjectDeserializer, dictionary, rootDeserializer);
			return true;
		}
	}
	internal sealed class EnumerableNodeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			Type type;
			if (expectedType == typeof(IEnumerable))
			{
				type = typeof(object);
			}
			else
			{
				Type implementationOfOpenGenericInterface = expectedType.GetImplementationOfOpenGenericInterface(typeof(IEnumerable<>));
				if (implementationOfOpenGenericInterface != expectedType)
				{
					value = null;
					return false;
				}
				type = implementationOfOpenGenericInterface.GetGenericArguments()[0];
			}
			Type arg = typeof(List<>).MakeGenericType(type);
			value = nestedObjectDeserializer(parser, arg);
			return true;
		}
	}
	internal sealed class FsharpListNodeDeserializer : INodeDeserializer
	{
		private readonly ITypeInspector typeInspector;

		private readonly INamingConvention enumNamingConvention;

		public FsharpListNodeDeserializer(ITypeInspector typeInspector, INamingConvention enumNamingConvention)
		{
			this.typeInspector = typeInspector;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!FsharpHelper.IsFsharpListType(expectedType))
			{
				value = false;
				return false;
			}
			Type type = expectedType.GetGenericArguments()[0];
			Type t = expectedType.GetGenericTypeDefinition().MakeGenericType(type);
			ArrayList arrayList = new ArrayList();
			CollectionNodeDeserializer.DeserializeHelper(type, parser, nestedObjectDeserializer, arrayList, canUpdate: true, enumNamingConvention, typeInspector);
			Array array = Array.CreateInstance(type, arrayList.Count);
			arrayList.CopyTo(array, 0);
			object obj = FsharpHelper.CreateFsharpListFromArray(t, type, array);
			value = obj;
			return true;
		}
	}
	internal sealed class NullNodeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			value = null;
			if (parser.Accept<NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		private static bool NodeIsNull(NodeEvent nodeEvent)
		{
			if (nodeEvent.Tag == "tag:yaml.org,2002:null")
			{
				return true;
			}
			if (nodeEvent is YamlDotNet.Core.Events.Scalar { Style: ScalarStyle.Plain, IsKey: false } scalar)
			{
				string value = scalar.Value;
				switch (value)
				{
				default:
					return value == "NULL";
				case "":
				case "~":
				case "null":
				case "Null":
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class ObjectNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly ITypeInspector typeInspector;

		private readonly bool ignoreUnmatched;

		private readonly bool duplicateKeyChecking;

		private readonly ITypeConverter typeConverter;

		private readonly INamingConvention enumNamingConvention;

		private readonly bool enforceNullability;

		private readonly bool caseInsensitivePropertyMatching;

		private readonly bool enforceRequiredProperties;

		private readonly TypeConverterCache typeConverters;

		public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeInspector, bool ignoreUnmatched, bool duplicateKeyChecking, ITypeConverter typeConverter, INamingConvention enumNamingConvention, bool enforceNullability, bool caseInsensitivePropertyMatching, bool enforceRequiredProperties, IEnumerable<IYamlTypeConverter> typeConverters)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.typeInspector = typeInspector ?? throw new ArgumentNullException("typeInspector");
			this.ignoreUnmatched = ignoreUnmatched;
			this.duplicateKeyChecking = duplicateKeyChecking;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.enumNamingConvention = enumNamingConvention ?? throw new ArgumentNullException("enumNamingConvention");
			this.enforceNullability = enforceNullability;
			this.caseInsensitivePropertyMatching = caseInsensitivePropertyMatching;
			this.enforceRequiredProperties = enforceRequiredProperties;
			this.typeConverters = new TypeConverterCache(typeConverters);
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			value = objectFactory.Create(type);
			objectFactory.ExecuteOnDeserializing(value);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			Mark start = Mark.Empty;
			MappingEnd event2;
			while (!parser.TryConsume<MappingEnd>(out event2))
			{
				YamlDotNet.Core.Events.Scalar propertyName = parser.Consume<YamlDotNet.Core.Events.Scalar>();
				if (duplicateKeyChecking && !hashSet.Add(propertyName.Value))
				{
					throw new YamlException(propertyName.Start, propertyName.End, "Encountered duplicate key " + propertyName.Value);
				}
				try
				{
					IPropertyDescriptor property = typeInspector.GetProperty(type, null, propertyName.Value, ignoreUnmatched, caseInsensitivePropertyMatching);
					if (property == null)
					{
						parser.SkipThisAndNestedEvents();
						continue;
					}
					hashSet2.Add(property.Name);
					object obj;
					if (property.ConverterType != null)
					{
						IYamlTypeConverter converterByType = typeConverters.GetConverterByType(property.ConverterType);
						obj = converterByType.ReadYaml(parser, property.Type, rootDeserializer);
					}
					else
					{
						obj = nestedObjectDeserializer(parser, property.Type);
					}
					if (obj is IValuePromise valuePromise)
					{
						object valueRef = value;
						valuePromise.ValueAvailable += delegate(object? v)
						{
							object value3 = typeConverter.ChangeType(v, property.Type, enumNamingConvention, typeInspector);
							NullCheck(value3, property, propertyName);
							property.Write(valueRef, value3);
						};
					}
					else
					{
						object value2 = typeConverter.ChangeType(obj, property.Type, enumNamingConvention, typeInspector);
						NullCheck(value2, property, propertyName);
						property.Write(value, value2);
					}
				}
				catch (SerializationException ex)
				{
					throw new YamlException(propertyName.Start, propertyName.End, ex.Message);
				}
				catch (YamlException)
				{
					throw;
				}
				catch (Exception innerException)
				{
					throw new YamlException(propertyName.Start, propertyName.End, "Exception during deserialization", innerException);
				}
				start = propertyName.End;
			}
			if (enforceRequiredProperties)
			{
				IEnumerable<IPropertyDescriptor> properties = typeInspector.GetProperties(type, value);
				List<string> list = new List<string>();
				foreach (IPropertyDescriptor item in properties)
				{
					if (item.Required && !hashSet2.Contains(item.Name))
					{
						list.Add(item.Name);
					}
				}
				if (list.Count > 0)
				{
					string text = string.Join(",", list);
					throw new YamlException(in start, in start, "Missing properties, '" + text + "' in source yaml.");
				}
			}
			objectFactory.ExecuteOnDeserialized(value);
			return true;
		}

		public void NullCheck(object value, IPropertyDescriptor property, YamlDotNet.Core.Events.Scalar propertyName)
		{
			if (enforceNullability && value == null && !property.AllowNulls)
			{
				throw new YamlException(propertyName.Start, propertyName.End, "Strict nullability enforcement error.", new NullReferenceException("Yaml value is null when target property requires non null values."));
			}
		}
	}
	internal sealed class ScalarNodeDeserializer : INodeDeserializer
	{
		private const string BooleanTruePattern = "^(true|y|yes|on)$";

		private const string BooleanFalsePattern = "^(false|n|no|off)$";

		private readonly bool attemptUnknownTypeDeserialization;

		private readonly ITypeConverter typeConverter;

		private readonly ITypeInspector typeInspector;

		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		public ScalarNodeDeserializer(bool attemptUnknownTypeDeserialization, ITypeConverter typeConverter, ITypeInspector typeInspector, YamlFormatter formatter, INamingConvention enumNamingConvention)
		{
			this.attemptUnknownTypeDeserialization = attemptUnknownTypeDeserialization;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.typeInspector = typeInspector;
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!parser.TryConsume<YamlDotNet.Core.Events.Scalar>(out var @event))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? FsharpHelper.GetOptionUnderlyingType(expectedType) ?? expectedType;
			if (type.IsEnum())
			{
				string name = enumNamingConvention.Reverse(@event.Value);
				name = typeInspector.GetEnumName(type, name);
				value = Enum.Parse(type, name, ignoreCase: true);
				return true;
			}
			TypeCode typeCode = type.GetTypeCode();
			switch (typeCode)
			{
			case TypeCode.Boolean:
				value = DeserializeBooleanHelper(@event.Value);
				break;
			case TypeCode.SByte:
			case TypeCode.Byte:
			case TypeCode.Int16:
			case TypeCode.UInt16:
			case TypeCode.Int32:
			case TypeCode.UInt32:
			case TypeCode.Int64:
			case TypeCode.UInt64:
				value = DeserializeIntegerHelper(typeCode, @event.Value);
				break;
			case TypeCode.Single:
				value = float.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.Double:
				value = double.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.Decimal:
				value = decimal.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.String:
				value = @event.Value;
				break;
			case TypeCode.Char:
				value = @event.Value[0];
				break;
			case TypeCode.DateTime:
				value = DateTime.Parse(@event.Value, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
				break;
			default:
				if (expectedType == typeof(object))
				{
					if (!@event.IsKey && attemptUnknownTypeDeserialization)
					{
						value = AttemptUnknownTypeDeserialization(@event);
					}
					else
					{
						value = @event.Value;
					}
				}
				else
				{
					value = typeConverter.ChangeType(@event.Value, expectedType, enumNamingConvention, typeInspector);
				}
				break;
			}
			return true;
		}

		private static bool DeserializeBooleanHelper(string value)
		{
			if (Regex.IsMatch(value, "^(true|y|yes|on)$", RegexOptions.IgnoreCase))
			{
				return true;
			}
			if (Regex.IsMatch(value, "^(false|n|no|off)$", RegexOptions.IgnoreCase))
			{
				return false;
			}
			throw new FormatException("The value \"" + value + "\" is not a valid YAML Boolean");
		}

		private object DeserializeIntegerHelper(TypeCode typeCode, string value)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				int i = 0;
				bool flag = false;
				ulong num = 0uL;
				if (value[0] == '-')
				{
					i++;
					flag = true;
				}
				else if (value[0] == '+')
				{
					i++;
				}
				if (value[i] == '0')
				{
					int num2;
					if (i == value.Length - 1)
					{
						num2 = 10;
						num = 0uL;
					}
					else
					{
						i++;
						if (value[i] == 'b')
						{
							num2 = 2;
							i++;
						}
						else if (value[i] == 'x')
						{
							num2 = 16;
							i++;
						}
						else
						{
							num2 = 8;
						}
					}
					for (; i < value.Length; i++)
					{
						if (value[i] != '_')
						{
							builder.Append(value[i]);
						}
					}
					switch (num2)
					{
					case 2:
					case 8:
						num = Convert.ToUInt64(builder.ToString(), num2);
						break;
					case 16:
						num = ulong.Parse(builder.ToString(), NumberStyles.HexNumber, formatter.NumberFormat);
						break;
					}
				}
				else
				{
					string[] array = value.Substring(i).Split(new char[1] { ':' });
					num = 0uL;
					for (int j = 0; j < array.Length; j++)
					{
						num *= 60;
						num += ulong.Parse(array[j].Replace("_", ""), CultureInfo.InvariantCulture);
					}
				}
				if (!flag)
				{
					return CastInteger(num, typeCode);
				}
				long number = ((num != 9223372036854775808uL) ? checked(-(long)num) : long.MinValue);
				return CastInteger(number, typeCode);
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private static object CastInteger(long number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => (ulong)number, 
				_ => number, 
			});
		}

		private static object CastInteger(ulong number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => (long)number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => number, 
				_ => number, 
			});
		}

		private object? AttemptUnknownTypeDeserialization(YamlDotNet.Core.Events.Scalar value)
		{
			if (value.Style == ScalarStyle.SingleQuoted || value.Style == ScalarStyle.DoubleQuoted || value.Style == ScalarStyle.Folded)
			{
				return value.Value;
			}
			string v = value.Value;
			switch (v)
			{
			case "null":
			case "Null":
			case "NULL":
			case "~":
			case "":
				return null;
			case "true":
			case "True":
			case "TRUE":
				return true;
			case "False":
			case "FALSE":
			case "false":
				return false;
			default:
				if (Regex.IsMatch(v, "^0x[0-9a-fA-F]+$"))
				{
					v = v.Substring(2);
					if (byte.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result))
					{
						return result;
					}
					if (short.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result2))
					{
						return result2;
					}
					if (int.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result3))
					{
						return result3;
					}
					if (long.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result4))
					{
						return result4;
					}
					if (ulong.TryParse(v, NumberStyles.AllowHexSpecifier, formatter.NumberFormat, out var result5))
					{
						return result5;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^0o[0-9a-fA-F]+$"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 8), out object value2) && !TryAndSwallow(() => Convert.ToInt16(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 8), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 8), out value2))
					{
						return v;
					}
					return value2;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?$"))
				{
					if (byte.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result6))
					{
						return result6;
					}
					if (short.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result7))
					{
						return result7;
					}
					if (int.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result8))
					{
						return result8;
					}
					if (long.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result9))
					{
						return result9;
					}
					if (ulong.TryParse(v, NumberStyles.Integer, formatter.NumberFormat, out var result10))
					{
						return result10;
					}
					if (float.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result11))
					{
						return result11;
					}
					if (double.TryParse(v, NumberStyles.Float, formatter.NumberFormat, out var result12))
					{
						return result12;
					}
					return v;
				}
				if (Regex.IsMatch(v, "^[-+]?(\\.inf|\\.Inf|\\.INF)$"))
				{
					if (Polyfills.StartsWith(v, '-'))
					{
						return float.NegativeInfinity;
					}
					return float.PositiveInfinity;
				}
				if (Regex.IsMatch(v, "^(\\.nan|\\.NaN|\\.NAN)$"))
				{
					return float.NaN;
				}
				return v;
			}
		}

		private static bool TryAndSwallow(Func<object> attempt, out object? value)
		{
			try
			{
				value = attempt();
				return true;
			}
			catch
			{
				value = null;
				return false;
			}
		}
	}
	internal sealed class StaticArrayNodeDeserializer : INodeDeserializer
	{
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			private object?[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object? this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			public object SyncRoot => data;

			public ArrayList()
			{
				Clear();
			}

			public int Add(object? value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object? value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object? value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object? value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly StaticObjectFactory factory;

		public StaticArrayNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!factory.IsArray(expectedType))
			{
				value = false;
				return false;
			}
			Type valueType = factory.GetValueType(expectedType);
			ArrayList arrayList = new ArrayList();
			StaticCollectionNodeDeserializer.DeserializeHelper(valueType, parser, nestedObjectDeserializer, arrayList, factory);
			Array array = factory.CreateArray(expectedType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	internal sealed class StaticCollectionNodeDeserializer : INodeDeserializer
	{
		private readonly StaticObjectFactory factory;

		public StaticCollectionNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!factory.IsList(expectedType))
			{
				value = null;
				return false;
			}
			DeserializeHelper(result: (IList)(value = factory.Create(expectedType) as IList), tItem: factory.GetValueType(expectedType), parser: parser, nestedObjectDeserializer: nestedObjectDeserializer, factory: factory);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, Func<IParser, Type, object?> nestedObjectDeserializer, IList result, IObjectFactory factory)
		{
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					int index = result.Add(factory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += delegate(object? v)
					{
						result[index] = v;
					};
				}
				else
				{
					result.Add(obj);
				}
			}
		}
	}
	internal class StaticDictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly StaticObjectFactory objectFactory;

		public StaticDictionaryNodeDeserializer(StaticObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (objectFactory.IsDictionary(expectedType))
			{
				if (!(objectFactory.Create(expectedType) is IDictionary dictionary))
				{
					value = null;
					return false;
				}
				Type keyType = objectFactory.GetKeyType(expectedType);
				Type valueType = objectFactory.GetValueType(expectedType);
				value = dictionary;
				base.Deserialize(keyType, valueType, reader, nestedObjectDeserializer, dictionary, rootDeserializer);
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class TypeConverterNodeDeserializer : INodeDeserializer
	{
		private readonly TypeConverterCache converters;

		public TypeConverterNodeDeserializer(IEnumerable<IYamlTypeConverter> converters)
		{
			this.converters = new TypeConverterCache(converters);
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!converters.TryGetConverterForType(expectedType, out IYamlTypeConverter typeConverter))
			{
				value = null;
				return false;
			}
			value = typeConverter.ReadYaml(parser, expectedType, rootDeserializer);
			return true;
		}
	}
	internal sealed class YamlConvertibleNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlConvertibleNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
			{
				IYamlConvertible yamlConvertible = (IYamlConvertible)objectFactory.Create(expectedType);
				yamlConvertible.Read(parser, expectedType, (Type type) => nestedObjectDeserializer(parser, type));
				value = yamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	internal sealed class YamlSerializableNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlSerializableNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (typeof(IYamlSerializable).IsAssignableFrom(expectedType))
			{
				IYamlSerializable yamlSerializable = (IYamlSerializable)objectFactory.Create(expectedType);
				yamlSerializable.ReadYaml(parser);
				value = yamlSerializable;
				return true;
			}
			value = null;
			return false;
		}
	}
}
namespace YamlDotNet.Serialization.NamingConventions
{
	internal sealed class CamelCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public CamelCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToCamelCase();
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class HyphenatedNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public HyphenatedNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.FromCamelCase("-");
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class LowerCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new LowerCaseNamingConvention();

		private LowerCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToCamelCase().ToLower(CultureInfo.InvariantCulture);
		}

		public string Reverse(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return value;
			}
			return char.ToUpperInvariant(value[0]) + value.Substring(1);
		}
	}
	internal sealed class NullNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public NullNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value;
		}

		public string Reverse(string value)
		{
			return value;
		}
	}
	internal sealed class PascalCaseNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public PascalCaseNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.ToPascalCase();
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class UnderscoredNamingConvention : INamingConvention
	{
		public static readonly INamingConvention Instance = new UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public UnderscoredNamingConvention()
		{
		}

		public string Apply(string value)
		{
			return value.FromCamelCase("_");
		}

		public string Reverse(string value)
		{
			return value.ToPascalCase();
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	internal abstract class ChainedEventEmitter : IEventEmitter
	{
		protected readonly IEventEmitter nextEmitter;

		protected ChainedEventEmitter(IEventEmitter nextEmitter)
		{
			this.nextEmitter = nextEmitter ?? throw new ArgumentNullException("nextEmitter");
		}

		public virtual void Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}
	}
	internal sealed class JsonEventEmitter : ChainedEventEmitter
	{
		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public JsonEventEmitter(IEventEmitter nextEmitter, YamlFormatter formatter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.formatter = formatter;
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public override void Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.NeedsExpansion = true;
		}

		public override void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.IsPlainImplicit = true;
			eventInfo.Style = ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.RenderedValue = "null";
			}
			else
			{
				TypeCode typeCode = eventInfo.Source.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.RenderedValue = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum())
					{
						eventInfo.RenderedValue = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						eventInfo.Style = ((!formatter.PotentiallyQuoteEnums(value)) ? ScalarStyle.Plain : ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
				{
					float f = (float)value;
					eventInfo.RenderedValue = f.ToString("G", CultureInfo.InvariantCulture);
					if (float.IsNaN(f) || float.IsInfinity(f))
					{
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Double:
				{
					double d = (double)value;
					eventInfo.RenderedValue = d.ToString("G", CultureInfo.InvariantCulture);
					if (double.IsNaN(d) || double.IsInfinity(d))
					{
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					break;
				}
				case TypeCode.Decimal:
					eventInfo.RenderedValue = ((decimal)value).ToString(CultureInfo.InvariantCulture);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.RenderedValue = value.ToString();
					eventInfo.Style = ScalarStyle.DoubleQuoted;
					break;
				case TypeCode.DateTime:
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.RenderedValue = "null";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.Style = MappingStyle.Flow;
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.Style = SequenceStyle.Flow;
			base.Emit(eventInfo, emitter);
		}
	}
	internal sealed class TypeAssigningEventEmitter : ChainedEventEmitter
	{
		private readonly IDictionary<Type, TagName> tagMappings;

		private readonly bool quoteNecessaryStrings;

		private readonly Regex? isSpecialStringValue_Regex;

		private static readonly string SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|[-+]?[0-9]+|0o[0-7]+|0x[0-9a-fA-F]+|[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?|[-+]?(\\.inf|\\.Inf|\\.INF)|\\.nan|\\.NaN|\\.NAN|\\s.*)$";

		private static readonly string CombinedYaml1_1SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|y|Y|yes|Yes|YES|n|N|no|No|NO|on|On|ON|off|Off|OFF|[-+]?0b[0-1_]+|[-+]?0o?[0-7_]+|[-+]?(0|[1-9][0-9_]*)|[-+]?0x[0-9a-fA-F_]+|[-+]?[1-9][0-9_]*(:[0-5]?[0-9])+|[-+]?([0-9][0-9_]*)?\\.[0-9_]*([eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(inf|Inf|INF)|\\.(nan|NaN|NAN))$";

		private readonly ScalarStyle defaultScalarStyle;

		private readonly YamlFormatter formatter;

		private readonly INamingConvention enumNamingConvention;

		private readonly ITypeInspector typeInspector;

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings, ScalarStyle defaultScalarStyle, YamlFormatter formatter, INamingConvention enumNamingConvention, ITypeInspector typeInspector)
			: base(nextEmitter)
		{
			this.defaultScalarStyle = defaultScalarStyle;
			this.formatter = formatter;
			this.tagMappings = tagMappings;
			this.quoteNecessaryStrings = quoteNecessaryStrings;
			isSpecialStringValue_Regex = new Regex(quoteYaml1_1Strings ? CombinedYaml1_1SpecialStrings_Pattern : SpecialStrings_Pattern, RegexOptions.Compiled);
			this.enumNamingConvention = enumNamingConvention;
			this.typeInspector = typeInspector;
		}

		public override void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			ScalarStyle style = ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.Tag = JsonSchema.Tags.Null;
				eventInfo.RenderedValue = "";
			}
			else
			{
				TypeCode typeCode = eventInfo.Source.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.Tag = JsonSchema.Tags.Bool;
					eventInfo.RenderedValue = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum)
					{
						eventInfo.Tag = FailsafeSchema.Tags.Str;
						eventInfo.RenderedValue = formatter.FormatEnum(value, typeInspector, enumNamingConvention);
						style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue) || !formatter.PotentiallyQuoteEnums(value)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.Tag = JsonSchema.Tags.Int;
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((float)value);
					break;
				case TypeCode.Double:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((double)value);
					break;
				case TypeCode.Decimal:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.Tag = FailsafeSchema.Tags.Str;
					eventInfo.RenderedValue = value.ToString();
					style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
					break;
				case TypeCode.DateTime:
					eventInfo.Tag = DefaultSchema.Tags.Timestamp;
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.Tag = JsonSchema.Tags.Null;
					eventInfo.RenderedValue = "";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			eventInfo.IsPlainImplicit = true;
			if (eventInfo.Style == ScalarStyle.Any)
			{
				eventInfo.Style = style;
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		private void AssignTypeIfNeeded(ObjectEventInfo eventInfo)
		{
			if (tagMappings.TryGetValue(eventInfo.Source.Type, out var value))
			{
				eventInfo.Tag = value;
			}
		}

		private bool IsSpecialStringValue(string value)
		{
			if (value.Trim() == string.Empty)
			{
				return true;
			}
			return isSpecialStringValue_Regex?.IsMatch(value) ?? false;
		}
	}
	internal sealed class WriterEventEmitter : IEventEmitter
	{
		void IEventEmitter.Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(eventInfo.Alias));
		}

		void IEventEmitter.Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(eventInfo.Anchor, eventInfo.Tag, eventInfo.RenderedValue, eventInfo.Style, eventInfo.IsPlainImplicit, eventInfo.IsQuotedImplicit));
		}

		void IEventEmitter.Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingEnd());
		}

		void IEventEmitter.Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceEnd());
		}
	}
}
namespace YamlDotNet.Serialization.Converters
{
	internal class DateTime8601Converter : IYamlTypeConverter
	{
		private readonly ScalarStyle scalarStyle;

		public DateTime8601Converter()
			: this(ScalarStyle.Any)
		{
		}

		public DateTime8601Converter(ScalarStyle scalarStyle)
		{
			this.scalarStyle = scalarStyle;
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTime dateTime = DateTime.ParseExact(value, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
			return dateTime;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			string value2 = ((DateTime)value).ToString("O", CultureInfo.InvariantCulture);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, scalarStyle, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class DateTimeConverter : IYamlTypeConverter
	{
		private readonly DateTimeKind kind;

		private readonly IFormatProvider provider;

		private readonly bool doubleQuotes;

		private readonly string[] formats;

		public DateTimeConverter(DateTimeKind kind = DateTimeKind.Utc, IFormatProvider? provider = null, bool doubleQuotes = false, params string[] formats)
		{
			this.kind = ((kind == DateTimeKind.Unspecified) ? DateTimeKind.Utc : kind);
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.doubleQuotes = doubleQuotes;
			this.formats = formats.DefaultIfEmpty("G").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTimeStyles style = ((kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal);
			DateTime dt = DateTime.ParseExact(value, formats, provider, style);
			dt = EnsureDateTimeKind(dt, kind);
			return dt;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			DateTime dateTime = (DateTime)value;
			string value2 = ((kind == DateTimeKind.Local) ? dateTime.ToLocalTime() : dateTime.ToUniversalTime()).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, doubleQuotes ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}

		private static DateTime EnsureDateTimeKind(DateTime dt, DateTimeKind kind)
		{
			if (dt.Kind == DateTimeKind.Local && kind == DateTimeKind.Utc)
			{
				return dt.ToUniversalTime();
			}
			if (dt.Kind == DateTimeKind.Utc && kind == DateTimeKind.Local)
			{
				return dt.ToLocalTime();
			}
			return dt;
		}
	}
	internal class DateTimeOffsetConverter : IYamlTypeConverter
	{
		private readonly IFormatProvider provider;

		private readonly ScalarStyle style;

		private readonly DateTimeStyles dateStyle;

		private readonly string[] formats;

		public DateTimeOffsetConverter(IFormatProvider? provider = null, ScalarStyle style = ScalarStyle.Any, DateTimeStyles dateStyle = DateTimeStyles.None, params string[] formats)
		{
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.style = style;
			this.dateStyle = dateStyle;
			this.formats = formats.DefaultIfEmpty("O").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTimeOffset);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			DateTimeOffset dateTimeOffset = DateTimeOffset.ParseExact(value, formats, provider, dateStyle);
			return dateTimeOffset;
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			string value2 = ((DateTimeOffset)value).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, style, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class GuidConverter : IYamlTypeConverter
	{
		private readonly bool jsonCompatible;

		public GuidConverter(bool jsonCompatible)
		{
			this.jsonCompatible = jsonCompatible;
		}

		public bool Accepts(Type type)
		{
			return type == typeof(Guid);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			return new Guid(value);
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			Guid guid = (Guid)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, guid.ToString("D"), jsonCompatible ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	internal class SystemTypeConverter : IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return typeof(Type).IsAssignableFrom(type);
		}

		public object ReadYaml(IParser parser, Type type, ObjectDeserializer rootDeserializer)
		{
			string value = parser.Consume<YamlDotNet.Core.Events.Scalar>().Value;
			return Type.GetType(value, throwOnError: true);
		}

		public void WriteYaml(IEmitter emitter, object? value, Type type, ObjectSerializer serializer)
		{
			Type type2 = (Type)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, type2.AssemblyQualifiedName, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
}
namespace YamlDotNet.Serialization.Callbacks
{
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnDeserializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnDeserializingAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnSerializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnSerializingAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization
{
	internal interface ITypeDiscriminatingNodeDeserializerOptions
	{
		void AddTypeDiscriminator(ITypeDiscriminator discriminator);

		void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping);

		void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping);
	}
	internal class ParserBuffer : IParser
	{
		private readonly LinkedList<ParsingEvent> buffer;

		private LinkedListNode<ParsingEvent>? current;

		public ParsingEvent? Current => current?.Value;

		public ParserBuffer(IParser parserToBuffer, int maxDepth, int maxLength)
		{
			buffer = new LinkedList<ParsingEvent>();
			buffer.AddLast(parserToBuffer.Consume<MappingStart>());
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parserToBuffer.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
				buffer.AddLast(parsingEvent);
				if (maxDepth > -1 && num > maxDepth)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max depth");
				}
				if (maxLength > -1 && buffer.Count > maxLength)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max length");
				}
			}
			while (num >= 0);
			current = buffer.First;
		}

		public bool MoveNext()
		{
			current = current?.Next;
			return current != null;
		}

		public void Reset()
		{
			current = buffer.First;
		}
	}
	internal class TypeDiscriminatingNodeDeserializer : INodeDeserializer
	{
		private readonly IList<INodeDeserializer> innerDeserializers;

		private readonly IList<ITypeDiscriminator> typeDiscriminators;

		private readonly int maxDepthToBuffer;

		private readonly int maxLengthToBuffer;

		public TypeDiscriminatingNodeDeserializer(IList<INodeDeserializer> innerDeserializers, IList<ITypeDiscriminator> typeDiscriminators, int maxDepthToBuffer, int maxLengthToBuffer)
		{
			this.innerDeserializers = innerDeserializers;
			this.typeDiscriminators = typeDiscriminators;
			this.maxDepthToBuffer = maxDepthToBuffer;
			this.maxLengthToBuffer = maxLengthToBuffer;
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value, ObjectDeserializer rootDeserializer)
		{
			if (!reader.Accept<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			IEnumerable<ITypeDiscriminator> enumerable = typeDiscriminators.Where((ITypeDiscriminator t) => t.BaseType.IsAssignableFrom(expectedType));
			if (!enumerable.Any())
			{
				value = null;
				return false;
			}
			Mark start = reader.Current.Start;
			Type expectedType2 = expectedType;
			ParserBuffer parserBuffer;
			try
			{
				parserBuffer = new ParserBuffer(reader, maxDepthToBuffer, maxLengthToBuffer);
			}
			catch (Exception innerException)
			{
				throw new YamlException(in start, reader.Current.End, "Failed to buffer yaml node", innerException);
			}
			try
			{
				foreach (ITypeDiscriminator item in enumerable)
				{
					parserBuffer.Reset();
					if (item.TryDiscriminate(parserBuffer, out Type suggestedType))
					{
						expectedType2 = suggestedType;
						break;
					}
				}
			}
			catch (Exception innerException2)
			{
				throw new YamlException(in start, reader.Current.End, "Failed to discriminate type", innerException2);
			}
			parserBuffer.Reset();
			foreach (INodeDeserializer innerDeserializer in innerDeserializers)
			{
				if (innerDeserializer.Deserialize(parserBuffer, expectedType2, nestedObjectDeserializer, out value, rootDeserializer))
				{
					return true;
				}
			}
			value = null;
			return false;
		}
	}
	internal class TypeDiscriminatingNodeDeserializerOptions : ITypeDiscriminatingNodeDeserializerOptions
	{
		internal readonly List<ITypeDiscriminator> discriminators = new List<ITypeDiscriminator>();

		public void AddTypeDiscriminator(ITypeDiscriminator discriminator)
		{
			discriminators.Add(discriminator);
		}

		public void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping)
		{
			discriminators.Add(new KeyValueTypeDiscriminator(typeof(T), discriminatorKey, valueTypeMapping));
		}

		public void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping)
		{
			discriminators.Add(new UniqueKeyTypeDiscriminator(typeof(T), uniqueKeyTypeMapping));
		}
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
	internal interface ITypeDiscriminator
	{
		Type BaseType { get; }

		bool TryDiscriminate(IParser buffer, out Type? suggestedType);
	}
	internal class KeyValueTypeDiscriminator : ITypeDiscriminator
	{
		private readonly string targetKey;

		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public KeyValueTypeDiscriminator(Type baseType, string targetKey, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.targetKey = targetKey;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(IParser parser, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar2) => targetKey == scalar2.Value, out YamlDotNet.Core.Events.Scalar _, out ParsingEvent value) && value is YamlDotNet.Core.Events.Scalar scalar && typeMapping.TryGetValue(scalar.Value, out Type value2))
			{
				suggestedType = value2;
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
	internal class UniqueKeyTypeDiscriminator : ITypeDiscriminator
	{
		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public UniqueKeyTypeDiscriminator(Type baseType, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(IParser parser, out Type? suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => typeMapping.ContainsKey(scalar.Value), out YamlDotNet.Core.Events.Scalar key, out ParsingEvent _))
			{
				suggestedType = typeMapping[key.Value];
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
}
namespace YamlDotNet.RepresentationModel
{
	internal class DocumentLoadingState
	{
		private readonly Dictionary<AnchorName, YamlNode> anchors = new Dictionary<AnchorName, YamlNode>();

		private readonly List<YamlNode> nodesWithUnresolvedAliases = new List<YamlNode>();

		public void AddAnchor(YamlNode node)
		{
			if (node.Anchor.IsEmpty)
			{
				throw new ArgumentException("The specified node does not have an anchor");
			}
			anchors[node.Anchor] = node;
		}

		public YamlNode GetNode(AnchorName anchor, Mark start, Mark end)
		{
			if (anchors.TryGetValue(anchor, out YamlNode value))
			{
				return value;
			}
			throw new AnchorNotFoundException(in start, in end, $"The anchor '{anchor}' does not exists");
		}

		public bool TryGetNode(AnchorName anchor, [NotNullWhen(true)] out YamlNode? node)
		{
			return anchors.TryGetValue(anchor, out node);
		}

		public void AddNodeWithUnresolvedAliases(YamlNode node)
		{
			nodesWithUnresolvedAliases.Add(node);
		}

		public void ResolveAliases()
		{
			foreach (YamlNode nodesWithUnresolvedAlias in nodesWithUnresolvedAliases)
			{
				nodesWithUnresolvedAlias.ResolveAliases(this);
			}
		}
	}
	internal class EmitterState
	{
		public HashSet<AnchorName> EmittedAnchors { get; } = new HashSet<AnchorName>();
	}
	internal interface IYamlVisitor
	{
		void Visit(YamlStream stream);

		void Visit(YamlDocument document);

		void Visit(YamlScalarNode scalar);

		void Visit(YamlSequenceNode sequence);

		void Visit(YamlMappingNode mapping);
	}
	internal class LibYamlEventStream
	{
		private readonly IParser parser;

		public LibYamlEventStream(IParser iParser)
		{
			parser = iParser ?? throw new ArgumentNullException("iParser");
		}

		public void WriteTo(TextWriter textWriter)
		{
			while (parser.MoveNext())
			{
				ParsingEvent current = parser.Current;
				if (!(current is YamlDotNet.Core.Events.AnchorAlias anchorAlias))
				{
					if (!(current is YamlDotNet.Core.Events.DocumentEnd documentEnd))
					{
						if (!(current is YamlDotNet.Core.Events.DocumentStart documentStart))
						{
							if (!(current is MappingEnd))
							{
								if (!(current is MappingStart nodeEvent))
								{
									if (!(current is YamlDotNet.Core.Events.Scalar scalar))
									{
										if (!(current is SequenceEnd))
										{
											if (!(current is SequenceStart nodeEvent2))
											{
												if (!(current is YamlDotNet.Core.Events.StreamEnd))
												{
													if (current is YamlDotNet.Core.Events.StreamStart)
													{
														textWriter.Write("+STR");
													}
												}
												else
												{
													textWriter.Write("-STR");
												}
											}
											else
											{
												textWriter.Write("+SEQ");
												WriteAnchorAndTag(textWriter, nodeEvent2);
											}
										}
										else
										{
											textWriter.Write("-SEQ");
										}
									}
									else
									{
										textWriter.Write("=VAL");
										WriteAnchorAndTag(textWriter, scalar);
										switch (scalar.Style)
										{
										case ScalarStyle.DoubleQuoted:
											textWriter.Write(" \"");
											break;
										case ScalarStyle.SingleQuoted:
											textWriter.Write(" '");
											break;
										case ScalarStyle.Folded:
											textWriter.Write(" >");
											break;
										case ScalarStyle.Literal:
											textWriter.Write(" |");
											break;
										default:
											textWriter.Write(" :");
											break;
										}
										string value = scalar.Value;
										foreach (char c in value)
										{
											switch (c)
											{
											case '\b':
												textWriter.Write("\\b");
												break;
											case '\t':
												textWriter.Write("\\t");
												break;
											case '\n':
												textWriter.Write("\\n");
												break;
											case '\r':
												textWriter.Write("\\r");
												break;
											case '\\':
												textWriter.Write("\\\\");
												break;
											default:
												textWriter.Write(c);
												break;
											}
										}
									}
								}
								else
								{
									textWriter.Write("+MAP");
									WriteAnchorAndTag(textWriter, nodeEvent);
								}
							}
							else
							{
								textWriter.Write("-MAP");
							}
						}
						else
						{
							textWriter.Write("+DOC");
							if (!documentStart.IsImplicit)
							{
								textWriter.Write(" ---");
							}
						}
					}
					else
					{
						textWriter.Write("-DOC");
						if (!documentEnd.IsImplicit)
						{
							textWriter.Write(" ...");
						}
					}
				}
				else
				{
					textWriter.Write("=ALI *");
					textWriter.Write(anchorAlias.Value);
				}
				textWriter.WriteLine();
			}
		}

		private static void WriteAnchorAndTag(TextWriter textWriter, NodeEvent nodeEvent)
		{
			if (!nodeEvent.Anchor.IsEmpty)
			{
				textWriter.Write(" &");
				textWriter.Write(nodeEvent.Anchor);
			}
			if (!nodeEvent.Tag.IsEmpty)
			{
				textWriter.Write(" <");
				textWriter.Write(nodeEvent.Tag.Value);
				textWriter.Write(">");
			}
		}
	}
	internal class YamlAliasNode : YamlNode
	{
		public override YamlNodeType NodeType => YamlNodeType.Alias;

		internal YamlAliasNode(AnchorName anchor)
		{
			base.Anchor = anchor;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on an alias node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be saved.");
		}

		public override void Accept(IYamlVisitor visitor)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be visited.");
		}

		public override bool Equals(object? obj)
		{
			if (obj is YamlAliasNode yamlAliasNode && Equals(yamlAliasNode))
			{
				return object.Equals(base.Anchor, yamlAliasNode.Anchor);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		internal override string ToString(RecursionLevel level)
		{
			return "*" + base.Anchor;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}
	}
	internal class YamlDocument
	{
		private class AnchorAssigningVisitor : YamlVisitorBase
		{
			private readonly HashSet<AnchorName> existingAnchors = new HashSet<AnchorName>();

			private readonly Dictionary<YamlNode, bool> visitedNodes = new Dictionary<YamlNode, bool>();

			public void AssignAnchors(YamlDocument document)
			{
				existingAnchors.Clear();
				visitedNodes.Clear();
				document.Accept(this);
				Random random = new Random();
				foreach (KeyValuePair<YamlNode, bool> visitedNode in visitedNodes)
				{
					if (!visitedNode.Value)
					{
						continue;
					}
					AnchorName anchorName;
					if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
					{
						anchorName = visitedNode.Key.Anchor;
					}
					else
					{
						do
						{
							anchorName = new AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
						}
						while (existingAnchors.Contains(anchorName));
					}
					existingAnchors.Add(anchorName);
					visitedNode.Key.Anchor = anchorName;
				}
			}

			private bool VisitNodeAndFindDuplicates(YamlNode node)
			{
				if (visitedNodes.TryGetValue(node, out var value))
				{
					if (!value)
					{
						visitedNodes[node] = true;
					}
					return !value;
				}
				visitedNodes.Add(node, value: false);
				return false;
			}

			public override void Visit(YamlScalarNode scalar)
			{
				VisitNodeAndFindDuplicates(scalar);
			}

			public override void Visit(YamlMappingNode mapping)
			{
				if (!VisitNodeAndFindDuplicates(mapping))
				{
					base.Visit(mapping);
				}
			}

			public override void Visit(YamlSequenceNode sequence)
			{
				if (!VisitNodeAndFindDuplicates(sequence))
				{
					base.Visit(sequence);
				}
			}
		}

		public YamlNode RootNode { get; private set; }

		public IEnumerable<YamlNode> AllNodes => RootNode.AllNodes;

		public YamlDocument(YamlNode rootNode)
		{
			RootNode = rootNode;
		}

		public YamlDocument(string rootNode)
		{
			RootNode = new YamlScalarNode(rootNode);
		}

		internal YamlDocument(IParser parser)
		{
			DocumentLoadingState documentLoadingState = new DocumentLoadingState();
			parser.Consume<YamlDotNet.Core.Events.DocumentStart>();
			YamlDotNet.Core.Events.DocumentEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.DocumentEnd>(out @event))
			{
				RootNode = YamlNode.ParseNode(parser, documentLoadingState);
				if (RootNode is YamlAliasNode)
				{
					throw new YamlException("A document cannot contain only an alias");
				}
			}
			documentLoadingState.ResolveAliases();
			if (RootNode == null)
			{
				throw new ArgumentException("Atempted to parse an empty document");
			}
		}

		private void AssignAnchors()
		{
			AnchorAssigningVisitor anchorAssigningVisitor = new AnchorAssigningVisitor();
			anchorAssigningVisitor.AssignAnchors(this);
		}

		internal void Save(IEmitter emitter, bool assignAnchors = true)
		{
			if (assignAnchors)
			{
				AssignAnchors();
			}
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			RootNode.Save(emitter, new EmitterState());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: false));
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class YamlMappingNode : YamlNode, IEnumerable<KeyValuePair<YamlNode, YamlNode>>, IEnumerable, IYamlConvertible
	{
		private readonly OrderedDictionary<YamlNode, YamlNode> children = new OrderedDictionary<YamlNode, YamlNode>();

		public IOrderedDictionary<YamlNode, YamlNode> Children => children;

		public MappingStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Mapping;

		internal YamlMappingNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			MappingStart mappingStart = parser.Consume<MappingStart>();
			Load(mappingStart, state);
			Style = mappingStart.Style;
			bool flag = false;
			MappingEnd @event;
			while (!parser.TryConsume<MappingEnd>(out @event))
			{
				YamlNode yamlNode = YamlNode.ParseNode(parser, state);
				YamlNode yamlNode2 = YamlNode.ParseNode(parser, state);
				if (!children.TryAdd(yamlNode, yamlNode2))
				{
					throw new YamlException(yamlNode.Start, yamlNode.End, $"Duplicate key {yamlNode}");
				}
				flag = flag || yamlNode is YamlAliasNode || yamlNode2 is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlMappingNode()
		{
		}

		public YamlMappingNode(params KeyValuePair<YamlNode, YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<YamlNode, YamlNode>>)children)
		{
		}

		public YamlMappingNode(IEnumerable<KeyValuePair<YamlNode, YamlNode>> children)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				this.children.Add(child);
			}
		}

		public YamlMappingNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlMappingNode(IEnumerable<YamlNode> children)
		{
			using IEnumerator<YamlNode> enumerator = children.GetEnumerator();
			while (enumerator.MoveNext())
			{
				YamlNode current = enumerator.Current;
				if (!enumerator.MoveNext())
				{
					throw new ArgumentException("When constructing a mapping node with a sequence, the number of elements of the sequence must be even.");
				}
				Add(current, enumerator.Current);
			}
		}

		public void Add(YamlNode key, YamlNode value)
		{
			children.Add(key, value);
		}

		public void Add(string key, YamlNode value)
		{
			children.Add(new YamlScalarNode(key), value);
		}

		public void Add(YamlNode key, string value)
		{
			children.Add(key, new YamlScalarNode(value));
		}

		public void Add(string key, string value)
		{
			children.Add(new YamlScalarNode(key), new YamlScalarNode(value));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			Dictionary<YamlNode, YamlNode> dictionary = null;
			Dictionary<YamlNode, YamlNode> dictionary2 = null;
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (child.Key is YamlAliasNode)
				{
					if (dictionary == null)
					{
						dictionary = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary.Add(child.Key, state.GetNode(child.Key.Anchor, child.Key.Start, child.Key.End));
				}
				if (child.Value is YamlAliasNode)
				{
					if (dictionary2 == null)
					{
						dictionary2 = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary2.Add(child.Key, state.GetNode(child.Value.Anchor, child.Value.Start, child.Value.End));
				}
			}
			if (dictionary2 != null)
			{
				foreach (KeyValuePair<YamlNode, YamlNode> item in dictionary2)
				{
					children[item.Key] = item.Value;
				}
			}
			if (dictionary == null)
			{
				return;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> item2 in dictionary)
			{
				YamlNode value = children[item2.Key];
				children.Remove(item2.Key);
				children.Add(item2.Value, value);
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new MappingStart(base.Anchor, base.Tag, isImplicit: true, Style));
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				child.Key.Save(emitter, state);
				child.Value.Save(emitter, state);
			}
			emitter.Emit(new MappingEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is YamlMappingNode yamlMappingNode) || !object.Equals(base.Tag, yamlMappingNode.Tag) || children.Count != yamlMappingNode.children.Count)
			{
				return false;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (!yamlMappingNode.children.TryGetValue(child.Key, out YamlNode value) || !object.Equals(child.Value, value))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int num = base.GetHashCode();
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				num = YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Key);
				num = (child.Value.Anchor.IsEmpty ? YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value) : YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value.Anchor));
			}
			return num;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				foreach (YamlNode item in child.Key.SafeAllNodes(level))
				{
					yield return item;
				}
				foreach (YamlNode item2 in child.Value.SafeAllNodes(level))
				{
					yield return item2;
				}
			}
			level.Decrement();
		}

		internal override string ToString(RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("{ ");
				foreach (KeyValuePair<YamlNode, YamlNode> child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append("{ ").Append(child.Key.ToString(level)).Append(", ")
						.Append(child.Value.ToString(level))
						.Append(" }");
				}
				builder.Append(" }");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		public IEnumerator<KeyValuePair<YamlNode, YamlNode>> GetEnumerator()
		{
			return children.GetEnumerator();
		}

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

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}

		public static YamlMappingNode FromObject(object mapping)
		{
			if (mapping == null)
			{
				throw new ArgumentNullException("mapping");
			}
			YamlMappingNode yamlMappingNode = new YamlMappingNode();
			foreach (PropertyInfo publicProperty in mapping.GetType().GetPublicProperties())
			{
				if (publicProperty.CanRead && publicProperty.GetGetMethod(nonPublic: false).GetParameters().Length == 0)
				{
					object value = publicProperty.GetValue(mapping, null);
					YamlNode yamlNode = value as YamlNode;
					if (yamlNode == null)
					{
						string text = Convert.ToString(value, CultureInfo.InvariantCulture);
						yamlNode = text ?? string.Empty;
					}
					yamlMappingNode.Add(publicProperty.Name, yamlNode);
				}
			}
			return yamlMappingNode;
		}
	}
	internal abstract class YamlNode
	{
		private const int MaximumRecursionLevel = 1000;

		internal const string MaximumRecursionLevelReachedToStringValue = "WARNING! INFINITE RECURSION!";

		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		public Mark Start { get; private set; } = Mark.Empty;

		public Mark End { get; private set; } = Mark.Empty;

		public IEnumerable<YamlNode> AllNodes
		{
			get
			{
				RecursionLevel level = new RecursionLevel(1000);
				return SafeAllNodes(level);
			}
		}

		public abstract YamlNodeType NodeType { get; }

		public YamlNode this[int index]
		{
			get
			{
				if (!(this is YamlSequenceNode yamlSequenceNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {index}. Only Sequences can be indexed by number.");
				}
				return yamlSequenceNode.Children[index];
			}
		}

		public YamlNode this[YamlNode key]
		{
			get
			{
				if (!(this is YamlMappingNode yamlMappingNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {key}. Only Mappings can be indexed by key.");
				}
				return yamlMappingNode.Children[key];
			}
		}

		internal void Load(NodeEvent yamlEvent, DocumentLoadingState state)
		{
			Tag = yamlEvent.Tag;
			if (!yamlEvent.Anchor.IsEmpty)
			{
				Anchor = yamlEvent.Anchor;
				state.AddAnchor(this);
			}
			Start = yamlEvent.Start;
			End = yamlEvent.End;
		}

		internal static YamlNode ParseNode(IParser parser, DocumentLoadingState state)
		{
			if (parser.Accept<YamlDotNet.Core.Events.Scalar>(out var _))
			{
				return new YamlScalarNode(parser, state);
			}
			if (parser.Accept<SequenceStart>(out var _))
			{
				return new YamlSequenceNode(parser, state);
			}
			if (parser.Accept<MappingStart>(out var _))
			{
				return new YamlMappingNode(parser, state);
			}
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var event4))
			{
				if (!state.TryGetNode(event4.Value, out YamlNode node))
				{
					return new YamlAliasNode(event4.Value);
				}
				return node;
			}
			throw new ArgumentException("The current event is of an unsupported type.", "parser");
		}

		internal abstract void ResolveAliases(DocumentLoadingState state);

		internal void Save(IEmitter emitter, EmitterState state)
		{
			if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
			{
				emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(Anchor));
			}
			else
			{
				Emit(emitter, state);
			}
		}

		internal abstract void Emit(IEmitter emitter, EmitterState state);

		public abstract void Accept(IYamlVisitor visitor);

		public override string ToString()
		{
			RecursionLevel recursionLevel = new RecursionLevel(1000);
			return ToString(recursionLevel);
		}

		internal abstract string ToString(RecursionLevel level);

		internal abstract IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level);

		public static implicit operator YamlNode(string value)
		{
			return new YamlScalarNode(value);
		}

		public static implicit operator YamlNode(string[] sequence)
		{
			return new YamlSequenceNode(((IEnumerable<string>)sequence).Select((Func<string, YamlNode>)((string i) => i)));
		}

		public static explicit operator string?(YamlNode node)
		{
			if (!(node is YamlScalarNode yamlScalarNode))
			{
				throw new ArgumentException($"Attempted to convert a '{node.NodeType}' to string. This conversion is valid only for Scalars.");
			}
			return yamlScalarNode.Value;
		}
	}
	internal sealed class YamlNodeIdentityEqualityComparer : IEqualityComparer<YamlNode>
	{
		public bool Equals([AllowNull] YamlNode x, [AllowNull] YamlNode y)
		{
			return x == y;
		}

		public int GetHashCode(YamlNode obj)
		{
			return obj.GetHashCode();
		}
	}
	internal enum YamlNodeType
	{
		Alias,
		Mapping,
		Scalar,
		Sequence
	}
	[DebuggerDisplay("{Value}")]
	internal sealed class YamlScalarNode : YamlNode, IYamlConvertible
	{
		private bool forceImplicitPlain;

		private string? value;

		public string? Value
		{
			get
			{
				return value;
			}
			set
			{
				if (value == null)
				{
					forceImplicitPlain = true;
				}
				else
				{
					forceImplicitPlain = false;
				}
				this.value = value;
			}
		}

		public ScalarStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Scalar;

		internal YamlScalarNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void Load(IParser parser, DocumentLoadingState state)
		{
			YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
			Load(scalar, state);
			string text = scalar.Value;
			if (scalar.Style == ScalarStyle.Plain && base.Tag.IsEmpty)
			{
				forceImplicitPlain = text.Length switch
				{
					0 => true, 
					1 => text == "~", 
					4 => text == "null" || text == "Null" || text == "NULL", 
					_ => false, 
				};
			}
			value = text;
			Style = scalar.Style;
		}

		public YamlScalarNode()
		{
		}

		public YamlScalarNode(string? value)
		{
			Value = value;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on a scalar node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			TagName tag = base.Tag;
			bool isPlainImplicit = tag.IsEmpty;
			if (forceImplicitPlain && Style == ScalarStyle.Plain && (Value == null || Value == ""))
			{
				tag = JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			else if (tag.IsEmpty && Value == null && (Style == ScalarStyle.Plain || Style == ScalarStyle.Any))
			{
				tag = JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(base.Anchor, tag, Value ?? string.Empty, Style, isPlainImplicit, isQuotedImplicit: false));
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (obj is YamlScalarNode yamlScalarNode && object.Equals(base.Tag, yamlScalarNode.Tag))
			{
				return object.Equals(Value, yamlScalarNode.Value);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return YamlDotNet.Core.HashCode.CombineHashCodes(base.Tag.GetHashCode(), Value);
		}

		public static explicit operator string?(YamlScalarNode value)
		{
			return value.Value;
		}

		internal override string ToString(RecursionLevel level)
		{
			return Value ?? string.Empty;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}
	}
	[DebuggerDisplay("Count = {children.Count}")]
	internal sealed class YamlSequenceNode : YamlNode, IEnumerable<YamlNode>, IEnumerable, IYamlConvertible
	{
		private readonly List<YamlNode> children = new List<YamlNode>();

		public IList<YamlNode> Children => children;

		public SequenceStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Sequence;

		internal YamlSequenceNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			SequenceStart sequenceStart = parser.Consume<SequenceStart>();
			Load(sequenceStart, state);
			Style = sequenceStart.Style;
			bool flag = false;
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				YamlNode yamlNode = YamlNode.ParseNode(parser, state);
				children.Add(yamlNode);
				flag = flag || yamlNode is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlSequenceNode()
		{
		}

		public YamlSequenceNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlSequenceNode(IEnumerable<YamlNode> children)
		{
			foreach (YamlNode child in children)
			{
				this.children.Add(child);
			}
		}

		public void Add(YamlNode child)
		{
			children.Add(child);
		}

		public void Add(string child)
		{
			children.Add(new YamlScalarNode(child));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			for (int i = 0; i < children.Count; i++)
			{
				if (children[i] is YamlAliasNode)
				{
					children[i] = state.GetNode(children[i].Anchor, children[i].Start, children[i].End);
				}
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new SequenceStart(base.Anchor, base.Tag, base.Tag.IsEmpty, Style));
			foreach (YamlNode child in children)
			{
				child.Save(emitter, state);
			}
			emitter.Emit(new SequenceEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override bool Equals(object? obj)
		{
			if (!(obj is YamlSequenceNode yamlSequenceNode) || !object.Equals(base.Tag, yamlSequenceNode.Tag) || children.Count != yamlSequenceNode.children.Count)
			{
				return false;
			}
			for (int i = 0; i < children.Count; i++)
			{
				if (!object.Equals(children[i], yamlSequenceNode.children[i]))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int h = 0;
			foreach (YamlNode child in children)
			{
				h = YamlDotNet.Core.HashCode.CombineHashCodes(h, child);
			}
			return YamlDotNet.Core.HashCode.CombineHashCodes(h, base.Tag);
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (YamlNode child in children)
			{
				foreach (YamlNode item in child.SafeAllNodes(level))
				{
					yield return item;
				}
			}
			level.Decrement();
		}

		internal override string ToString(RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("[ ");
				foreach (YamlNode child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append(child.ToString(level));
				}
				builder.Append(" ]");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		public IEnumerator<YamlNode> GetEnumerator()
		{
			return Children.GetEnumerator();
		}

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

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}
	}
	internal class YamlStream : IEnumerable<YamlDocument>, IEnumerable
	{
		private readonly List<YamlDocument> documents = new List<YamlDocument>();

		public IList<YamlDocument> Documents => documents;

		public YamlStream()
		{
		}

		public YamlStream(params YamlDocument[] documents)
			: this((IEnumerable<YamlDocument>)documents)
		{
		}

		public YamlStream(IEnumerable<YamlDocument> documents)
		{
			foreach (YamlDocument document in documents)
			{
				this.documents.Add(document);
			}
		}

		public void Add(YamlDocument document)
		{
			documents.Add(document);
		}

		public void Load(TextReader input)
		{
			Load(new Parser(input));
		}

		public void Load(IParser parser)
		{
			documents.Clear();
			parser.Consume<YamlDotNet.Core.Events.StreamStart>();
			YamlDotNet.Core.Events.StreamEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.StreamEnd>(out @event))
			{
				YamlDocument item = new YamlDocument(parser);
				documents.Add(item);
			}
		}

		public void Save(TextWriter output)
		{
			Save(output, assignAnchors: true);
		}

		public void Save(TextWriter output, bool assignAnchors)
		{
			Save(new Emitter(output), assignAnchors);
		}

		public void Save(IEmitter emitter, bool assignAnchors)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			foreach (YamlDocument document in documents)
			{
				document.Save(emitter, assignAnchors);
			}
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public IEnumerator<YamlDocument> GetEnumerator()
		{
			return documents.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[Obsolete("Use YamlVisitorBase")]
	internal abstract class YamlVisitor : IYamlVisitor
	{
		protected virtual void Visit(YamlStream stream)
		{
		}

		protected virtual void Visited(YamlStream stream)
		{
		}

		protected virtual void Visit(YamlDocument document)
		{
		}

		protected virtual void Visited(YamlDocument document)
		{
		}

		protected virtual void Visit(YamlScalarNode scalar)
		{
		}

		protected virtual void Visited(YamlScalarNode scalar)
		{
		}

		protected virtual void Visit(YamlSequenceNode sequence)
		{
		}

		protected virtual void Visited(YamlSequenceNode sequence)
		{
		}

		protected virtual void Visit(YamlMappingNode mapping)
		{
		}

		protected virtual void Visited(YamlMappingNode mapping)
		{
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				child.Key.Accept(this);
				child.Value.Accept(this);
			}
		}

		void IYamlVisitor.Visit(YamlStream stream)
		{
			Visit(stream);
			VisitChildren(stream);
			Visited(stream);
		}

		void IYamlVisitor.Visit(YamlDocument document)
		{
			Visit(document);
			VisitChildren(document);
			Visited(document);
		}

		void IYamlVisitor.Visit(YamlScalarNode scalar)
		{
			Visit(scalar);
			Visited(scalar);
		}

		void IYamlVisitor.Visit(YamlSequenceNode sequence)
		{
			Visit(sequence);
			VisitChildren(sequence);
			Visited(sequence);
		}

		void IYamlVisitor.Visit(YamlMappingNode mapping)
		{
			Visit(mapping);
			VisitChildren(mapping);
			Visited(mapping);
		}
	}
	internal abstract class YamlVisitorBase : IYamlVisitor
	{
		public virtual void Visit(YamlStream stream)
		{
			VisitChildren(stream);
		}

		public virtual void Visit(YamlDocument document)
		{
			VisitChildren(document);
		}

		public virtual void Visit(YamlScalarNode scalar)
		{
		}

		public virtual void Visit(YamlSequenceNode sequence)
		{
			VisitChildren(sequence);
		}

		public virtual void Visit(YamlMappingNode mapping)
		{
			VisitChildren(mapping);
		}

		protected virtual void VisitPair(YamlNode key, YamlNode value)
		{
			key.Accept(this);
			value.Accept(this);
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				VisitPair(child.Key, child.Value);
			}
		}
	}
}
namespace YamlDotNet.Helpers
{
	internal class DefaultFsharpHelper : IFsharpHelper
	{
		private static bool IsFsharpCore(Type t)
		{
			return t.Namespace == "Microsoft.FSharp.Core";
		}

		public bool IsOptionType(Type t)
		{
			if (IsFsharpCore(t))
			{
				return t.Name == "FSharpOption`1";
			}
			return false;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			if (!t.IsGenericType || !IsOptionType(t))
			{
				return null;
			}
			return t.GenericTypeArguments[0];
		}

		public object? GetValue(IObjectDescriptor objectDescriptor)
		{
			if (!IsOptionType(objectDescriptor.Type))
			{
				throw new InvalidOperationException("Should not be called on non-Option<> type");
			}
			if (objectDescriptor.Value == null)
			{
				return null;
			}
			return objectDescriptor.Type.GetProperty("Value").GetValue(objectDescriptor.Value);
		}

		public bool IsFsharpListType(Type t)
		{
			if (t.Namespace == "Microsoft.FSharp.Collections")
			{
				return t.Name == "FSharpList`1";
			}
			return false;
		}

		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			if (!IsFsharpListType(t))
			{
				return null;
			}
			return t.Assembly.GetType("Microsoft.FSharp.Collections.ListModule").GetMethod("OfArray").MakeGenericMethod(itemsType)
				.Invoke(null, new object[1] { arr });
		}
	}
	internal static class DictionaryExtensions
	{
		public static bool TryAdd<T, V>(this Dictionary<T, V> dictionary, T key, V value)
		{
			if (dictionary.ContainsKey(key))
			{
				return false;
			}
			dictionary.Add(key, value);
			return true;
		}

		public static TValue GetOrAdd<TKey, TValue, TArg>(this ConcurrentDictionary<TKey, TValue> dictionary, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg arg)
		{
			if (dictionary == null)
			{
				throw new ArgumentNullException("dictionary");
			}
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			if (valueFactory == null)
			{
				throw new ArgumentNullException("valueFactory");
			}
			TValue value;
			do
			{
				if (dictionary.TryGetValue(key, out value))
				{
					return value;
				}
				value = valueFactory(key, arg);
			}
			while (!dictionary.TryAdd(key, value));
			return value;
		}
	}
	internal static class ExpressionExtensions
	{
		public static PropertyInfo AsProperty(this LambdaExpression propertyAccessor)
		{
			PropertyInfo propertyInfo = TryGetMemberExpression<PropertyInfo>(propertyAccessor);
			if (propertyInfo == null)
			{
				throw new ArgumentException("Expected a lambda expression in the form: x => x.SomeProperty", "propertyAccessor");
			}
			return propertyInfo;
		}

		[return: MaybeNull]
		private static TMemberInfo TryGetMemberExpression<TMemberInfo>(LambdaExpression lambdaExpression) where TMemberInfo : MemberInfo
		{
			if (lambdaExpression.Parameters.Count != 1)
			{
				return null;
			}
			Expression expression = lambdaExpression.Body;
			if (expression is UnaryExpression unaryExpression)
			{
				if (unaryExpression.NodeType != ExpressionType.Convert)
				{
					return null;
				}
				expression = unaryExpression.Operand;
			}
			if (expression is MemberExpression memberExpression)
			{
				if (memberExpression.Expression != lambdaExpression.Parameters[0])
				{
					return null;
				}
				return memberExpression.Member as TMemberInfo;
			}
			return null;
		}
	}
	internal static class FsharpHelper
	{
		public static IFsharpHelper? Instance { get; set; }

		public static bool IsOptionType(Type t)
		{
			return Instance?.IsOptionType(t) ?? false;
		}

		public static Type? GetOptionUnderlyingType(Type t)
		{
			return Instance?.GetOptionUnderlyingType(t);
		}

		public static object? GetValue(IObjectDescriptor objectDescriptor)
		{
			return Instance?.GetValue(objectDescriptor);
		}

		public static bool IsFsharpListType(Type t)
		{
			return Instance?.IsFsharpListType(t) ?? false;
		}

		public static object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return Instance?.CreateFsharpListFromArray(t, itemsType, arr);
		}
	}
	internal sealed class GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
	{
		private readonly ICollection<T> genericCollection;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object? this[int index]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				((IList<T>)genericCollection)[index] = (T)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericCollectionToNonGenericAdapter(ICollection<T> genericCollection)
		{
			this.genericCollection = genericCollection ?? throw new ArgumentNullException("genericCollection");
		}

		public int Add(object? value)
		{
			int count = genericCollection.Count;
			genericCollection.Add((T)value);
			return count;
		}

		public void Clear()
		{
			genericCollection.Clear();
		}

		public bool Contains(object? value)
		{
			throw new NotSupportedException();
		}

		public int IndexOf(object? value)
		{
			throw new NotSupportedException();
		}

		public void Insert(int index, object? value)
		{
			throw new NotSupportedException();
		}

		public void Remove(object? value)
		{
			throw new NotSupportedException();
		}

		public void RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		public IEnumerator GetEnumerator()
		{
			return genericCollection.GetEnumerator();
		}
	}
	internal sealed class GenericDictionaryToNonGenericAdapter<TKey, TValue> : IDictionary, ICollection, IEnumerable where TKey : notnull
	{
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

			public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

			public object Key => enumerator.Current.Key;

			public object? Value => enumerator.Current.Value;

			public object Current => Entry;

			public DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> enumerator)
			{
				this.enumerator = enumerator;
			}

			public bool MoveNext()
			{
				return enumerator.MoveNext();
			}

			public void Reset()
			{
				enumerator.Reset();
			}
		}

		private readonly IDictionary<TKey, TValue> genericDictionary;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Keys
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Values
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object? this[object key]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				genericDictionary[(TKey)key] = (TValue)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericDictionaryToNonGenericAdapter(IDictionary<TKey, TValue> genericDictionary)
		{
			this.genericDictionary = genericDictionary ?? throw new ArgumentNullException("genericDictionary");
		}

		public void Add(object key, object? value)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public bool Contains(object key)
		{
			throw new NotSupportedException();
		}

		public IDictionaryEnumerator GetEnumerator()
		{
			return new DictionaryEnumerator(genericDictionary.GetEnumerator());
		}

		public void Remove(object key)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal interface IFsharpHelper
	{
		bool IsOptionType(Type t);

		Type? GetOptionUnderlyingType(Type t);

		object? GetValue(IObjectDescriptor objectDescriptor);

		bool IsFsharpListType(Type t);

		object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr);
	}
	internal interface IOrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		KeyValuePair<TKey, TValue> this[int index] { get; set; }

		void Insert(int index, TKey key, TValue value);

		void RemoveAt(int index);
	}
	internal class NullFsharpHelper : IFsharpHelper
	{
		public object? CreateFsharpListFromArray(Type t, Type itemsType, Array arr)
		{
			return null;
		}

		public Type? GetOptionUnderlyingType(Type t)
		{
			return null;
		}

		public object? GetValue(IObjectDescriptor objectDescriptor)
		{
			return null;
		}

		public bool IsFsharpListType(Type t)
		{
			return false;
		}

		public bool IsOptionType(Type t)
		{
			return false;
		}
	}
	internal static class NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	internal sealed class OrderedDictionary<TKey, TValue> : IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TKey : notnull
	{
		private class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TKey item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TKey item)
			{
				return orderedDictionary.dictionary.ContainsKey(item);
			}

			public KeyCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
			{
				this.orderedDictionary = orderedDictionary;
			}

			public void CopyTo(TKey[] array, int arrayIndex)
			{
				for (int i = 0; i < orderedDictionary.list.Count; i++)
				{
					array[i] = orderedDictionary.list[i + arrayIndex].Key;
				}
			}

			public IEnumerator<TKey> GetEnumerator()
			{
				return orderedDictionary.list.Select((KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
			}

			public bool Remove(TKey item)
			{
				throw new NotSupportedException();
			}

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

		private class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TValue item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TValue item)
			{
				return orderedDictionary.dictionary.ContainsValue(item);
			}

			public ValueCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
			{
				this.orderedDictionary = orderedDictionary;
			}

			public void CopyTo(TValue[] array, int arrayIndex)
			{
				for (int i = 0; i < orderedDictionary.list.Count; i++)
				{
					array[i] = orderedDictionary.list[i + arrayIndex].Value;
				}
			}

			public IEnumerator<TValue> GetEnumerator()
			{
				return orderedDictionary.list.Select((KeyValuePair<TKey, TValue> kvp) => kvp.Value).GetEnumerator();
			}

			public bool Remove(TValue item)
			{
				throw new NotSupportedException();
			}

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

		[NonSerialized]
		private Dictionary<TKey, TValue> dictionary;

		private readonly List<KeyValuePair<TKey, TValue>> list;

		private readonly IEqualityComparer<TKey> comparer;

		public TValue this[TKey key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				if (dictionary.ContainsKey(key))
				{
					int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
					dictionary[key] = value;
					list[index] = new KeyValuePair<TKey, TValue>(key, value);
				}
				else
				{
					Add(key, value);
				}
			}
		}

		public ICollection<TKey> Keys => new KeyCollection(this);

		public ICollection<TValue> Values => new ValueCollection(this);

		public int Count => dictionary.Count;

		public bool IsReadOnly => false;

		public KeyValuePair<TKey, TValue> this[int index]
		{
			get
			{
				return list[index];
			}
			set
			{
				list[index] = value;
			}
		}

		public OrderedDictionary()
			: this((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public OrderedDictionary(IEqualityComparer<TKey> comparer)
		{
			list = new List<KeyValuePair<TKey, TValue>>();
			dictionary = new Dictionary<TKey, TValue>(comparer);
			this.comparer = comparer;
		}

		public void Add(KeyValuePair<TKey, TValue> item)
		{
			if (!TryAdd(item))
			{
				ThrowDuplicateKeyException(item.Key);
			}
		}

		public void Add(TKey key, TValue value)
		{
			if (!TryAdd(key, value))
			{
				ThrowDuplicateKeyException(key);
			}
		}

		private static void ThrowDuplicateKeyException(TKey key)
		{
			throw new ArgumentException($"An item with the same key {key} has already been added.");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(TKey key, TValue value)
		{
			if (DictionaryExtensions.TryAdd(dictionary, key, value))
			{
				list.Add(new KeyValuePair<TKey, TValue>(key, value));
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryAdd(KeyValuePair<TKey, TValue> item)
		{
			if (DictionaryExtensions.TryAdd(dictionary, item.Key, item.Value))
			{
				list.Add(item);
				return true;
			}
			return false;
		}

		public void Clear()
		{
			dictionary.Clear();
			list.Clear();
		}

		public bool Contains(KeyValuePair<TKey, TValue> item)
		{
			return dictionary.Contains(item);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return list.GetEnumerator();
		}

		public void Insert(int index, TKey key, TValue value)
		{
			dictionary.Add(key, value);
			list.Insert(index, new KeyValuePair<TKey, TValue>(key, value));
		}

		public bool Remove(TKey key)
		{
			if (dictionary.ContainsKey(key))
			{
				int index = list.FindIndex((KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
				list.RemoveAt(index);
				if (!dictionary.Remove(key))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove(KeyValuePair<TKey, TValue> item)
		{
			return Remove(item.Key);
		}

		public void RemoveAt(int index)
		{
			TKey key = list[index].Key;
			dictionary.Remove(key);
			list.RemoveAt(index);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			return dictionary.TryGetValue(key, out value);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return list.GetEnumerator();
		}

		[System.Runtime.Serialization.OnDeserialized]
		internal void OnDeserializedMethod(StreamingContext context)
		{
			dictionary = new Dictionary<TKey, TValue>();
			foreach (KeyValuePair<TKey, TValue> item in list)
			{
				dictionary[item.Key] = item.Value;
			}
		}
	}
	internal static class ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, TValue>(this Dictionary<TKey, TValue> dictionary) where TKey : notnull
		{
			return dictionary;
		}
	}
	internal static class ThrowHelper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowArgumentOutOfRangeException(string paramName, string message)
		{
			throw new ArgumentOutOfRangeException(paramName, message);
		}
	}
}
namespace YamlDotNet.Core
{
	internal readonly struct AnchorName : IEquatable<AnchorName>
	{
		public static readonly AnchorName Empty;

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of an empty anchor");

		public bool IsEmpty => value == null;

		public AnchorName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (!AnchorPattern.IsMatch(value))
			{
				throw new ArgumentException("Anchor cannot be empty or contain disallowed characters: []{},\nThe value was '" + value + "'.", "value");
			}
		}

		public override string ToString()
		{
			return value ?? "[empty]";
		}

		public bool Equals(AnchorName other)
		{
			return object.Equals(value, other.value);
		}

		public override bool Equals(object? obj)
		{
			if (obj is AnchorName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(AnchorName left, AnchorName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(AnchorName left, AnchorName right)
		{
			return !(left == right);
		}

		public static implicit operator AnchorName(string? value)
		{
			if (value != null)
			{
				return new AnchorName(value);
			}
			return Empty;
		}
	}
	internal class AnchorNotFoundException : YamlException
	{
		public AnchorNotFoundException(string message)
			: base(message)
		{
		}

		public AnchorNotFoundException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public AnchorNotFoundException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[DebuggerStepThrough]
	internal readonly struct CharacterAnalyzer<TBuffer> where TBuffer : ILookAheadBuffer
	{
		public TBuffer Buffer { get; }

		public bool EndOfInput => Buffer.EndOfInput;

		public CharacterAnalyzer(TBuffer buffer)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			Buffer = buffer;
		}

		public char Peek(int offset)
		{
			return Buffer.Peek(offset);
		}

		public void Skip(int length)
		{
			Buffer.Skip(length);
		}

		public bool IsAlphaNumericDashOrUnderscore(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && c != '_')
			{
				return c == '-';
			}
			return true;
		}

		public bool IsAscii(int offset = 0)
		{
			return Buffer.Peek(offset) <= '\u007f';
		}

		public bool IsPrintable(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			switch (c)
			{
			default:
				if (c != '\u0085' && (c < '\u00a0' || c > '\ud7ff'))
				{
					if (c >= '\ue000')
					{
						return c <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		public bool IsDigit(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if (c >= '0')
			{
				return c <= '9';
			}
			return false;
		}

		public int AsDigit(int offset = 0)
		{
			return Buffer.Peek(offset) - 48;
		}

		public bool IsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'F'))
			{
				if (c >= 'a')
				{
					return c <= 'f';
				}
				return false;
			}
			return true;
		}

		public int AsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if (c <= '9')
			{
				return c - 48;
			}
			if (c <= 'F')
			{
				return c - 65 + 10;
			}
			return c - 97 + 10;
		}

		public bool IsSpace(int offset = 0)
		{
			return Check(' ', offset);
		}

		public bool IsZero(int offset = 0)
		{
			return Check('\0', offset);
		}

		public bool IsTab(int offset = 0)
		{
			return Check('\t', offset);
		}

		public bool IsWhite(int offset = 0)
		{
			if (!IsSpace(offset))
			{
				return IsTab(offset);
			}
			return true;
		}

		public bool IsBreak(int offset = 0)
		{
			return Check("\r\n\u0085\u2028\u2029", offset);
		}

		public bool IsCrLf(int offset = 0)
		{
			if (Check('\r', offset))
			{
				return Check('\n', offset + 1);
			}
			return false;
		}

		public bool IsBreakOrZero(int offset = 0)
		{
			if (!IsBreak(offset))
			{
				return IsZero(offset);
			}
			return true;
		}

		public bool IsWhiteBreakOrZero(int offset = 0)
		{
			if (!IsWhite(offset))
			{
				return IsBreakOrZero(offset);
			}
			return true;
		}

		public bool Check(char expected, int offset = 0)
		{
			return Buffer.Peek(offset) == expected;
		}

		public bool Check(string expectedCharacters, int offset = 0)
		{
			char c = Buffer.Peek(offset);
			return Polyfills.Contains(expectedCharacters, c);
		}
	}
	internal static class Constants
	{
		public static readonly TagDirective[] DefaultTagDirectives = new TagDirective[2]
		{
			new TagDirective("!", "!"),
			new TagDirective("!!", "tag:yaml.org,2002:")
		};

		public const int MajorVersion = 1;

		public const int MinorVersion = 3;
	}
	[DebuggerStepThrough]
	internal sealed class Cursor
	{
		public long Index { get; private set; }

		public long Line { get; private set; }

		public long LineOffset { get; private set; }

		public Cursor()
		{
			Line = 1L;
		}

		public Cursor(Cursor cursor)
		{
			Index = cursor.Index;
			Line = cursor.Line;
			LineOffset = cursor.LineOffset;
		}

		public Mark Mark()
		{
			return new Mark(Index, Line, LineOffset + 1);
		}

		public void Skip()
		{
			Index++;
			LineOffset++;
		}

		public void SkipLineByOffset(int offset)
		{
			Index += offset;
			Line++;
			LineOffset = 0L;
		}

		public void ForceSkipLineAfterNonBreak()
		{
			if (LineOffset != 0L)
			{
				Line++;
				LineOffset = 0L;
			}
		}
	}
	internal class Emitter : IEmitter
	{
		private class AnchorData
		{
			public AnchorName Anchor;

			public bool IsAlias;
		}

		private class TagData
		{
			public string? Handle;

			public string? Suffix;
		}

		private class ScalarData
		{
			public string Value = string.Empty;

			public bool IsMultiline;

			public bool IsFlowPlainAllowed;

			public bool IsBlockPlainAllowed;

			public bool IsSingleQuotedAllowed;

			public bool IsBlockAllowed;

			public bool HasSingleQuotes;

			public ScalarStyle Style;
		}

		private static readonly Regex UriReplacer = new Regex("[^0-9A-Za-z_\\-;?@=$~\\\\\\)\\]/:&+,\\.\\*\\(\\[!]", RegexOptions.Compiled | RegexOptions.Singleline);

		private static readonly string[] NewLineSeparators = new string[3] { "\r\n", "\r", "\n" };

		private readonly TextWriter output;

		private readonly bool outputUsesUnicodeEncoding;

		private readonly int maxSimpleKeyLength;

		private readonly bool isCanonical;

		private readonly bool skipAnchorName;

		private readonly int bestIndent;

		private readonly int bestWidth;

		private EmitterState state;

		private readonly Stack<EmitterState> states = new Stack<EmitterState>();

		private readonly Queue<ParsingEvent> events = new Queue<ParsingEvent>();

		private readonly Stack<int> indents = new Stack<int>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private int indent;

		private int flowLevel;

		private bool isMappingContext;

		private bool isSimpleKeyContext;

		private int column;

		private bool isWhitespace;

		private bool isIndentation;

		private readonly bool forceIndentLess;

		private readonly bool useUtf16SurrogatePair;

		private bool isDocumentEndWritten;

		private readonly AnchorData anchorData = new AnchorData();

		private readonly TagData tagData = new TagData();

		private readonly ScalarData scalarData = new ScalarData();

		public Emitter(TextWriter output)
			: this(output, EmitterSettings.Default)
		{
		}

		public Emitter(TextWriter output, int bestIndent)
			: this(output, bestIndent, int.MaxValue)
		{
		}

		public Emitter(TextWriter output, int bestIndent, int bestWidth)
			: this(output, bestIndent, bestWidth, isCanonical: false)
		{
		}

		public Emitter(TextWriter output, int bestIndent, int bestWidth, bool isCanonical)
			: this(output, new EmitterSettings(bestIndent, bestWidth, isCanonical, 1024))
		{
		}

		public Emitter(TextWriter output, EmitterSettings settings)
		{
			bestIndent = settings.BestIndent;
			bestWidth = settings.BestWidth;
			isCanonical = settings.IsCanonical;
			maxSimpleKeyLength = settings.MaxSimpleKeyLength;
			skipAnchorName = settings.SkipAnchorName;
			forceIndentLess = !settings.IndentSequences;
			useUtf16SurrogatePair = settings.UseUtf16SurrogatePairs;
			this.output = output;
			this.output.NewLine = settings.NewLine;
			outputUsesUnicodeEncoding = IsUnicode(output.Encoding);
		}

		public void Emit(ParsingEvent @event)
		{
			events.Enqueue(@event);
			while (!NeedMoreEvents())
			{
				ParsingEvent evt = events.Peek();
				try
				{
					AnalyzeEvent(evt);
					StateMachine(evt);
				}
				finally
				{
					events.Dequeue();
				}
			}
		}

		private bool NeedMoreEvents()
		{
			if (events.Count == 0)
			{
				return true;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.DocumentStart:
				num = 1;
				break;
			case EventType.SequenceStart:
				num = 2;
				break;
			case EventType.MappingStart:
				num = 3;
				break;
			default:
				return false;
			}
			if (events.Count > num)
			{
				return false;
			}
			int num2 = 0;
			foreach (ParsingEvent @event in events)
			{
				switch (@event.Type)
				{
				case EventType.DocumentStart:
				case EventType.SequenceStart:
				case EventType.MappingStart:
					num2++;
					break;
				case EventType.DocumentEnd:
				case EventType.SequenceEnd:
				case EventType.MappingEnd:
					num2--;
					break;
				}
				if (num2 == 0)
				{
					return false;
				}
			}
			return true;
		}

		private void AnalyzeEvent(ParsingEvent evt)
		{
			anchorData.Anchor = AnchorName.Empty;
			tagData.Handle = null;
			tagData.Suffix = null;
			if (evt is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				AnalyzeAnchor(anchorAlias.Value, isAlias: true);
			}
			else if (evt is NodeEvent nodeEvent)
			{
				if (evt is YamlDotNet.Core.Events.Scalar scalar)
				{
					AnalyzeScalar(scalar);
				}
				AnalyzeAnchor(nodeEvent.Anchor, isAlias: false);
				if (!nodeEvent.Tag.IsEmpty && (isCanonical || nodeEvent.IsCanonical))
				{
					AnalyzeTag(nodeEvent.Tag);
				}
			}
		}

		private void AnalyzeAnchor(AnchorName anchor, bool isAlias)
		{
			anchorData.Anchor = anchor;
			anchorData.IsAlias = isAlias;
		}

		private void AnalyzeScalar(YamlDotNet.Core.Events.Scalar scalar)
		{
			string value = scalar.Value;
			scalarData.Value = value;
			if (value.Length == 0)
			{
				if (scalar.Tag == "tag:yaml.org,2002:null")
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = true;
					scalarData.IsSingleQuotedAllowed = false;
					scalarData.IsBlockAllowed = false;
				}
				else
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = true;
					scalarData.IsBlockAllowed = false;
				}
				return;
			}
			bool flag = false;
			bool flag2 = false;
			if (value.StartsWith("---", StringComparison.Ordinal) || value.StartsWith("...", StringComparison.Ordinal))
			{
				flag = true;
				flag2 = true;
			}
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(bufferWrapper.Buffer);
				bool flag3 = true;
				bool flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
				bool flag5 = false;
				bool flag6 = false;
				bool flag7 = false;
				bool flag8 = false;
				bool flag9 = false;
				bool flag10 = false;
				bool flag11 = false;
				bool flag12 = false;
				bool flag13 = false;
				bool flag14 = false;
				bool flag15 = false;
				bool flag16 = !ValueIsRepresentableInOutputEncoding(value);
				bool flag17 = false;
				bool flag18 = false;
				bool flag19 = true;
				while (!characterAnalyzer.EndOfInput)
				{
					if (flag19)
					{
						if (characterAnalyzer.Check("#,[]{}&*!|>\"%@`'"))
						{
							flag = true;
							flag2 = true;
							flag9 = characterAnalyzer.Check('\'');
							flag17 |= characterAnalyzer.Check('\'');
						}
						if (characterAnalyzer.Check("?:"))
						{
							flag = true;
							if (flag4)
							{
								flag2 = true;
							}
						}
						if (characterAnalyzer.Check('-') && flag4)
						{
							flag = true;
							flag2 = true;
						}
					}
					else
					{
						if (characterAnalyzer.Check(",?[]{}"))
						{
							flag = true;
						}
						if (characterAnalyzer.Check(':'))
						{
							flag = true;
							if (flag4)
							{
								flag2 = true;
							}
						}
						if (characterAnalyzer.Check('#') && flag3)
						{
							flag = true;
							flag2 = true;
						}
						flag17 |= characterAnalyzer.Check('\'');
					}
					if (!flag16 && !characterAnalyzer.IsPrintable())
					{
						flag16 = true;
					}
					if (characterAnalyzer.IsBreak())
					{
						flag15 = true;
					}
					if (characterAnalyzer.IsSpace())
					{
						if (flag19)
						{
							flag5 = true;
						}
						if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
						{
							flag7 = true;
						}
						if (flag13)
						{
							flag10 = true;
							flag14 = true;
						}
						flag12 = true;
						flag13 = false;
					}
					else if (characterAnalyzer.IsBreak())
					{
						if (flag19)
						{
							flag6 = true;
						}
						if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
						{
							flag8 = true;
						}
						if (flag12)
						{
							flag11 = true;
						}
						if (flag14)
						{
							flag18 = true;
						}
						flag12 = false;
						flag13 = true;
					}
					else
					{
						flag12 = false;
						flag13 = false;
						flag14 = false;
					}
					flag3 = characterAnalyzer.IsWhiteBreakOrZero();
					characterAnalyzer.Skip(1);
					if (!characterAnalyzer.EndOfInput)
					{
						flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
					}
					flag19 = false;
				}
				scalarData.IsFlowPlainAllowed = true;
				scalarData.IsBlockPlainAllowed = true;
				scalarData.IsSingleQuotedAllowed = true;
				scalarData.IsBlockAllowed = true;
				if (flag5 || flag6 || flag7 || flag8 || flag9)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
				}
				if (flag7)
				{
					scalarData.IsBlockAllowed = false;
				}
				if (flag10)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = false;
				}
				if (flag11 || flag16)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = false;
				}
				if (flag18)
				{
					scalarData.IsBlockAllowed = false;
				}
				scalarData.IsMultiline = flag15;
				if (flag15)
				{
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
				}
				if (flag)
				{
					scalarData.IsFlowPlainAllowed = false;
				}
				if (flag2)
				{
					scalarData.IsBlockPlainAllowed = false;
				}
				scalarData.HasSingleQuotes = flag17;
			}
			finally
			{
				((IDisposable)bufferWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private bool ValueIsRepresentableInOutputEncoding(string value)
		{
			if (outputUsesUnicodeEncoding)
			{
				return true;
			}
			try
			{
				byte[] bytes = output.Encoding.GetBytes(value);
				string text = output.Encoding.GetString(bytes, 0, bytes.Length);
				return text.Equals(value);
			}
			catch (EncoderFallbackException)
			{
				return false;
			}
			catch (ArgumentOutOfRangeException)
			{
				return false;
			}
		}

		private static bool IsUnicode(Encoding encoding)
		{
			if (!(encoding is UTF8Encoding) && !(encoding is UnicodeEncoding))
			{
				return encoding is UTF7Encoding;
			}
			return true;
		}

		private void AnalyzeTag(TagName tag)
		{
			tagData.Handle = tag.Value;
			foreach (TagDirective tagDirective in tagDirectives)
			{
				if (tag.Value.StartsWith(tagDirective.Prefix, StringComparison.Ordinal))
				{
					tagData.Handle = tagDirective.Handle;
					tagData.Suffix = tag.Value.Substring(tagDirective.Prefix.Length);
					break;
				}
			}
		}

		private void StateMachine(ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.Comment comment)
			{
				EmitComment(comment);
				return;
			}
			switch (state)
			{
			case EmitterState.StreamStart:
				EmitStreamStart(evt);
				break;
			case EmitterState.FirstDocumentStart:
				EmitDocumentStart(evt, isFirst: true);
				break;
			case EmitterState.DocumentStart:
				EmitDocumentStart(evt, isFirst: false);
				break;
			case EmitterState.DocumentContent:
				EmitDocumentContent(evt);
				break;
			case EmitterState.DocumentEnd:
				EmitDocumentEnd(evt);
				break;
			case EmitterState.FlowSequenceFirstItem:
				EmitFlowSequenceItem(evt, isFirst: true);
				break;
			case EmitterState.FlowSequenceItem:
				EmitFlowSequenceItem(evt, isFirst: false);
				break;
			case EmitterState.FlowMappingFirstKey:
				EmitFlowMappingKey(evt, isFirst: true);
				break;
			case EmitterState.FlowMappingKey:
				EmitFlowMappingKey(evt, isFirst: false);
				break;
			case EmitterState.FlowMappingSimpleValue:
				EmitFlowMappingValue(evt, isSimple: true);
				break;
			case EmitterState.FlowMappingValue:
				EmitFlowMappingValue(evt, isSimple: false);
				break;
			case EmitterState.BlockSequenceFirstItem:
				EmitBlockSequenceItem(evt, isFirst: true);
				break;
			case EmitterState.BlockSequenceItem:
				EmitBlockSequenceItem(evt, isFirst: false);
				break;
			case EmitterState.BlockMappingFirstKey:
				EmitBlockMappingKey(evt, isFirst: true);
				break;
			case EmitterState.BlockMappingKey:
				EmitBlockMappingKey(evt, isFirst: false);
				break;
			case EmitterState.BlockMappingSimpleValue:
				EmitBlockMappingValue(evt, isSimple: true);
				break;
			case EmitterState.BlockMappingValue:
				EmitBlockMappingValue(evt, isSimple: false);
				break;
			case EmitterState.StreamEnd:
				throw new YamlException("Expected nothing after STREAM-END");
			default:
				throw new InvalidOperationException();
			}
		}

		private void EmitComment(YamlDotNet.Core.Events.Comment comment)
		{
			if (flowLevel > 0 || state == EmitterState.FlowMappingFirstKey || state == EmitterState.FlowSequenceFirstItem)
			{
				return;
			}
			string[] array = comment.Value.Split(NewLineSeparators, StringSplitOptions.None);
			if (comment.IsInline)
			{
				Write(" # ");
				Write(string.Join(" ", array));
			}
			else
			{
				bool flag = state == EmitterState.BlockMappingFirstKey;
				if (flag)
				{
					IncreaseIndent(isFlow: false, isIndentless: false);
				}
				string[] array2 = array;
				foreach (string value in array2)
				{
					WriteIndent();
					Write("# ");
					Write(value);
					WriteBreak();
				}
				if (flag)
				{
					indent = indents.Pop();
				}
			}
			isIndentation = true;
		}

		private void EmitStreamStart(ParsingEvent evt)
		{
			if (!(evt is YamlDotNet.Core.Events.StreamStart))
			{
				throw new ArgumentException("Expected STREAM-START.", "evt");
			}
			indent = -1;
			column = 0;
			isWhitespace = true;
			isIndentation = true;
			state = EmitterState.FirstDocumentStart;
		}

		private void EmitDocumentStart(ParsingEvent evt, bool isFirst)
		{
			if (evt is YamlDotNet.Core.Events.DocumentStart documentStart)
			{
				bool flag = documentStart.IsImplicit && isFirst && !isCanonical;
				TagDirectiveCollection tagDirectiveCollection = NonDefaultTagsAmong(documentStart.Tags);
				if (!isFirst && !isDocumentEndWritten && (documentStart.Version != null || tagDirectiveCollection.Count > 0))
				{
					isDocumentEndWritten = false;
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				if (documentStart.Version != null)
				{
					AnalyzeVersionDirective(documentStart.Version);
					Version version = documentStart.Version.Version;
					flag = false;
					WriteIndicator("%YAML", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndicator(string.Format(CultureInfo.InvariantCulture, "{0}.{1}", version.Major, version.Minor), needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				foreach (TagDirective item in tagDirectiveCollection)
				{
					AppendTagDirectiveTo(item, allowDuplicates: false, tagDirectives);
				}
				TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
				foreach (TagDirective value in defaultTagDirectives)
				{
					AppendTagDirectiveTo(value, allowDuplicates: true, tagDirectives);
				}
				if (tagDirectiveCollection.Count > 0)
				{
					flag = false;
					TagDirective[] defaultTagDirectives2 = Constants.DefaultTagDirectives;
					foreach (TagDirective value2 in defaultTagDirectives2)
					{
						AppendTagDirectiveTo(value2, allowDuplicates: true, tagDirectiveCollection);
					}
					foreach (TagDirective item2 in tagDirectiveCollection)
					{
						WriteIndicator("%TAG", needWhitespace: true, whitespace: false, indentation: false);
						WriteTagHandle(item2.Handle);
						WriteTagContent(item2.Prefix, needsWhitespace: true);
						WriteIndent();
					}
				}
				if (CheckEmptyDocument())
				{
					flag = false;
				}
				if (!flag)
				{
					WriteIndent();
					WriteIndicator("---", needWhitespace: true, whitespace: false, indentation: false);
					if (isCanonical)
					{
						WriteIndent();
					}
				}
				state = EmitterState.DocumentContent;
			}
			else
			{
				if (!(evt is YamlDotNet.Core.Events.StreamEnd))
				{
					throw new YamlException("Expected DOCUMENT-START or STREAM-END");
				}
				state = EmitterState.StreamEnd;
			}
		}

		private static TagDirectiveCollection NonDefaultTagsAmong(IEnumerable<TagDirective>? tagCollection)
		{
			TagDirectiveCollection tagDirectiveCollection = new TagDirectiveCollection();
			if (tagCollection == null)
			{
				return tagDirectiveCollection;
			}
			foreach (TagDirective item2 in tagCollection)
			{
				AppendTagDirectiveTo(item2, allowDuplicates: false, tagDirectiveCollection);
			}
			TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
			foreach (TagDirective item in defaultTagDirectives)
			{
				tagDirectiveCollection.Remove(item);
			}
			return tagDirectiveCollection;
		}

		private static void AnalyzeVersionDirective(VersionDirective versionDirective)
		{
			if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
			{
				throw new YamlException("Incompatible %YAML directive");
			}
		}

		private static void AppendTagDirectiveTo(TagDirective value, bool allowDuplicates, TagDirectiveCollection tagDirectives)
		{
			if (tagDirectives.Contains(value))
			{
				if (!allowDuplicates)
				{
					throw new YamlException("Duplicate %TAG directive.");
				}
			}
			else
			{
				tagDirectives.Add(value);
			}
		}

		private void EmitDocumentContent(ParsingEvent evt)
		{
			states.Push(EmitterState.DocumentEnd);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitNode(ParsingEvent evt, bool isMapping, bool isSimpleKey)
		{
			isMappingContext = isMapping;
			isSimpleKeyContext = isSimpleKey;
			switch (evt.Type)
			{
			case EventType.Alias:
				EmitAlias();
				break;
			case EventType.Scalar:
				EmitScalar(evt);
				break;
			case EventType.SequenceStart:
				EmitSequenceStart(evt);
				break;
			case EventType.MappingStart:
				EmitMappingStart(evt);
				break;
			default:
				throw new YamlException($"Expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, got {evt.Type}");
			}
		}

		private void EmitAlias()
		{
			ProcessAnchor();
			state = states.Pop();
		}

		private void EmitScalar(ParsingEvent evt)
		{
			SelectScalarStyle(evt);
			ProcessAnchor();
			ProcessTag();
			IncreaseIndent(isFlow: true, isIndentless: false);
			ProcessScalar();
			indent = indents.Pop();
			state = states.Pop();
		}

		private void SelectScalarStyle(ParsingEvent evt)
		{
			YamlDotNet.Core.Events.Scalar scalar = (YamlDotNet.Core.Events.Scalar)evt;
			ScalarStyle scalarStyle = scalar.Style;
			bool flag = tagData.Handle == null && tagData.Suffix == null;
			if (flag && !scalar.IsPlainImplicit && !scalar.IsQuotedImplicit)
			{
				throw new YamlException("Neither tag nor isImplicit flags are specified.");
			}
			if (scalarStyle == ScalarStyle.Any)
			{
				scalarStyle = ((!scalarData.IsMultiline) ? ScalarStyle.Plain : ScalarStyle.Folded);
			}
			if (isCanonical)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (isSimpleKeyContext && scalarData.IsMultiline)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (scalarStyle == ScalarStyle.Plain)
			{
				if ((flowLevel != 0 && !scalarData.IsFlowPlainAllowed) || (flowLevel == 0 && !scalarData.IsBlockPlainAllowed))
				{
					scalarStyle = ((scalarData.IsSingleQuotedAllowed && !scalarData.HasSingleQuotes) ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted);
				}
				if (string.IsNullOrEmpty(scalarData.Value) && (flowLevel != 0 || isSimpleKeyContext))
				{
					scalarStyle = ScalarStyle.SingleQuoted;
				}
				if (flag && !scalar.IsPlainImplicit)
				{
					scalarStyle = ScalarStyle.SingleQuoted;
				}
			}
			if (scalarStyle == ScalarStyle.SingleQuoted && !scalarData.IsSingleQuotedAllowed)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if ((scalarStyle == ScalarStyle.Literal || scalarStyle == ScalarStyle.Folded) && (!scalarData.IsBlockAllowed || flowLevel != 0 || isSimpleKeyContext))
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (scalarStyle == ScalarStyle.ForcePlain)
			{
				scalarStyle = ScalarStyle.Plain;
			}
			scalarData.Style = scalarStyle;
		}

		private void ProcessScalar()
		{
			switch (scalarData.Style)
			{
			case ScalarStyle.Plain:
				WritePlainScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.SingleQuoted:
				WriteSingleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.DoubleQuoted:
				WriteDoubleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.Literal:
				WriteLiteralScalar(scalarData.Value);
				break;
			case ScalarStyle.Folded:
				WriteFoldedScalar(scalarData.Value);
				break;
			default:
				throw new InvalidOperationException();
			}
		}

		private void WritePlainScalar(string value, bool allowBreaks)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsSpace(c))
				{
					if (allowBreaks && !flag && column > bestWidth && i + 1 < value.Length && value[i + 1] != ' ')
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					flag = true;
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					if (!flag2 && c == '\n')
					{
						WriteBreak();
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag2 = true;
					continue;
				}
				if (flag2)
				{
					WriteIndent();
				}
				Write(c);
				isIndentation = false;
				flag = false;
				flag2 = false;
			}
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteSingleQuotedScalar(string value, bool allowBreaks)
		{
			WriteIndicator("'", needWhitespace: true, whitespace: false, indentation: false);
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == ' ')
				{
					if (allowBreaks && !flag && column > bestWidth && i != 0 && i + 1 < value.Length && value[i + 1] != ' ')
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					flag = true;
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					if (!flag2 && c == '\n')
					{
						WriteBreak();
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag2 = true;
					continue;
				}
				if (flag2)
				{
					WriteIndent();
				}
				if (c == '\'')
				{
					Write(c);
				}
				Write(c);
				isIndentation = false;
				flag = false;
				flag2 = false;
			}
			WriteIndicator("'", needWhitespace: false, whitespace: false, indentation: false);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteDoubleQuotedScalar(string value, bool allowBreaks)
		{
			WriteIndicator("\"", needWhitespace: true, whitespace: false, indentation: false);
			bool flag = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsPrintable(c) && !IsBreak(c, out var _))
				{
					switch (c)
					{
					case '"':
					case '\\':
						break;
					case ' ':
						if (allowBreaks && !flag && column > bestWidth && i > 0 && i + 1 < value.Length)
						{
							WriteIndent();
							if (value[i + 1] == ' ')
							{
								Write('\\');
							}
						}
						else
						{
							Write(c);
						}
						flag = true;
						continue;
					default:
						Write(c);
						flag = false;
						continue;
					}
				}
				Write('\\');
				switch (c)
				{
				case '\0':
					Write('0');
					break;
				case '\a':
					Write('a');
					break;
				case '\b':
					Write('b');
					break;
				case '\t':
					Write('t');
					break;
				case '\n':
					Write('n');
					break;
				case '\v':
					Write('v');
					break;
				case '\f':
					Write('f');
					break;
				case '\r':
					Write('r');
					break;
				case '\u001b':
					Write('e');
					break;
				case '"':
					Write('"');
					break;
				case '\\':
					Write('\\');
					break;
				case '\u0085':
					Write('N');
					break;
				case '\u00a0':
					Write('_');
					break;
				case '\u2028':
					Write('L');
					break;
				case '\u2029':
					Write('P');
					break;
				default:
				{
					ushort num = c;
					if (num <= 255)
					{
						Write('x');
						Write(num.ToString("X02", CultureInfo.InvariantCulture));
					}
					else if (IsHighSurrogate(c))
					{
						if (i + 1 >= value.Length || !IsLowSurrogate(value[i + 1]))
						{
							throw new SyntaxErrorException("While writing a quoted scalar, found an orphaned high surrogate.");
						}
						if (useUtf16SurrogatePair)
						{
							Write('u');
							Write(num.ToString("X04", CultureInfo.InvariantCulture));
							Write('\\');
							Write('u');
							Write(((ushort)value[i + 1]).ToString("X04", CultureInfo.InvariantCulture));
						}
						else
						{
							Write('U');
							Write(char.ConvertToUtf32(c, value[i + 1]).ToString("X08", CultureInfo.InvariantCulture));
						}
						i++;
					}
					else
					{
						Write('u');
						Write(num.ToString("X04", CultureInfo.InvariantCulture));
					}
					break;
				}
				}
				flag = false;
			}
			WriteIndicator("\"", needWhitespace: false, whitespace: false, indentation: false);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteLiteralScalar(string value)
		{
			bool flag = true;
			WriteIndicator("|", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
				{
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
					continue;
				}
				if (flag)
				{
					WriteIndent();
				}
				Write(c);
				isIndentation = false;
				flag = false;
			}
		}

		private void WriteFoldedScalar(string value)
		{
			bool flag = true;
			bool flag2 = true;
			WriteIndicator(">", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsBreak(c, out var breakChar))
				{
					if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
					{
						continue;
					}
					if (!flag && !flag2 && breakChar == '\n')
					{
						int j;
						char breakChar2;
						for (j = 0; i + j < value.Length && IsBreak(value[i + j], out breakChar2); j++)
						{
						}
						if (i + j < value.Length && !IsBlank(value[i + j]) && !IsBreak(value[i + j], out breakChar2))
						{
							WriteBreak();
						}
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
				}
				else
				{
					if (flag)
					{
						WriteIndent();
						flag2 = IsBlank(c);
					}
					if (!flag && c == ' ' && i + 1 < value.Length && value[i + 1] != ' ' && column > bestWidth)
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					isIndentation = false;
					flag = false;
				}
			}
		}

		private static bool IsSpace(char character)
		{
			return character == ' ';
		}

		private static bool IsBreak(char character, out char breakChar)
		{
			switch (character)
			{
			case '\n':
			case '\r':
			case '\u0085':
				breakChar = '\n';
				return true;
			case '\u2028':
			case '\u2029':
				breakChar = character;
				return true;
			default:
				breakChar = '\0';
				return false;
			}
		}

		private static bool IsBlank(char character)
		{
			if (character != ' ')
			{
				return character == '\t';
			}
			return true;
		}

		private static bool IsPrintable(char character)
		{
			switch (character)
			{
			default:
				if (character != '\u0085' && (character < '\u00a0' || character > '\ud7ff'))
				{
					if (character >= '\ue000')
					{
						return character <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		private static bool IsHighSurrogate(char c)
		{
			if ('\ud800' <= c)
			{
				return c <= '\udbff';
			}
			return false;
		}

		private static bool IsLowSurrogate(char c)
		{
			if ('\udc00' <= c)
			{
				return c <= '\udfff';
			}
			return false;
		}

		private void EmitSequenceStart(ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			SequenceStart sequenceStart = (SequenceStart)evt;
			if (flowLevel != 0 || isCanonical || sequenceStart.Style == SequenceStyle.Flow || CheckEmptySequence())
			{
				state = EmitterState.FlowSequenceFirstItem;
			}
			else
			{
				state = EmitterState.BlockSequenceFirstItem;
			}
		}

		private void EmitMappingStart(ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			MappingStart mappingStart = (MappingStart)evt;
			if (flowLevel != 0 || isCanonical || mappingStart.Style == MappingStyle.Flow || CheckEmptyMapping())
			{
				state = EmitterState.FlowMappingFirstKey;
			}
			else
			{
				state = EmitterState.BlockMappingFirstKey;
			}
		}

		private void ProcessAnchor()
		{
			if (!anchorData.Anchor.IsEmpty && !skipAnchorName)
			{
				WriteIndicator(anchorData.IsAlias ? "*" : "&", needWhitespace: true, whitespace: false, indentation: false);
				WriteAnchor(anchorData.Anchor);
			}
		}

		private void ProcessTag()
		{
			if (tagData.Handle == null && tagData.Suffix == null)
			{
				return;
			}
			if (tagData.Handle != null)
			{
				WriteTagHandle(tagData.Handle);
				if (tagData.Suffix != null)
				{
					WriteTagContent(tagData.Suffix, needsWhitespace: false);
				}
			}
			else
			{
				WriteIndicator("!<", needWhitespace: true, whitespace: false, indentation: false);
				WriteTagContent(tagData.Suffix, needsWhitespace: false);
				WriteIndicator(">", needWhitespace: false, whitespace: false, indentation: false);
			}
		}

		private void EmitDocumentEnd(ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.DocumentEnd documentEnd)
			{
				WriteIndent();
				if (!documentEnd.IsImplicit)
				{
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
					isDocumentEndWritten = true;
				}
				state = EmitterState.DocumentStart;
				tagDirectives.Clear();
				return;
			}
			throw new YamlException("Expected DOCUMENT-END.");
		}

		private void EmitFlowSequenceItem(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("[", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is SequenceEnd)
			{
				flowLevel--;
				indent = indents.Pop();
				if (isCanonical && !isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
					WriteIndent();
				}
				WriteIndicator("]", needWhitespace: false, whitespace: false, indentation: false);
				state = states.Pop();
			}
			else
			{
				if (!isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
				}
				if (isCanonical || column > bestWidth)
				{
					WriteIndent();
				}
				states.Push(EmitterState.FlowSequenceItem);
				EmitNode(evt, isMapping: false, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingKey(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("{", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is MappingEnd)
			{
				flowLevel--;
				indent = indents.Pop();
				if (isCanonical && !isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
					WriteIndent();
				}
				WriteIndicator("}", needWhitespace: false, whitespace: false, indentation: false);
				state = states.Pop();
				return;
			}
			if (!isFirst)
			{
				WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
			}
			if (isCanonical || column > bestWidth)
			{
				WriteIndent();
			}
			if (!isCanonical && CheckSimpleKey())
			{
				states.Push(EmitterState.FlowMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: false);
				states.Push(EmitterState.FlowMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (isSimple)
			{
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				if (isCanonical || column > bestWidth)
				{
					WriteIndent();
				}
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: false);
			}
			states.Push(EmitterState.FlowMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void EmitBlockSequenceItem(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isMappingContext && !isIndentation);
			}
			if (evt is SequenceEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			WriteIndicator("-", needWhitespace: true, whitespace: false, indentation: true);
			states.Push(EmitterState.BlockSequenceItem);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitBlockMappingKey(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isIndentless: false);
			}
			if (evt is MappingEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			if (CheckSimpleKey())
			{
				states.Push(EmitterState.BlockMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: true);
				states.Push(EmitterState.BlockMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitBlockMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (!isSimple)
			{
				WriteIndent();
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: true);
			}
			states.Push(EmitterState.BlockMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void IncreaseIndent(bool isFlow, bool isIndentless)
		{
			indents.Push(indent);
			if (indent < 0)
			{
				indent = (isFlow ? bestIndent : 0);
			}
			else if (!isIndentless || !forceIndentLess)
			{
				indent += bestIndent;
			}
		}

		private bool CheckEmptyDocument()
		{
			int num = 0;
			foreach (ParsingEvent @event in events)
			{
				num++;
				if (num == 2)
				{
					if (@event is YamlDotNet.Core.Events.Scalar scalar)
					{
						return string.IsNullOrEmpty(scalar.Value);
					}
					break;
				}
			}
			return false;
		}

		private bool CheckSimpleKey()
		{
			if (events.Count < 1)
			{
				return false;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.Alias:
				num = AnchorNameLength(anchorData.Anchor);
				break;
			case EventType.Scalar:
				if (scalarData.IsMultiline)
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix) + SafeStringLength(scalarData.Value);
				break;
			case EventType.SequenceStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			case EventType.MappingStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			default:
				return false;
			}
			return num <= maxSimpleKeyLength;
		}

		private static int AnchorNameLength(AnchorName value)
		{
			if (!value.IsEmpty)
			{
				return value.Value.Length;
			}
			return 0;
		}

		private static int SafeStringLength(string? value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<SequenceStart, SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<MappingStart, MappingEnd>();
		}

		private bool CheckEmptyStructure<TStart, TEnd>() where TStart : NodeEvent where TEnd : ParsingEvent
		{
			if (events.Count < 2)
			{
				return false;
			}
			using Queue<ParsingEvent>.Enumerator enumerator = events.GetEnumerator();
			return enumerator.MoveNext() && enumerator.Current is TStart && enumerator.MoveNext() && enumerator.Current is TEnd;
		}

		private void WriteBlockScalarHints(string value)
		{
			StringLookAheadBufferPool.BufferWrapper bufferWrapper = StringLookAheadBufferPool.Rent(value);
			try
			{
				CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(bufferWrapper.Buffer);
				if (characterAnalyzer.IsSpace() || characterAnalyzer.IsBreak())
				{
					int num = bestIndent;
					string indicator = num.ToString(CultureInfo.InvariantCulture);
					WriteIndicator(indicator, needWhitespace: false, whitespace: false, indentation: false);
				}
				string text = null;
				if (value.Length == 0 || !characterAnalyzer.IsBreak(value.Length - 1))
				{
					text = "-";
				}
				else if (value.Length >= 2 && characterAnalyzer.IsBreak(value.Length - 2))
				{
					text = "+";
				}
				if (text != null)
				{
					WriteIndicator(text, needWhitespace: false, whitespace: false, indentation: false);
				}
			}
			finally
			{
				((IDisposable)bufferWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void WriteIndicator(string indicator, bool needWhitespace, bool whitespace, bool indentation)
		{
			if (needWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(indicator);
			isWhitespace = whitespace;
			isIndentation &= indentation;
		}

		private void WriteIndent()
		{
			int num = Math.Max(indent, 0);
			if (!isIndentation || column > num || (column == num && !isWhitespace))
			{
				WriteBreak();
			}
			while (column < num)
			{
				Write(' ');
			}
			isWhitespace = true;
			isIndentation = true;
		}

		private void WriteAnchor(AnchorName value)
		{
			Write(value.Value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagHandle(string value)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			Write(value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagContent(string value, bool needsWhitespace)
		{
			if (needsWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(UrlEncode(value));
			isWhitespace = false;
			isIndentation = false;
		}

		private static string UrlEncode(string text)
		{
			return UriReplacer.Replace(text, delegate(Match match)
			{
				StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder = builderWrapper.Builder;
					byte[] bytes = Encoding.UTF8.GetBytes(match.Value);
					foreach (byte b in bytes)
					{
						builder.AppendFormat(CultureInfo.InvariantCulture, "%{0:X02}", b);
					}
					return builder.ToString();
				}
				finally
				{
					((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
				}
			});
		}

		private void Write(char value)
		{
			output.Write(value);
			column++;
		}

		private void Write(string value)
		{
			output.Write(value);
			column += value.Length;
		}

		private void WriteBreak(char breakCharacter = '\n')
		{
			if (breakCharacter == '\n')
			{
				output.WriteLine();
			}
			else
			{
				output.Write(breakCharacter);
			}
			column = 0;
		}
	}
	internal sealed class EmitterSettings
	{
		public static readonly EmitterSettings Default = new EmitterSettings();

		public int BestIndent { get; } = 2;

		public int BestWidth { get; } = int.MaxValue;

		public string NewLine { get; } = Environment.NewLine;

		public bool IsCanonical { get; }

		public bool SkipAnchorName { get; private set; }

		public int MaxSimpleKeyLength { get; } = 1024;

		public bool IndentSequences { get; }

		public bool UseUtf16SurrogatePairs { get; }

		public EmitterSettings()
		{
		}

		public EmitterSettings(int bestIndent, int bestWidth, bool isCanonical, int maxSimpleKeyLength, bool skipAnchorName = false, bool indentSequences = false, string? newLine = null, bool useUtf16SurrogatePairs = false)
		{
			if (bestIndent < 2 || bestIndent > 9)
			{
				throw new ArgumentOutOfRangeException("bestIndent", "BestIndent must be between 2 and 9, inclusive");
			}
			if (bestWidth <= bestIndent * 2)
			{
				throw new ArgumentOutOfRangeException("bestWidth", "BestWidth must be greater than BestIndent x 2.");
			}
			if (maxSimpleKeyLength < 0)
			{
				throw new ArgumentOutOfRangeException("maxSimpleKeyLength", "MaxSimpleKeyLength must be >= 0");
			}
			BestIndent = bestIndent;
			BestWidth = bestWidth;
			IsCanonical = isCanonical;
			MaxSimpleKeyLength = maxSimpleKeyLength;
			SkipAnchorName = skipAnchorName;
			IndentSequences = indentSequences;
			NewLine = newLine ?? Environment.NewLine;
			UseUtf16SurrogatePairs = useUtf16SurrogatePairs;
		}

		public EmitterSettings WithBestIndent(int bestIndent)
		{
			return new EmitterSettings(bestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithBestWidth(int bestWidth)
		{
			return new EmitterSettings(BestIndent, bestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithMaxSimpleKeyLength(int maxSimpleKeyLength)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, maxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithNewLine(string newLine)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, newLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings Canonical()
		{
			return new EmitterSettings(BestIndent, BestWidth, isCanonical: true, MaxSimpleKeyLength, SkipAnchorName);
		}

		public EmitterSettings WithoutAnchorName()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, skipAnchorName: true, IndentSequences, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithIndentedSequences()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, indentSequences: true, NewLine, UseUtf16SurrogatePairs);
		}

		public EmitterSettings WithUtf16SurrogatePairs()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine, useUtf16SurrogatePairs: true);
		}
	}
	internal enum EmitterState
	{
		StreamStart,
		StreamEnd,
		FirstDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		FlowSequenceFirstItem,
		FlowSequenceItem,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingSimpleValue,
		FlowMappingValue,
		BlockSequenceFirstItem,
		BlockSequenceItem,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingSimpleValue,
		BlockMappingValue
	}
	internal sealed class ForwardAnchorNotSupportedException : YamlException
	{
		public ForwardAnchorNotSupportedException(string message)
			: base(message)
		{
		}

		public ForwardAnchorNotSupportedException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public ForwardAnchorNotSupportedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal static class HashCode
	{
		public static int CombineHashCodes(int h1, int h2)
		{
			return ((h1 << 5) + h1) ^ h2;
		}

		public static int CombineHashCodes(int h1, object? o2)
		{
			return CombineHashCodes(h1, GetHashCode(o2));
		}

		private static int GetHashCode(object? obj)
		{
			return obj?.GetHashCode() ?? 0;
		}
	}
	internal interface IEmitter
	{
		void Emit(ParsingEvent @event);
	}
	internal interface ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	internal sealed class InsertionQueue<T> : IEnumerable<T>, IEnumerable
	{
		private const int DefaultInitialCapacity = 128;

		private T[] items;

		private int readPtr;

		private int writePtr;

		private int mask;

		private int count;

		public int Count => count;

		public int Capacity => items.Length;

		public InsertionQueue(int initialCapacity = 128)
		{
			if (initialCapacity <= 0)
			{
				throw new ArgumentOutOfRangeException("initialCapacity", "The initial capacity must be a positive number.");
			}
			if (!initialCapacity.IsPowerOfTwo())
			{
				throw new ArgumentException("The initial capacity must be a power of 2.", "initialCapacity");
			}
			items = new T[initialCapacity];
			readPtr = initialCapacity / 2;
			writePtr = initialCapacity / 2;
			mask = initialCapacity - 1;
		}

		public void Enqueue(T item)
		{
			ResizeIfNeeded();
			items[writePtr] = item;
			writePtr = (writePtr - 1) & mask;
			count++;
		}

		public T Dequeue()
		{
			if (count == 0)
			{
				throw new InvalidOperationException("The queue is empty");
			}
			T result = items[readPtr];
			readPtr = (readPtr - 1) & mask;
			count--;
			return result;
		}

		public void Insert(int index, T item)
		{
			if (index > count)
			{
				throw new InvalidOperationException("Cannot insert outside of the bounds of the queue");
			}
			ResizeIfNeeded();
			CalculateInsertionParameters(mask, count, index, ref readPtr, ref writePtr, out var insertPtr, out var copyIndex, out var copyOffset, out var copyLength);
			if (copyLength != 0)
			{
				Array.Copy(items, copyIndex, items, copyIndex + copyOffset, copyLength);
			}
			items[insertPtr] = item;
			count++;
		}

		private void ResizeIfNeeded()
		{
			int num = items.Length;
			if (count == num)
			{
				T[] destinationArray = new T[num * 2];
				int num2 = readPtr + 1;
				if (num2 > 0)
				{
					Array.Copy(items, 0, destinationArray, 0, num2);
				}
				writePtr += num;
				int num3 = num - num2;
				if (num3 > 0)
				{
					Array.Copy(items, readPtr + 1, destinationArray, writePtr + 1, num3);
				}
				items = destinationArray;
				mask = mask * 2 + 1;
			}
		}

		internal static void CalculateInsertionParameters(int mask, int count, int index, ref int readPtr, ref int writePtr, out int insertPtr, out int copyIndex, out int copyOffset, out int copyLength)
		{
			int num = (readPtr + 1) & mask;
			if (index == 0)
			{
				insertPtr = (readPtr = num);
				copyIndex = 0;
				copyOffset = 0;
				copyLength = 0;
				return;
			}
			insertPtr = (readPtr - index) & mask;
			if (index == count)
			{
				writePtr = (writePtr - 1) & mask;
				copyIndex = 0;
				copyOffset = 0;
				copyLength = 0;
				return;
			}
			int num2 = ((num >= insertPtr) ? (readPtr - insertPtr) : int.MaxValue);
			int num3 = ((writePtr <= insertPtr) ? (insertPtr - writePtr) : int.MaxValue);
			if (num2 <= num3)
			{
				insertPtr++;
				readPtr++;
				copyIndex = insertPtr;
				copyOffset = 1;
				copyLength = num2;
			}
			else
			{
				copyIndex = writePtr + 1;
				copyOffset = -1;
				copyLength = num3;
				writePtr = (writePtr - 1) & mask;
			}
		}

		public IEnumerator<T> GetEnumerator()
		{
			int ptr = readPtr;
			for (int i = 0; i < Count; i++)
			{
				yield return items[ptr];
				ptr = (ptr - 1) & mask;
			}
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal interface IParser
	{
		ParsingEvent? Current { get; }

		bool MoveNext();
	}
	internal interface IScanner
	{
		Mark CurrentPosition { get; }

		Token? Current { get; }

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	[DebuggerStepThrough]
	internal sealed class LookAheadBuffer : ILookAheadBuffer
	{
		private readonly TextReader input;

		private readonly char[] buffer;

		private readonly int blockSize;

		private readonly int mask;

		private int firstIndex;

		private int writeOffset;

		private int count;

		private bool endOfInput;

		public bool EndOfInput
		{
			get
			{
				if (endOfInput)
				{
					return count == 0;
				}
				return false;
			}
		}

		public LookAheadBuffer(TextReader input, int capacity)
		{
			if (capacity < 1)
			{
				throw new ArgumentOutOfRangeException("capacity", "The capacity must be positive.");
			}
			if (!capacity.IsPowerOfTwo())
			{
				throw new ArgumentException("The capacity must be a power of 2.", "capacity");
			}
			this.input = input ?? throw new ArgumentNullException("input");
			blockSize = capacity;
			buffer = new char[capacity * 2];
			mask = capacity * 2 - 1;
		}

		private int GetIndexForOffset(int offset)
		{
			return (firstIndex + offset) & mask;
		}

		public char Peek(int offset)
		{
			if (offset >= count)
			{
				FillBuffer();
			}
			if (offset < count)
			{
				return buffer[(firstIndex + offset) & mask];
			}
			return '\0';
		}

		public void Cache(int length)
		{
			if (length >= count)
			{
				FillBuffer();
			}
		}

		private void FillBuffer()
		{
			if (endOfInput)
			{
				return;
			}
			int num = blockSize;
			do
			{
				int num2 = input.Read(buffer, writeOffset, num);
				if (num2 == 0)
				{
					endOfInput = true;
					return;
				}
				num -= num2;
				writeOffset += num2;
				count += num2;
			}
			while (num > 0);
			if (writeOffset == buffer.Length)
			{
				writeOffset = 0;
			}
		}

		public void Skip(int length)
		{
			if (length < 1 || length > blockSize)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be between 1 and the number of characters in the buffer. Use the Peek() and / or Cache() methods to fill the buffer.");
			}
			firstIndex = GetIndexForOffset(length);
			count -= length;
		}
	}
	internal readonly struct Mark : IEquatable<Mark>, IComparable<Mark>, IComparable
	{
		public static readonly Mark Empty = new Mark(0L, 1L, 1L);

		public long Index { get; }

		public long Line { get; }

		public long Column { get; }

		public Mark(long index, long line, long column)
		{
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("index", "Index must be greater than or equal to zero.");
			}
			if (line < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("line", "Line must be greater than or equal to 1.");
			}
			if (column < 1)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("column", "Column must be greater than or equal to 1.");
			}
			Index = index;
			Line = line;
			Column = column;
		}

		public override string ToString()
		{
			return $"Line: {Line}, Col: {Column}, Idx: {Index}";
		}

		public override bool Equals(object? obj)
		{
			return Equals((Mark)(obj ?? ((object)Empty)));
		}

		public bool Equals(Mark other)
		{
			if (Index == other.Index && Line == other.Line)
			{
				return Column == other.Column;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.CombineHashCodes(Index.GetHashCode(), HashCode.CombineHashCodes(Line.GetHashCode(), Column.GetHashCode()));
		}

		public int CompareTo(object? obj)
		{
			return CompareTo((Mark)(obj ?? ((object)Empty)));
		}

		public int CompareTo(Mark other)
		{
			int num = Line.CompareTo(other.Line);
			if (num == 0)
			{
				num = Column.CompareTo(other.Column);
			}
			return num;
		}

		public static bool operator ==(Mark left, Mark right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(Mark left, Mark right)
		{
			return !(left == right);
		}

		public static bool operator <(Mark left, Mark right)
		{
			return left.CompareTo(right) < 0;
		}

		public static bool operator <=(Mark left, Mark right)
		{
			return left.CompareTo(right) <= 0;
		}

		public static bool operator >(Mark left, Mark right)
		{
			return left.CompareTo(right) > 0;
		}

		public static bool operator >=(Mark left, Mark right)
		{
			return left.CompareTo(right) >= 0;
		}
	}
	internal sealed class MaximumRecursionLevelReachedException : YamlException
	{
		public MaximumRecursionLevelReachedException(string message)
			: base(message)
		{
		}

		public MaximumRecursionLevelReachedException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public MaximumRecursionLevelReachedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class MergingParser : IParser
	{
		private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<ParsingEvent>>, IEnumerable
		{
			private readonly LinkedList<ParsingEvent> events;

			private readonly HashSet<LinkedListNode<ParsingEvent>> deleted;

			private readonly Dictionary<AnchorName, LinkedListNode<ParsingEvent>> references;

			public ParsingEventCollection()
			{
				events = new LinkedList<ParsingEvent>();
				deleted = new HashSet<LinkedListNode<ParsingEvent>>();
				references = new Dictionary<AnchorName, LinkedListNode<ParsingEvent>>();
			}

			public void AddAfter(LinkedListNode<ParsingEvent> node, IEnumerable<ParsingEvent> items)
			{
				foreach (ParsingEvent item in items)
				{
					node = events.AddAfter(node, item);
				}
			}

			public void Add(ParsingEvent item)
			{
				LinkedListNode<ParsingEvent> node = events.AddLast(item);
				AddReference(item, node);
			}

			public void MarkDeleted(LinkedListNode<ParsingEvent> node)
			{
				deleted.Add(node);
			}

			public bool IsDeleted(LinkedListNode<ParsingEvent> node)
			{
				return deleted.Contains(node);
			}

			public void CleanMarked()
			{
				foreach (LinkedListNode<ParsingEvent> item in deleted)
				{
					events.Remove(item);
				}
			}

			public IEnumerable<LinkedListNode<ParsingEvent>> FromAnchor(AnchorName anchor)
			{
				LinkedListNode<ParsingEvent> next = references[anchor].Next;
				return Enumerate(next);
			}

			public IEnumerator<LinkedListNode<ParsingEvent>> GetEnumerator()
			{
				return Enumerate(events.First).GetEnumerator();
			}

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

			private static IEnumerable<LinkedListNode<ParsingEvent>> Enumerate(LinkedListNode<ParsingEvent>? node)
			{
				while (node != null)
				{
					yield return node;
					node = node.Next;
				}
			}

			private void AddReference(ParsingEvent item, LinkedListNode<ParsingEvent> node)
			{
				if (item is MappingStart { Anchor: { IsEmpty: false } anchor })
				{
					references[anchor] = node;
				}
			}
		}

		private sealed class ParsingEventCloner : IParsingEventVisitor
		{
			private ParsingEvent? clonedEvent;

			public ParsingEvent Clone(ParsingEvent e)
			{
				e.Accept(this);
				if (clonedEvent == null)
				{
					throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
				}
				return clonedEvent;
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.AnchorAlias e)
			{
				clonedEvent = new YamlDotNet.Core.Events.AnchorAlias(e.Value, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Scalar e)
			{
				clonedEvent = new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceStart e)
			{
				clonedEvent = new SequenceStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceEnd e)
			{
				clonedEvent = new SequenceEnd(e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(MappingStart e)
			{
				clonedEvent = new MappingStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(MappingEnd e)
			{
				clonedEvent = new MappingEnd(e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Comment e)
			{
				throw new NotSupportedException();
			}
		}

		private readonly ParsingEventCollection events;

		private readonly IParser innerParser;

		private IEnumerator<LinkedListNode<ParsingEvent>> iterator;

		private bool merged;

		public ParsingEvent? Current => iterator.Current?.Value;

		public MergingParser(IParser innerParser)
		{
			events = new ParsingEventCollection();
			merged = false;
			iterator = events.GetEnumerator();
			this.innerParser = innerParser;
		}

		public bool MoveNext()
		{
			if (!merged)
			{
				Merge();
				events.CleanMarked();
				iterator = events.GetEnumerator();
				merged = true;
			}
			return iterator.MoveNext();
		}

		private void Merge()
		{
			while (innerParser.MoveNext())
			{
				events.Add(innerParser.Current);
			}
			foreach (LinkedListNode<ParsingEvent> @event in events)
			{
				if (IsMergeToken(@event))
				{
					events.MarkDeleted(@event);
					if (!HandleMerge(@event.Next))
					{
						throw new SemanticErrorException(@event.Value.Start, @event.Value.End, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge(LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(node, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool HandleMergeSequence(LinkedListNode<ParsingEvent> sequenceStart, LinkedListNode<ParsingEvent>? node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(sequenceStart, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private static bool IsMergeToken(LinkedListNode<ParsingEvent> node)
		{
			if (node.Value is YamlDotNet.Core.Events.Scalar scalar)
			{
				return scalar.Value == "<<";
			}
			return false;
		}

		private bool HandleAnchorAlias(LinkedListNode<ParsingEvent> node, LinkedListNode<ParsingEvent> anchorNode, YamlDotNet.Core.Events.AnchorAlias anchorAlias)
		{
			IEnumerable<ParsingEvent> mappingEvents = GetMappingEvents(anchorAlias.Value);
			events.AddAfter(node, mappingEvents);
			events.MarkDeleted(anchorNode);
			return true;
		}

		private bool HandleSequence(LinkedListNode<ParsingEvent> node)
		{
			events.MarkDeleted(node);
			LinkedListNode<ParsingEvent> linkedListNode = node;
			while (linkedListNode != null)
			{
				if (linkedListNode.Value is SequenceEnd)
				{
					events.MarkDeleted(linkedListNode);
					return true;
				}
				LinkedListNode<ParsingEvent> next = linkedListNode.Next;
				HandleMergeSequence(node, next);
				linkedListNode = next;
			}
			return true;
		}

		private IEnumerable<ParsingEvent> GetMappingEvents(AnchorName anchor)
		{
			ParsingEventCloner parsingEventCloner = new ParsingEventCloner();
			int nesting = 0;
			return (from e in events.FromAnchor(anchor)
				where !events.IsDeleted(e)
				select e.Value).TakeWhile((ParsingEvent e) => (nesting += e.NestingIncrease) >= 0).Select(parsingEventCloner.Clone);
		}
	}
	internal class Parser : IParser
	{
		private class EventQueue
		{
			private readonly Queue<ParsingEvent> highPriorityEvents = new Queue<ParsingEvent>();

			private readonly Queue<ParsingEvent> normalPriorityEvents = new Queue<ParsingEvent>();

			public int Count => highPriorityEvents.Count + normalPriorityEvents.Count;

			public void Enqueue(ParsingEvent @event)
			{
				EventType type = @event.Type;
				if (type == EventType.StreamStart || type == EventType.DocumentStart)
				{
					highPriorityEvents.Enqueue(@event);
				}
				else
				{
					normalPriorityEvents.Enqueue(@event);
				}
			}

			public ParsingEvent Dequeue()
			{
				if (highPriorityEvents.Count <= 0)
				{
					return normalPriorityEvents.Dequeue();
				}
				return highPriorityEvents.Dequeue();
			}
		}

		private readonly Stack<ParserState> states = new Stack<ParserState>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private ParserState state;

		private readonly IScanner scanner;

		private Token? currentToken;

		private VersionDirective? version;

		private readonly EventQueue pendingEvents = new EventQueue();

		public ParsingEvent? Current { get; private set; }

		private Token? GetCurrentToken()
		{
			if (currentToken == null)
			{
				while (scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (!(currentToken is YamlDotNet.Core.Tokens.Comment comment))
					{
						break;
					}
					pendingEvents.Enqueue(new YamlDotNet.Core.Events.Comment(comment.Value, comment.IsInline, comment.Start, comment.End));
					scanner.ConsumeCurrent();
				}
			}
			return currentToken;
		}

		public Parser(TextReader input)
			: this(new Scanner(input))
		{
		}

		public Parser(IScanner scanner)
		{
			this.scanner = scanner;
		}

		public bool MoveNext()
		{
			if (state == ParserState.StreamEnd)
			{
				Current = null;
				return false;
			}
			if (pendingEvents.Count == 0)
			{
				pendingEvents.Enqueue(StateMachine());
			}
			Current = pendingEvents.Dequeue();
			return true;
		}

		private ParsingEvent StateMachine()
		{
			return state switch
			{
				ParserState.StreamStart => ParseStreamStart(), 
				ParserState.ImplicitDocumentStart => ParseDocumentStart(isImplicit: true), 
				ParserState.DocumentStart => ParseDocumentStart(isImplicit: false), 
				ParserState.DocumentContent => ParseDocumentContent(), 
				ParserState.DocumentEnd => ParseDocumentEnd(), 
				ParserState.BlockNode => ParseNode(isBlock: true, isIndentlessSequence: false), 
				ParserState.BlockNodeOrIndentlessSequence => ParseNode(isBlock: true, isIndentlessSequence: true), 
				ParserState.FlowNode => ParseNode(isBlock: false, isIndentlessSequence: false), 
				ParserState.BlockSequenceFirstEntry => ParseBlockSequenceEntry(isFirst: true), 
				ParserState.BlockSequenceEntry => ParseBlockSequenceEntry(isFirst: false), 
				ParserState.IndentlessSequenceEntry => ParseIndentlessSequenceEntry(), 
				ParserState.BlockMappingFirstKey => ParseBlockMappingKey(isFirst: true), 
				ParserState.BlockMappingKey => ParseBlockMappingKey(isFirst: false), 
				ParserState.BlockMappingValue => ParseBlockMappingValue(), 
				ParserState.FlowSequenceFirstEntry => ParseFlowSequenceEntry(isFirst: true), 
				ParserState.FlowSequenceEntry => ParseFlowSequenceEntry(isFirst: false), 
				ParserState.FlowSequenceEntryMappingKey => ParseFlowSequenceEntryMappingKey(), 
				ParserState.FlowSequenceEntryMappingValue => ParseFlowSequenceEntryMappingValue(), 
				ParserState.FlowSequenceEntryMappingEnd => ParseFlowSequenceEntryMappingEnd(), 
				ParserState.FlowMappingFirstKey => ParseFlowMappingKey(isFirst: true), 
				ParserState.FlowMappingKey => ParseFlowMappingKey(isFirst: false), 
				ParserState.FlowMappingValue => ParseFlowMappingValue(isEmpty: false), 
				ParserState.FlowMappingEmptyValue => ParseFlowMappingValue(isEmpty: true), 
				_ => throw new InvalidOperationException(), 
			};
		}

		private void Skip()
		{
			if (currentToken != null)
			{
				currentToken = null;
				scanner.ConsumeCurrent();
			}
		}

		private YamlDotNet.Core.Events.StreamStart ParseStreamStart()
		{
			Token token = GetCurrentToken();
			if (!(token is YamlDotNet.Core.Tokens.StreamStart streamStart))
			{
				throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "Did not find expected <stream-start>.");
			}
			Skip();
			state = ParserState.ImplicitDocumentStart;
			return new YamlDotNet.Core.Events.StreamStart(streamStart.Start, streamStart.End);
		}

		private ParsingEvent ParseDocumentStart(bool isImplicit)
		{
			if (currentToken is VersionDirective)
			{
				throw new SyntaxErrorException("While parsing a document start node, could not find document end marker before version directive.");
			}
			Token token = GetCurrentToken();
			if (!isImplicit)
			{
				while (token is YamlDotNet.Core.Tokens.DocumentEnd)
				{
					Skip();
					token = GetCurrentToken();
				}
			}
			if (token == null)
			{
				throw new SyntaxErrorException("Reached the end of the stream while parsing a document start.");
			}
			if (token is YamlDotNet.Core.Tokens.Scalar && (state == ParserState.ImplicitDocumentStart || state == ParserState.DocumentStart))
			{
				isImplicit = true;
			}
			if ((isImplicit && !(token is VersionDirective) && !(token is TagDirective) && !(token is YamlDotNet.Core.Tokens.DocumentStart) && !(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd)) || token is BlockMappingStart)
			{
				TagDirectiveCollection tags = new TagDirectiveCollection();
				ProcessDirectives(tags);
				states.Push(ParserState.DocumentEnd);
				state = ParserState.BlockNode;
				return new YamlDotNet.Core.Events.DocumentStart(null, tags, isImplicit: true, token.Start, token.End);
			}
			if (!(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd))
			{
				Mark start = token.Start;
				TagDirectiveCollection tags2 = new TagDirectiveCollection();
				VersionDirective versionDirective = ProcessDirectives(tags2);
				token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
				if (!(token is YamlDotNet.Core.Tokens.DocumentStart))
				{
					throw new SemanticErrorException(token.Start, token.End, "Did not find expected <document start>.");
				}
				states.Push(ParserState.DocumentEnd);
				state = ParserState.DocumentContent;
				Mark end = token.End;
				Skip();
				return new YamlDotNet.Core.Events.DocumentStart(versionDirective, tags2, isImplicit: false, start, end);
			}
			if (token is YamlDotNet.Core.Tokens.DocumentEnd)
			{
				Skip();
			}
			state = ParserState.StreamEnd;
			token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
			YamlDotNet.Core.Events.StreamEnd result = new YamlDotNet.Core.Events.StreamEnd(token.Start, token.End);
			if (scanner.MoveNextWithoutConsuming())
			{
				throw new InvalidOperationException("The scanner should contain no more tokens.");
			}
			return result;
		}

		private VersionDirective? ProcessDirectives(TagDirectiveCollection tags)
		{
			bool flag = false;
			VersionDirective result = null;
			while (true)
			{
				if (GetCurrentToken() is VersionDirective versionDirective)
				{
					if (version != null)
					{
						throw new SemanticErrorException(versionDirective.Start, versionDirective.End, "Found duplicate %YAML directive.");
					}
					if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
					{
						throw new SemanticErrorException(versionDirective.Start, versionDirective.End, "Found incompatible YAML document.");
					}
					result = (version = versionDirective);
					flag = true;
				}
				else
				{
					if (!(GetCurrentToken() is TagDirective tagDirective))
					{
						break;
					}
					if (tags.Contains(tagDirective.Handle))
					{
						throw new SemanticErrorException(tagDirective.Start, tagDirective.End, "Found duplicate %TAG directive.");
					}
					tags.Add(tagDirective);
					flag = true;
				}
				Skip();
			}
			if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && (version == null || (version.Version.Major == 1 && version.Version.Minor > 1)))
			{
				if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && version == null)
				{
					version = new VersionDirective(new Version(1, 2));
				}
				flag = true;
			}
			AddTagDirectives(tags, Constants.DefaultTagDirectives);
			if (flag)
			{
				tagDirectives.Clear();
			}
			AddTagDirectives(tagDirectives, tags);
			return result;
		}

		private static void AddTagDirectives(TagDirectiveCollection directives, IEnumerable<TagDirective> source)
		{
			foreach (TagDirective item in source)
			{
				if (!directives.Contains(item))
				{
					directives.Add(item);
				}
			}
		}

		private ParsingEvent ParseDocumentContent()
		{
			if (GetCurrentToken() is VersionDirective || GetCurrentToken() is TagDirective || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentEnd || GetCurrentToken() is YamlDotNet.Core.Tokens.StreamEnd)
			{
				state = states.Pop();
				return ProcessEmptyScalar(scanner.CurrentPosition);
			}
			return ParseNode(isBlock: true, isIndentlessSequence: false);
		}

		private static YamlDotNet.Core.Events.Scalar ProcessEmptyScalar(in Mark position)
		{
			return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, string.Empty, ScalarStyle.Plain, isPlainImplicit: true, isQuotedImplicit: false, position, position);
		}

		private ParsingEvent ParseNode(bool isBlock, bool isIndentlessSequence)
		{
			if (GetCurrentToken() is Error { Start: var start } error)
			{
				throw new SemanticErrorException(in start, error.End, error.Value);
			}
			Token token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				state = states.Pop();
				ParsingEvent result = new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
				Skip();
				return result;
			}
			Mark start2 = token.Start;
			AnchorName anchor = AnchorName.Empty;
			TagName tag = TagName.Empty;
			Anchor anchor2 = null;
			Tag tag2 = null;
			while (true)
			{
				if (anchor.IsEmpty && token is Anchor anchor3)
				{
					anchor2 = anchor3;
					anchor = anchor3.Value;
					Skip();
				}
				else
				{
					if (!tag.IsEmpty || !(token is Tag tag3))
					{
						if (token is Anchor { Start: var start3 } anchor4)
						{
							throw new SemanticErrorException(in start3, anchor4.End, "While parsing a node, found more than one anchor.");
						}
						if (token is YamlDotNet.Core.Tokens.AnchorAlias { Start: var start4 } anchorAlias2)
						{
							throw new SemanticErrorException(in start4, anchorAlias2.End, "While parsing a node, did not find expected token.");
						}
						if (!(token is Error error2))
						{
							break;
						}
						if (tag2 != null && anchor2 != null && !anchor.IsEmpty)
						{
							return new YamlDotNet.Core.Events.Scalar(anchor, default(TagName), string.Empty, ScalarStyle.Any, isPlainImplicit: false, isQuotedImplicit: false, anchor2.Start, anchor2.End);
						}
						throw new SemanticErrorException(error2.Start, error2.End, error2.Value);
					}
					tag2 = tag3;
					if (string.IsNullOrEmpty(tag3.Handle))
					{
						tag = new TagName(tag3.Suffix);
					}
					else
					{
						if (!tagDirectives.Contains(tag3.Handle))
						{
							throw new SemanticErrorException(tag3.Start, tag3.End, "While parsing a node, found undefined tag handle.");
						}
						tag = new TagName(tagDirectives[tag3.Handle].Prefix + tag3.Suffix);
					}
					Skip();
				}
				token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
			}
			bool isEmpty = tag.IsEmpty;
			if (isIndentlessSequence && GetCurrentToken() is BlockEntry)
			{
				state = ParserState.IndentlessSequenceEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, token.End);
			}
			if (token is YamlDotNet.Core.Tokens.Scalar scalar)
			{
				bool isPlainImplicit = false;
				bool isQuotedImplicit = false;
				if ((scalar.Style == ScalarStyle.Plain && tag.IsEmpty) || tag.IsNonSpecific)
				{
					isPlainImplicit = true;
				}
				else if (tag.IsEmpty)
				{
					isQuotedImplicit = true;
				}
				state = states.Pop();
				Skip();
				ParsingEvent result2 = new YamlDotNet.Core.Events.Scalar(anchor, tag, scalar.Value, scalar.Style, isPlainImplicit, isQuotedImplicit, start2, scalar.End, scalar.IsKey);
				if (!anchor.IsEmpty && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken is Error)
					{
						Error error3 = currentToken as Error;
						throw new SemanticErrorException(error3.Start, error3.End, error3.Value);
					}
				}
				if (state == ParserState.FlowMappingKey && !(scanner.Current is FlowMappingEnd) && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken != null && !(currentToken is FlowEntry) && !(currentToken is FlowMappingEnd))
					{
						throw new SemanticErrorException(currentToken.Start, currentToken.End, "While parsing a flow mapping, did not find expected ',' or '}'.");
					}
				}
				return result2;
			}
			if (token is FlowSequenceStart flowSequenceStart)
			{
				state = ParserState.FlowSequenceFirstEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Flow, start2, flowSequenceStart.End);
			}
			if (token is FlowMappingStart flowMappingStart)
			{
				state = ParserState.FlowMappingFirstKey;
				return new MappingStart(anchor, tag, isEmpty, MappingStyle.Flow, start2, flowMappingStart.End);
			}
			if (isBlock)
			{
				if (token is BlockSequenceStart blockSequenceStart)
				{
					state = ParserState.BlockSequenceFirstEntry;
					return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, blockSequenceStart.End);
				}
				if (token is BlockMappingStart blockMappingStart)
				{
					state = ParserState.BlockMappingFirstKey;
					return new MappingStart(anchor, tag, isEmpty, MappingStyle.Block, start2, blockMappingStart.End);
				}
			}
			if (!anchor.IsEmpty || !tag.IsEmpty)
			{
				state = states.Pop();
				return new YamlDotNet.Core.Events.Scalar(anchor, tag, string.Empty, ScalarStyle.Plain, isEmpty, isQuotedImplicit: false, start2, token.End);
			}
			throw new SemanticErrorException(token.Start, token.End, "While parsing a node, did not find expected node content.");
		}

		private YamlDotNet.Core.Events.DocumentEnd ParseDocumentEnd()
		{
			Token token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document end");
			bool isImplicit = true;
			Mark start = token.Start;
			Mark end = start;
			if (token is YamlDotNet.Core.Tokens.DocumentEnd)
			{
				end = token.End;
				Skip();
				isImplicit = false;
			}
			else if (!(currentToken is YamlDotNet.Core.Tokens.StreamEnd) && !(currentToken is YamlDotNet.Core.Tokens.DocumentStart) && !(currentToken is FlowSequenceEnd) && !(currentToken is VersionDirective) && (!(Current is YamlDotNet.Core.Events.Scalar) || !(currentToken is Error)))
			{
				throw new SemanticErrorException(in start, in end, "Did not find expected <document end>.");
			}
			if (version != null && version.Version.Major == 1 && version.Version.Minor > 1)
			{
				version = null;
			}
			state = ParserState.DocumentStart;
			return new YamlDotNet.Core.Events.DocumentEnd(isImplicit, start, end);
		}

		private ParsingEvent ParseBlockSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (token is BlockEntry { End: var position })
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.BlockSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				ParsingEvent result = new SequenceEnd(blockEnd.Start, blockEnd.End);
				Skip();
				return result;
			}
			throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a block collection, did not find expected '-' indicator.");
		}

		private ParsingEvent ParseIndentlessSequenceEntry()
		{
			Token token = GetCurrentToken();
			if (token is BlockEntry { End: var position })
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.IndentlessSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.IndentlessSequenceEntry;
				return ProcessEmptyScalar(in position);
			}
			state = states.Pop();
			return new SequenceEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		}

		private ParsingEvent ParseBlockMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (token is Key { End: var position })
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingValue);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingValue;
				return ProcessEmptyScalar(in position);
			}
			if (token is Value value)
			{
				Skip();
				return ProcessEmptyScalar(value.End);
			}
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				Skip();
				return new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
			}
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				ParsingEvent result = new MappingEnd(blockEnd.Start, blockEnd.End);
				Skip();
				return result;
			}
			if (GetCurrentToken() is Error { Start: var start } error)
			{
				throw new SyntaxErrorException(in start, error.End, error.Value);
			}
			throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a block mapping, did not find expected key.");
		}

		private ParsingEvent ParseBlockMappingValue()
		{
			Token token = GetCurrentToken();
			if (token is Value { End: var position })
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingKey);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingKey;
				return ProcessEmptyScalar(in position);
			}
			if (token is Error { Start: var start } error)
			{
				throw new SemanticErrorException(in start, error.End, error.Value);
			}
			state = ParserState.BlockMappingKey;
			return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			ParsingEvent result;
			if (!(token is FlowSequenceEnd))
			{
				if (!isFirst)
				{
					if (!(token is FlowEntry))
					{
						throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a flow sequence, did not find expected ',' or ']'.");
					}
					Skip();
					token = GetCurrentToken();
				}
				if (token is Key)
				{
					state = ParserState.FlowSequenceEntryMappingKey;
					result = new MappingStart(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Flow);
					Skip();
					return result;
				}
				if (!(token is FlowSequenceEnd))
				{
					states.Push(ParserState.FlowSequenceEntry);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			result = new SequenceEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
			Skip();
			return result;
		}

		private ParsingEvent ParseFlowSequenceEntryMappingKey()
		{
			Token token = GetCurrentToken();
			if (!(token is Value) && !(token is FlowEntry) && !(token is FlowSequenceEnd))
			{
				states.Push(ParserState.FlowSequenceEntryMappingValue);
				return ParseNode(isBlock: false, isIndentlessSequence: false);
			}
			Mark position = token?.End ?? Mark.Empty;
			Skip();
			state = ParserState.FlowSequenceEntryMappingValue;
			return ProcessEmptyScalar(in position);
		}

		private ParsingEvent ParseFlowSequenceEntryMappingValue()
		{
			Token token = GetCurrentToken();
			if (token is Value)
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is FlowEntry) && !(token is FlowSequenceEnd))
				{
					states.Push(ParserState.FlowSequenceEntryMappingEnd);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = ParserState.FlowSequenceEntryMappingEnd;
			return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
		}

		private MappingEnd ParseFlowSequenceEntryMappingEnd()
		{
			state = ParserState.FlowSequenceEntry;
			Token token = GetCurrentToken();
			return new MappingEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (!(token is FlowMappingEnd))
			{
				if (!isFirst)
				{
					if (token is FlowEntry)
					{
						Skip();
						token = GetCurrentToken();
					}
					else if (!(token is YamlDotNet.Core.Tokens.Scalar))
					{
						throw new SemanticErrorException(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty, "While parsing a flow mapping,  did not find expected ',' or '}'.");
					}
				}
				if (token is Key)
				{
					Skip();
					token = GetCurrentToken();
					if (!(token is Value) && !(token is FlowEntry) && !(token is FlowMappingEnd))
					{
						states.Push(ParserState.FlowMappingValue);
						return ParseNode(isBlock: false, isIndentlessSequence: false);
					}
					state = ParserState.FlowMappingValue;
					return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
				}
				if (token is YamlDotNet.Core.Tokens.Scalar)
				{
					states.Push(ParserState.FlowMappingValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
				if (!(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingEmptyValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			Skip();
			return new MappingEnd(token?.Start ?? Mark.Empty, token?.End ?? Mark.Empty);
		}

		private ParsingEvent ParseFlowMappingValue(bool isEmpty)
		{
			Token token = GetCurrentToken();
			if (!isEmpty && token is Value)
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is FlowEntry) && !(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingKey);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = ParserState.FlowMappingKey;
			if (!isEmpty && token is YamlDotNet.Core.Tokens.Scalar scalar)
			{
				Skip();
				return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, scalar.Value, scalar.Style, isPlainImplicit: false, isQuotedImplicit: false, token.Start, scalar.End);
			}
			return ProcessEmptyScalar(token?.Start ?? Mark.Empty);
		}
	}
	internal static class ParserExtensions
	{
		public static T Consume<T>(this IParser parser) where T : ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Accept<T>(out @event))
			{
				parser.MoveNext();
				return true;
			}
			return false;
		}

		public static T Require<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				ParsingEvent current = parser.Current;
				if (current == null)
				{
					throw new YamlException("Expected '" + typeof(T).Name + "', got nothing.");
				}
				throw new YamlException(current.Start, current.End, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Current == null && !parser.MoveNext())
			{
				throw new EndOfStreamException();
			}
			if (parser.Current is T val)
			{
				@event = val;
				return true;
			}
			@event = null;
			return false;
		}

		public static void SkipThisAndNestedEvents(this IParser parser)
		{
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parser.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
			}
			while (num > 0);
		}

		[Obsolete("Please use Consume<T>() instead")]
		public static T Expect<T>(this IParser parser) where T : ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Allow<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.TryConsume<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use Accept<T>(out var evt) instead")]
		[return: MaybeNull]
		public static T? Peek<T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use TryConsume<T>(out var evt) or Accept<T>(out var evt) instead")]
		public static bool Accept<T>(this IParser parser) where T : ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}

		public static bool TryFindMappingEntry(this IParser parser, Func<YamlDotNet.Core.Events.Scalar, bool> selector, [MaybeNullWhen(false)] out YamlDotNet.Core.Events.Scalar? key, [MaybeNullWhen(false)] out ParsingEvent? value)
		{
			if (parser.TryConsume<MappingStart>(out var _))
			{
				while (parser.Current != null)
				{
					ParsingEvent current = parser.Current;
					if (!(current is YamlDotNet.Core.Events.Scalar scalar))
					{
						if (current is MappingStart || current is SequenceStart)
						{
							parser.SkipThisAndNestedEvents();
						}
						else
						{
							parser.MoveNext();
						}
						continue;
					}
					bool flag = selector(scalar);
					parser.MoveNext();
					if (flag)
					{
						value = parser.Current;
						key = scalar;
						return true;
					}
					parser.SkipThisAndNestedEvents();
				}
			}
			key = null;
			value = null;
			return false;
		}
	}
	internal enum ParserState
	{
		StreamStart,
		StreamEnd,
		ImplicitDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		BlockNode,
		BlockNodeOrIndentlessSequence,
		FlowNode,
		BlockSequenceFirstEntry,
		BlockSequenceEntry,
		IndentlessSequenceEntry,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingValue,
		FlowSequenceFirstEntry,
		FlowSequenceEntry,
		FlowSequenceEntryMappingKey,
		FlowSequenceEntryMappingValue,
		FlowSequenceEntryMappingEnd,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingValue,
		FlowMappingEmptyValue
	}
	internal sealed class RecursionLevel
	{
		private int current;

		public int Maximum { get; }

		public RecursionLevel(int maximum)
		{
			Maximum = maximum;
		}

		public void Increment()
		{
			if (!TryIncrement())
			{
				throw new MaximumRecursionLevelReachedException("Maximum level of recursion reached");
			}
		}

		public bool TryIncrement()
		{
			if (current < Maximum)
			{
				current++;
				return true;
			}
			return false;
		}

		public void Decrement()
		{
			if (current == 0)
			{
				throw new InvalidOperationException("Attempted to decrement RecursionLevel to a negative value");
			}
			current--;
		}
	}
	internal enum ScalarStyle
	{
		Any,
		Plain,
		SingleQuoted,
		DoubleQuoted,
		Literal,
		Folded,
		ForcePlain
	}
	internal class Scanner : IScanner
	{
		private const int MaxVersionNumberLength = 9;

		private static readonly SortedDictionary<char, char> SimpleEscapeCodes = new SortedDictionary<char, char>
		{
			{ '0', '\0' },
			{ 'a', '\a' },
			{ 'b', '\b' },
			{ 't', '\t' },
			{ '\t', '\t' },
			{ 'n', '\n' },
			{ 'v', '\v' },
			{ 'f', '\f' },
			{ 'r', '\r' },
			{ 'e', '\u001b' },
			{ ' ', ' ' },
			{ '"', '"' },
			{ '\\', '\\' },
			{ '/', '/' },
			{ 'N', '\u0085' },
			{ '_', '\u00a0' },
			{ 'L', '\u2028' },
			{ 'P', '\u2029' }
		};

		private readonly Stack<long> indents = new Stack<long>();

		private readonly InsertionQueue<Token> tokens = new InsertionQueue<Token>();

		private readonly Stack<SimpleKey> simpleKeys = new Stack<SimpleKey>();

		private readonly CharacterAnalyzer<LookAheadBuffer> analyzer;

		private readonly Cursor cursor;

		private bool streamStartProduced;

		private bool streamEndProduced;

		private bool plainScalarFollowedByComment;

		private bool flowCollectionFetched;

		private bool startFlowCollectionFetched;

		private long indent = -1L;

		private bool flowScalarFetched;

		private bool simpleKeyAllowed;

		private int flowLevel;

		private int tokensParsed;

		private bool tokenAvailable;

		private Token? previous;

		private Anchor? previousAnchor;

		private YamlDotNet.Core.Tokens.Scalar? lastScalar;

		private readonly int maxKeySize;

		private static readonly byte[] EmptyBytes = Array.Empty<byte>();

		public bool SkipComments { get; private set; }

		public Token? Current { get; private set; }

		public Mark CurrentPosition => cursor.Mark();

		private bool IsDocumentStart()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0L && analyzer.Check('-') && analyzer.Check('-', 1) && analyzer.Check('-', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentEnd()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0L && analyzer.Check('.') && analyzer.Check('.', 1) && analyzer.Check('.', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentIndicator()
		{
			if (!IsDocumentStart())
			{
				return IsDocumentEnd();
			}
			return true;
		}

		public Scanner(TextReader input, bool skipComments = true)
			: this(input, skipComments, 1024)
		{
		}

		public Scanner(TextReader input, bool skipComments, int maxKeySize)
		{
			analyzer = new CharacterAnalyzer<LookAheadBuffer>(new LookAheadBuffer(input, 1024));
			cursor = new Cursor();
			SkipComments = skipComments;
			this.maxKeySize = maxKeySize;
		}

		public bool MoveNext()
		{
			if (Current != null)
			{
				ConsumeCurrent();
			}
			return MoveNextWithoutConsuming();
		}

		public bool MoveNextWithoutConsuming()
		{
			if (!tokenAvailable && !streamEndProduced)
			{
				FetchMoreTokens();
			}
			if (tokens.Count > 0)
			{
				Current = tokens.Dequeue();
				tokenAvailable = false;
				return true;
			}
			Current = null;
			return false;
		}

		public void ConsumeCurrent()
		{
			tokensParsed++;
			tokenAvailable = false;
			previous = Current;
			Current = null;
		}

		private char ReadCurrentCharacter()
		{
			char result = analyzer.Peek(0);
			Skip();
			return result;
		}

		private char ReadLine()
		{
			if (analyzer.Check("\r\n\u0085"))
			{
				SkipLine();
				return '\n';
			}
			char result = analyzer.Peek(0);
			SkipLine();
			return result;
		}

		private void FetchMoreTokens()
		{
			while (true)
			{
				bool flag = false;
				if (tokens.Count == 0)
				{
					flag = true;
				}
				else
				{
					foreach (SimpleKey simpleKey in simpleKeys)
					{
						if (simpleKey.IsPossible && simpleKey.TokenNumber == tokensParsed)
						{
							flag = true;
							break;
						}
					}
				}
				if (!flag)
				{
					break;
				}
				FetchNextToken();
			}
			tokenAvailable = true;
		}

		private static bool StartsWith(StringBuilder what, char start)
		{
			if (what.Length > 0)
			{
				return what[0] == start;
			}
			return false;
		}

		private void StaleSimpleKeys()
		{
			foreach (SimpleKey simpleKey in simpleKeys)
			{
				if (simpleKey.IsPossible && (simpleKey.Line < cursor.Line || simpleKey.Index + maxKeySize < cursor.Index))
				{
					if (simpleKey.IsRequired)
					{
						Mark mark = cursor.Mark();
						tokens.Enqueue(new Error("While scanning a simple key, could not find expected ':'.", mark, mark));
					}
					simpleKey.MarkAsImpossible();
				}
			}
		}

		private void FetchNextToken()
		{
			if (!streamStartProduced)
			{
				FetchStreamStart();
				return;
			}
			ScanToNextToken();
			StaleSimpleKeys();
			UnrollIndent(cursor.LineOffset);
			analyzer.Buffer.Cache(4);
			if (analyzer.Buffer.EndOfInput)
			{
				lastScalar = null;
				FetchStreamEnd();
			}
			if (cursor.LineOffset == 0L && analyzer.Check('%'))
			{
				lastScalar = null;
				FetchDirective();
				return;
			}
			if (IsDocumentStart())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: true);
				return;
			}
			if (IsDocumentEnd())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: false);
				return;
			}
			if (analyzer.Check('['))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('{'))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(']'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('}'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(','))
			{
				lastScalar = null;
				FetchFlowEntry();
				return;
			}
			if (analyzer.Check('-'))
			{
				if (analyzer.IsWhiteBreakOrZero(1))
				{
					FetchBlockEntry();
					return;
				}
				if (flowLevel > 0 && analyzer.Check(",[]{}", 1))
				{
					tokens.Enqueue(new Error("Invalid key indicator format.", cursor.Mark(), cursor.Mark()));
				}
			}
			if (analyzer.Check('?') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && analyzer.IsWhiteBreakOrZero(1))
			{
				FetchKey();
			}
			else if (analyzer.Check(':') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && (!simpleKeyAllowed || flowLevel <= 0) && (!flowScalarFetched || !analyzer.Check(':', 1)) && (analyzer.IsWhiteBreakOrZero(1) || analyzer.Check(',', 1) || flowScalarFetched || flowCollectionFetched || startFlowCollectionFetched))
			{
				if (lastScalar != null)
				{
					lastScalar.IsKey = true;
					lastScalar = null;
				}
				FetchValue();
			}
			else if (analyzer.Check('*'))
			{
				FetchAnchor(isAlias: true);
			}
			else if (analyzer.Check('&'))
			{
				FetchAnchor(isAlias: false);
			}
			else if (analyzer.Check('!'))
			{
				FetchTag();
			}
			else if (analyzer.Check('|') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: true);
			}
			else if (analyzer.Check('>') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: false);
			}
			else if (analyzer.Check('\''))
			{
				FetchQuotedScalar(isSingleQuoted: true);
			}
			else if (analyzer.Check('"'))
			{
				FetchQuotedScalar(isSingleQuoted: false);
			}
			else if ((!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("-?:,[]{}#&*!|>'\"%@`")) || (analyzer.Check('-') && !analyzer.IsWhite(1)) || (analyzer.Check("?:") && !analyzer.IsWhiteBreakOrZero(1)) || (simpleKeyAllowed && flowLevel > 0))
			{
				if (plainScalarFollowedByComment)
				{
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("While scanning plain scalar, found a comment between adjacent scalars.", mark, mark));
				}
				if ((flowScalarFetched || (flowCollectionFetched && !startFlowCollectionFetched)) && analyzer.Check(':'))
				{
					Skip();
				}
				flowScalarFetched = false;
				flowCollectionFetched = false;
				startFlowCollectionFetched = false;
				plainScalarFollowedByComment = false;
				FetchPlainScalar();
			}
			else
			{
				if (simpleKeyAllowed && indent >= cursor.LineOffset && analyzer.IsTab())
				{
					throw new SyntaxErrorException("While scanning a mapping, found invalid tab as indentation.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					Mark start = cursor.Mark();
					Skip();
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning for the next token, found character that cannot start any token.");
				}
				Skip();
			}
		}

		private bool CheckWhiteSpace()
		{
			if (!analyzer.Check(' '))
			{
				if (flowLevel > 0 || !simpleKeyAllowed)
				{
					return analyzer.Check('\t');
				}
				return false;
			}
			return true;
		}

		private void Skip()
		{
			cursor.Skip();
			analyzer.Buffer.Skip(1);
		}

		private void SkipLine()
		{
			if (analyzer.IsCrLf())
			{
				cursor.SkipLineByOffset(2);
				analyzer.Buffer.Skip(2);
			}
			else if (analyzer.IsBreak())
			{
				cursor.SkipLineByOffset(1);
				analyzer.Buffer.Skip(1);
			}
			else if (!analyzer.IsZero())
			{
				throw new InvalidOperationException("Not at a break.");
			}
		}

		private void ScanToNextToken()
		{
			while (true)
			{
				if (CheckWhiteSpace())
				{
					Skip();
					continue;
				}
				ProcessComment();
				if (analyzer.IsBreak())
				{
					SkipLine();
					if (flowLevel == 0)
					{
						simpleKeyAllowed = true;
					}
					continue;
				}
				break;
			}
		}

		private void ProcessComment()
		{
			if (!analyzer.Check('#'))
			{
				return;
			}
			Mark start = cursor.Mark();
			Skip();
			while (analyzer.IsSpace())
			{
				Skip();
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsBreakOrZero())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (!SkipComments)
				{
					bool isInline = previous != null && previous.End.Line == start.Line && previous.End.Column != 1 && !(previous is YamlDotNet.Core.Tokens.StreamStart);
					tokens.Enqueue(new YamlDotNet.Core.Tokens.Comment(builder.ToString(), isInline, start, cursor.Mark()));
				}
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void FetchStreamStart()
		{
			simpleKeys.Push(new SimpleKey());
			simpleKeyAllowed = true;
			streamStartProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamStart(in start, in start));
		}

		private void UnrollIndent(long column)
		{
			if (flowLevel == 0)
			{
				while (indent > column)
				{
					Mark start = cursor.Mark();
					tokens.Enqueue(new BlockEnd(in start, in start));
					indent = indents.Pop();
				}
			}
		}

		private void FetchStreamEnd()
		{
			cursor.ForceSkipLineAfterNonBreak();
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			streamEndProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamEnd(in start, in start));
		}

		private void FetchDirective()
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Token token = ScanDirective();
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		private Token? ScanDirective()
		{
			Mark start = cursor.Mark();
			Skip();
			string text = ScanDirectiveName(in start);
			Token result;
			if (!(text == "YAML"))
			{
				if (!(text == "TAG"))
				{
					while (!analyzer.EndOfInput && !analyzer.Check('#') && !analyzer.IsBreak())
					{
						Skip();
					}
					return null;
				}
				result = ScanTagDirectiveValue(in start);
			}
			else
			{
				if (!(previous is YamlDotNet.Core.Tokens.DocumentStart) && !(previous is YamlDotNet.Core.Tokens.StreamStart) && !(previous is YamlDotNet.Core.Tokens.DocumentEnd))
				{
					throw new SemanticErrorException(in start, cursor.Mark(), "While scanning a version directive, did not find preceding <document end>.");
				}
				result = ScanVersionDirectiveValue(in start);
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, did not find expected comment or line break.");
			}
			if (analyzer.IsBreak())
			{
				SkipLine();
			}
			return result;
		}

		private void FetchDocumentIndicator(bool isStartToken)
		{
			UnrollIndent(-1L);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Mark start = cursor.Mark();
			Skip();
			Skip();
			Skip();
			if (isStartToken)
			{
				tokens.Enqueue(new YamlDotNet.Core.Tokens.DocumentStart(in start, cursor.Mark()));
				return;
			}
			Token token = null;
			while (!analyzer.EndOfInput && !analyzer.IsBreak() && !analyzer.Check('#'))
			{
				if (!analyzer.IsWhite())
				{
					token = new Error("While scanning a document end, found invalid content after '...' marker.", start, cursor.Mark());
					break;
				}
				Skip();
			}
			tokens.Enqueue(new YamlDotNet.Core.Tokens.DocumentEnd(in start, in start));
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		private void FetchFlowCollectionStart(bool isSequenceToken)
		{
			SaveSimpleKey();
			IncreaseFlowLevel();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			Token item = ((!isSequenceToken) ? ((Token)new FlowMappingStart(in start, in start)) : ((Token)new FlowSequenceStart(in start, in start)));
			tokens.Enqueue(item);
			startFlowCollectionFetched = true;
		}

		private void IncreaseFlowLevel()
		{
			simpleKeys.Push(new SimpleKey());
			flowLevel++;
		}

		private void FetchFlowCollectionEnd(bool isSequenceToken)
		{
			RemoveSimpleKey();
			DecreaseFlowLevel();
			simpleKeyAllowed = false;
			Mark start = cursor.Mark();
			Skip();
			Token token = null;
			Token item;
			if (isSequenceToken)
			{
				if (analyzer.Check('#'))
				{
					token = new Error("While scanning a flow sequence end, found invalid comment after ']'.", start, start);
				}
				item = new FlowSequenceEnd(in start, in start);
			}
			else
			{
				item = new FlowMappingEnd(in start, in start);
			}
			tokens.Enqueue(item);
			if (token != null)
			{
				tokens.Enqueue(token);
			}
			flowCollectionFetched = true;
		}

		private void DecreaseFlowLevel()
		{
			if (flowLevel > 0)
			{
				flowLevel--;
				simpleKeys.Pop();
			}
		}

		private void FetchFlowEntry()
		{
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			Mark end = cursor.Mark();
			if (analyzer.Check('#'))
			{
				tokens.Enqueue(new Error("While scanning a flow entry, found invalid comment after comma.", start, end));
			}
			else
			{
				tokens.Enqueue(new FlowEntry(in start, in end));
			}
		}

		private void FetchBlockEntry()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					if (previousAnchor != null && previousAnchor.End.Line == cursor.Line)
					{
						throw new SemanticErrorException(previousAnchor.Start, previousAnchor.End, "Anchor before sequence entry on same line is not allowed.");
					}
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("Block sequence entries are not allowed in this context.", mark, mark));
				}
				RollIndent(cursor.LineOffset, -1, isSequence: true, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			tokens.Enqueue(new BlockEntry(in start, cursor.Mark()));
		}

		private void FetchKey()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					Mark start = cursor.Mark();
					throw new SyntaxErrorException(in start, in start, "Mapping keys are not allowed in this context.");
				}
				RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = flowLevel == 0;
			Mark start2 = cursor.Mark();
			Skip();
			tokens.Enqueue(new Key(in start2, cursor.Mark()));
		}

		private void FetchValue()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			if (simpleKey.IsPossible)
			{
				tokens.Insert(simpleKey.TokenNumber - tokensParsed, new Key(simpleKey.Mark, simpleKey.Mark));
				RollIndent(simpleKey.LineOffset, simpleKey.TokenNumber, isSequence: false, simpleKey.Mark);
				simpleKey.MarkAsImpossible();
				simpleKeyAllowed = false;
			}
			else
			{
				bool flag = flowLevel == 0;
				if (flag)
				{
					if (!simpleKeyAllowed)
					{
						Mark mark = cursor.Mark();
						tokens.Enqueue(new Error("Mapping values are not allowed in this context.", mark, mark));
						return;
					}
					RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
					if (cursor.LineOffset == 0L && simpleKey.LineOffset == 0L)
					{
						tokens.Insert(tokens.Count, new Key(simpleKey.Mark, simpleKey.Mark));
						flag = false;
					}
				}
				simpleKeyAllowed = flag;
			}
			Mark start = cursor.Mark();
			Skip();
			tokens.Enqueue(new Value(in start, cursor.Mark()));
		}

		private void RollIndent(long column, int number, bool isSequence, Mark position)
		{
			if (flowLevel <= 0 && indent < column)
			{
				indents.Push(indent);
				indent = column;
				Token item = ((!isSequence) ? ((Token)new BlockMappingStart(in position, in position)) : ((Token)new BlockSequenceStart(in position, in position)));
				if (number == -1)
				{
					tokens.Enqueue(item);
				}
				else
				{
					tokens.Insert(number - tokensParsed, item);
				}
			}
		}

		private void FetchAnchor(bool isAlias)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanAnchor(isAlias));
		}

		private Token ScanAnchor(bool isAlias)
		{
			Mark start = cursor.Mark();
			Skip();
			bool flag = false;
			if (isAlias)
			{
				SimpleKey simpleKey = simpleKeys.Peek();
				flag = simpleKey.IsRequired && simpleKey.IsPossible;
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("[]{},") && (!flag || !analyzer.Check(':') || !analyzer.IsWhiteBreakOrZero(1)))
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0 || (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("?:,]}%@`")))
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning an anchor or alias, found value containing disallowed: []{},");
				}
				AnchorName value = new AnchorName(builder.ToString());
				if (isAlias)
				{
					return new YamlDotNet.Core.Tokens.AnchorAlias(value, start, cursor.Mark());
				}
				return previousAnchor = new Anchor(value, start, cursor.Mark());
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void FetchTag()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanTag());
		}

		private Tag ScanTag()
		{
			Mark start = cursor.Mark();
			string text;
			string text2;
			if (analyzer.Check('<', 1))
			{
				text = string.Empty;
				Skip();
				Skip();
				text2 = ScanTagUri(null, start);
				if (!analyzer.Check('>'))
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find the expected '>'.");
				}
				Skip();
			}
			else
			{
				string text3 = ScanTagHandle(isDirective: false, start);
				if (text3.Length > 1 && text3[0] == '!' && text3[text3.Length - 1] == '!')
				{
					text = text3;
					text2 = ScanTagUri(null, start);
				}
				else
				{
					text2 = ScanTagUri(text3, start);
					text = "!";
					if (text2.Length == 0)
					{
						text2 = text;
						text = string.Empty;
					}
				}
			}
			if (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check(','))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find expected whitespace, comma or line break.");
			}
			return new Tag(text, text2, start, cursor.Mark());
		}

		private void FetchBlockScalar(bool isLiteral)
		{
			SaveSimpleKey();
			simpleKeyAllowed = true;
			tokens.Enqueue(ScanBlockScalar(isLiteral));
		}

		private YamlDotNet.Core.Tokens.Scalar ScanBlockScalar(bool isLiteral)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						int num = 0;
						int num2 = 0;
						long currentIndent = 0L;
						bool flag = false;
						bool? isFirstLine = null;
						Mark start = cursor.Mark();
						Skip();
						if (analyzer.Check("+-"))
						{
							num = (analyzer.Check('+') ? 1 : (-1));
							Skip();
							if (analyzer.IsDigit())
							{
								if (analyzer.Check('0'))
								{
									throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, found an indentation indicator equal to 0.");
								}
								num2 = analyzer.AsDigit();
								Skip();
							}
						}
						else if (analyzer.IsDigit())
						{
							if (analyzer.Check('0'))
							{
								throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, found an indentation indicator equal to 0.");
							}
							num2 = analyzer.AsDigit();
							Skip();
							if (analyzer.Check("+-"))
							{
								num = (analyzer.Check('+') ? 1 : (-1));
								Skip();
							}
						}
						if (analyzer.Check('#'))
						{
							throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, found a comment without whtespace after '>' indicator.");
						}
						while (analyzer.IsWhite())
						{
							Skip();
						}
						ProcessComment();
						if (!analyzer.IsBreakOrZero())
						{
							throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a block scalar, did not find expected comment or line break.");
						}
						if (analyzer.IsBreak())
						{
							SkipLine();
							if (!isFirstLine.HasValue)
							{
								isFirstLine = true;
							}
							else if (isFirstLine == true)
							{
								isFirstLine = false;
							}
						}
						Mark end = cursor.Mark();
						if (num2 != 0)
						{
							currentIndent = ((indent >= 0) ? (indent + num2) : num2);
						}
						currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end, ref isFirstLine);
						isFirstLine = false;
						while (cursor.LineOffset == currentIndent && !analyzer.IsZero() && !IsDocumentEnd())
						{
							bool flag2 = analyzer.IsWhite();
							if (!isLiteral && StartsWith(builder2, '\n') && !flag && !flag2)
							{
								if (builder3.Length == 0)
								{
									builder.Append(' ');
								}
								builder2.Length = 0;
							}
							else
							{
								builder.Append((object?)builder2);
								builder2.Length = 0;
							}
							builder.Append((object?)builder3);
							builder3.Length = 0;
							flag = analyzer.IsWhite();
							while (!analyzer.IsBreakOrZero())
							{
								builder.Append(ReadCurrentCharacter());
							}
							char c = ReadLine();
							if (c != 0)
							{
								builder2.Append(c);
							}
							currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end, ref isFirstLine);
						}
						if (num != -1)
						{
							builder.Append((object?)builder2);
						}
						if (num == 1)
						{
							builder.Append((object?)builder3);
						}
						ScalarStyle style = (isLiteral ? ScalarStyle.Literal : ScalarStyle.Folded);
						return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), style, start, end);
					}
					finally
					{
						((IDisposable)builderWrapper3/*cast due to .constrained prefix*/).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private long ScanBlockScalarBreaks(long currentIndent, StringBuilder breaks, bool isLiteral, ref Mark end, ref bool? isFirstLine)
		{
			long num = 0L;
			long num2 = -1L;
			end = cursor.Mark();
			while (true)
			{
				if ((currentIndent == 0L || cursor.LineOffset < currentIndent) && analyzer.IsSpace())
				{
					Skip();
					continue;
				}
				if (cursor.LineOffset > num)
				{
					num = cursor.LineOffset;
				}
				if (!analyzer.IsBreak())
				{
					break;
				}
				if (isFirstLine == true)
				{
					isFirstLine = false;
					num2 = cursor.LineOffset;
				}
				breaks.Append(ReadLine());
				end = cursor.Mark();
			}
			if (isLiteral && isFirstLine == true)
			{
				long num3 = cursor.LineOffset;
				int num4 = 0;
				while (!analyzer.IsBreak(num4) && analyzer.IsSpace(num4))
				{
					num4++;
					num3++;
				}
				if (analyzer.IsBreak(num4) && num3 > cursor.LineOffset)
				{
					isFirstLine = false;
					num2 = num3;
				}
			}
			if (isLiteral && num2 > 1 && currentIndent < num2 - 1)
			{
				throw new SemanticErrorException(in end, cursor.Mark(), "While scanning a literal block scalar, found extra spaces in first line.");
			}
			if (!isLiteral && num > cursor.LineOffset && num2 > -1)
			{
				throw new SemanticErrorException(in end, cursor.Mark(), "While scanning a literal block scalar, found more spaces in lines above first content line.");
			}
			if (currentIndent == 0L && (cursor.LineOffset > 0 || indent > -1))
			{
				currentIndent = Math.Max(num, Math.Max(indent + 1, 1L));
			}
			return currentIndent;
		}

		private void FetchQuotedScalar(bool isSingleQuoted)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			flowScalarFetched = flowLevel > 0;
			YamlDotNet.Core.Tokens.Scalar item = ScanFlowScalar(isSingleQuoted);
			tokens.Enqueue(item);
			lastScalar = item;
			if (!isSingleQuoted && analyzer.Check('#'))
			{
				Mark mark = cursor.Mark();
				tokens.Enqueue(new Error("While scanning a flow sequence end, found invalid comment after double-quoted scalar.", mark, mark));
			}
		}

		private YamlDotNet.Core.Tokens.Scalar ScanFlowScalar(bool isSingleQuoted)
		{
			Mark start = cursor.Mark();
			Skip();
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							while (true)
							{
								if (IsDocumentIndicator())
								{
									throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found unexpected document indicator.");
								}
								if (analyzer.IsZero())
								{
									throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found unexpected end of stream.");
								}
								if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
								{
									throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a multi-line double-quoted scalar, found wrong indentation.");
								}
								flag = false;
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if (isSingleQuoted && analyzer.Check('\'') && analyzer.Check('\'', 1))
									{
										builder.Append('\'');
										Skip();
										Skip();
										continue;
									}
									if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
									{
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\') && analyzer.IsBreak(1))
									{
										Skip();
										SkipLine();
										flag = true;
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\'))
									{
										int num = 0;
										char c = analyzer.Peek(1);
										switch (c)
										{
										case 'x':
											num = 2;
											break;
										case 'u':
											num = 4;
											break;
										case 'U':
											num = 8;
											break;
										default:
										{
											if (SimpleEscapeCodes.TryGetValue(c, out var value))
											{
												builder.Append(value);
												break;
											}
											throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found unknown escape character.");
										}
										}
										Skip();
										Skip();
										if (num <= 0)
										{
											continue;
										}
										int num2 = 0;
										for (int i = 0; i < num; i++)
										{
											if (!analyzer.IsHex(i))
											{
												throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, did not find expected hexadecimal number.");
											}
											num2 = (num2 << 4) + analyzer.AsHex(i);
										}
										if (num2 >= 55296 && num2 <= 57343)
										{
											for (int j = 0; j < num; j++)
											{
												Skip();
											}
											if (analyzer.Peek(0) != '\\' || (analyzer.Peek(1) != 'u' && analyzer.Peek(1) != 'U'))
											{
												throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found invalid Unicode surrogates.");
											}
											Skip();
											num = ((analyzer.Peek(0) != 'u') ? 8 : 4);
											Skip();
											int num3 = 0;
											for (int k = 0; k < num; k++)
											{
												if (!analyzer.IsHex(0))
												{
													throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, did not find expected hexadecimal number.");
												}
												num3 = (num3 << 4) + analyzer.AsHex(k);
											}
											for (int l = 0; l < num; l++)
											{
												Skip();
											}
											num2 = char.ConvertToUtf32((char)num2, (char)num3);
										}
										else
										{
											if (num2 > 1114111)
											{
												throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a quoted scalar, found invalid Unicode character escape code.");
											}
											for (int m = 0; m < num; m++)
											{
												Skip();
											}
										}
										builder.Append(char.ConvertFromUtf32(num2));
									}
									else
									{
										builder.Append(ReadCurrentCharacter());
									}
								}
								if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else if (!flag)
									{
										builder2.Length = 0;
										builder3.Append(ReadLine());
										flag = true;
									}
									else
									{
										builder4.Append(ReadLine());
									}
								}
								if (flag)
								{
									if (StartsWith(builder3, '\n'))
									{
										if (builder4.Length == 0)
										{
											builder.Append(' ');
										}
										else
										{
											builder.Append((object?)builder4);
										}
									}
									else
									{
										builder.Append((object?)builder3);
										builder.Append((object?)builder4);
									}
									builder3.Length = 0;
									builder4.Length = 0;
								}
								else
								{
									builder.Append((object?)builder2);
									builder2.Length = 0;
								}
							}
							Skip();
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), isSingleQuoted ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted, start, cursor.Mark());
						}
						finally
						{
							((IDisposable)builderWrapper4/*cast due to .constrained prefix*/).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3/*cast due to .constrained prefix*/).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void FetchPlainScalar()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			bool isMultiline = false;
			YamlDotNet.Core.Tokens.Scalar item = (lastScalar = ScanPlainScalar(ref isMultiline));
			if (isMultiline && analyzer.Check(':') && flowLevel == 0 && indent < cursor.LineOffset)
			{
				tokens.Enqueue(new Error("While scanning a multiline plain scalar, found invalid mapping.", cursor.Mark(), cursor.Mark()));
			}
			tokens.Enqueue(item);
		}

		private YamlDotNet.Core.Tokens.Scalar ScanPlainScalar(ref bool isMultiline)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							long num = indent + 1;
							Mark start = cursor.Mark();
							Mark end = start;
							SimpleKey simpleKey = simpleKeys.Peek();
							while (!IsDocumentIndicator())
							{
								if (analyzer.Check('#'))
								{
									if (indent < 0 && flowLevel == 0)
									{
										plainScalarFollowedByComment = true;
									}
									break;
								}
								bool flag2 = analyzer.Check('*') && (!simpleKey.IsPossible || !simpleKey.IsRequired);
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if ((analyzer.Check(':') && !flag2 && (analyzer.IsWhiteBreakOrZero(1) || (flowLevel > 0 && analyzer.Check(',', 1)))) || (flowLevel > 0 && analyzer.Check(",[]{}")))
									{
										if (flowLevel == 0 && !simpleKey.IsPossible)
										{
											tokens.Enqueue(new Error("While scanning a plain scalar value, found invalid mapping.", cursor.Mark(), cursor.Mark()));
										}
										break;
									}
									if (flag || builder2.Length > 0)
									{
										if (flag)
										{
											if (StartsWith(builder3, '\n'))
											{
												if (builder4.Length == 0)
												{
													builder.Append(' ');
												}
												else
												{
													builder.Append((object?)builder4);
												}
											}
											else
											{
												builder.Append((object?)builder3);
												builder.Append((object?)builder4);
											}
											builder3.Length = 0;
											builder4.Length = 0;
											flag = false;
										}
										else
										{
											builder.Append((object?)builder2);
											builder2.Length = 0;
										}
									}
									if (flowLevel > 0 && cursor.LineOffset < num)
									{
										throw new InvalidOperationException();
									}
									builder.Append(ReadCurrentCharacter());
									end = cursor.Mark();
								}
								if (!analyzer.IsWhite() && !analyzer.IsBreak())
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (flag && cursor.LineOffset < num && analyzer.IsTab())
										{
											throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a plain scalar, found a tab character that violate indentation.");
										}
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else
									{
										isMultiline = true;
										if (!flag)
										{
											builder2.Length = 0;
											builder3.Append(ReadLine());
											flag = true;
										}
										else
										{
											builder4.Append(ReadLine());
										}
									}
								}
								if (flowLevel == 0 && cursor.LineOffset < num)
								{
									break;
								}
							}
							if (flag)
							{
								simpleKeyAllowed = true;
							}
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), ScalarStyle.Plain, start, end);
						}
						finally
						{
							((IDisposable)builderWrapper4/*cast due to .constrained prefix*/).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3/*cast due to .constrained prefix*/).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void RemoveSimpleKey()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			if (simpleKey.IsPossible && simpleKey.IsRequired)
			{
				throw new SyntaxErrorException(simpleKey.Mark, simpleKey.Mark, "While scanning a simple key, could not find expected ':'.");
			}
			simpleKey.MarkAsImpossible();
		}

		private string ScanDirectiveName(in Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, could not find expected directive name.");
				}
				if (analyzer.EndOfInput)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, found unexpected end of stream.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a directive, found unexpected non-alphabetical character.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void SkipWhitespaces()
		{
			while (analyzer.IsWhite())
			{
				Skip();
			}
		}

		private VersionDirective ScanVersionDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			int major = ScanVersionDirectiveNumber(in start);
			if (!analyzer.Check('.'))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %YAML directive, did not find expected digit or '.' character.");
			}
			Skip();
			int minor = ScanVersionDirectiveNumber(in start);
			return new VersionDirective(new Version(major, minor), start, start);
		}

		private TagDirective ScanTagDirectiveValue(in Mark start)
		{
			SkipWhitespaces();
			string handle = ScanTagHandle(isDirective: true, start);
			if (!analyzer.IsWhite())
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %TAG directive, did not find expected whitespace.");
			}
			SkipWhitespaces();
			string prefix = ScanTagUri(null, start);
			if (!analyzer.IsWhiteBreakOrZero())
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %TAG directive, did not find expected whitespace or line break.");
			}
			return new TagDirective(handle, prefix, start, start);
		}

		private string ScanTagUri(string? head, Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				if (head != null && head.Length > 1)
				{
					builder.Append(head.Substring(1));
				}
				while (analyzer.IsAlphaNumericDashOrUnderscore() || analyzer.Check(";/?:@&=+$.!~*'()[]%") || (analyzer.Check(',') && !analyzer.IsBreak(1)))
				{
					if (analyzer.Check('%'))
					{
						builder.Append(ScanUriEscapes(in start));
					}
					else if (analyzer.Check('+'))
					{
						builder.Append(' ');
						Skip();
					}
					else
					{
						builder.Append(ReadCurrentCharacter());
					}
				}
				if (builder.Length == 0)
				{
					return string.Empty;
				}
				string text = builder.ToString();
				if (Polyfills.EndsWith(text, ','))
				{
					throw new SyntaxErrorException(cursor.Mark(), cursor.Mark(), "Unexpected comma at end of tag");
				}
				return text;
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private string ScanUriEscapes(in Mark start)
		{
			byte[] array = EmptyBytes;
			int count = 0;
			int num = 0;
			do
			{
				if (!analyzer.Check('%') || !analyzer.IsHex(1) || !analyzer.IsHex(2))
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find URI escaped octet.");
				}
				int num2 = (analyzer.AsHex(1) << 4) + analyzer.AsHex(2);
				if (num == 0)
				{
					num = (((num2 & 0x80) == 0) ? 1 : (((num2 & 0xE0) == 192) ? 2 : (((num2 & 0xF0) == 224) ? 3 : (((num2 & 0xF8) == 240) ? 4 : 0))));
					if (num == 0)
					{
						throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, found an incorrect leading UTF-8 octet.");
					}
					array = new byte[num];
				}
				else if ((num2 & 0xC0) != 128)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, found an incorrect trailing UTF-8 octet.");
				}
				array[count++] = (byte)num2;
				Skip();
				Skip();
				Skip();
			}
			while (--num > 0);
			string text = Encoding.UTF8.GetString(array, 0, count);
			if (text.Length == 0 || text.Length > 2)
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, found an incorrect UTF-8 sequence.");
			}
			return text;
		}

		private string ScanTagHandle(bool isDirective, Mark start)
		{
			if (!analyzer.Check('!'))
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag, did not find expected '!'.");
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append(ReadCurrentCharacter());
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (analyzer.Check('!'))
				{
					builder.Append(ReadCurrentCharacter());
				}
				else if (isDirective && (builder.Length != 1 || builder[0] != '!'))
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a tag directive, did not find expected '!'.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private int ScanVersionDirectiveNumber(in Mark start)
		{
			int num = 0;
			int num2 = 0;
			while (analyzer.IsDigit())
			{
				if (++num2 > 9)
				{
					throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %YAML directive, found extremely long version number.");
				}
				num = num * 10 + analyzer.AsDigit();
				Skip();
			}
			if (num2 == 0)
			{
				throw new SyntaxErrorException(in start, cursor.Mark(), "While scanning a %YAML directive, did not find expected version number.");
			}
			return num;
		}

		private void SaveSimpleKey()
		{
			bool isRequired = flowLevel == 0 && indent == cursor.LineOffset;
			if (simpleKeyAllowed)
			{
				SimpleKey item = new SimpleKey(isRequired, tokensParsed + tokens.Count, cursor);
				RemoveSimpleKey();
				simpleKeys.Pop();
				simpleKeys.Push(item);
			}
		}
	}
	internal class SemanticErrorException : YamlException
	{
		public SemanticErrorException(string message)
			: base(message)
		{
		}

		public SemanticErrorException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public SemanticErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class SimpleKey
	{
		private readonly Cursor cursor;

		public bool IsPossible { get; private set; }

		public bool IsRequired { get; }

		public int TokenNumber { get; }

		public long Index => cursor.Index;

		public long Line => cursor.Line;

		public long LineOffset => cursor.LineOffset;

		public Mark Mark => cursor.Mark();

		public void MarkAsImpossible()
		{
			IsPossible = false;
		}

		public SimpleKey()
		{
			cursor = new Cursor();
		}

		public SimpleKey(bool isRequired, int tokenNumber, Cursor cursor)
		{
			IsPossible = true;
			IsRequired = isRequired;
			TokenNumber = tokenNumber;
			this.cursor = new Cursor(cursor);
		}
	}
	internal sealed class StringLookAheadBuffer : ILookAheadBuffer, IResettable
	{
		public string Value { get; set; } = string.Empty;

		public int Position { get; private set; }

		public int Length => Value.Length;

		public bool EndOfInput => IsOutside(Position);

		public char Peek(int offset)
		{
			int index = Position + offset;
			if (!IsOutside(index))
			{
				return Value[index];
			}
			return '\0';
		}

		private bool IsOutside(int index)
		{
			return index >= Value.Length;
		}

		public void Skip(int length)
		{
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be positive.");
			}
			Position += length;
		}

		public bool TryReset()
		{
			Position = 0;
			Value = string.Empty;
			return true;
		}
	}
	internal sealed class SyntaxErrorException : YamlException
	{
		public SyntaxErrorException(string message)
			: base(message)
		{
		}

		public SyntaxErrorException(in Mark start, in Mark end, string message)
			: base(in start, in end, message)
		{
		}

		public SyntaxErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	internal sealed class TagDirectiveCollection : KeyedCollection<string, TagDirective>
	{
		public TagDirectiveCollection()
		{
		}

		public TagDirectiveCollection(IEnumerable<TagDirective> tagDirectives)
		{
			foreach (TagDirective tagDirective in tagDirectives)
			{
				Add(tagDirective);
			}
		}

		protected override string GetKeyForItem(TagDirective item)
		{
			return item.Handle;
		}

		public new bool Contains(TagDirective directive)
		{
			return Contains(GetKeyForItem(directive));
		}
	}
	internal readonly struct TagName : IEquatable<TagName>
	{
		public static readonly TagName Empty;

		private readonly string? value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of a non-specific tag");

		public bool IsEmpty => value == null;

		public bool IsNonSpecific
		{
			get
			{
				if (!IsEmpty)
				{
					if (!(value == "!"))
					{
						return value == "?";
					}
					return true;
				}
				return false;
			}
		}

		public bool IsLocal
		{
			get
			{
				if (!IsEmpty)
				{
					return Value[0] == '!';
				}
				return false;
			}
		}

		public bool IsGlobal
		{
			get
			{
				if (!IsEmpty)
				{
					return !IsLocal;
				}
				return false;
			}
		}

		public TagName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (value.Length == 0)
			{
				throw new ArgumentException("Tag value must not be empty.", "value");
			}
			if (IsGlobal && !Uri.IsWellFormedUriString(value, UriKind.RelativeOrAbsolute))
			{
				throw new ArgumentException("Global tags must be valid URIs.", "value");
			}
		}

		public override string ToString()
		{
			return value ?? "?";
		}

		public bool Equals(TagName other)
		{
			return object.Equals(value, other.value);
		}

		public override bool Equals(object? obj)
		{
			if (obj is TagName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(TagName left, TagName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(TagName left, TagName right)
		{
			return !(left == right);
		}

		public static bool operator ==(TagName left, string right)
		{
			return object.Equals(left.value, right);
		}

		public static bool operator !=(TagName left, string right)
		{
			return !(left == right);
		}

		public static implicit operator TagName(string? value)
		{
			if (value != null)
			{
				return new TagName(value);
			}
			return Empty;
		}
	}
	internal sealed class Version
	{
		public int Major { get; }

		public int Minor { get; }

		public Version(int major, int minor)
		{
			if (major < 0)
			{
				throw new ArgumentOutOfRangeException("major", $"{major} should be >= 0");
			}
			Major = major;
			if (minor < 0)
			{
				throw new ArgumentOutOfRangeException("minor", $"{minor} should be >= 0");
			}
			Minor = minor;
		}

		public override bool Equals(object? obj)
		{
			if (obj is Version version && Major == version.Major)
			{
				return Minor == version.Minor;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.CombineHashCodes(Major.GetHashCode(), Minor.GetHashCode());
		}
	}
	internal class YamlException : Exception
	{
		public Mark Start { get; }

		public Mark End { get; }

		public YamlException(string message)
			: this(in Mark.Empty, in Mark.Empty, message)
		{
		}

		public YamlException(in Mark start, in Mark end, string message)
			: this(in start, in end, message, null)
		{
		}

		public YamlException(in Mark start, in Mark end, string message, Exception? innerException)
			: base(message, innerException)
		{
			Start = start;
			End = end;
		}

		public YamlException(string message, Exception inner)
			: this(in Mark.Empty, in Mark.Empty, message, inner)
		{
		}

		public override string ToString()
		{
			return $"({Start}) - ({End}): {Message}";
		}
	}
}
namespace YamlDotNet.Core.Tokens
{
	internal class Anchor : Token
	{
		public AnchorName Value { get; }

		public Anchor(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public Anchor(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class AnchorAlias : Token
	{
		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class BlockEnd : Token
	{
		public BlockEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class BlockEntry : Token
	{
		public BlockEntry()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockEntry(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class BlockMappingStart : Token
	{
		public BlockMappingStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockMappingStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class BlockSequenceStart : Token
	{
		public BlockSequenceStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public BlockSequenceStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Comment : Token
	{
		public string Value { get; }

		public bool IsInline { get; }

		public Comment(string value, bool isInline)
			: this(value, isInline, Mark.Empty, Mark.Empty)
		{
		}

		public Comment(string value, bool isInline, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			IsInline = isInline;
		}
	}
	internal sealed class DocumentEnd : Token
	{
		public DocumentEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public DocumentEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class DocumentStart : Token
	{
		public DocumentStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public DocumentStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal class Error : Token
	{
		public string Value { get; }

		public Error(string value, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value;
		}
	}
	internal sealed class FlowEntry : Token
	{
		public FlowEntry()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowEntry(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowMappingEnd : Token
	{
		public FlowMappingEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowMappingEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowMappingStart : Token
	{
		public FlowMappingStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowMappingStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowSequenceEnd : Token
	{
		public FlowSequenceEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowSequenceEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class FlowSequenceStart : Token
	{
		public FlowSequenceStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public FlowSequenceStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Key : Token
	{
		public Key()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public Key(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Scalar : Token
	{
		public bool IsKey { get; set; }

		public string Value { get; }

		public ScalarStyle Style { get; }

		public Scalar(string value)
			: this(value, ScalarStyle.Any)
		{
		}

		public Scalar(string value, ScalarStyle style)
			: this(value, style, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(string value, ScalarStyle style, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			Style = style;
		}
	}
	internal sealed class StreamEnd : Token
	{
		public StreamEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class StreamStart : Token
	{
		public StreamStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class Tag : Token
	{
		public string Handle { get; }

		public string Suffix { get; }

		public Tag(string handle, string suffix)
			: this(handle, suffix, Mark.Empty, Mark.Empty)
		{
		}

		public Tag(string handle, string suffix, Mark start, Mark end)
			: base(in start, in end)
		{
			Handle = handle ?? throw new ArgumentNullException("handle");
			Suffix = suffix ?? throw new ArgumentNullException("suffix");
		}
	}
	internal class TagDirective : Token
	{
		private static readonly Regex TagHandlePattern = new Regex("^!([0-9A-Za-z_\\-]*!)?$", RegexOptions.Compiled);

		public string Handle { get; }

		public string Prefix { get; }

		public TagDirective(string handle, string prefix)
			: this(handle, prefix, Mark.Empty, Mark.Empty)
		{
		}

		public TagDirective(string handle, string prefix, Mark start, Mark end)
			: base(in start, in end)
		{
			if (string.IsNullOrEmpty(handle))
			{
				throw new ArgumentNullException("handle", "Tag handle must not be empty.");
			}
			if (!TagHandlePattern.IsMatch(handle))
			{
				throw new ArgumentException("Tag handle must start and end with '!' and contain alphanumerical characters only.", "handle");
			}
			Handle = handle;
			if (string.IsNullOrEmpty(prefix))
			{
				throw new ArgumentNullException("prefix", "Tag prefix must not be empty.");
			}
			Prefix = prefix;
		}

		public override bool Equals(object? obj)
		{
			if (obj is TagDirective tagDirective && Handle.Equals(tagDirective.Handle))
			{
				return Prefix.Equals(tagDirective.Prefix);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Handle.GetHashCode() ^ Prefix.GetHashCode();
		}

		public override string ToString()
		{
			return Handle + " => " + Prefix;
		}
	}
	internal abstract class Token
	{
		public Mark Start { get; }

		public Mark End { get; }

		protected Token(in Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	internal sealed class Value : Token
	{
		public Value()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public Value(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}
	}
	internal sealed class VersionDirective : Token
	{
		public Version Version { get; }

		public VersionDirective(Version version)
			: this(version, Mark.Empty, Mark.Empty)
		{
		}

		public VersionDirective(Version version, Mark start, Mark end)
			: base(in start, in end)
		{
			Version = version;
		}

		public override bool Equals(object? obj)
		{
			if (obj is VersionDirective versionDirective)
			{
				return Version.Equals(versionDirective.Version);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Version.GetHashCode();
		}
	}
}
namespace YamlDotNet.Core.ObjectPool
{
	internal class DefaultObjectPool<T> : ObjectPool<T> where T : class
	{
		private readonly Func<T> createFunc;

		private readonly Func<T, bool> returnFunc;

		private readonly int maxCapacity;

		private int numItems;

		private protected readonly ConcurrentQueue<T> items = new ConcurrentQueue<T>();

		private protected T? fastItem;

		public DefaultObjectPool(IPooledObjectPolicy<T> policy)
			: this(policy, Environment.ProcessorCount * 2)
		{
		}

		public DefaultObjectPool(IPooledObjectPolicy<T> policy, int maximumRetained)
		{
			createFunc = policy.Create;
			returnFunc = policy.Return;
			maxCapacity = maximumRetained - 1;
		}

		public override T Get()
		{
			T result = fastItem;
			if (result == null || Interlocked.CompareExchange(ref fastItem, null, result) != result)
			{
				if (items.TryDequeue(out result))
				{
					Interlocked.Decrement(ref numItems);
					return result;
				}
				return createFunc();
			}
			return result;
		}

		public override void Return(T obj)
		{
			ReturnCore(obj);
		}

		private protected bool ReturnCore(T obj)
		{
			if (!returnFunc(obj))
			{
				return false;
			}
			if (fastItem != null || Interlocked.CompareExchange(ref fastItem, obj, null) != null)
			{
				if (Interlocked.Increment(ref numItems) <= maxCapacity)
				{
					items.Enqueue(obj);
					return true;
				}
				Interlocked.Decrement(ref numItems);
				return false;
			}
			return true;
		}
	}
	internal class DefaultPooledObjectPolicy<T> : IPooledObjectPolicy<T> where T : class, new()
	{
		public T Create()
		{
			return new T();
		}

		public bool Return(T obj)
		{
			if (obj is IResettable resettable)
			{
				return resettable.TryReset();
			}
			return true;
		}
	}
	internal interface IPooledObjectPolicy<T> where T : notnull
	{
		T Create();

		bool Return(T obj);
	}
	internal interface IResettable
	{
		bool TryReset();
	}
	internal abstract class ObjectPool<T> where T : class
	{
		public abstract T Get();

		public abstract void Return(T obj);
	}
	internal static class ObjectPool
	{
		public static ObjectPool<T> Create<T>(IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>());
		}

		public static ObjectPool<T> Create<T>(int maximumRetained, IPooledObjectPolicy<T>? policy = null) where T : class, new()
		{
			return new DefaultObjectPool<T>(policy ?? new DefaultPooledObjectPolicy<T>(), maximumRetained);
		}
	}
	[DebuggerStepThrough]
	internal static class StringBuilderPool
	{
		internal readonly struct BuilderWrapper : IDisposable
		{
			public readonly StringBuilder Builder;

			private readonly ObjectPool<StringBuilder> pool;

			public BuilderWrapper(StringBuilder builder, ObjectPool<StringBuilder> pool)
			{
				Builder = builder;
				this.pool = pool;
			}

			public override string ToString()
			{
				return Builder.ToString();
			}

			public void Dispose()
			{
				pool.Return(Builder);
			}
		}

		private static readonly ObjectPool<StringBuilder> Pool = ObjectPool.Create(new StringBuilderPooledObjectPolicy
		{
			InitialCapacity = 16,
			MaximumRetainedCapacity = 1024
		});

		public static BuilderWrapper Rent()
		{
			StringBuilder builder = Pool.Get();
			return new BuilderWrapper(builder, Pool);
		}
	}
	internal class StringBuilderPooledObjectPolicy : IPooledObjectPolicy<StringBuilder>
	{
		public int InitialCapacity { get; set; } = 100;

		public int MaximumRetainedCapacity { get; set; } = 4096;

		public StringBuilder Create()
		{
			return new StringBuilder(InitialCapacity);
		}

		public bool Return(StringBuilder obj)
		{
			if (obj.Capacity > MaximumRetainedCapacity)
			{
				return false;
			}
			obj.Clear();
			return true;
		}
	}
	internal static class StringLookAheadBufferPool
	{
		internal readonly struct BufferWrapper : IDisposable
		{
			public readonly StringLookAheadBuffer Buffer;

			private readonly ObjectPool<StringLookAheadBuffer> pool;

			public BufferWrapper(StringLookAheadBuffer buffer, ObjectPool<StringLookAheadBuffer> pool)
			{
				Buffer = buffer;
				this.pool = pool;
			}

			public override string ToString()
			{
				return Buffer.ToString();
			}

			public void Dispose()
			{
				pool.Return(Buffer);
			}
		}

		private static readonly ObjectPool<StringLookAheadBuffer> Pool = ObjectPool.Create(new DefaultPooledObjectPolicy<StringLookAheadBuffer>());

		public static BufferWrapper Rent(string value)
		{
			StringLookAheadBuffer stringLookAheadBuffer = Pool.Get();
			stringLookAheadBuffer.Value = value;
			return new BufferWrapper(stringLookAheadBuffer, Pool);
		}
	}
}
namespace YamlDotNet.Core.Events
{
	internal sealed class AnchorAlias : ParsingEvent
	{
		internal override EventType Type => EventType.Alias;

		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(in start, in end)
		{
			if (value.IsEmpty)
			{
				throw new YamlException(in start, in end, "Anchor value must not be empty.");
			}
			Value = value;
		}

		public AnchorAlias(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Alias [value = {Value}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class Comment : ParsingEvent
	{
		public string Value { get; }

		public bool IsInline { get; }

		internal override EventType Type => EventType.Comment;

		public Comment(string value, bool isInline)
			: this(value, isInline, Mark.Empty, Mark.Empty)
		{
		}

		public Comment(string value, bool isInline, Mark start, Mark end)
			: base(in start, in end)
		{
			Value = value;
			IsInline = isInline;
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override string ToString()
		{
			return (IsInline ? "Inline" : "Block") + " Comment [" + Value + "]";
		}
	}
	internal sealed class DocumentEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.DocumentEnd;

		public bool IsImplicit { get; }

		public DocumentEnd(bool isImplicit, Mark start, Mark end)
			: base(in start, in end)
		{
			IsImplicit = isImplicit;
		}

		public DocumentEnd(bool isImplicit)
			: this(isImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document end [isImplicit = {IsImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class DocumentStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.DocumentStart;

		public TagDirectiveCollection? Tags { get; }

		public VersionDirective? Version { get; }

		public bool IsImplicit { get; }

		public DocumentStart(VersionDirective? version, TagDirectiveCollection? tags, bool isImplicit, Mark start, Mark end)
			: base(in start, in end)
		{
			Version = version;
			Tags = tags;
			IsImplicit = isImplicit;
		}

		public DocumentStart(VersionDirective? version, TagDirectiveCollection? tags, bool isImplicit)
			: this(version, tags, isImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public DocumentStart(in Mark start, in Mark end)
			: this(null, null, isImplicit: true, start, end)
		{
		}

		public DocumentStart()
			: this(null, null, isImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	internal interface IParsingEventVisitor
	{
		void Visit(AnchorAlias e);

		void Visit(StreamStart e);

		void Visit(StreamEnd e);

		void Visit(DocumentStart e);

		void Visit(DocumentEnd e);

		void Visit(Scalar e);

		void Visit(SequenceStart e);

		void Visit(SequenceEnd e);

		void Visit(MappingStart e);

		void Visit(MappingEnd e);

		void Visit(Comment e);
	}
	internal class MappingEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.MappingEnd;

		public MappingEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public MappingEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Mapping end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class MappingStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.MappingStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public MappingStyle Style { get; }

		public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public MappingStart()
			: this(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Any, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Mapping start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum MappingStyle
	{
		Any,
		Block,
		Flow
	}
	internal abstract class NodeEvent : ParsingEvent
	{
		public AnchorName Anchor { get; }

		public TagName Tag { get; }

		public abstract bool IsCanonical { get; }

		protected NodeEvent(AnchorName anchor, TagName tag, Mark start, Mark end)
			: base(in start, in end)
		{
			Anchor = anchor;
			Tag = tag;
		}

		protected NodeEvent(AnchorName anchor, TagName tag)
			: this(anchor, tag, Mark.Empty, Mark.Empty)
		{
		}
	}
	internal abstract class ParsingEvent
	{
		public virtual int NestingIncrease => 0;

		internal abstract EventType Type { get; }

		public Mark Start { get; }

		public Mark End { get; }

		public abstract void Accept(IParsingEventVisitor visitor);

		internal ParsingEvent(in Mark start, in Mark end)
		{
			Start = start;
			End = end;
		}
	}
	internal sealed class Scalar : NodeEvent
	{
		internal override EventType Type => EventType.Scalar;

		public string Value { get; }

		public ScalarStyle Style { get; }

		public bool IsPlainImplicit { get; }

		public bool IsQuotedImplicit { get; }

		public override bool IsCanonical
		{
			get
			{
				if (!IsPlainImplicit)
				{
					return !IsQuotedImplicit;
				}
				return false;
			}
		}

		public bool IsKey { get; }

		public Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit, Mark start, Mark end, bool isKey = false)
			: base(anchor, tag, start, end)
		{
			Value = value;
			Style = style;
			IsPlainImplicit = isPlainImplicit;
			IsQuotedImplicit = isQuotedImplicit;
			IsKey = isKey;
		}

		public Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit)
			: this(anchor, tag, value, style, isPlainImplicit, isQuotedImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(string value)
			: this(AnchorName.Empty, TagName.Empty, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(TagName tag, string value)
			: this(AnchorName.Empty, tag, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(AnchorName anchor, TagName tag, string value)
			: this(anchor, tag, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Scalar [anchor = {base.Anchor}, tag = {base.Tag}, value = {Value}, style = {Style}, isPlainImplicit = {IsPlainImplicit}, isQuotedImplicit = {IsQuotedImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class SequenceEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.SequenceEnd;

		public SequenceEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public SequenceEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Sequence end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class SequenceStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.SequenceStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public SequenceStyle Style { get; }

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Sequence start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum SequenceStyle
	{
		Any,
		Block,
		Flow
	}
	internal sealed class StreamEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.StreamEnd;

		public StreamEnd(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public StreamEnd()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Stream end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal sealed class StreamStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.StreamStart;

		public StreamStart()
			: this(in Mark.Empty, in Mark.Empty)
		{
		}

		public StreamStart(in Mark start, in Mark end)
			: base(in start, in end)
		{
		}

		public override string ToString()
		{
			return "Stream start";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}
namespace Concentus
{
	internal static class Analysis
	{
		private const double M_PI = 3.141592653;

		private const float cA = 0.43157974f;

		private const float cB = 0.678484f;

		private const float cC = 0.08595542f;

		private const float cE = (float)Math.PI / 2f;

		private const int NB_TONAL_SKIP_BANDS = 9;

		internal static float fast_atan2f(float y, float x)
		{
			if (Inlines.ABS16(x) + Inlines.ABS16(y) < 1E-09f)
			{
				x *= 1E+12f;
				y *= 1E+12f;
			}
			float num = x * x;
			float num2 = y * y;
			if (num < num2)
			{
				float num3 = (num2 + 0.678484f * num) * (num2 + 0.08595542f * num);
				if (num3 != 0f)
				{
					return (0f - x) * y * (num2 + 0.43157974f * num) / num3 + ((y < 0f) ? (-(float)Math.PI / 2f) : ((float)Math.PI / 2f));
				}
				if (!(y < 0f))
				{
					return (float)Math.PI / 2f;
				}
				return -(float)Math.PI / 2f;
			}
			float num4 = (num + 0.678484f * num2) * (num + 0.08595542f * num2);
			if (num4 != 0f)
			{
				return x * y * (num + 0.43157974f * num2) / num4 + ((y < 0f) ? (-(float)Math.PI / 2f) : ((float)Math.PI / 2f)) - ((x * y < 0f) ? (-(float)Math.PI / 2f) : ((float)Math.PI / 2f));
			}
			return ((y < 0f) ? (-(float)Math.PI / 2f) : ((float)Math.PI / 2f)) - ((x * y < 0f) ? (-(float)Math.PI / 2f) : ((float)Math.PI / 2f));
		}

		internal static void tonality_analysis_init(TonalityAnalysisState tonal)
		{
			tonal.Reset();
		}

		internal static void tonality_get_info(TonalityAnalysisState tonal, AnalysisInfo info_out, int len)
		{
			int num = tonal.read_pos;
			int num2 = tonal.write_pos - tonal.read_pos;
			if (num2 < 0)
			{
				num2 += 200;
			}
			if (len > 480 && num != tonal.write_pos)
			{
				num++;
				if (num == 200)
				{
					num = 0;
				}
			}
			if (num == tonal.write_pos)
			{
				num--;
			}
			if (num < 0)
			{
				num = 199;
			}
			info_out.Assign(tonal.info[num]);
			tonal.read_subframe += len / 120;
			while (tonal.read_subframe >= 4)
			{
				tonal.read_subframe -= 4;
				tonal.read_pos++;
			}
			if (tonal.read_pos >= 200)
			{
				tonal.read_pos -= 200;
			}
			num2 = Inlines.IMAX(num2 - 10, 0);
			float num3 = 0f;
			int i;
			for (i = 0; i < 200 - num2; i++)
			{
				num3 += tonal.pmusic[i];
			}
			for (; i < 200; i++)
			{
				num3 += tonal.pspeech[i];
			}
			num3 = num3 * tonal.music_confidence + (1f - num3) * tonal.speech_confidence;
			info_out.music_prob = num3;
		}

		internal static void tonality_analysis<T>(TonalityAnalysisState tonal, CeltMode celt_mode, T[] x, int x_ptr, int len, int offset, int c1, int c2, int C, int lsb_depth, Downmix.downmix_func<T> downmix)
		{
			int num = 480;
			int num2 = 240;
			float[] angle = tonal.angle;
			float[] d_angle = tonal.d_angle;
			float[] d2_angle = tonal.d2_angle;
			float[] array = new float[18];
			float[] array2 = new float[18];
			float[] array3 = new float[8];
			float[] array4 = new float[25];
			float num3 = 97.40909f;
			float num4 = 0f;
			float[] array5 = new float[2];
			int num5 = 0;
			float num6 = 0f;
			tonal.last_transition++;
			float num7 = 1f / (float)Inlines.IMIN(20, 1 + tonal.count);
			float num8 = 1f / (float)Inlines.IMIN(50, 1 + tonal.count);
			float num9 = 1f / (float)Inlines.IMIN(1000, 1 + tonal.count);
			if (tonal.count < 4)
			{
				tonal.music_prob = 0.5f;
			}
			FFTState st = celt_mode.mdct.kfft[0];
			if (tonal.count == 0)
			{
				tonal.mem_fill = 240;
			}
			downmix(x, x_ptr, tonal.inmem, tonal.mem_fill, Inlines.IMIN(len, 720 - tonal.mem_fill), offset, c1, c2, C);
			if (tonal.mem_fill + len < 720)
			{
				tonal.mem_fill += len;
				return;
			}
			AnalysisInfo analysisInfo = tonal.info[tonal.write_pos++];
			if (tonal.write_pos >= 200)
			{
				tonal.write_pos -= 200;
			}
			int[] array6 = new int[960];
			int[] array7 = new int[960];
			float[] array8 = new float[240];
			float[] array9 = new float[240];
			for (int i = 0; i < num2; i++)
			{
				float num10 = Tables.analysis_window[i];
				array6[2 * i] = (int)(num10 * (float)tonal.inmem[i]);
				array6[2 * i + 1] = (int)(num10 * (float)tonal.inmem[num2 + i]);
				array6[2 * (num - i - 1)] = (int)(num10 * (float)tonal.inmem[num - i - 1]);
				array6[2 * (num - i - 1) + 1] = (int)(num10 * (float)tonal.inmem[num + num2 - i - 1]);
			}
			Arrays.MemMoveInt(tonal.inmem, 480, 0, 240);
			int num11 = len - (720 - tonal.mem_fill);
			downmix(x, x_ptr, tonal.inmem, 240, num11, offset + 720 - tonal.mem_fill, c1, c2, C);
			tonal.mem_fill = 240 + num11;
			KissFFT.opus_fft(st, array6, array7);
			for (int i = 1; i < num2; i++)
			{
				float x2 = (float)array7[2 * i] + (float)array7[2 * (num - i)];
				float y = (float)array7[2 * i + 1] - (float)array7[2 * (num - i) + 1];
				float x3 = (float)array7[2 * i + 1] + (float)array7[2 * (num - i) + 1];
				float y2 = (float)array7[2 * (num - i)] - (float)array7[2 * i];
				float num12 = 1f / (2f * (float)Math.PI) * fast_atan2f(y, x2);
				float num13 = num12 - angle[i];
				float num14 = num13 - d_angle[i];
				float num15 = 1f / (2f * (float)Math.PI) * fast_atan2f(y2, x3);
				float num16 = num15 - num12;
				float num17 = num16 - num13;
				float num18 = num14 - (float)Math.Floor(0.5f + num14);
				array9[i] = Inlines.ABS16(num18);
				num18 *= num18;
				num18 *= num18;
				float num19 = num17 - (float)Math.Floor(0.5f + num17);
				array9[i] += Inlines.ABS16(num19);
				num19 *= num19;
				num19 *= num19;
				float num20 = 0.25f * (d2_angle[i] + 2f * num18 + num19);
				array8[i] = 1f / (1f + 640f * num3 * num20) - 0.015f;
				angle[i] = num15;
				d_angle[i] = num16;
				d2_angle[i] = num19;
			}
			float num21 = 0f;
			float num22 = 0f;
			analysisInfo.activity = 0f;
			float num23 = 0f;
			float num24 = 0f;
			if (tonal.count == 0)
			{
				for (int j = 0; j < 18; j++)
				{
					tonal.lowE[j] = 1E+10f;
					tonal.highE[j] = -1E+10f;
				}
			}
			float num25 = 0f;
			float num26 = 0f;
			for (int j = 0; j < 18; j++)
			{
				float num27 = 0f;
				float num28 = 0f;
				float num29 = 0f;
				for (int i = Tables.tbands[j]; i < Tables.tbands[j + 1]; i++)
				{
					float num30 = (float)array7[2 * i] * (float)array7[2 * i] + (float)array7[2 * (num - i)] * (float)array7[2 * (num - i)] + (float)array7[2 * i + 1] * (float)array7[2 * i + 1] + (float)array7[2 * (num - i) + 1] * (float)array7[2 * (num - i) + 1];
					num30 *= 5.55E-17f;
					num27 += num30;
					num28 += num30 * array8[i];
					num29 += num30 * 2f * (0.5f - array9[i]);
				}
				tonal.E[tonal.E_count][j] = num27;
				num23 += num29 / (1E-15f + num27);
				num26 += (float)Math.Sqrt(num27 + 1E-10f);
				array2[j] = (float)Math.Log(num27 + 1E-10f);
				tonal.lowE[j] = Inlines.MIN32(array2[j], tonal.lowE[j] + 0.01f);
				tonal.highE[j] = Inlines.MAX32(array2[j], tonal.highE[j] - 0.1f);
				if (tonal.highE[j] < tonal.lowE[j] + 1f)
				{
					tonal.highE[j] += 0.5f;
					tonal.lowE[j] -= 0.5f;
				}
				num25 += (array2[j] - tonal.lowE[j]) / (1E-15f + tonal.highE[j] - tonal.lowE[j]);
				float num32;
				float num31 = (num32 = 0f);
				for (int i = 0; i < 8; i++)
				{
					num31 += (float)Math.Sqrt(tonal.E[i][j]);
					num32 += tonal.E[i][j];
				}
				float num33 = Inlines.MIN16(0.99f, num31 / (float)Math.Sqrt(1E-15 + (double)(8f * num32)));
				num33 *= num33;
				num33 *= num33;
				num24 += num33;
				array[j] = Inlines.MAX16(num28 / (1E-15f + num27), num33 * tonal.prev_band_tonality[j]);
				num21 += array[j];
				if (j >= 9)
				{
					num21 -= array[j - 18 + 9];
				}
				num22 = Inlines.MAX16(num22, (1f + 0.03f * (float)(j - 18)) * num21);
				num4 += array[j] * (float)(j - 8);
				tonal.prev_band_tonality[j] = array[j];
			}
			float num34 = 0f;
			num5 = 0;
			num6 = 0f;
			float num35 = 0.00057f / (float)(1 << Inlines.IMAX(0, lsb_depth - 8));
			num35 *= 134217730f;
			num35 *= num35;
			for (int j = 0; j < 21; j++)
			{
				float num36 = 0f;
				int num37 = Tables.extra_bands[j];
				int num38 = Tables.extra_bands[j + 1];
				for (int i = num37; i < num38; i++)
				{
					float num39 = (float)array7[2 * i] * (float)array7[2 * i] + (float)array7[2 * (num - i)] * (float)array7[2 * (num - i)] + (float)array7[2 * i + 1] * (float)array7[2 * i + 1] + (float)array7[2 * (num - i) + 1] * (float)array7[2 * (num - i) + 1];
					num36 += num39;
				}
				num6 = Inlines.MAX32(num6, num36);
				tonal.meanE[j] = Inlines.MAX32((1f - num9) * tonal.meanE[j], num36);
				num36 = Inlines.MAX32(num36, tonal.meanE[j]);
				num34 = Inlines.MAX32(0.05f * num34, num36);
				if ((double)num36 > 0.1 * (double)num34 && num36 * 1E+09f > num6 && num36 > num35 * (float)(num38 - num37))
				{
					num5 = j;
				}
			}
			if (tonal.count <= 2)
			{
				num5 = 20;
			}
			num26 = 20f * (float)Math.Log10(num26);
			tonal.Etracker = Inlines.MAX32(tonal.Etracker - 0.03f, num26);
			tonal.lowECount *= 1f - num8;
			if (num26 < tonal.Etracker - 30f)
			{
				tonal.lowECount += num8;
			}
			for (int i = 0; i < 8; i++)
			{
				float num40 = 0f;
				for (int j = 0; j < 16; j++)
				{
					num40 += Tables.dct_table[i * 16 + j] * array2[j];
				}
				array3[i] = num40;
			}
			num24 /= 18f;
			num25 /= 18f;
			if (tonal.count < 10)
			{
				num25 = 0.5f;
			}
			num23 /= 18f;
			analysisInfo.activity = num23 + (1f - num23) * num25;
			num21 = num22 / 9f;
			num21 = (tonal.prev_tonality = Inlines.MAX16(num21, tonal.prev_tonality * 0.8f));
			num4 /= 64f;
			analysisInfo.tonality_slope = num4;
			tonal.E_count = (tonal.E_count + 1) % 8;
			tonal.count++;
			analysisInfo.tonality = num21;
			for (int i = 0; i < 4; i++)
			{
				array4[i] = -0.12299f * (array3[i] + tonal.mem[i + 24]) + 0.49195f * (tonal.mem[i] + tonal.mem[i + 16]) + 0.69693f * tonal.mem[i + 8] - 1.4349f * tonal.cmean[i];
			}
			for (int i = 0; i < 4; i++)
			{
				tonal.cmean[i] = (1f - num7) * tonal.cmean[i] + num7 * array3[i];
			}
			for (int i = 0; i < 4; i++)
			{
				array4[4 + i] = 0.63246f * (array3[i] - tonal.mem[i + 24]) + 0.31623f * (tonal.mem[i] - tonal.mem[i + 16]);
			}
			for (int i = 0; i < 3; i++)
			{
				array4[8 + i] = 0.53452f * (array3[i] + tonal.mem[i + 24]) - 0.26726f * (tonal.mem[i] + tonal.mem[i + 16]) - 0.53452f * tonal.mem[i + 8];
			}
			if (tonal.count > 5)
			{
				for (int i = 0; i < 9; i++)
				{
					tonal.std[i] = (1f - num7) * tonal.std[i] + num7 * array4[i] * array4[i];
				}
			}
			for (int i = 0; i < 8; i++)
			{
				tonal.mem[i + 24] = tonal.mem[i + 16];
				tonal.mem[i + 16] = tonal.mem[i + 8];
				tonal.mem[i + 8] = tonal.mem[i];
				tonal.mem[i] = array3[i];
			}
			for (int i = 0; i < 9; i++)
			{
				array4[11 + i] = (float)Math.Sqrt(tonal.std[i]);
			}
			array4[20] = analysisInfo.tonality;
			array4[21] = analysisInfo.activity;
			array4[22] = num24;
			array4[23] = analysisInfo.tonality_slope;
			array4[24] = tonal.lowECount;
			mlp.mlp_process(Tables.net, array4, array5);
			array5[0] = 0.5f * (array5[0] + 1f);
			array5[0] = 0.01f + 1.21f * array5[0] * array5[0] - 0.23f * (float)Math.Pow(array5[0], 10.0);
			array5[1] = 0.5f * array5[1] + 0.5f;
			array5[0] = array5[1] * array5[0] + (1f - array5[1]) * 0.5f;
			float num41 = 5E-05f * array5[1];
			float num42 = 0.05f;
			float num43 = Inlines.MAX16(0.05f, Inlines.MIN16(0.95f, array5[0]));
			float num44 = Inlines.MAX16(0.05f, Inlines.MIN16(0.95f, tonal.music_prob));
			num42 = 0.01f + 0.05f * Inlines.ABS16(num43 - num44) / (num43 * (1f - num44) + num44 * (1f - num43));
			float num45 = (1f - tonal.music_prob) * (1f - num41) + tonal.music_prob * num41;
			float num46 = tonal.music_prob * (1f - num41) + (1f - tonal.music_prob) * num41;
			num45 *= (float)Math.Pow(1f - array5[0], num42);
			num46 *= (float)Math.Pow(array5[0], num42);
			tonal.music_prob = num46 / (num45 + num46);
			analysisInfo.music_prob = tonal.music_prob;
			float num47 = 1E-20f;
			float num48 = (float)Math.Pow(1f - array5[0], num42);
			float num49 = (float)Math.Pow(array5[0], num42);
			if (tonal.count == 1)
			{
				tonal.pspeech[0] = 0.5f;
				tonal.pmusic[0] = 0.5f;
			}
			float num50 = tonal.pspeech[0] + tonal.pspeech[1];
			float num51 = tonal.pmusic[0] + tonal.pmusic[1];
			tonal.pspeech[0] = num50 * (1f - num41) * num48;
			tonal.pmusic[0] = num51 * (1f - num41) * num49;
			for (int i = 1; i < 199; i++)
			{
				tonal.pspeech[i] = tonal.pspeech[i + 1] * num48;
				tonal.pmusic[i] = tonal.pmusic[i + 1] * num49;
			}
			tonal.pspeech[199] = num51 * num41 * num48;
			tonal.pmusic[199] = num50 * num41 * num49;
			for (int i = 0; i < 200; i++)
			{
				num47 += tonal.pspeech[i] + tonal.pmusic[i];
			}
			num47 = 1f / num47;
			for (int i = 0; i < 200; i++)
			{
				tonal.pspeech[i] *= num47;
				tonal.pmusic[i] *= num47;
			}
			num47 = tonal.pmusic[0];
			for (int i = 1; i < 200; i++)
			{
				num47 += tonal.pspeech[i];
			}
			if ((double)array5[1] > 0.75)
			{
				if ((double)tonal.music_prob > 0.9)
				{
					float num52 = 1f / (float)(++tonal.music_confidence_count);
					tonal.music_confidence_count = Inlines.IMIN(tonal.music_confidence_count, 500);
					tonal.music_confidence += num52 * Inlines.MAX16(-0.2f, array5[0] - tonal.music_confidence);
				}
				if ((double)tonal.music_prob < 0.1)
				{
					float num53 = 1f / (float)(++tonal.speech_confidence_count);
					tonal.speech_confidence_count = Inlines.IMIN(tonal.speech_confidence_count, 500);
					tonal.speech_confidence += num53 * Inlines.MIN16(0.2f, array5[0] - tonal.speech_confidence);
				}
			}
			else
			{
				if (tonal.music_confidence_count == 0)
				{
					tonal.music_confidence = 0.9f;
				}
				if (tonal.speech_confidence_count == 0)
				{
					tonal.speech_confidence = 0.1f;
				}
			}
			if (tonal.last_music != ((tonal.music_prob > 0.5f) ? 1 : 0))
			{
				tonal.last_transition = 0;
			}
			tonal.last_music = ((tonal.music_prob > 0.5f) ? 1 : 0);
			analysisInfo.bandwidth = num5;
			analysisInfo.noisiness = num23;
			analysisInfo.valid = 1;
		}

		internal static void run_analysis<T>(TonalityAnalysisState analysis, CeltMode celt_mode, T[] analysis_pcm, int analysis_pcm_ptr, int analysis_frame_size, int frame_size, int c1, int c2, int C, int Fs, int lsb_depth, Downmix.downmix_func<T> downmix, AnalysisInfo analysis_info)
		{
			if (analysis_pcm != null)
			{
				analysis_frame_size = Inlines.IMIN(195 * Fs / 100, analysis_frame_size);
				int num = analysis_frame_size - analysis.analysis_offset;
				int num2 = analysis.analysis_offset;
				do
				{
					tonality_analysis(analysis, celt_mode, analysis_pcm, analysis_pcm_ptr, Inlines.IMIN(480, num), num2, c1, c2, C, lsb_depth, downmix);
					num2 += 480;
					num -= 480;
				}
				while (num > 0);
				analysis.analysis_offset = analysis_frame_size;
				analysis.analysis_offset -= frame_size;
			}
			analysis_info.valid = 0;
			tonality_get_info(analysis, analysis_info, frame_size);
		}
	}
	internal static class CodecHelpers
	{
		private const int MAX_DYNAMIC_FRAMESIZE = 24;

		internal static byte gen_toc(OpusMode mode, int framerate, OpusBandwidth bandwidth, int channels)
		{
			int num = 0;
			while (framerate < 400)
			{
				framerate <<= 1;
				num++;
			}
			byte b;
			switch (mode)
			{
			case OpusMode.MODE_SILK_ONLY:
				b = (byte)((int)(bandwidth - 1101) << 5);
				b |= (byte)(num - 2 << 3);
				break;
			case OpusMode.MODE_CELT_ONLY:
			{
				int num2 = (int)(bandwidth - 1102);
				if (num2 < 0)
				{
					num2 = 0;
				}
				b = 128;
				b |= (byte)(num2 << 5);
				b |= (byte)(num << 3);
				break;
			}
			default:
				b = 96;
				b |= (byte)((int)(bandwidth - 1104) << 4);
				b |= (byte)(num - 2 << 3);
				break;
			}
			return (byte)(b | (byte)(((channels == 2) ? 1u : 0u) << 2));
		}

		internal static void hp_cutoff(short[] input, int input_ptr, int cutoff_Hz, short[] output, int output_ptr, int[] hp_mem, int len, int channels, int Fs)
		{
			int[] array = new int[3];
			int[] array2 = new int[2];
			int num = Inlines.silk_DIV32_16(Inlines.silk_SMULBB(2471, cutoff_Hz), Fs / 1000);
			int num2 = (array[0] = 268435456 - Inlines.silk_MUL(471, num));
			array[1] = Inlines.silk_LSHIFT(-num2, 1);
			array[2] = num2;
			int num3 = Inlines.silk_RSHIFT(num2, 6);
			array2[0] = Inlines.silk_SMULWW(num3, Inlines.silk_SMULWW(num, num) - 8388608);
			array2[1] = Inlines.silk_SMULWW(num3, num3);
			Filters.silk_biquad_alt(input, input_ptr, array, array2, hp_mem, 0, output, output_ptr, len, channels);
			if (channels == 2)
			{
				Filters.silk_biquad_alt(input, input_ptr + 1, array, array2, hp_mem, 2, output, output_ptr + 1, len, channels);
			}
		}

		internal static void dc_reject(short[] input, int input_ptr, int cutoff_Hz, short[] output, int output_ptr, int[] hp_mem, int len, int channels, int Fs)
		{
			int shift = Inlines.celt_ilog2(Fs / (cutoff_Hz * 3));
			for (int i = 0; i < channels; i++)
			{
				for (int j = 0; j < len; j++)
				{
					int num = Inlines.SHL32(Inlines.EXTEND32(input[channels * j + i + input_ptr]), 15);
					int num2 = num - hp_mem[2 * i];
					hp_mem[2 * i] += Inlines.PSHR32(num - hp_mem[2 * i], shift);
					int a = num2 - hp_mem[2 * i + 1];
					hp_mem[2 * i + 1] += Inlines.PSHR32(num2 - hp_mem[2 * i + 1], shift);
					output[channels * j + i + output_ptr] = Inlines.EXTRACT16(Inlines.SATURATE(Inlines.PSHR32(a, 15), 32767));
				}
			}
		}

		internal static void stereo_fade(short[] pcm_buf, int g1, int g2, int overlap48, int frame_size, int channels, int[] window, int Fs)
		{
			int num = 48000 / Fs;
			int num2 = overlap48 / num;
			g1 = 32767 - g1;
			g2 = 32767 - g2;
			int i;
			for (i = 0; i < num2; i++)
			{
				int num3 = Inlines.MULT16_16_Q15(window[i * num], window[i * num]);
				int a = Inlines.SHR32(Inlines.MAC16_16(Inlines.MULT16_16(num3, g2), 32767 - num3, g1), 15);
				int b = Inlines.EXTRACT16(Inlines.HALF32(pcm_buf[i * channels] - pcm_buf[i * channels + 1]));
				b = Inlines.MULT16_16_Q15(a, b);
				pcm_buf[i * channels] = (short)(pcm_buf[i * channels] - b);
				pcm_buf[i * channels + 1] = (short)(pcm_buf[i * channels + 1] + b);
			}
			for (; i < frame_size; i++)
			{
				int b2 = Inlines.EXTRACT16(Inlines.HALF32(pcm_buf[i * channels] - pcm_buf[i * channels + 1]));
				b2 = Inlines.MULT16_16_Q15(g2, b2);
				pcm_buf[i * channels] = (short)(pcm_buf[i * channels] - b2);
				pcm_buf[i * channels + 1] = (short)(pcm_buf[i * channels + 1] + b2);
			}
		}

		internal static void gain_fade(short[] buffer, int buf_ptr, int g1, int g2, int overlap48, int frame_size, int channels, int[] window, int Fs)
		{
			int num = 48000 / Fs;
			int num2 = overlap48 / num;
			if (channels == 1)
			{
				for (int i = 0; i < num2; i++)
				{
					int num3 = Inlines.MULT16_16_Q15(window[i * num], window[i * num]);
					int a = Inlines.SHR32(Inlines.MAC16_16(Inlines.MULT16_16(num3, g2), 32767 - num3, g1), 15);
					buffer[buf_ptr + i] = (short)Inlines.MULT16_16_Q15(a, buffer[buf_ptr + i]);
				}
			}
			else
			{
				for (int i = 0; i < num2; i++)
				{
					int num4 = Inlines.MULT16_16_Q15(window[i * num], window[i * num]);
					int a2 = Inlines.SHR32(Inlines.MAC16_16(Inlines.MULT16_16(num4, g2), 32767 - num4, g1), 15);
					buffer[buf_ptr + i * 2] = (short)Inlines.MULT16_16_Q15(a2, buffer[buf_ptr + i * 2]);
					buffer[buf_ptr + i * 2 + 1] = (short)Inlines.MULT16_16_Q15(a2, buffer[buf_ptr + i * 2 + 1]);
				}
			}
			int num5 = 0;
			do
			{
				for (int i = num2; i < frame_size; i++)
				{
					buffer[buf_ptr + i * channels + num5] = (short)Inlines.MULT16_16_Q15(g2, buffer[buf_ptr + i * channels + num5]);
				}
			}
			while (++num5 < channels);
		}

		internal static float transient_boost(float[] E, int E_ptr, float[] E_1, int LM, int maxM)
		{
			float num = 0f;
			float num2 = 0f;
			int num3 = Inlines.IMIN(maxM, (1 << LM) + 1);
			for (int i = E_ptr; i < num3 + E_ptr; i++)
			{
				num += E[i];
				num2 += E_1[i];
			}
			float num4 = num * num2 / (float)(num3 * num3);
			return Inlines.MIN16(1f, (float)Math.Sqrt(Inlines.MAX16(0f, 0.05f * (num4 - 2f))));
		}

		internal static int transient_viterbi(float[] E, float[] E_1, int N, int frame_cost, int rate)
		{
			float[][] array = Arrays.InitTwoDimensionalArray<float>(24, 16);
			int[][] array2 = Arrays.InitTwoDimensionalArray<int>(24, 16);
			float num = ((rate < 80) ? 0f : ((rate <= 160) ? (((float)rate - 80f) / 80f) : 1f));
			for (int i = 0; i < 16; i++)
			{
				array2[0][i] = -1;
				array[0][i] = 1E+10f;
			}
			for (int i = 0; i < 4; i++)
			{
				array[0][1 << i] = (float)(frame_cost + rate * (1 << i)) * (1f + num * transient_boost(E, 0, E_1, i, N + 1));
				array2[0][1 << i] = i;
			}
			for (int i = 1; i < N; i++)
			{
				for (int j = 2; j < 16; j++)
				{
					array[i][j] = array[i - 1][j - 1];
					array2[i][j] = j - 1;
				}
				for (int j = 0; j < 4; j++)
				{
					array2[i][1 << j] = 1;
					float num2 = array[i - 1][1];
					for (int k = 1; k < 4; k++)
					{
						float num3 = array[i - 1][(1 << k + 1) - 1];
						if (num3 < num2)
						{
							array2[i][1 << j] = (1 << k + 1) - 1;
							num2 = num3;
						}
					}
					float num4 = (float)(frame_cost + rate * (1 << j)) * (1f + num * transient_boost(E, i, E_1, j, N - i + 1));
					array[i][1 << j] = num2;
					if (N - i < 1 << j)
					{
						array[i][1 << j] += num4 * (float)(N - i) / (float)(1 << j);
					}
					else
					{
						array[i][1 << j] += num4;
					}
				}
			}
			int num5 = 1;
			float num6 = array[N - 1][1];
			for (int i = 2; i < 16; i++)
			{
				if (array[N - 1][i] < num6)
				{
					num6 = array[N - 1][i];
					num5 = i;
				}
			}
			for (int i = N - 1; i >= 0; i--)
			{
				num5 = array2[i][num5];
			}
			return num5;
		}

		internal static int optimize_framesize<T>(T[] x, int x_ptr, int len, int C, int Fs, int bitrate, int tonality, float[] mem, int buffering, Downmix.downmix_func<T> downmix)
		{
			float[] array = new float[28];
			float[] array2 = new float[27];
			int num = 0;
			int num2 = Fs / 400;
			int[] array3 = new int[num2];
			array[0] = mem[0];
			array2[0] = 1f / (1f + mem[0]);
			int num3;
			int num4;
			if (buffering != 0)
			{
				num3 = 2 * num2 - buffering;
				len -= num3;
				array[1] = mem[1];
				array2[1] = 1f / (1f + mem[1]);
				array[2] = mem[2];
				array2[2] = 1f / (1f + mem[2]);
				num4 = 3;
			}
			else
			{
				num4 = 1;
				num3 = 0;
			}
			int num5 = Inlines.IMIN(len / num2, 24);
			int num6 = 0;
			int i;
			for (i = 0; i < num5; i++)
			{
				float num7 = 1f;
				downmix(x, x_ptr, array3, 0, num2, i * num2 + num3, 0, -2, C);
				if (i == 0)
				{
					num6 = array3[0];
				}
				for (int j = 0; j < num2; j++)
				{
					int num8 = array3[j];
					num7 += (float)(num8 - num6) * (float)(num8 - num6);
					num6 = num8;
				}
				array[i + num4] = num7;
				array2[i + num4] = 1f / num7;
			}
			array[i + num4] = array[i + num4 - 1];
			if (buffering != 0)
			{
				num5 = Inlines.IMIN(24, num5 + 2);
			}
			num = transient_viterbi(array, array2, num5, (int)((1f + 0.5f * (float)tonality) * (float)(60 * C + 40)), bitrate / 400);
			mem[0] = array[1 << num];
			if (buffering != 0)
			{
				mem[1] = array[(1 << num) + 1];
				mem[2] = array[(1 << num) + 2];
			}
			return num;
		}

		internal static int frame_size_select(int frame_size, OpusFramesize variable_duration, int Fs)
		{
			if (frame_size < Fs / 400)
			{
				return -1;
			}
			int num;
			switch (variable_duration)
			{
			case OpusFramesize.OPUS_FRAMESIZE_ARG:
				num = frame_size;
				break;
			case OpusFramesize.OPUS_FRAMESIZE_VARIABLE:
				num = Fs / 50;
				break;
			case OpusFramesize.OPUS_FRAMESIZE_2_5_MS:
			case OpusFramesize.OPUS_FRAMESIZE_5_MS:
			case OpusFramesize.OPUS_FRAMESIZE_10_MS:
			case OpusFramesize.OPUS_FRAMESIZE_20_MS:
			case OpusFramesize.OPUS_FRAMESIZE_40_MS:
			case OpusFramesize.OPUS_FRAMESIZE_60_MS:
				num = Inlines.IMIN(3 * Fs / 50, Fs / 400 << (int)(variable_duration - 5001));
				break;
			default:
				return -1;
			}
			if (num > frame_size)
			{
				return -1;
			}
			if (400 * num != Fs && 200 * num != Fs && 100 * num != Fs && 50 * num != Fs && 25 * num != Fs && 50 * num != 3 * Fs)
			{
				return -1;
			}
			return num;
		}

		internal static int compute_frame_size<T>(T[] analysis_pcm, int analysis_pcm_ptr, int frame_size, OpusFramesize variable_duration, int C, int Fs, int bitrate_bps, int delay_compensation, Downmix.downmix_func<T> downmix, float[] subframe_mem, bool analysis_enabled)
		{
			if (analysis_enabled && variable_duration == OpusFramesize.OPUS_FRAMESIZE_VARIABLE && frame_size >= Fs / 200)
			{
				int num = 3;
				num = optimize_framesize(analysis_pcm, analysis_pcm_ptr, frame_size, C, Fs, bitrate_bps, 0, subframe_mem, delay_compensation, downmix);
				while (Fs / 400 << num > frame_size)
				{
					num--;
				}
				frame_size = Fs / 400 << num;
			}
			else
			{
				frame_size = frame_size_select(frame_size, variable_duration, Fs);
			}
			if (frame_size < 0)
			{
				return -1;
			}
			return frame_size;
		}

		internal static int compute_stereo_width(short[] pcm, int pcm_ptr, int frame_size, int Fs, StereoWidthState mem)
		{
			int num = Fs / frame_size;
			int a = 32767 - 819175 / Inlines.IMAX(50, num);
			int num3;
			int num4;
			int num2 = (num3 = (num4 = 0));
			for (int i = 0; i < frame_size - 3; i += 4)
			{
				int num5 = 0;
				int num6 = 0;
				int num7 = 0;
				int num8 = pcm_ptr + 2 * i;
				int num9 = pcm[num8];
				int num10 = pcm[num8 + 1];
				num5 = Inlines.SHR32(Inlines.MULT16_16(num9, num9), 2);
				num6 = Inlines.SHR32(Inlines.MULT16_16(num9, num10), 2);
				num7 = Inlines.SHR32(Inlines.MULT16_16(num10, num10), 2);
				num9 = pcm[num8 + 2];
				num10 = pcm[num8 + 3];
				num5 += Inlines.SHR32(Inlines.MULT16_16(num9, num9), 2);
				num6 += Inlines.SHR32(Inlines.MULT16_16(num9, num10), 2);
				num7 += Inlines.SHR32(Inlines.MULT16_16(num10, num10), 2);
				num9 = pcm[num8 + 4];
				num10 = pcm[num8 + 5];
				num5 += Inlines.SHR32(Inlines.MULT16_16(num9, num9), 2);
				num6 += Inlines.SHR32(Inlines.MULT16_16(num9, num10), 2);
				num7 += Inlines.SHR32(Inlines.MULT16_16(num10, num10), 2);
				num9 = pcm[num8 + 6];
				num10 = pcm[num8 + 7];
				num5 += Inlines.SHR32(Inlines.MULT16_16(num9, num9), 2);
				num6 += Inlines.SHR32(Inlines.MULT16_16(num9, num10), 2);
				num7 += Inlines.SHR32(Inlines.MULT16_16(num10, num10), 2);
				num2 += Inlines.SHR32(num5, 10);
				num3 += Inlines.SHR32(num6, 10);
				num4 += Inlines.SHR32(num7, 10);
			}
			mem.XX += Inlines.MULT16_32_Q15(a, num2 - mem.XX);
			mem.XY += Inlines.MULT16_32_Q15(a, num3 - mem.XY);
			mem.YY += Inlines.MULT16_32_Q15(a, num4 - mem.YY);
			mem.XX = Inlines.MAX32(0, mem.XX);
			mem.XY = Inlines.MAX32(0, mem.XY);
			mem.YY = Inlines.MAX32(0, mem.YY);
			if (Inlines.MAX32(mem.XX, mem.YY) > 210)
			{
				int num11 = Inlines.celt_sqrt(mem.XX);
				int num12 = Inlines.celt_sqrt(mem.YY);
				int num13 = Inlines.celt_sqrt(num11);
				int num14 = Inlines.celt_sqrt(num12);
				mem.XY = Inlines.MIN32(mem.XY, num11 * num12);
				int num15 = Inlines.SHR32(Inlines.frac_div32(mem.XY, 1 + Inlines.MULT16_16(num11, num12)), 16);
				int b = 32767 * Inlines.ABS16(num13 - num14) / (1 + num13 + num14);
				int num16 = Inlines.MULT16_16_Q15(Inlines.celt_sqrt(1073741824 - Inlines.MULT16_16(num15, num15)), b);
				mem.smoothed_width += (num16 - mem.smoothed_width) / num;
				mem.max_follower = Inlines.MAX16(mem.max_follower - 655 / num, mem.smoothed_width);
			}
			else
			{
				int num16 = 0;
				int num15 = 32767;
				int b = 0;
			}
			return Inlines.EXTRACT16(Inlines.MIN32(32767, 20 * mem.max_follower));
		}

		internal static void smooth_fade(short[] in1, int in1_ptr, short[] in2, int in2_ptr, short[] output, int output_ptr, int overlap, int channels, int[] window, int Fs)
		{
			int num = 48000 / Fs;
			for (int i = 0; i < channels; i++)
			{
				for (int j = 0; j < overlap; j++)
				{
					int num2 = Inlines.MULT16_16_Q15(window[j * num], window[j * num]);
					output[output_ptr + j * channels + i] = (short)Inlines.SHR32(Inlines.MAC16_16(Inlines.MULT16_16(num2, in2[in2_ptr + j * channels + i]), 32767 - num2, in1[in1_ptr + j * channels + i]), 15);
				}
			}
		}

		internal static string opus_strerror(int error)
		{
			string[] array = new string[8] { "success", "invalid argument", "buffer too small", "internal error", "corrupted stream", "request not implemented", "invalid state", "memory allocation failed" };
			if (error > 0 || error < -7)
			{
				return "unknown error";
			}
			return array[-error];
		}

		public static string GetVersionString()
		{
			return "Concentus 1.1.6";
		}
	}
	internal static class Downmix
	{
		public delegate void downmix_func<T>(T[] _x, int x_ptr, int[] sub, int sub_ptr, int subframe, int offset, int c1, int c2, int C);

		internal static void downmix_float(float[] x, int x_ptr, int[] sub, int sub_ptr, int subframe, int offset, int c1, int c2, int C)
		{
			int num = c1 + x_ptr;
			for (int i = 0; i < subframe; i++)
			{
				sub[sub_ptr + i] = Inlines.FLOAT2INT16(x[(i + offset) * C + num]);
			}
			if (c2 > -1)
			{
				int num2 = c2 + x_ptr;
				for (int i = 0; i < subframe; i++)
				{
					sub[sub_ptr + i] += Inlines.FLOAT2INT16(x[(i + offset) * C + num2]);
				}
			}
			else if (c2 == -2)
			{
				for (int j = 1; j < C; j++)
				{
					int num3 = j + x_ptr;
					for (int i = 0; i < subframe; i++)
					{
						sub[sub_ptr + i] += Inlines.FLOAT2INT16(x[(i + offset) * C + num3]);
					}
				}
			}
			int num4 = 4096;
			num4 = ((C != -2) ? (num4 / 2) : (num4 / C));
			for (int i = 0; i < subframe; i++)
			{
				sub[sub_ptr + i] *= num4;
			}
		}

		internal static void downmix_int(short[] x, int x_ptr, int[] sub, int sub_ptr, int subframe, int offset, int c1, int c2, int C)
		{
			for (int i = 0; i < subframe; i++)
			{
				sub[i + sub_ptr] = x[(i + offset) * C + c1];
			}
			if (c2 > -1)
			{
				for (int i = 0; i < subframe; i++)
				{
					sub[i + sub_ptr] += x[(i + offset) * C + c2];
				}
			}
			else if (c2 == -2)
			{
				for (int j = 1; j < C; j++)
				{
					for (int i = 0; i < subframe; i++)
					{
						sub[i + sub_ptr] += x[(i + offset) * C + j];
					}
				}
			}
			int num = 4096;
			num = ((C != -2) ? (num / 2) : (num / C));
			for (int i = 0; i < subframe; i++)
			{
				sub[i + sub_ptr] *= num;
			}
		}
	}
	internal static class mlp
	{
		private const int MAX_NEURONS = 100;

		internal static float tansig_approx(float x)
		{
			float num = 1f;
			if (!(x < 8f))
			{
				return 1f;
			}
			if (!(x > -8f))
			{
				return -1f;
			}
			if (x < 0f)
			{
				x = 0f - x;
				num = -1f;
			}
			int num2 = (int)Math.Floor(0.5f + 25f * x);
			x -= 0.04f * (float)num2;
			float num3 = Tables.tansig_table[num2];
			float num4 = 1f - num3 * num3;
			num3 += x * num4 * (1f - num3 * x);
			return num * num3;
		}

		internal static void mlp_process(MLP m, float[] input, float[] output)
		{
			float[] array = new float[100];
			float[] weights = m.weights;
			int num = 0;
			for (int i = 0; i < m.topo[1]; i++)
			{
				float num2 = weights[num];
				num++;
				for (int j = 0; j < m.topo[0]; j++)
				{
					num2 += input[j] * weights[num];
					num++;
				}
				array[i] = tansig_approx(num2);
			}
			for (int i = 0; i < m.topo[2]; i++)
			{
				float num3 = weights[num];
				num++;
				for (int k = 0; k < m.topo[1]; k++)
				{
					num3 += array[k] * weights[num];
					num++;
				}
				output[i] = tansig_approx(num3);
			}
		}
	}
	internal static class OpusCompare
	{
		private const int NBANDS = 21;

		private const int NFREQS = 240;

		private const int TEST_WIN_SIZE = 480;

		private const int TEST_WIN_STEP = 120;

		private static readonly int[] BANDS = new int[22]
		{
			0, 2, 4, 6, 8, 10, 12, 14, 16, 20,
			24, 28, 32, 40, 48, 56, 68, 80, 96, 120,
			156, 200
		};

		private static void band_energy(Pointer<float> _out, Pointer<float> _ps, Pointer<int> _bands, int _nbands, Pointer<float> _in, int _nchannels, int _nframes, int _window_sz, int _step, int _downsample)
		{
			Pointer<float> pointer = Concentus.Common.CPlusPlus.Pointer.Malloc<float>((3 + _nchannels) * _window_sz);
			Pointer<float> pointer2 = pointer.Point(_window_sz);
			Pointer<float> pointer3 = pointer2.Point(_window_sz);
			Pointer<float> pointer4 = pointer3.Point(_window_sz);
			int num = _window_sz / 2;
			for (int i = 0; i < _window_sz; i++)
			{
				pointer[i] = (float)(0.5 - 0.5 * Math.Cos(Math.PI * 2.0 / (double)(_window_sz - 1) * (double)i));
			}
			for (int i = 0; i < _window_sz; i++)
			{
				pointer2[i] = (float)Math.Cos(Math.PI * 2.0 / (double)_window_sz * (double)i);
			}
			for (int i = 0; i < _window_sz; i++)
			{
				pointer3[i] = (float)Math.Sin(Math.PI * 2.0 / (double)_window_sz * (double)i);
			}
			for (int j = 0; j < _nframes; j++)
			{
				for (int k = 0; k < _nchannels; k++)
				{
					for (int l = 0; l < _window_sz; l++)
					{
						pointer4[k * _window_sz + l] = pointer[l] * _in[(j * _step + l) * _nchannels + k];
					}
				}
				int i;
				for (int m = (i = 0); m < _nbands; m++)
				{
					float[] array = new float[2];
					for (; i < _bands[m + 1]; i++)
					{
						for (int k = 0; k < _nchannels; k++)
						{
							int num2 = 0;
							float num4;
							float num3 = (num4 = 0f);
							for (int l = 0; l < _window_sz; l++)
							{
								num3 += pointer2[num2] * pointer4[k * _window_sz + l];
								num4 -= pointer3[num2] * pointer4[k * _window_sz + l];
								num2 += i;
								if (num2 >= _window_sz)
								{
									num2 -= _window_sz;
								}
							}
							num3 *= (float)_downsample;
							num4 *= (float)_downsample;
							_ps[(j * num + i) * _nchannels + k] = num3 * num3 + num4 * num4 + 100000f;
							array[k] += _ps[(j * num + i) * _nchannels + k];
						}
					}
					if (_out != null)
					{
						_out[(j * _nbands + m) * _nchannels] = array[0] / (float)(_bands[m + 1] - _bands[m]);
						if (_nchannels == 2)
						{
							_out[(j * _nbands + m) * _nchannels + 1] = array[1] / (float)(_bands[m + 1] - _bands[m]);
						}
					}
				}
			}
		}

		internal static float compare(float[] x, float[] y, int nchannels, int rate = 48000)
		{
			int num = x.Length;
			int num2 = y.Length;
			int num3 = 21;
			int num4 = 240;
			if (rate != 8000 && rate != 12000 && rate != 16000 && rate != 24000 && rate != 48000)
			{
				throw new ArgumentException("Sampling rate must be 8000, 12000, 16000, 24000, or 48000\n");
			}
			int num5;
			if (rate != 48000)
			{
				num5 = 48000 / rate;
				switch (rate)
				{
				case 8000:
					num3 = 13;
					break;
				case 12000:
					num3 = 15;
					break;
				case 16000:
					num3 = 17;
					break;
				case 24000:
					num3 = 19;
					break;
				}
				num4 = 240 / num5;
			}
			else
			{
				num5 = 1;
			}
			if (num != num2 * num5)
			{
				throw new ArgumentException("Sample counts do not match");
			}
			if (num < 480)
			{
				throw new ArgumentException("Insufficient sample data");
			}
			int num6 = (num - 480 + 120) / 120;
			Pointer<float> pointer = Concentus.Common.CPlusPlus.Pointer.Malloc<float>(num6 * 21 * nchannels);
			Pointer<float> pointer2 = Concentus.Common.CPlusPlus.Pointer.Malloc<float>(num6 * 240 * nchannels);
			Pointer<float> pointer3 = Concentus.Common.CPlusPlus.Pointer.Malloc<float>(num6 * num4 * nchannels);
			band_energy(pointer, pointer2, BANDS.GetPointer(), 21, x.GetPointer(), nchannels, num6, 480, 120, 1);
			band_energy(null, pointer3, BANDS.GetPointer(), num3, y.GetPointer(), nchannels, num6, 480 / num5, 120 / num5, num5);
			for (int i = 0; i < num6; i++)
			{
				int j;
				for (j = 1; j < 21; j++)
				{
					for (int k = 0; k < nchannels; k++)
					{
						pointer[(i * 21 + j) * nchannels + k] += 0.1f * pointer[(i * 21 + j - 1) * nchannels + k];
					}
				}
				j = 20;
				while (j-- > 0)
				{
					for (int k = 0; k < nchannels; k++)
					{
						pointer[(i * 21 + j) * nchannels + k] += 0.03f * pointer[(i * 21 + j + 1) * nchannels + k];
					}
				}
				if (i > 0)
				{
					for (j = 0; j < 21; j++)
					{
						for (int k = 0; k < nchannels; k++)
						{
							pointer[(i * 21 + j) * nchannels + k] += 0.5f * pointer[((i - 1) * 21 + j) * nchannels + k];
						}
					}
				}
				if (nchannels == 2)
				{
					for (j = 0; j < 21; j++)
					{
						float num7 = pointer[(i * 21 + j) * nchannels];
						float num8 = pointer[(i * 21 + j) * nchannels + 1];
						pointer[(i * 21 + j) * nchannels] += 0.01f * num8;
						pointer[(i * 21 + j) * nchannels + 1] += 0.01f * num7;
					}
				}
				for (j = 0; j < num3; j++)
				{
					for (int l = BANDS[j]; l < BANDS[j + 1]; l++)
					{
						for (int k = 0; k < nchannels; k++)
						{
							pointer2[(i * 240 + l) * nchannels + k] += 0.1f * pointer[(i * 21 + j) * nchannels + k];
							pointer3[(i * num4 + l) * nchannels + k] += 0.1f * pointer[(i * 21 + j) * nchannels + k];
						}
					}
				}
			}
			for (int j = 0; j < num3; j++)
			{
				for (int l = BANDS[j]; l < BANDS[j + 1]; l++)
				{
					for (int k = 0; k < nchannels; k++)
					{
						float num9 = pointer2[l * nchannels + k];
						float num10 = pointer3[l * nchannels + k];
						for (int i = 1; i < num6; i++)
						{
							float num11 = pointer2[(i * 240 + l) * nchannels + k];
							float num12 = pointer3[(i * num4 + l) * nchannels + k];
							pointer2[(i * 240 + l) * nchannels + k] += num9;
							pointer3[(i * num4 + l) * nchannels + k] += num10;
							num9 = num11;
							num10 = num12;
						}
					}
				}
			}
			int num13 = rate switch
			{
				48000 => BANDS[21], 
				12000 => BANDS[num3], 
				_ => BANDS[num3] - 3, 
			};
			double num14 = 0.0;
			for (int i = 0; i < num6; i++)
			{
				double num15 = 0.0;
				for (int j = 0; j < num3; j++)
				{
					double num16 = 0.0;
					for (int l = BANDS[j]; l < BANDS[j + 1] && l < num13; l++)
					{
						for (int k = 0; k < nchannels; k++)
						{
							float num17 = pointer3[(i * num4 + l) * nchannels + k] / pointer2[(i * 240 + l) * nchannels + k];
							float num18 = num17 - (float)Math.Log(num17) - 1f;
							if (l >= 79 && l <= 81)
							{
								num18 *= 0.1f;
							}
							if (l == 80)
							{
								num18 *= 0.1f;
							}
							num16 += (double)num18;
						}
					}
					num16 /= (double)((BANDS[j + 1] - BANDS[j]) * nchannels);
					num15 += num16 * num16;
				}
				num15 /= 21.0;
				num15 *= num15;
				num14 += num15 * num15;
			}
			num14 = Math.Pow(num14 / (double)num6, 0.0625);
			float result = (float)(100.0 * (1.0 - 0.5 * Math.Log(1.0 + num14) / Math.Log(1.13)));
			_ = 0f;
			return result;
		}
	}
	internal static class OpusConstants
	{
		public const int OPUS_AUTO = -1000;

		public const int OPUS_BITRATE_MAX = -1;

		public const int NB_FRAMES = 8;

		public const int NB_TBANDS = 18;

		public const int NB_TOT_BANDS = 21;

		public const int NB_TONAL_SKIP_BANDS = 9;

		public const int ANALYSIS_BUF_SIZE = 720;

		public const int DETECT_SIZE = 200;

		public const int MAX_ENCODER_BUFFER = 480;
	}
	internal class OpusException : Exception
	{
		public OpusException()
		{
		}

		public OpusException(string message)
			: base(message)
		{
		}

		public OpusException(string message, int opus_error_code)
			: base(message + ": " + CodecHelpers.opus_strerror(opus_error_code))
		{
		}
	}
	internal static class OpusMultistream
	{
		internal static int validate_layout(ChannelLayout layout)
		{
			int num = layout.nb_streams + layout.nb_coupled_streams;
			if (num > 255)
			{
				return 0;
			}
			for (int i = 0; i < layout.nb_channels; i++)
			{
				if (layout.mapping[i] >= num && layout.mapping[i] != byte.MaxValue)
				{
					return 0;
				}
			}
			return 1;
		}

		internal static int get_left_channel(ChannelLayout layout, int stream_id, int prev)
		{
			for (int i = ((prev >= 0) ? (prev + 1) : 0); i < layout.nb_channels; i++)
			{
				if (layout.mapping[i] == stream_id * 2)
				{
					return i;
				}
			}
			return -1;
		}

		internal static int get_right_channel(ChannelLayout layout, int stream_id, int prev)
		{
			for (int i = ((prev >= 0) ? (prev + 1) : 0); i < layout.nb_channels; i++)
			{
				if (layout.mapping[i] == stream_id * 2 + 1)
				{
					return i;
				}
			}
			return -1;
		}

		internal static int get_mono_channel(ChannelLayout layout, int stream_id, int prev)
		{
			for (int i = ((prev >= 0) ? (prev + 1) : 0); i < layout.nb_channels; i++)
			{
				if (layout.mapping[i] == stream_id + layout.nb_coupled_streams)
				{
					return i;
				}
			}
			return -1;
		}
	}
	internal static class Tables
	{
		internal static readonly float[] dct_table = new float[128]
		{
			0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f,
			0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.351851f, 0.33833f, 0.311806f, 0.2733f,
			0.224292f, 0.166664f, 0.102631f, 0.034654f, -0.034654f, -0.102631f, -0.166664f, -0.224292f, -0.2733f, -0.311806f,
			-0.33833f, -0.351851f, 0.34676f, 0.293969f, 0.196424f, 0.068975f, -0.068975f, -0.196424f, -0.293969f, -0.34676f,
			-0.34676f, -0.293969f, -0.196424f, -0.068975f, 0.068975f, 0.196424f, 0.293969f, 0.34676f, 0.33833f, 0.224292f,
			0.034654f, -0.166664f, -0.311806f, -0.351851f, -0.2733f, -0.102631f, 0.102631f, 0.2733f, 0.351851f, 0.311806f,
			0.166664f, -0.034654f, -0.224292f, -0.33833f, 0.326641f, 0.135299f, -0.135299f, -0.326641f, -0.326641f, -0.135299f,
			0.135299f, 0.326641f, 0.326641f, 0.135299f, -0.135299f, -0.326641f, -0.326641f, -0.135299f, 0.135299f, 0.326641f,
			0.311806f, 0.034654f, -0.2733f, -0.33833f, -0.102631f, 0.224292f, 0.351851f, 0.166664f, -0.166664f, -0.351851f,
			-0.224292f, 0.102631f, 0.33833f, 0.2733f, -0.034654f, -0.311806f, 0.293969f, -0.068975f, -0.34676f, -0.196424f,
			0.196424f, 0.34676f, 0.068975f, -0.293969f, -0.293969f, 0.068975f, 0.34676f, 0.196424f, -0.196424f, -0.34676f,
			-0.068975f, 0.293969f, 0.2733f, -0.166664f, -0.33833f, 0.034654f, 0.351851f, 0.102631f, -0.311806f, -0.224292f,
			0.224292f, 0.311806f, -0.102631f, -0.351851f, -0.034654f, 0.33833f, 0.166664f, -0.2733f
		};

		internal static readonly float[] analysis_window = new float[240]
		{
			4.3E-05f, 0.000171f, 0.000385f, 0.000685f, 0.001071f, 0.001541f, 0.002098f, 0.002739f, 0.003466f, 0.004278f,
			0.005174f, 0.006156f, 0.007222f, 0.008373f, 0.009607f, 0.010926f, 0.012329f, 0.013815f, 0.015385f, 0.017037f,
			0.018772f, 0.02059f, 0.02249f, 0.024472f, 0.026535f, 0.028679f, 0.030904f, 0.03321f, 0.035595f, 0.03806f,
			0.040604f, 0.043227f, 0.045928f, 0.048707f, 0.051564f, 0.054497f, 0.057506f, 0.060591f, 0.063752f, 0.066987f,
			0.070297f, 0.07368f, 0.077136f, 0.080665f, 0.084265f, 0.087937f, 0.091679f, 0.095492f, 0.099373f, 0.103323f,
			0.107342f, 0.111427f, 0.115579f, 0.119797f, 0.12408f, 0.128428f, 0.132839f, 0.137313f, 0.141849f, 0.146447f,
			0.151105f, 0.155823f, 0.1606f, 0.165435f, 0.170327f, 0.175276f, 0.18028f, 0.18534f, 0.190453f, 0.195619f,
			0.200838f, 0.206107f, 0.211427f, 0.216797f, 0.222215f, 0.22768f, 0.233193f, 0.238751f, 0.244353f, 0.25f,
			0.255689f, 0.261421f, 0.267193f, 0.273005f, 0.278856f, 0.284744f, 0.29067f, 0.296632f, 0.302628f, 0.308658f,
			0.314721f, 0.320816f, 0.326941f, 0.333097f, 0.33928f, 0.345492f, 0.351729f, 0.357992f, 0.36428f, 0.37059f,
			0.376923f, 0.383277f, 0.389651f, 0.396044f, 0.402455f, 0.408882f, 0.415325f, 0.421783f, 0.428254f, 0.434737f,
			0.441231f, 0.447736f, 0.454249f, 0.46077f, 0.467298f, 0.473832f, 0.48037f, 0.486912f, 0.493455f, 0.5f,
			0.506545f, 0.513088f, 0.51963f, 0.526168f, 0.532702f, 0.53923f, 0.545751f, 0.552264f, 0.558769f, 0.565263f,
			0.571746f, 0.578217f, 0.584675f, 0.591118f, 0.597545f, 0.603956f, 0.610349f, 0.616723f, 0.623077f, 0.62941f,
			0.63572f, 0.642008f, 0.648271f, 0.654508f, 0.66072f, 0.666903f, 0.673059f, 0.679184f, 0.685279f, 0.691342f,
			0.697372f, 0.703368f, 0.70933f, 0.715256f, 0.721144f, 0.726995f, 0.732807f, 0.738579f, 0.744311f, 0.75f,
			0.755647f, 0.761249f, 0.766807f, 0.77232f, 0.777785f, 0.783203f, 0.788573f, 0.793893f, 0.799162f, 0.804381f,
			0.809547f, 0.81466f, 0.81972f, 0.824724f, 0.829673f, 0.834565f, 0.8394f, 0.844177f, 0.848895f, 0.853553f,
			0.858151f, 0.862687f, 0.867161f, 0.871572f, 0.87592f, 0.880203f, 0.884421f, 0.888573f, 0.892658f, 0.896677f,
			0.900627f, 0.904508f, 0.908321f, 0.912063f, 0.915735f, 0.919335f, 0.922864f, 0.92632f, 0.929703f, 0.933013f,
			0.936248f, 0.939409f, 0.942494f, 0.945503f, 0.948436f, 0.951293f, 0.954072f, 0.956773f, 0.959396f, 0.96194f,
			0.964405f, 0.96679f, 0.969096f, 0.971321f, 0.973465f, 0.975528f, 0.97751f, 0.97941f, 0.981228f, 0.982963f,
			0.984615f, 0.986185f, 0.987671f, 0.989074f, 0.990393f, 0.991627f, 0.992778f, 0.993844f, 0.994826f, 0.995722f,
			0.996534f, 0.997261f, 0.997902f, 0.998459f, 0.998929f, 0.999315f, 0.999615f, 0.999829f, 0.999957f, 1f
		};

		internal static readonly int[] tbands = new int[19]
		{
			2, 4, 6, 8, 10, 12, 14, 16, 20, 24,
			28, 32, 40, 48, 56, 68, 80, 96, 120
		};

		internal static readonly int[] extra_bands = new int[22]
		{
			1, 2, 4, 6, 8, 10, 12, 14, 16, 20,
			24, 28, 32, 40, 48, 56, 68, 80, 96, 120,
			160, 200
		};

		internal static readonly float[] weights = new float[422]
		{
			-0.0941125f,
			-0.302976f,
			-0.603555f,
			-0.19393f,
			-0.185983f,
			-0.601617f,
			-0.0465317f,
			-0.114563f,
			-0.103599f,
			-0.618938f,
			-0.317859f,
			-0.169949f,
			-0.0702885f,
			0.148065f,
			0.409524f,
			0.548432f,
			0.367649f,
			-0.494393f,
			0.764306f,
			-1.83957f,
			0.170849f,
			12.786f,
			-1.08848f,
			-1.27284f,
			-16.2606f,
			24.1773f,
			-5.57454f,
			-0.17276f,
			-0.163388f,
			-0.224421f,
			-0.0948944f,
			-0.0728695f,
			-0.26557f,
			-0.100283f,
			-0.0515459f,
			-0.146142f,
			-0.120674f,
			-0.180655f,
			0.12857f,
			0.442138f,
			-0.493735f,
			0.167767f,
			0.206699f,
			-0.197567f,
			0.417999f,
			1.50364f,
			-0.773341f,
			-10.0401f,
			0.401872f,
			2.97966f,
			15.2165f,
			-1.88905f,
			-1.19254f,
			0.0285397f,
			-0.00405139f,
			0.0707565f,
			0.00825699f,
			-0.0927269f,
			-0.010393f,
			-0.00428882f,
			-0.00489743f,
			-0.0709731f,
			-0.00255992f,
			0.0395619f,
			0.226424f,
			0.0325231f,
			0.162175f,
			-0.100118f,
			0.485789f,
			0.12697f,
			0.285937f,
			0.0155637f,
			0.10546f,
			3.05558f,
			1.15059f,
			-1.00904f,
			-1.83088f,
			3.31766f,
			-3.42516f,
			-0.119135f,
			-0.0405654f,
			0.00690068f,
			0.0179877f,
			-0.0382487f,
			0.00597941f,
			-0.0183611f,
			0.00190395f,
			-0.144322f,
			-0.0435671f,
			0.000990594f,
			0.221087f,
			0.142405f,
			0.484066f,
			0.404395f,
			0.511955f,
			-0.237255f,
			0.241742f,
			0.35045f,
			-0.699428f,
			10.3993f,
			2.6507f,
			-2.43459f,
			-4.18838f,
			1.05928f,
			1.71067f,
			0.00667811f,
			-0.0721335f,
			-0.0397346f,
			0.0362704f,
			-0.11496f,
			-0.0235776f,
			0.0082161f,
			-0.0141741f,
			-0.0329699f,
			-0.0354253f,
			0.00277404f,
			-0.290654f,
			-1.14767f,
			-0.319157f,
			-0.686544f,
			0.36897f,
			0.478899f,
			0.182579f,
			-0.411069f,
			0.881104f,
			-4.60683f,
			1.4697f,
			325f / (356f * (float)Math.E),
			-1.81905f,
			-30.1699f,
			5.55225f,
			0.0019508f,
			-0.123576f,
			-0.0727332f,
			-0.0641597f,
			-0.0534458f,
			-0.108166f,
			-0.0937368f,
			-0.0697883f,
			-0.0275475f,
			-0.192309f,
			-0.110074f,
			0.285375f,
			-0.405597f,
			0.0926724f,
			-0.287881f,
			-0.851193f,
			-0.099493f,
			-0.233764f,
			-1.2852f,
			1.13611f,
			3.12168f,
			-0.0699f,
			-1.86216f,
			2.65292f,
			-7.31036f,
			2.44776f,
			-0.00111802f,
			-0.0632786f,
			-0.0376296f,
			-0.149851f,
			0.142963f,
			0.184368f,
			0.123433f,
			0.0756158f,
			0.117312f,
			0.0933395f,
			0.0692163f,
			0.0842592f,
			0.0704683f,
			0.0589963f,
			0.0942205f,
			-0.448862f,
			0.0262677f,
			0.270352f,
			-0.262317f,
			0.172586f,
			2.00227f,
			-0.159216f,
			0.038422f,
			10.2073f,
			4.15536f,
			-2.3407f,
			-0.0550265f,
			0.00964792f,
			-0.141336f,
			0.0274501f,
			0.0343921f,
			-0.0487428f,
			0.0950172f,
			-0.00775017f,
			-0.0372492f,
			-0.00548121f,
			-0.0663695f,
			0.0960506f,
			-0.200008f,
			-0.0412827f,
			0.58728f,
			0.0515787f,
			0.337254f,
			0.855024f,
			0.668371f,
			-0.114904f,
			-3.62962f,
			-0.467477f,
			-0.215472f,
			2.61537f,
			0.406117f,
			-1.36373f,
			0.0425394f,
			0.12208f,
			0.0934502f,
			0.123055f,
			0.0340935f,
			-0.142466f,
			0.035037f,
			-0.0490666f,
			0.0733208f,
			0.0576672f,
			0.123984f,
			-0.0517194f,
			-0.253018f,
			0.590565f,
			0.145849f,
			0.315185f,
			0.221534f,
			-0.149081f,
			0.216161f,
			-0.349575f,
			24.5664f,
			-0.994196f,
			0.614289f,
			-18.7905f,
			-2.83277f,
			-0.716801f,
			-0.347201f,
			0.479515f,
			-0.246027f,
			0.0758683f,
			0.137293f,
			-0.17781f,
			0.118751f,
			-0.00108329f,
			-0.237334f,
			0.355732f,
			-0.12991f,
			-0.0547627f,
			-0.318576f,
			-0.325524f,
			0.180494f,
			-0.0625604f,
			0.141219f,
			0.344064f,
			0.37658f,
			-0.591772f,
			5.8427f,
			-0.38075f,
			0.221894f,
			-1.41934f,
			-1879430f,
			1.34114f,
			0.0283355f,
			-0.0447856f,
			-0.0211466f,
			-0.0256927f,
			0.0139618f,
			0.0207934f,
			-0.0107666f,
			0.0110969f,
			0.0586069f,
			-0.0253545f,
			-0.0328433f,
			0.11872f,
			-0.216943f,
			0.145748f,
			0.119808f,
			-0.0915211f,
			-0.120647f,
			-0.0787719f,
			-0.143644f,
			-0.595116f,
			-1.152f,
			-1.25335f,
			-1.17092f,
			4.34023f,
			-975268f,
			-1.37033f,
			-0.0401123f,
			0.210602f,
			-0.136656f,
			0.135962f,
			-0.0523293f,
			0.0444604f,
			0.0143928f,
			0.00412666f,
			-0.0193003f,
			0.218452f,
			-0.110204f,
			-2.02563f,
			0.918238f,
			-2.45362f,
			1.19542f,
			-0.061362f,
			-1.92243f,
			0.308111f,
			0.49764f,
			0.912356f,
			0.209272f,
			-2.34525f,
			2.19326f,
			-6.47121f,
			1.69771f,
			-0.725123f,
			0.0118929f,
			0.0377944f,
			0.0554003f,
			0.0226452f,
			-0.0704421f,
			-0.0300309f,
			0.0122978f,
			-0.0041782f,
			-0.0686612f,
			0.0313115f,
			0.039111f,
			0.364111f,
			-0.0945548f,
			0.0229876f,
			-0.17414f,
			0.329795f,
			0.114714f,
			0.30022f,
			0.106997f,
			0.132355f,
			5.79932f,
			0.908058f,
			-0.905324f,
			-3.3561f,
			0.190647f,
			0.184211f,
			-0.673648f,
			0.231807f,
			-0.0586222f,
			0.230752f,
			-0.438277f,
			0.245857f,
			-0.17215f,
			0.0876383f,
			-0.720512f,
			0.162515f,
			0.0170571f,
			0.101781f,
			0.388477f,
			1.32931f,
			1.08548f,
			-0.936301f,
			-2.36958f,
			-6.71988f,
			-3.44376f,
			2.13818f,
			14.2318f,
			4.91459f,
			-3.09052f,
			-9.69191f,
			-0.768234f,
			1.79604f,
			0.0549653f,
			0.163399f,
			0.0797025f,
			0.0343933f,
			-0.0555876f,
			-0.00505673f,
			0.0187258f,
			0.0326628f,
			0.0231486f,
			0.15573f,
			0.0476223f,
			-0.254824f,
			1.60155f,
			-0.801221f,
			2.55496f,
			0.737629f,
			-1.36249f,
			-0.695463f,
			-2.44301f,
			-1.73188f,
			3.95279f,
			1.89068f,
			0.486087f,
			-11.3343f,
			3941600f,
			-0.381439f,
			0.12115f,
			-0.906927f,
			2.93878f,
			1.6388f,
			0.882811f,
			0.874344f,
			1.21726f,
			-0.874545f,
			0.321706f,
			0.785055f,
			0.946558f,
			-0.575066f,
			-3.46553f,
			0.884905f,
			0.0924047f,
			-9.90712f,
			0.391338f,
			0.160103f,
			-2.04954f,
			4.1455f,
			0.0684029f,
			-0.144761f,
			-0.285282f,
			0.379244f,
			-1.1584f,
			-0.0277241f,
			-9.85f,
			-4.82386f,
			3.71333f,
			3.87308f,
			3.52558f
		};

		internal static readonly int[] topo = new int[3] { 25, 15, 2 };

		internal static readonly MLP net = new MLP
		{
			layers = 3,
			topo = topo,
			weights = weights
		};

		internal static readonly float[] tansig_table = new float[201]
		{
			0f, 0.039979f, 0.07983f, 0.119427f, 0.158649f, 0.197375f, 0.235496f, 0.272905f, 0.309507f, 0.345214f,
			0.379949f, 0.413644f, 0.446244f, 0.4777f, 0.507977f, 0.53705f, 0.5649f, 0.591519f, 0.616909f, 0.641077f,
			0.664037f, 0.685809f, 0.706419f, 0.725897f, 0.744277f, 0.761594f, 0.777888f, 0.793199f, 0.807569f, 0.82104f,
			0.833655f, 0.845456f, 0.856485f, 0.866784f, 0.876393f, 0.885352f, 0.893698f, 0.901468f, 0.908698f, 0.91542f,
			0.921669f, 0.927473f, 0.932862f, 0.937863f, 0.942503f, 0.946806f, 0.950795f, 0.954492f, 0.957917f, 0.96109f,
			0.964028f, 0.966747f, 0.969265f, 0.971594f, 0.973749f, 0.975743f, 0.977587f, 0.979293f, 0.980869f, 0.982327f,
			0.983675f, 0.984921f, 0.986072f, 0.987136f, 0.988119f, 0.989027f, 0.989867f, 0.990642f, 0.991359f, 0.99202f,
			0.992631f, 0.993196f, 0.993718f, 0.994199f, 0.994644f, 0.995055f, 0.995434f, 0.995784f, 0.996108f, 0.996407f,
			0.996682f, 0.996937f, 0.997172f, 0.997389f, 0.99759f, 0.997775f, 0.997946f, 0.998104f, 0.998249f, 0.998384f,
			0.998508f, 0.998623f, 0.998728f, 0.998826f, 0.998916f, 0.999f, 0.999076f, 0.999147f, 0.999213f, 0.999273f,
			0.999329f, 0.999381f, 0.999428f, 0.999472f, 0.999513f, 0.99955f, 0.999585f, 0.999617f, 0.999646f, 0.999673f,
			0.999699f, 0.999722f, 0.999743f, 0.999763f, 0.999781f, 0.999798f, 0.999813f, 0.999828f, 0.999841f, 0.999853f,
			0.999865f, 0.999875f, 0.999885f, 0.999893f, 0.999902f, 0.999909f, 0.999916f, 0.999923f, 0.999929f, 0.999934f,
			0.999939f, 0.999944f, 0.999948f, 0.999952f, 0.999956f, 0.999959f, 0.999962f, 0.999965f, 0.999968f, 0.99997f,
			0.999973f, 0.999975f, 0.999977f, 0.999978f, 0.99998f, 0.999982f, 0.999983f, 0.999984f, 0.999986f, 0.999987f,
			0.999988f, 0.999989f, 0.99999f, 0.99999f, 0.999991f, 0.999992f, 0.999992f, 0.999993f, 0.999994f, 0.999994f,
			0.999994f, 0.999995f, 0.999995f, 0.999996f, 0.999996f, 0.999996f, 0.999997f, 0.999997f, 0.999997f, 0.999997f,
			0.999997f, 0.999998f, 0.999998f, 0.999998f, 0.999998f, 0.999998f, 0.999998f, 0.999999f, 0.999999f, 0.999999f,
			0.999999f, 0.999999f, 0.999999f, 0.999999f, 0.999999f, 0.999999f, 0.999999f, 0.999999f, 0.999999f, 0.999999f,
			1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f,
			1f
		};

		internal static readonly int[] mono_voice_bandwidth_thresholds = new int[8] { 11000, 1000, 14000, 1000, 17000, 1000, 21000, 2000 };

		internal static readonly int[] mono_music_bandwidth_thresholds = new int[8] { 12000, 1000, 15000, 1000, 18000, 2000, 22000, 2000 };

		internal static readonly int[] stereo_voice_bandwidth_thresholds = new int[8] { 11000, 1000, 14000, 1000, 21000, 2000, 28000, 2000 };

		internal static readonly int[] stereo_music_bandwidth_thresholds = new int[8] { 12000, 1000, 18000, 2000, 21000, 2000, 30000, 2000 };

		public const int stereo_voice_threshold = 30000;

		public const int stereo_music_threshold = 30000;

		internal static readonly int[][] mode_thresholds = new int[2][]
		{
			new int[2] { 64000, 16000 },
			new int[2] { 36000, 16000 }
		};
	}
}
namespace Concentus.Silk
{
	internal static class ApplySineWindow
	{
		private static readonly short[] freq_table_Q16 = new short[27]
		{
			12111, 9804, 8235, 7100, 6239, 5565, 5022, 4575, 4202, 3885,
			3612, 3375, 3167, 2984, 2820, 2674, 2542, 2422, 2313, 2214,
			2123, 2038, 1961, 1889, 1822, 1760, 1702
		};

		internal static void silk_apply_sine_window(short[] px_win, int px_win_ptr, short[] px, int px_ptr, int win_type, int length)
		{
			int num = (length >> 2) - 4;
			int num2 = freq_table_Q16[num];
			int num3 = Inlines.silk_SMULWB(num2, -num2);
			int num4;
			int num5;
			if (win_type == 1)
			{
				num4 = 0;
				num5 = num2 + Inlines.silk_RSHIFT(length, 3);
			}
			else
			{
				num4 = 65536;
				num5 = 65536 + Inlines.silk_RSHIFT(num3, 1) + Inlines.silk_RSHIFT(length, 4);
			}
			for (num = 0; num < length; num += 4)
			{
				int num6 = px_win_ptr + num;
				int num7 = px_ptr + num;
				px_win[num6] = (short)Inlines.silk_SMULWB(Inlines.silk_RSHIFT(num4 + num5, 1), px[num7]);
				px_win[num6 + 1] = (short)Inlines.silk_SMULWB(num5, px[num7 + 1]);
				num4 = Inlines.silk_SMULWB(num5, num3) + Inlines.silk_LSHIFT(num5, 1) - num4 + 1;
				num4 = Inlines.silk_min(num4, 65536);
				px_win[num6 + 2] = (short)Inlines.silk_SMULWB(Inlines.silk_RSHIFT(num4 + num5, 1), px[num7 + 2]);
				px_win[num6 + 3] = (short)Inlines.silk_SMULWB(num4, px[num7 + 3]);
				num5 = Inlines.silk_SMULWB(num4, num3) + Inlines.silk_LSHIFT(num4, 1) - num5;
				num5 = Inlines.silk_min(num5, 65536);
			}
		}
	}
	internal static class BurgModified
	{
		private const int MAX_FRAME_SIZE = 384;

		private const int QA = 25;

		private const int N_BITS_HEAD_ROOM = 2;

		private const int MIN_RSHIFTS = -16;

		private const int MAX_RSHIFTS = 7;

		internal static void silk_burg_modified(BoxedValueInt res_nrg, BoxedValueInt res_nrg_Q, int[] A_Q16, short[] x, int x_ptr, int minInvGain_Q30, int subfr_length, int nb_subfr, int D)
		{
			int[] array = new int[16];
			int[] array2 = new int[16];
			int[] array3 = new int[16];
			int[] array4 = new int[17];
			int[] array5 = new int[17];
			int[] array6 = new int[16];
			long num = Inlines.silk_inner_prod16_aligned_64(x, x_ptr, x, x_ptr, subfr_length * nb_subfr);
			int num2 = Inlines.silk_CLZ64(num);
			int num3 = 35 - num2;
			if (num3 > 7)
			{
				num3 = 7;
			}
			if (num3 < -16)
			{
				num3 = -16;
			}
			int num4 = (int)((num3 <= 0) ? Inlines.silk_LSHIFT32((int)num, -num3) : Inlines.silk_RSHIFT64(num, num3));
			array5[0] = (array4[0] = num4 + Inlines.silk_SMMUL(42950, num4) + 1);
			Arrays.MemSetInt(array, 0, 16);
			if (num3 > 0)
			{
				for (int i = 0; i < nb_subfr; i++)
				{
					int num5 = x_ptr + i * subfr_length;
					for (int j = 1; j < D + 1; j++)
					{
						array[j - 1] += (int)Inlines.silk_RSHIFT64(Inlines.silk_inner_prod16_aligned_64(x, num5, x, num5 + j, subfr_length - j), num3);
					}
				}
			}
			else
			{
				for (int i = 0; i < nb_subfr; i++)
				{
					int num5 = x_ptr + i * subfr_length;
					CeltPitchXCorr.pitch_xcorr(x, num5, x, num5 + 1, array6, subfr_length - D, D);
					for (int j = 1; j < D + 1; j++)
					{
						int k = j + subfr_length - D;
						int num6 = 0;
						for (; k < subfr_length; k++)
						{
							num6 = Inlines.MAC16_16(num6, x[num5 + k], x[num5 + k - j]);
						}
						array6[j - 1] += num6;
					}
					for (int j = 1; j < D + 1; j++)
					{
						array[j - 1] += Inlines.silk_LSHIFT32(array6[j - 1], -num3);
					}
				}
			}
			Array.Copy(array, array2, 16);
			array5[0] = (array4[0] = num4 + Inlines.silk_SMMUL(42950, num4) + 1);
			int num7 = 1073741824;
			int num8 = 0;
			for (int j = 0; j < D; j++)
			{
				int num9;
				int num10;
				if (num3 > -2)
				{
					for (int i = 0; i < nb_subfr; i++)
					{
						int num5 = x_ptr + i * subfr_length;
						int b = -Inlines.silk_LSHIFT32(x[num5 + j], 16 - num3);
						int b2 = -Inlines.silk_LSHIFT32(x[num5 + subfr_length - j - 1], 16 - num3);
						num9 = Inlines.silk_LSHIFT32(x[num5 + j], 9);
						num10 = Inlines.silk_LSHIFT32(x[num5 + subfr_length - j - 1], 9);
						for (int l = 0; l < j; l++)
						{
							array[l] = Inlines.silk_SMLAWB(array[l], b, x[num5 + j - l - 1]);
							array2[l] = Inlines.silk_SMLAWB(array2[l], b2, x[num5 + subfr_length - j + l]);
							int b3 = array3[l];
							num9 = Inlines.silk_SMLAWB(num9, b3, x[num5 + j - l - 1]);
							num10 = Inlines.silk_SMLAWB(num10, b3, x[num5 + subfr_length - j + l]);
						}
						num9 = Inlines.silk_LSHIFT32(-num9, 7 - num3);
						num10 = Inlines.silk_LSHIFT32(-num10, 7 - num3);
						for (int l = 0; l <= j; l++)
						{
							array4[l] = Inlines.silk_SMLAWB(array4[l], num9, x[num5 + j - l]);
							array5[l] = Inlines.silk_SMLAWB(array5[l], num10, x[num5 + subfr_length - j + l - 1]);
						}
					}
				}
				else
				{
					for (int i = 0; i < nb_subfr; i++)
					{
						int num5 = x_ptr + i * subfr_length;
						int b = -Inlines.silk_LSHIFT32(x[num5 + j], -num3);
						int b2 = -Inlines.silk_LSHIFT32(x[num5 + subfr_length - j - 1], -num3);
						num9 = Inlines.silk_LSHIFT32(x[num5 + j], 17);
						num10 = Inlines.silk_LSHIFT32(x[num5 + subfr_length - j - 1], 17);
						for (int l = 0; l < j; l++)
						{
							array[l] = Inlines.silk_MLA(array[l], b, x[num5 + j - l - 1]);
							array2[l] = Inlines.silk_MLA(array2[l], b2, x[num5 + subfr_length - j + l]);
							int c = Inlines.silk_RSHIFT_ROUND(array3[l], 8);
							num9 = Inlines.silk_MLA(num9, x[num5 + j - l - 1], c);
							num10 = Inlines.silk_MLA(num10, x[num5 + subfr_length - j + l], c);
						}
						num9 = -num9;
						num10 = -num10;
						for (int l = 0; l <= j; l++)
						{
							array4[l] = Inlines.silk_SMLAWW(array4[l], num9, Inlines.silk_LSHIFT32(x[num5 + j - l], -num3 - 1));
							array5[l] = Inlines.silk_SMLAWW(array5[l], num10, Inlines.silk_LSHIFT32(x[num5 + subfr_length - j + l - 1], -num3 - 1));
						}
					}
				}
				num9 = array[j];
				num10 = array2[j];
				int a = 0;
				int num11 = Inlines.silk_ADD32(array5[0], array4[0]);
				for (int l = 0; l < j; l++)
				{
					int b3 = array3[l];
					num2 = Inlines.silk_CLZ32(Inlines.silk_abs(b3)) - 1;
					num2 = Inlines.silk_min(7, num2);
					int c = Inlines.silk_LSHIFT32(b3, num2);
					num9 = Inlines.silk_ADD_LSHIFT32(num9, Inlines.silk_SMMUL(array2[j - l - 1], c), 7 - num2);
					num10 = Inlines.silk_ADD_LSHIFT32(num10, Inlines.silk_SMMUL(array[j - l - 1], c), 7 - num2);
					a = Inlines.silk_ADD_LSHIFT32(a, Inlines.silk_SMMUL(array5[j - l], c), 7 - num2);
					num11 = Inlines.silk_ADD_LSHIFT32(num11, Inlines.silk_SMMUL(Inlines.silk_ADD32(array5[l + 1], array4[l + 1]), c), 7 - num2);
				}
				array4[j + 1] = num9;
				array5[j + 1] = num10;
				a = Inlines.silk_ADD32(a, num10);
				a = Inlines.silk_LSHIFT32(-a, 1);
				int num12 = ((Inlines.silk_abs(a) >= num11) ? ((a > 0) ? int.MaxValue : int.MinValue) : Inlines.silk_DIV32_varQ(a, num11, 31));
				num9 = 1073741824 - Inlines.silk_SMMUL(num12, num12);
				num9 = Inlines.silk_LSHIFT(Inlines.silk_SMMUL(num7, num9), 2);
				if (num9 <= minInvGain_Q30)
				{
					num10 = 1073741824 - Inlines.silk_DIV32_varQ(minInvGain_Q30, num7, 30);
					num12 = Inlines.silk_SQRT_APPROX(num10);
					num12 = Inlines.silk_RSHIFT32(num12 + Inlines.silk_DIV32(num10, num12), 1);
					num12 = Inlines.silk_LSHIFT32(num12, 16);
					if (a < 0)
					{
						num12 = -num12;
					}
					num7 = minInvGain_Q30;
					num8 = 1;
				}
				else
				{
					num7 = num9;
				}
				for (int l = 0; l < j + 1 >> 1; l++)
				{
					num9 = array3[l];
					num10 = array3[j - l - 1];
					array3[l] = Inlines.silk_ADD_LSHIFT32(num9, Inlines.silk_SMMUL(num10, num12), 1);
					array3[j - l - 1] = Inlines.silk_ADD_LSHIFT32(num10, Inlines.silk_SMMUL(num9, num12), 1);
				}
				array3[j] = Inlines.silk_RSHIFT32(num12, 6);
				if (num8 != 0)
				{
					for (int l = j + 1; l < D; l++)
					{
						array3[l] = 0;
					}
					break;
				}
				for (int l = 0; l <= j + 1; l++)
				{
					num9 = array4[l];
					num10 = array5[j - l + 1];
					array4[l] = Inlines.silk_ADD_LSHIFT32(num9, Inlines.silk_SMMUL(num10, num12), 1);
					array5[j - l + 1] = Inlines.silk_ADD_LSHIFT32(num10, Inlines.silk_SMMUL(num9, num12), 1);
				}
			}
			if (num8 != 0)
			{
				for (int l = 0; l < D; l++)
				{
					A_Q16[l] = -Inlines.silk_RSHIFT_ROUND(array3[l], 9);
				}
				if (num3 > 0)
				{
					for (int i = 0; i < nb_subfr; i++)
					{
						int num5 = x_ptr + i * subfr_length;
						num4 -= (int)Inlines.silk_RSHIFT64(Inlines.silk_inner_prod16_aligned_64(x, num5, x, num5, D), num3);
					}
				}
				else
				{
					for (int i = 0; i < nb_subfr; i++)
					{
						int num5 = x_ptr + i * subfr_length;
						num4 -= Inlines.silk_LSHIFT32(Inlines.silk_inner_prod_self(x, num5, D), -num3);
					}
				}
				res_nrg.Val = Inlines.silk_LSHIFT(Inlines.silk_SMMUL(num7, num4), 2);
				res_nrg_Q.Val = -num3;
			}
			else
			{
				int num11 = array4[0];
				int num9 = 65536;
				for (int l = 0; l < D; l++)
				{
					int c = Inlines.silk_RSHIFT_ROUND(array3[l], 9);
					num11 = Inlines.silk_SMLAWW(num11, array4[l + 1], c);
					num9 = Inlines.silk_SMLAWW(num9, c, c);
					A_Q16[l] = -c;
				}
				res_nrg.Val = Inlines.silk_SMLAWW(num11, Inlines.silk_SMMUL(42950, num4), -num9);
				res_nrg_Q.Val = -num3;
			}
		}
	}
	internal static class BWExpander
	{
		internal static void silk_bwexpander_32(int[] ar, int d, int chirp_Q16)
		{
			int b = chirp_Q16 - 65536;
			for (int i = 0; i < d - 1; i++)
			{
				ar[i] = Inlines.silk_SMULWW(chirp_Q16, ar[i]);
				chirp_Q16 += Inlines.silk_RSHIFT_ROUND(Inlines.silk_MUL(chirp_Q16, b), 16);
			}
			ar[d - 1] = Inlines.silk_SMULWW(chirp_Q16, ar[d - 1]);
		}

		internal static void silk_bwexpander(short[] ar, int d, int chirp_Q16)
		{
			int b = chirp_Q16 - 65536;
			for (int i = 0; i < d - 1; i++)
			{
				ar[i] = (short)Inlines.silk_RSHIFT_ROUND(Inlines.silk_MUL(chirp_Q16, ar[i]), 16);
				chirp_Q16 += Inlines.silk_RSHIFT_ROUND(Inlines.silk_MUL(chirp_Q16, b), 16);
			}
			ar[d - 1] = (short)Inlines.silk_RSHIFT_ROUND(Inlines.silk_MUL(chirp_Q16, ar[d - 1]), 16);
		}
	}
	internal static class CNG
	{
		internal static void silk_CNG_exc(int[] exc_Q10, int exc_Q10_ptr, int[] exc_buf_Q14, int Gain_Q16, int length, ref int rand_seed)
		{
			int num;
			for (num = 255; num > length; num = Inlines.silk_RSHIFT(num, 1))
			{
			}
			int num2 = rand_seed;
			for (int i = exc_Q10_ptr; i < exc_Q10_ptr + length; i++)
			{
				num2 = Inlines.silk_RAND(num2);
				int num3 = Inlines.silk_RSHIFT(num2, 24) & num;
				exc_Q10[i] = (short)Inlines.silk_SAT16(Inlines.silk_SMULWW(exc_buf_Q14[num3], Gain_Q16 >> 4));
			}
			rand_seed = num2;
		}

		internal static void silk_CNG_Reset(SilkChannelDecoder psDec)
		{
			int num = Inlines.silk_DIV32_16(32767, (short)(psDec.LPC_order + 1));
			int num2 = 0;
			for (int i = 0; i < psDec.LPC_order; i++)
			{
				num2 += num;
				psDec.sCNG.CNG_smth_NLSF_Q15[i] = (short)num2;
			}
			psDec.sCNG.CNG_smth_Gain_Q16 = 0;
			psDec.sCNG.rand_seed = 3176576;
		}

		internal static void silk_CNG(SilkChannelDecoder psDec, SilkDecoderControl psDecCtrl, short[] frame, int frame_ptr, int length)
		{
			short[] array = new short[psDec.LPC_order];
			CNGState sCNG = psDec.sCNG;
			if (psDec.fs_kHz != sCNG.fs_kHz)
			{
				silk_CNG_Reset(psDec);
				sCNG.fs_kHz = psDec.fs_kHz;
			}
			if (psDec.lossCnt == 0 && psDec.prevSignalType == 0)
			{
				for (int i = 0; i < psDec.LPC_order; i++)
				{
					sCNG.CNG_smth_NLSF_Q15[i] += (short)Inlines.silk_SMULWB(psDec.prevNLSF_Q15[i] - sCNG.CNG_smth_NLSF_Q15[i], 16348);
				}
				int num = 0;
				for (int i = 0; i < psDec.nb_subfr; i++)
				{
					if (psDecCtrl.Gains_Q16[i] > num)
					{
						num = psDecCtrl.Gains_Q16[i];
					}
				}
				Arrays.MemMoveInt(sCNG.CNG_exc_buf_Q14, 0, psDec.subfr_length, (psDec.nb_subfr - 1) * psDec.subfr_length);
				for (int i = 0; i < psDec.nb_subfr; i++)
				{
					sCNG.CNG_smth_Gain_Q16 += Inlines.silk_SMULWB(psDecCtrl.Gains_Q16[i] - sCNG.CNG_smth_Gain_Q16, 4634);
				}
			}
			if (psDec.lossCnt != 0)
			{
				int[] array2 = new int[length + 16];
				int num2 = Inlines.silk_SMULWW(psDec.sPLC.randScale_Q14, psDec.sPLC.prevGain_Q16[1]);
				if (num2 >= 2097152 || sCNG.CNG_smth_Gain_Q16 > 8388608)
				{
					num2 = Inlines.silk_SMULTT(num2, num2);
					num2 = Inlines.silk_SUB_LSHIFT32(Inlines.silk_SMULTT(sCNG.CNG_smth_Gain_Q16, sCNG.CNG_smth_Gain_Q16), num2, 5);
					num2 = Inlines.silk_LSHIFT32(Inlines.silk_SQRT_APPROX(num2), 16);
				}
				else
				{
					num2 = Inlines.silk_SMULWW(num2, num2);
					num2 = Inlines.silk_SUB_LSHIFT32(Inlines.silk_SMULWW(sCNG.CNG_smth_Gain_Q16, sCNG.CNG_smth_Gain_Q16), num2, 5);
					num2 = Inlines.silk_LSHIFT32(Inlines.silk_SQRT_APPROX(num2), 8);
				}
				silk_CNG_exc(array2, 16, sCNG.CNG_exc_buf_Q14, num2, length, ref sCNG.rand_seed);
				NLSF.silk_NLSF2A(array, sCNG.CNG_smth_NLSF_Q15, psDec.LPC_order);
				Array.Copy(sCNG.CNG_synth_state, array2, 16);
				for (int i = 0; i < length; i++)
				{
					int num3 = 16 + i;
					int a = Inlines.silk_RSHIFT(psDec.LPC_order, 1);
					a = Inlines.silk_SMLAWB(a, array2[num3 - 1], array[0]);
					a = Inlines.silk_SMLAWB(a, array2[num3 - 2], array[1]);
					a = Inlines.silk_SMLAWB(a, array2[num3 - 3], array[2]);
					a = Inlines.silk_SMLAWB(a, array2[num3 - 4], array[3]);
					a = Inlines.silk_SMLAWB(a, array2[num3 - 5], array[4]);
					a = Inlines.silk_SMLAWB(a, array2[num3 - 6], array[5]);
					a = Inlines.silk_SMLAWB(a, array2[num3 - 7], array[6]);
					a = Inlines.silk_SMLAWB(a, array2[num3 - 8], array[7]);
					a = Inlines.silk_SMLAWB(a, array2[num3 - 9], array[8]);
					a = Inlines.silk_SMLAWB(a, array2[num3 - 10], array[9]);
					if (psDec.LPC_order == 16)
					{
						a = Inlines.silk_SMLAWB(a, array2[num3 - 11], array[10]);
						a = Inlines.silk_SMLAWB(a, array2[num3 - 12], array[11]);
						a = Inlines.silk_SMLAWB(a, array2[num3 - 13], array[12]);
						a = Inlines.silk_SMLAWB(a, array2[num3 - 14], array[13]);
						a = Inlines.silk_SMLAWB(a, array2[num3 - 15], array[14]);
						a = Inlines.silk_SMLAWB(a, array2[num3 - 16], array[15]);
					}
					array2[num3] = Inlines.silk_ADD_LSHIFT(array2[num3], a, 4);
					frame[frame_ptr + i] = Inlines.silk_ADD_SAT16(frame[frame_ptr + i], (short)Inlines.silk_RSHIFT_ROUND(array2[num3], 10));
				}
				Array.Copy(array2, length, sCNG.CNG_synth_state, 0, 16);
			}
			else
			{
				Arrays.MemSetInt(sCNG.CNG_synth_state, 0, psDec.LPC_order);
			}
		}
	}
	internal static class CodeSigns
	{
		private static int silk_enc_map(int a)
		{
			return Inlines.silk_RSHIFT(a, 15) + 1;
		}

		private static int silk_dec_map(int a)
		{
			return Inlines.silk_LSHIFT(a, 1) - 1;
		}

		internal static void silk_encode_signs(EntropyCoder psRangeEnc, sbyte[] pulses, int length, int signalType, int quantOffsetType, int[] sum_pulses)
		{
			byte[] array = new byte[2];
			byte[] silk_sign_iCDF = Tables.silk_sign_iCDF;
			array[1] = 0;
			int num = 0;
			int num2 = Inlines.silk_SMULBB(7, Inlines.silk_ADD_LSHIFT(quantOffsetType, signalType, 1));
			int num3 = num2;
			length = Inlines.silk_RSHIFT(length + 8, 4);
			for (num2 = 0; num2 < length; num2++)
			{
				int num4 = sum_pulses[num2];
				if (num4 > 0)
				{
					array[0] = silk_sign_iCDF[num3 + Inlines.silk_min(num4 & 0x1F, 6)];
					for (int i = num; i < num + 16; i++)
					{
						if (pulses[i] != 0)
						{
							psRangeEnc.enc_icdf(silk_enc_map(pulses[i]), array, 8u);
						}
					}
				}
				num += 16;
			}
		}

		internal static void silk_decode_signs(EntropyCoder psRangeDec, short[] pulses, int length, int signalType, int quantOffsetType, int[] sum_pulses)
		{
			byte[] array = new byte[2];
			byte[] silk_sign_iCDF = Tables.silk_sign_iCDF;
			array[1] = 0;
			int num = 0;
			int num2 = Inlines.silk_SMULBB(7, Inlines.silk_ADD_LSHIFT(quantOffsetType, signalType, 1));
			int num3 = num2;
			length = Inlines.silk_RSHIFT(length + 8, 4);
			for (num2 = 0; num2 < length; num2++)
			{
				int num4 = sum_pulses[num2];
				if (num4 > 0)
				{
					array[0] = silk_sign_iCDF[num3 + Inlines.silk_min(num4 & 0x1F, 6)];
					for (int i = 0; i < 16; i++)
					{
						if (pulses[num + i] > 0)
						{
							pulses[num + i] *= (short)silk_dec_map(psRangeDec.dec_icdf(array, 8u));
						}
					}
				}
				num += 16;
			}
		}
	}
	internal static class CorrelateMatrix
	{
		internal static void silk_corrVector(short[] x, int x_ptr, short[] t, int t_ptr, int L, int order, int[] Xt, int rshifts)
		{
			int num = x_ptr + order - 1;
			if (rshifts > 0)
			{
				for (int i = 0; i < order; i++)
				{
					int num2 = 0;
					for (int j = 0; j < L; j++)
					{
						num2 += Inlines.silk_RSHIFT32(Inlines.silk_SMULBB(x[num + j], t[t_ptr + j]), rshifts);
					}
					Xt[i] = num2;
					num--;
				}
			}
			else
			{
				for (int i = 0; i < order; i++)
				{
					Xt[i] = Inlines.silk_inner_prod(x, num, t, t_ptr, L);
					num--;
				}
			}
		}

		internal static void silk_corrMatrix(short[] x, int x_ptr, int L, int order, int head_room, int[] XX, int XX_ptr, BoxedValueInt rshifts)
		{
			SumSqrShift.silk_sum_sqr_shift(out var energy, out var shift, x, x_ptr, L + order - 1);
			int num = Inlines.silk_max(head_room - Inlines.silk_CLZ32(energy), 0);
			energy = Inlines.silk_RSHIFT32(energy, num);
			shift += num;
			for (int i = x_ptr; i < x_ptr + order - 1; i++)
			{
				energy -= Inlines.silk_RSHIFT32(Inlines.silk_SMULBB(x[i], x[i]), shift);
			}
			if (shift < rshifts.Val)
			{
				energy = Inlines.silk_RSHIFT32(energy, rshifts.Val - shift);
				shift = rshifts.Val;
			}
			Inlines.MatrixSet(XX, XX_ptr, 0, 0, order, energy);
			int num2 = x_ptr + order - 1;
			for (int j = 1; j < order; j++)
			{
				energy = Inlines.silk_SUB32(energy, Inlines.silk_RSHIFT32(Inlines.silk_SMULBB(x[num2 + L - j], x[num2 + L - j]), shift));
				energy = Inlines.silk_ADD32(energy, Inlines.silk_RSHIFT32(Inlines.silk_SMULBB(x[num2 - j], x[num2 - j]), shift));
				Inlines.MatrixSet(XX, XX_ptr, j, j, order, energy);
			}
			int num3 = x_ptr + order - 2;
			if (shift > 0)
			{
				for (int k = 1; k < order; k++)
				{
					energy = 0;
					for (int i = 0; i < L; i++)
					{
						energy += Inlines.silk_RSHIFT32(Inlines.silk_SMULBB(x[num2 + i], x[num3 + i]), shift);
					}
					Inlines.MatrixSet(XX, XX_ptr, k, 0, order, energy);
					Inlines.MatrixSet(XX, XX_ptr, 0, k, order, energy);
					for (int j = 1; j < order - k; j++)
					{
						energy = Inlines.silk_SUB32(energy, Inlines.silk_RSHIFT32(Inlines.silk_SMULBB(x[num2 + L - j], x[num3 + L - j]), shift));
						energy = Inlines.silk_ADD32(energy, Inlines.silk_RSHIFT32(Inlines.silk_SMULBB(x[num2 - j], x[num3 - j]), shift));
						Inlines.MatrixSet(XX, XX_ptr, k + j, j, order, energy);
						Inlines.MatrixSet(XX, XX_ptr, j, k + j, order, energy);
					}
					num3--;
				}
			}
			else
			{
				for (int k = 1; k < order; k++)
				{
					energy = Inlines.silk_inner_prod(x, num2, x, num3, L);
					Inlines.MatrixSet(XX, XX_ptr, k, 0, order, energy);
					Inlines.MatrixSet(XX, XX_ptr, 0, k, order, energy);
					for (int j = 1; j < order - k; j++)
					{
						energy = Inlines.silk_SUB32(energy, Inlines.silk_SMULBB(x[num2 + L - j], x[num3 + L - j]));
						energy = Inlines.silk_SMLABB(energy, x[num2 - j], x[num3 - j]);
						Inlines.MatrixSet(XX, XX_ptr, k + j, j, order, energy);
						Inlines.MatrixSet(XX, XX_ptr, j, k + j, order, energy);
					}
					num3--;
				}
			}
			rshifts.Val = shift;
		}
	}
	internal static class DecodeAPI
	{
		internal static int silk_InitDecoder(SilkDecoder decState)
		{
			decState.Reset();
			int result = SilkError.SILK_NO_ERROR;
			SilkChannelDecoder[] channel_state = decState.channel_state;
			for (int i = 0; i < 2; i++)
			{
				result = channel_state[i].silk_init_decoder();
			}
			decState.sStereo.Reset();
			decState.prev_decode_only_middle = 0;
			return result;
		}

		internal static int silk_Decode(SilkDecoder psDec, DecControlState decControl, int lostFlag, int newPacketFlag, EntropyCoder psRangeDec, short[] samplesOut, int samplesOut_ptr, out int nSamplesOut)
		{
			int num = 0;
			int num2 = SilkError.SILK_NO_ERROR;
			BoxedValueInt boxedValueInt = new BoxedValueInt();
			int[] array = new int[2];
			int[] array2 = new int[2];
			SilkChannelDecoder[] channel_state = psDec.channel_state;
			nSamplesOut = 0;
			if (newPacketFlag != 0)
			{
				for (int i = 0; i < decControl.nChannelsInternal; i++)
				{
					channel_state[i].nFramesDecoded = 0;
				}
			}
			if (decControl.nChannelsInternal > psDec.nChannelsInternal)
			{
				num2 += channel_state[1].silk_init_decoder();
			}
			int num3 = ((decControl.nChannelsInternal == 1 && psDec.nChannelsInternal == 2 && decControl.internalSampleRate == 1000 * channel_state[0].fs_kHz) ? 1 : 0);
			if (channel_state[0].nFramesDecoded == 0)
			{
				for (int i = 0; i < decControl.nChannelsInternal; i++)
				{
					if (decControl.payloadSize_ms == 0)
					{
						channel_state[i].nFramesPerPacket = 1;
						channel_state[i].nb_subfr = 2;
					}
					else if (decControl.payloadSize_ms == 10)
					{
						channel_state[i].nFramesPerPacket = 1;
						channel_state[i].nb_subfr = 2;
					}
					else if (decControl.payloadSize_ms == 20)
					{
						channel_state[i].nFramesPerPacket = 1;
						channel_state[i].nb_subfr = 4;
					}
					else if (decControl.payloadSize_ms == 40)
					{
						channel_state[i].nFramesPerPacket = 2;
						channel_state[i].nb_subfr = 4;
					}
					else
					{
						if (decControl.payloadSize_ms != 60)
						{
							return SilkError.SILK_DEC_INVALID_FRAME_SIZE;
						}
						channel_state[i].nFramesPerPacket = 3;
						channel_state[i].nb_subfr = 4;
					}
					int num4 = (decControl.internalSampleRate >> 10) + 1;
					if (num4 != 8 && num4 != 12 && num4 != 16)
					{
						return SilkError.SILK_DEC_INVALID_SAMPLING_FREQUENCY;
					}
					num2 += channel_state[i].silk_decoder_set_fs(num4, decControl.API_sampleRate);
				}
			}
			if (decControl.nChannelsAPI == 2 && decControl.nChannelsInternal == 2 && (psDec.nChannelsAPI == 1 || psDec.nChannelsInternal == 1))
			{
				Arrays.MemSetShort(psDec.sStereo.pred_prev_Q13, 0, 2);
				Arrays.MemSetShort(psDec.sStereo.sSide, 0, 2);
				channel_state[1].resampler_state.Assign(channel_state[0].resampler_state);
			}
			psDec.nChannelsAPI = decControl.nChannelsAPI;
			psDec.nChannelsInternal = decControl.nChannelsInternal;
			if (decControl.API_sampleRate > 48000 || decControl.API_sampleRate < 8000)
			{
				return SilkError.SILK_DEC_INVALID_SAMPLING_FREQUENCY;
			}
			if (lostFlag != 1 && channel_state[0].nFramesDecoded == 0)
			{
				for (int i = 0; i < decControl.nChannelsInternal; i++)
				{
					for (int j = 0; j < channel_state[i].nFramesPerPacket; j++)
					{
						channel_state[i].VAD_flags[j] = psRangeDec.dec_bit_logp(1u);
					}
					channel_state[i].LBRR_flag = psRangeDec.dec_bit_logp(1u);
				}
				for (int i = 0; i < decControl.nChannelsInternal; i++)
				{
					Arrays.MemSetInt(channel_state[i].LBRR_flags, 0, 3);
					if (channel_state[i].LBRR_flag == 0)
					{
						continue;
					}
					if (channel_state[i].nFramesPerPacket == 1)
					{
						channel_state[i].LBRR_flags[0] = 1;
						continue;
					}
					int a = psRangeDec.dec_icdf(Tables.silk_LBRR_flags_iCDF_ptr[channel_state[i].nFramesPerPacket - 2], 8u) + 1;
					for (int j = 0; j < channel_state[i].nFramesPerPacket; j++)
					{
						channel_state[i].LBRR_flags[j] = Inlines.silk_RSHIFT(a, j) & 1;
					}
				}
				if (lostFlag == 0)
				{
					for (int j = 0; j < channel_state[0].nFramesPerPacket; j++)
					{
						for (int i = 0; i < decControl.nChannelsInternal; i++)
						{
							if (channel_state[i].LBRR_flags[j] == 0)
							{
								continue;
							}
							short[] pulses = new short[320];
							if (decControl.nChannelsInternal == 2 && i == 0)
							{
								Stereo.silk_stereo_decode_pred(psRangeDec, array2);
								if (channel_state[1].LBRR_flags[j] == 0)
								{
									BoxedValueInt boxedValueInt2 = new BoxedValueInt(num);
									Stereo.silk_stereo_decode_mid_only(psRangeDec, boxedValueInt2);
									num = boxedValueInt2.Val;
								}
							}
							DecodeIndices.silk_decode_indices(condCoding: (j > 0 && channel_state[i].LBRR_flags[j - 1] != 0) ? 2 : 0, psDec: channel_state[i], psRangeDec: psRangeDec, FrameIndex: j, decode_LBRR: 1);
							DecodePulses.silk_decode_pulses(psRangeDec, pulses, channel_state[i].indices.signalType, channel_state[i].indices.quantOffsetType, channel_state[i].frame_length);
						}
					}
				}
			}
			if (decControl.nChannelsInternal == 2)
			{
				if (lostFlag == 0 || (lostFlag == 2 && channel_state[0].LBRR_flags[channel_state[0].nFramesDecoded] == 1))
				{
					Stereo.silk_stereo_decode_pred(psRangeDec, array2);
					if ((lostFlag == 0 && channel_state[1].VAD_flags[channel_state[0].nFramesDecoded] == 0) || (lostFlag == 2 && channel_state[1].LBRR_flags[channel_state[0].nFramesDecoded] == 0))
					{
						BoxedValueInt boxedValueInt3 = new BoxedValueInt(num);
						Stereo.silk_stereo_decode_mid_only(psRangeDec, boxedValueInt3);
						num = boxedValueInt3.Val;
					}
					else
					{
						num = 0;
					}
				}
				else
				{
					for (int i = 0; i < 2; i++)
					{
						array2[i] = psDec.sStereo.pred_prev_Q13[i];
					}
				}
			}
			if (decControl.nChannelsInternal == 2 && num == 0 && psDec.prev_decode_only_middle == 1)
			{
				Arrays.MemSetShort(psDec.channel_state[1].outBuf, 0, 480);
				Arrays.MemSetInt(psDec.channel_state[1].sLPC_Q14_buf, 0, 16);
				psDec.channel_state[1].lagPrev = 100;
				psDec.channel_state[1].LastGainIndex = 10;
				psDec.channel_state[1].prevSignalType = 0;
				psDec.channel_state[1].first_frame_after_reset = 1;
			}
			int num5 = ((decControl.internalSampleRate * decControl.nChannelsInternal < decControl.API_sampleRate * decControl.nChannelsAPI) ? 1 : 0);
			short[] array3;
			if (num5 != 0)
			{
				array3 = samplesOut;
				array[0] = samplesOut_ptr;
				array[1] = samplesOut_ptr + channel_state[0].frame_length + 2;
			}
			else
			{
				array3 = new short[decControl.nChannelsInternal * (channel_state[0].frame_length + 2)];
				array[0] = 0;
				array[1] = channel_state[0].frame_length + 2;
			}
			int num6 = ((lostFlag != 0) ? ((psDec.prev_decode_only_middle == 0 || (decControl.nChannelsInternal == 2 && lostFlag == 2 && channel_state[1].LBRR_flags[channel_state[1].nFramesDecoded] == 1)) ? 1 : 0) : ((num == 0) ? 1 : 0));
			for (int i = 0; i < decControl.nChannelsInternal; i++)
			{
				if (i == 0 || num6 != 0)
				{
					int num7 = channel_state[0].nFramesDecoded - i;
					int condCoding = ((num7 > 0) ? ((lostFlag == 2) ? ((channel_state[i].LBRR_flags[num7 - 1] != 0) ? 2 : 0) : ((i > 0 && psDec.prev_decode_only_middle != 0) ? 1 : 2)) : 0);
					num2 += channel_state[i].silk_decode_frame(psRangeDec, array3, array[i] + 2, boxedValueInt, lostFlag, condCoding);
				}
				else
				{
					Arrays.MemSetWithOffset(array3, (short)0, array[i] + 2, boxedValueInt.Val);
				}
				channel_state[i].nFramesDecoded++;
			}
			if (decControl.nChannelsAPI == 2 && decControl.nChannelsInternal == 2)
			{
				Stereo.silk_stereo_MS_to_LR(psDec.sStereo, array3, array[0], array3, array[1], array2, channel_state[0].fs_kHz, boxedValueInt.Val);
			}
			else
			{
				Array.Copy(psDec.sStereo.sMid, 0, array3, array[0], 2);
				Array.Copy(array3, array[0] + boxedValueInt.Val, psDec.sStereo.sMid, 0, 2);
			}
			nSamplesOut = Inlines.silk_DIV32(boxedValueInt.Val * decControl.API_sampleRate, Inlines.silk_SMULBB(channel_state[0].fs_kHz, 1000));
			short[] array4;
			int num8;
			if (decControl.nChannelsAPI == 2)
			{
				array4 = new short[nSamplesOut];
				num8 = 0;
			}
			else
			{
				array4 = samplesOut;
				num8 = samplesOut_ptr;
			}
			if (num5 != 0)
			{
				short[] array5 = new short[decControl.nChannelsInternal * (channel_state[0].frame_length + 2)];
				Array.Copy(samplesOut, samplesOut_ptr, array5, 0, decControl.nChannelsInternal * (channel_state[0].frame_length + 2));
				array3 = array5;
				array[0] = 0;
				array[1] = channel_state[0].frame_length + 2;
			}
			for (int i = 0; i < Inlines.silk_min(decControl.nChannelsAPI, decControl.nChannelsInternal); i++)
			{
				num2 += Resampler.silk_resampler(channel_state[i].resampler_state, array4, num8, array3, array[i] + 1, boxedValueInt.Val);
				if (decControl.nChannelsAPI == 2)
				{
					int num9 = samplesOut_ptr + i;
					for (int j = 0; j < nSamplesOut; j++)
					{
						samplesOut[num9 + 2 * j] = array4[num8 + j];
					}
				}
			}
			if (decControl.nChannelsAPI == 2 && decControl.nChannelsInternal == 1)
			{
				if (num3 != 0)
				{
					num2 += Resampler.silk_resampler(channel_state[1].resampler_state, array4, num8, array3, array[0] + 1, boxedValueInt.Val);
					for (int j = 0; j < nSamplesOut; j++)
					{
						samplesOut[samplesOut_ptr + 1 + 2 * j] = array4[num8 + j];
					}
				}
				else
				{
					for (int j = 0; j < nSamplesOut; j++)
					{
						samplesOut[samplesOut_ptr + 1 + 2 * j] = samplesOut[samplesOut_ptr + 2 * j];
					}
				}
			}
			if (channel_state[0].prevSignalType == 2)
			{
				int[] array6 = new int[3] { 6, 4, 3 };
				decControl.prevPitchLag = channel_state[0].lagPrev * array6[channel_state[0].fs_kHz - 8 >> 2];
			}
			else
			{
				decControl.prevPitchLag = 0;
			}
			if (lostFlag == 1)
			{
				for (int j = 0; j < psDec.nChannelsInternal; j++)
				{
					psDec.channel_state[j].LastGainIndex = 10;
				}
			}
			else
			{
				psDec.prev_decode_only_middle = num;
			}
			return num2;
		}
	}
	internal static class DecodeCore
	{
		internal static void silk_decode_core(SilkChannelDecoder psDec, SilkDecoderControl psDecCtrl, short[] xq, int xq_ptr, short[] pulses)
		{
			int num = 0;
			short[] lTPCoef_Q = psDecCtrl.LTPCoef_Q14;
			short[] array = new short[psDec.ltp_mem_length];
			int[] array2 = new int[psDec.ltp_mem_length + psDec.frame_length];
			int[] array3 = new int[psDec.subfr_length];
			int[] array4 = new int[psDec.subfr_length + 16];
			int num2 = Tables.silk_Quantization_Offsets_Q10[psDec.indices.signalType >> 1][psDec.indices.quantOffsetType];
			int num3 = ((psDec.indices.NLSFInterpCoef_Q2 < 4) ? 1 : 0);
			int seed = psDec.indices.Seed;
			for (int i = 0; i < psDec.frame_length; i++)
			{
				seed = Inlines.silk_RAND(seed);
				psDec.exc_Q14[i] = Inlines.silk_LSHIFT(pulses[i], 14);
				if (psDec.exc_Q14[i] > 0)
				{
					psDec.exc_Q14[i] -= 1280;
				}
				else if (psDec.exc_Q14[i] < 0)
				{
					psDec.exc_Q14[i] += 1280;
				}
				psDec.exc_Q14[i] += num2 << 4;
				if (seed < 0)
				{
					psDec.exc_Q14[i] = -psDec.exc_Q14[i];
				}
				seed = Inlines.silk_ADD32_ovflw(seed, pulses[i]);
			}
			Array.Copy(psDec.sLPC_Q14_buf, array4, 16);
			int num4 = 0;
			int num5 = xq_ptr;
			int num6 = psDec.ltp_mem_length;
			for (int j = 0; j < psDec.nb_subfr; j++)
			{
				int[] array5 = array3;
				int num7 = 0;
				short[] array6 = psDecCtrl.PredCoef_Q12[j >> 1];
				int num8 = j * 5;
				int num9 = psDec.indices.signalType;
				int b = Inlines.silk_RSHIFT(psDecCtrl.Gains_Q16[j], 6);
				int a = Inlines.silk_INVERSE32_varQ(psDecCtrl.Gains_Q16[j], 47);
				int num10;
				if (psDecCtrl.Gains_Q16[j] != psDec.prev_gain_Q16)
				{
					num10 = Inlines.silk_DIV32_varQ(psDec.prev_gain_Q16, psDecCtrl.Gains_Q16[j], 16);
					for (int i = 0; i < 16; i++)
					{
						array4[i] = Inlines.silk_SMULWW(num10, array4[i]);
					}
				}
				else
				{
					num10 = 65536;
				}
				psDec.prev_gain_Q16 = psDecCtrl.Gains_Q16[j];
				if (psDec.lossCnt != 0 && psDec.prevSignalType == 2 && psDec.indices.signalType != 2 && j < 2)
				{
					Arrays.MemSetWithOffset(lTPCoef_Q, (short)0, num8, 5);
					lTPCoef_Q[num8 + 2] = 4096;
					num9 = 2;
					psDecCtrl.pitchL[j] = psDec.lagPrev;
				}
				if (num9 == 2)
				{
					num = psDecCtrl.pitchL[j];
					if (j == 0 || (j == 2 && num3 != 0))
					{
						int num11 = psDec.ltp_mem_length - num - psDec.LPC_order - 2;
						if (j == 2)
						{
							Array.Copy(xq, xq_ptr, psDec.outBuf, psDec.ltp_mem_length, 2 * psDec.subfr_length);
						}
						Filters.silk_LPC_analysis_filter(array, num11, psDec.outBuf, num11 + j * psDec.subfr_length, array6, 0, psDec.ltp_mem_length - num11, psDec.LPC_order);
						if (j == 0)
						{
							a = Inlines.silk_LSHIFT(Inlines.silk_SMULWB(a, psDecCtrl.LTP_scale_Q14), 2);
						}
						for (int i = 0; i < num + 2; i++)
						{
							array2[num6 - i - 1] = Inlines.silk_SMULWB(a, array[psDec.ltp_mem_length - i - 1]);
						}
					}
					else if (num10 != 65536)
					{
						for (int i = 0; i < num + 2; i++)
						{
							array2[num6 - i - 1] = Inlines.silk_SMULWW(num10, array2[num6 - i - 1]);
						}
					}
				}
				if (num9 == 2)
				{
					int num12 = num6 - num + 2;
					for (int i = 0; i < psDec.subfr_length; i++)
					{
						int a2 = 2;
						a2 = Inlines.silk_SMLAWB(a2, array2[num12], lTPCoef_Q[num8]);
						a2 = Inlines.silk_SMLAWB(a2, array2[num12 - 1], lTPCoef_Q[num8 + 1]);
						a2 = Inlines.silk_SMLAWB(a2, array2[num12 - 2], lTPCoef_Q[num8 + 2]);
						a2 = Inlines.silk_SMLAWB(a2, array2[num12 - 3], lTPCoef_Q[num8 + 3]);
						a2 = Inlines.silk_SMLAWB(a2, array2[num12 - 4], lTPCoef_Q[num8 + 4]);
						num12++;
						array5[num7 + i] = Inlines.silk_ADD_LSHIFT32(psDec.exc_Q14[num4 + i], a2, 1);
						array2[num6] = Inlines.silk_LSHIFT(array5[num7 + i], 1);
						num6++;
					}
				}
				else
				{
					array5 = psDec.exc_Q14;
					num7 = num4;
				}
				for (int i = 0; i < psDec.subfr_length; i++)
				{
					int a3 = Inlines.silk_RSHIFT(psDec.LPC_order, 1);
					a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 1], array6[0]);
					a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 2], array6[1]);
					a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 3], array6[2]);
					a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 4], array6[3]);
					a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 5], array6[4]);
					a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 6], array6[5]);
					a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 7], array6[6]);
					a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 8], array6[7]);
					a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 9], array6[8]);
					a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 10], array6[9]);
					if (psDec.LPC_order == 16)
					{
						a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 11], array6[10]);
						a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 12], array6[11]);
						a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 13], array6[12]);
						a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 14], array6[13]);
						a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 15], array6[14]);
						a3 = Inlines.silk_SMLAWB(a3, array4[16 + i - 16], array6[15]);
					}
					array4[16 + i] = Inlines.silk_ADD_LSHIFT32(array5[num7 + i], a3, 4);
					xq[num5 + i] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULWW(array4[16 + i], b), 8));
				}
				Array.Copy(array4, psDec.subfr_length, array4, 0, 16);
				num4 += psDec.subfr_length;
				num5 += psDec.subfr_length;
			}
			Array.Copy(array4, 0, psDec.sLPC_Q14_buf, 0, 16);
		}
	}
	internal static class DecodeIndices
	{
		internal static void silk_decode_indices(SilkChannelDecoder psDec, EntropyCoder psRangeDec, int FrameIndex, int decode_LBRR, int condCoding)
		{
			short[] array = new short[psDec.LPC_order];
			byte[] pred_Q = new byte[psDec.LPC_order];
			int num = ((decode_LBRR == 0 && psDec.VAD_flags[FrameIndex] == 0) ? psRangeDec.dec_icdf(Tables.silk_type_offset_no_VAD_iCDF, 8u) : (psRangeDec.dec_icdf(Tables.silk_type_offset_VAD_iCDF, 8u) + 2));
			psDec.indices.signalType = (sbyte)Inlines.silk_RSHIFT(num, 1);
			psDec.indices.quantOffsetType = (sbyte)(num & 1);
			if (condCoding == 2)
			{
				psDec.indices.GainsIndices[0] = (sbyte)psRangeDec.dec_icdf(Tables.silk_delta_gain_iCDF, 8u);
			}
			else
			{
				psDec.indices.GainsIndices[0] = (sbyte)Inlines.silk_LSHIFT(psRangeDec.dec_icdf(Tables.silk_gain_iCDF[psDec.indices.signalType], 8u), 3);
				psDec.indices.GainsIndices[0] += (sbyte)psRangeDec.dec_icdf(Tables.silk_uniform8_iCDF, 8u);
			}
			for (int i = 1; i < psDec.nb_subfr; i++)
			{
				psDec.indices.GainsIndices[i] = (sbyte)psRangeDec.dec_icdf(Tables.silk_delta_gain_iCDF, 8u);
			}
			psDec.indices.NLSFIndices[0] = (sbyte)psRangeDec.dec_icdf(psDec.psNLSF_CB.CB1_iCDF, (psDec.indices.signalType >> 1) * psDec.psNLSF_CB.nVectors, 8u);
			NLSF.silk_NLSF_unpack(array, pred_Q, psDec.psNLSF_CB, psDec.indices.NLSFIndices[0]);
			for (int i = 0; i < psDec.psNLSF_CB.order; i++)
			{
				num = psRangeDec.dec_icdf(psDec.psNLSF_CB.ec_iCDF, array[i], 8u);
				switch (num)
				{
				case 0:
					num -= psRangeDec.dec_icdf(Tables.silk_NLSF_EXT_iCDF, 8u);
					break;
				case 8:
					num += psRangeDec.dec_icdf(Tables.silk_NLSF_EXT_iCDF, 8u);
					break;
				}
				psDec.indices.NLSFIndices[i + 1] = (sbyte)(num - 4);
			}
			if (psDec.nb_subfr == 4)
			{
				psDec.indices.NLSFInterpCoef_Q2 = (sbyte)psRangeDec.dec_icdf(Tables.silk_NLSF_interpolation_factor_iCDF, 8u);
			}
			else
			{
				psDec.indices.NLSFInterpCoef_Q2 = 4;
			}
			if (psDec.indices.signalType == 2)
			{
				int num2 = 1;
				if (condCoding == 2 && psDec.ec_prevSignalType == 2)
				{
					int num3 = (short)psRangeDec.dec_icdf(Tables.silk_pitch_delta_iCDF, 8u);
					if (num3 > 0)
					{
						num3 -= 9;
						psDec.indices.lagIndex = (short)(psDec.ec_prevLagIndex + num3);
						num2 = 0;
					}
				}
				if (num2 != 0)
				{
					psDec.indices.lagIndex = (short)(psRangeDec.dec_icdf(Tables.silk_pitch_lag_iCDF, 8u) * Inlines.silk_RSHIFT(psDec.fs_kHz, 1));
					psDec.indices.lagIndex += (short)psRangeDec.dec_icdf(psDec.pitch_lag_low_bits_iCDF, 8u);
				}
				psDec.ec_prevLagIndex = psDec.indices.lagIndex;
				psDec.indices.contourIndex = (sbyte)psRangeDec.dec_icdf(psDec.pitch_contour_iCDF, 8u);
				psDec.indices.PERIndex = (sbyte)psRangeDec.dec_icdf(Tables.silk_LTP_per_index_iCDF, 8u);
				for (int j = 0; j < psDec.nb_subfr; j++)
				{
					psDec.indices.LTPIndex[j] = (sbyte)psRangeDec.dec_icdf(Tables.silk_LTP_gain_iCDF_ptrs[psDec.indices.PERIndex], 8u);
				}
				if (condCoding == 0)
				{
					psDec.indices.LTP_scaleIndex = (sbyte)psRangeDec.dec_icdf(Tables.silk_LTPscale_iCDF, 8u);
				}
				else
				{
					psDec.indices.LTP_scaleIndex = 0;
				}
			}
			psDec.ec_prevSignalType = psDec.indices.signalType;
			psDec.indices.Seed = (sbyte)psRangeDec.dec_icdf(Tables.silk_uniform4_iCDF, 8u);
		}
	}
	internal class DecodeParameters
	{
		internal static void silk_decode_parameters(SilkChannelDecoder psDec, SilkDecoderControl psDecCtrl, int condCoding)
		{
			short[] array = new short[psDec.LPC_order];
			short[] array2 = new short[psDec.LPC_order];
			BoxedValueSbyte boxedValueSbyte = new BoxedValueSbyte(psDec.LastGainIndex);
			GainQuantization.silk_gains_dequant(psDecCtrl.Gains_Q16, psDec.indices.GainsIndices, boxedValueSbyte, (condCoding == 2) ? 1 : 0, psDec.nb_subfr);
			psDec.LastGainIndex = boxedValueSbyte.Val;
			NLSF.silk_NLSF_decode(array, psDec.indices.NLSFIndices, psDec.psNLSF_CB);
			NLSF.silk_NLSF2A(psDecCtrl.PredCoef_Q12[1], array, psDec.LPC_order);
			if (psDec.first_frame_after_reset == 1)
			{
				psDec.indices.NLSFInterpCoef_Q2 = 4;
			}
			if (psDec.indices.NLSFInterpCoef_Q2 < 4)
			{
				for (int i = 0; i < psDec.LPC_order; i++)
				{
					array2[i] = (short)(psDec.prevNLSF_Q15[i] + Inlines.silk_RSHIFT(Inlines.silk_MUL(psDec.indices.NLSFInterpCoef_Q2, array[i] - psDec.prevNLSF_Q15[i]), 2));
				}
				NLSF.silk_NLSF2A(psDecCtrl.PredCoef_Q12[0], array2, psDec.LPC_order);
			}
			else
			{
				Array.Copy(psDecCtrl.PredCoef_Q12[1], psDecCtrl.PredCoef_Q12[0], psDec.LPC_order);
			}
			Array.Copy(array, psDec.prevNLSF_Q15, psDec.LPC_order);
			if (psDec.lossCnt != 0)
			{
				BWExpander.silk_bwexpander(psDecCtrl.PredCoef_Q12[0], psDec.LPC_order, 63570);
				BWExpander.silk_bwexpander(psDecCtrl.PredCoef_Q12[1], psDec.LPC_order, 63570);
			}
			if (psDec.indices.signalType == 2)
			{
				DecodePitch.silk_decode_pitch(psDec.indices.lagIndex, psDec.indices.contourIndex, psDecCtrl.pitchL, psDec.fs_kHz, psDec.nb_subfr);
				sbyte[][] array3 = Tables.silk_LTP_vq_ptrs_Q7[psDec.indices.PERIndex];
				int num;
				for (int j = 0; j < psDec.nb_subfr; j++)
				{
					num = psDec.indices.LTPIndex[j];
					for (int i = 0; i < 5; i++)
					{
						psDecCtrl.LTPCoef_Q14[j * 5 + i] = (short)Inlines.silk_LSHIFT(array3[num][i], 7);
					}
				}
				num = psDec.indices.LTP_scaleIndex;
				psDecCtrl.LTP_scale_Q14 = Tables.silk_LTPScales_table_Q14[num];
			}
			else
			{
				Arrays.MemSetInt(psDecCtrl.pitchL, 0, psDec.nb_subfr);
				Arrays.MemSetShort(psDecCtrl.LTPCoef_Q14, 0, 5 * psDec.nb_subfr);
				psDec.indices.PERIndex = 0;
				psDecCtrl.LTP_scale_Q14 = 0;
			}
		}
	}
	internal static class DecodePitch
	{
		internal static void silk_decode_pitch(short lagIndex, sbyte contourIndex, int[] pitch_lags, int Fs_kHz, int nb_subfr)
		{
			sbyte[][] array = ((Fs_kHz == 8) ? ((nb_subfr != 4) ? Tables.silk_CB_lags_stage2_10_ms : Tables.silk_CB_lags_stage2) : ((nb_subfr != 4) ? Tables.silk_CB_lags_stage3_10_ms : Tables.silk_CB_lags_stage3));
			int num = Inlines.silk_SMULBB(2, Fs_kHz);
			int limit = Inlines.silk_SMULBB(18, Fs_kHz);
			int num2 = num + lagIndex;
			for (int i = 0; i < nb_subfr; i++)
			{
				pitch_lags[i] = num2 + array[i][contourIndex];
				pitch_lags[i] = Inlines.silk_LIMIT(pitch_lags[i], num, limit);
			}
		}
	}
	internal static class DecodePulses
	{
		internal static void silk_decode_pulses(EntropyCoder psRangeDec, short[] pulses, int signalType, int quantOffsetType, int frame_length)
		{
			int[] array = new int[20];
			int[] array2 = new int[20];
			int num = psRangeDec.dec_icdf(Tables.silk_rate_levels_iCDF[signalType >> 1], 8u);
			int num2 = Inlines.silk_RSHIFT(frame_length, 4);
			if (num2 * 16 < frame_length)
			{
				num2++;
			}
			for (int i = 0; i < num2; i++)
			{
				array2[i] = 0;
				array[i] = psRangeDec.dec_icdf(Tables.silk_pulses_per_block_iCDF[num], 8u);
				while (array[i] == 17)
				{
					array2[i]++;
					array[i] = psRangeDec.dec_icdf(Tables.silk_pulses_per_block_iCDF[9], (array2[i] == 10) ? 1 : 0, 8u);
				}
			}
			for (int i = 0; i < num2; i++)
			{
				if (array[i] > 0)
				{
					ShellCoder.silk_shell_decoder(pulses, Inlines.silk_SMULBB(i, 16), psRangeDec, array[i]);
				}
				else
				{
					Arrays.MemSetWithOffset(pulses, (short)0, Inlines.silk_SMULBB(i, 16), 16);
				}
			}
			for (int i = 0; i < num2; i++)
			{
				if (array2[i] <= 0)
				{
					continue;
				}
				int num3 = array2[i];
				int num4 = Inlines.silk_SMULBB(i, 16);
				for (int j = 0; j < 16; j++)
				{
					int num5 = pulses[num4 + j];
					for (int k = 0; k < num3; k++)
					{
						num5 = Inlines.silk_LSHIFT(num5, 1);
						num5 += psRangeDec.dec_icdf(Tables.silk_lsb_iCDF, 8u);
					}
					pulses[num4 + j] = (short)num5;
				}
				array[i] |= num3 << 5;
			}
			CodeSigns.silk_decode_signs(psRangeDec, pulses, frame_length, signalType, quantOffsetType, array);
		}
	}
	internal static class EncodeAPI
	{
		internal static int silk_InitEncoder(SilkEncoder encState, EncControlState encStatus)
		{
			int num = SilkError.SILK_NO_ERROR;
			encState.Reset();
			for (int i = 0; i < 2; i++)
			{
				num += SilkEncoder.silk_init_encoder(encState.state_Fxx[i]);
			}
			encState.nChannelsAPI = 1;
			encState.nChannelsInternal = 1;
			return num + silk_QueryEncoder(encState, encStatus);
		}

		internal static int silk_QueryEncoder(SilkEncoder encState, EncControlState encStatus)
		{
			int sILK_NO_ERROR = SilkError.SILK_NO_ERROR;
			SilkChannelEncoder silkChannelEncoder = encState.state_Fxx[0];
			encStatus.Reset();
			encStatus.nChannelsAPI = encState.nChannelsAPI;
			encStatus.nChannelsInternal = encState.nChannelsInternal;
			encStatus.API_sampleRate = silkChannelEncoder.API_fs_Hz;
			encStatus.maxInternalSampleRate = silkChannelEncoder.maxInternal_fs_Hz;
			encStatus.minInternalSampleRate = silkChannelEncoder.minInternal_fs_Hz;
			encStatus.desiredInternalSampleRate = silkChannelEncoder.desiredInternal_fs_Hz;
			encStatus.payloadSize_ms = silkChannelEncoder.PacketSize_ms;
			encStatus.bitRate = silkChannelEncoder.TargetRate_bps;
			encStatus.packetLossPercentage = silkChannelEncoder.PacketLoss_perc;
			encStatus.complexity = silkChannelEncoder.Complexity;
			encStatus.useInBandFEC = silkChannelEncoder.useInBandFEC;
			encStatus.useDTX = silkChannelEncoder.useDTX;
			encStatus.useCBR = silkChannelEncoder.useCBR;
			encStatus.internalSampleRate = Inlines.silk_SMULBB(silkChannelEncoder.fs_kHz, 1000);
			encStatus.allowBandwidthSwitch = silkChannelEncoder.allow_bandwidth_switch;
			encStatus.inWBmodeWithoutVariableLP = ((silkChannelEncoder.fs_kHz == 16 && silkChannelEncoder.sLP.mode == 0) ? 1 : 0);
			return sILK_NO_ERROR;
		}

		internal static int silk_Encode(SilkEncoder psEnc, EncControlState encControl, short[] samplesIn, int nSamplesIn, EntropyCoder psRangeEnc, BoxedValueInt nBytesOut, int prefillFlag)
		{
			int sILK_NO_ERROR = SilkError.SILK_NO_ERROR;
			int payloadSize_ms = 0;
			int complexity = 0;
			int num = 0;
			int[] array = new int[2];
			nBytesOut.Val = 0;
			if (encControl.reducedDependency != 0)
			{
				psEnc.state_Fxx[0].first_frame_after_reset = 1;
				psEnc.state_Fxx[1].first_frame_after_reset = 1;
			}
			psEnc.state_Fxx[0].nFramesEncoded = (psEnc.state_Fxx[1].nFramesEncoded = 0);
			sILK_NO_ERROR += encControl.check_control_input();
			if (sILK_NO_ERROR != SilkError.SILK_NO_ERROR)
			{
				return sILK_NO_ERROR;
			}
			encControl.switchReady = 0;
			if (encControl.nChannelsInternal > psEnc.nChannelsInternal)
			{
				sILK_NO_ERROR += SilkEncoder.silk_init_encoder(psEnc.state_Fxx[1]);
				Arrays.MemSetShort(psEnc.sStereo.pred_prev_Q13, 0, 2);
				Arrays.MemSetShort(psEnc.sStereo.sSide, 0, 2);
				psEnc.sStereo.mid_side_amp_Q0[0] = 0;
				psEnc.sStereo.mid_side_amp_Q0[1] = 1;
				psEnc.sStereo.mid_side_amp_Q0[2] = 0;
				psEnc.sStereo.mid_side_amp_Q0[3] = 1;
				psEnc.sStereo.width_prev_Q14 = 0;
				psEnc.sStereo.smth_width_Q14 = 16384;
				if (psEnc.nChannelsAPI == 2)
				{
					psEnc.state_Fxx[1].resampler_state.Assign(psEnc.state_Fxx[0].resampler_state);
					Array.Copy(psEnc.state_Fxx[0].In_HP_State, psEnc.state_Fxx[1].In_HP_State, 2);
				}
			}
			int num2 = ((encControl.payloadSize_ms != psEnc.state_Fxx[0].PacketSize_ms || psEnc.nChannelsInternal != encControl.nChannelsInternal) ? 1 : 0);
			psEnc.nChannelsAPI = encControl.nChannelsAPI;
			psEnc.nChannelsInternal = encControl.nChannelsInternal;
			int num3 = Inlines.silk_DIV32(100 * nSamplesIn, encControl.API_sampleRate);
			int num4 = ((num3 <= 1) ? 1 : (num3 >> 1));
			int num5 = 0;
			if (prefillFlag != 0)
			{
				if (num3 != 1)
				{
					return SilkError.SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
				}
				for (int i = 0; i < encControl.nChannelsInternal; i++)
				{
					sILK_NO_ERROR += SilkEncoder.silk_init_encoder(psEnc.state_Fxx[i]);
				}
				payloadSize_ms = encControl.payloadSize_ms;
				encControl.payloadSize_ms = 10;
				complexity = encControl.complexity;
				encControl.complexity = 0;
				for (int i = 0; i < encControl.nChannelsInternal; i++)
				{
					psEnc.state_Fxx[i].controlled_since_last_payload = 0;
					psEnc.state_Fxx[i].prefillFlag = 1;
				}
			}
			else
			{
				if (num3 * encControl.API_sampleRate != 100 * nSamplesIn || nSamplesIn < 0)
				{
					return SilkError.SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
				}
				if (1000 * nSamplesIn > encControl.payloadSize_ms * encControl.API_sampleRate)
				{
					return SilkError.SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES;
				}
			}
			int targetRate_bps = Inlines.silk_RSHIFT32(encControl.bitRate, encControl.nChannelsInternal - 1);
			for (int i = 0; i < encControl.nChannelsInternal; i++)
			{
				int force_fs_kHz = ((i == 1) ? psEnc.state_Fxx[0].fs_kHz : 0);
				sILK_NO_ERROR += psEnc.state_Fxx[i].silk_control_encoder(encControl, targetRate_bps, psEnc.allowBandwidthSwitch, i, force_fs_kHz);
				if (sILK_NO_ERROR != SilkError.SILK_NO_ERROR)
				{
					return sILK_NO_ERROR;
				}
				if (psEnc.state_Fxx[i].first_frame_after_reset != 0 || num2 != 0)
				{
					for (int j = 0; j < psEnc.state_Fxx[0].nFramesPerPacket; j++)
					{
						psEnc.state_Fxx[i].LBRR_flags[j] = 0;
					}
				}
				psEnc.state_Fxx[i].inDTX = psEnc.state_Fxx[i].useDTX;
			}
			int num6 = 10 * num3 * psEnc.state_Fxx[0].fs_kHz;
			short[] array2 = new short[Inlines.silk_DIV32_16(num6 * psEnc.state_Fxx[0].API_fs_Hz, (short)(psEnc.state_Fxx[0].fs_kHz * 1000))];
			int num7 = 0;
			while (true)
			{
				int a = psEnc.state_Fxx[0].frame_length - psEnc.state_Fxx[0].inputBufIx;
				a = Inlines.silk_min(a, num6);
				num = Inlines.silk_DIV32_16(a * psEnc.state_Fxx[0].API_fs_Hz, psEnc.state_Fxx[0].fs_kHz * 1000);
				if (encControl.nChannelsAPI == 2 && encControl.nChannelsInternal == 2)
				{
					int nFramesEncoded = psEnc.state_Fxx[0].nFramesEncoded;
					for (int i = 0; i < num; i++)
					{
						array2[i] = samplesIn[num7 + 2 * i];
					}
					if (psEnc.nPrevChannelsInternal == 1 && nFramesEncoded == 0)
					{
						psEnc.state_Fxx[1].resampler_state.Assign(psEnc.state_Fxx[0].resampler_state);
					}
					sILK_NO_ERROR += Resampler.silk_resampler(psEnc.state_Fxx[0].resampler_state, psEnc.state_Fxx[0].inputBuf, psEnc.state_Fxx[0].inputBufIx + 2, array2, 0, num);
					psEnc.state_Fxx[0].inputBufIx += a;
					a = psEnc.state_Fxx[1].frame_length - psEnc.state_Fxx[1].inputBufIx;
					a = Inlines.silk_min(a, 10 * num3 * psEnc.state_Fxx[1].fs_kHz);
					for (int i = 0; i < num; i++)
					{
						array2[i] = samplesIn[num7 + 2 * i + 1];
					}
					sILK_NO_ERROR += Resampler.silk_resampler(psEnc.state_Fxx[1].resampler_state, psEnc.state_Fxx[1].inputBuf, psEnc.state_Fxx[1].inputBufIx + 2, array2, 0, num);
					psEnc.state_Fxx[1].inputBufIx += a;
				}
				else if (encControl.nChannelsAPI == 2 && encControl.nChannelsInternal == 1)
				{
					for (int i = 0; i < num; i++)
					{
						int a2 = samplesIn[num7 + 2 * i] + samplesIn[num7 + 2 * i + 1];
						array2[i] = (short)Inlines.silk_RSHIFT_ROUND(a2, 1);
					}
					sILK_NO_ERROR += Resampler.silk_resampler(psEnc.state_Fxx[0].resampler_state, psEnc.state_Fxx[0].inputBuf, psEnc.state_Fxx[0].inputBufIx + 2, array2, 0, num);
					if (psEnc.nPrevChannelsInternal == 2 && psEnc.state_Fxx[0].nFramesEncoded == 0)
					{
						sILK_NO_ERROR += Resampler.silk_resampler(psEnc.state_Fxx[1].resampler_state, psEnc.state_Fxx[1].inputBuf, psEnc.state_Fxx[1].inputBufIx + 2, array2, 0, num);
						for (int i = 0; i < psEnc.state_Fxx[0].frame_length; i++)
						{
							psEnc.state_Fxx[0].inputBuf[psEnc.state_Fxx[0].inputBufIx + i + 2] = (short)Inlines.silk_RSHIFT(psEnc.state_Fxx[0].inputBuf[psEnc.state_Fxx[0].inputBufIx + i + 2] + psEnc.state_Fxx[1].inputBuf[psEnc.state_Fxx[1].inputBufIx + i + 2], 1);
						}
					}
					psEnc.state_Fxx[0].inputBufIx += a;
				}
				else
				{
					Array.Copy(samplesIn, num7, array2, 0, num);
					sILK_NO_ERROR += Resampler.silk_resampler(psEnc.state_Fxx[0].resampler_state, psEnc.state_Fxx[0].inputBuf, psEnc.state_Fxx[0].inputBufIx + 2, array2, 0, num);
					psEnc.state_Fxx[0].inputBufIx += a;
				}
				num7 += num * encControl.nChannelsAPI;
				nSamplesIn -= num;
				psEnc.allowBandwidthSwitch = 0;
				if (psEnc.state_Fxx[0].inputBufIx < psEnc.state_Fxx[0].frame_length)
				{
					break;
				}
				if (psEnc.state_Fxx[0].nFramesEncoded == 0 && prefillFlag == 0)
				{
					psRangeEnc.enc_icdf(0, new byte[2]
					{
						(byte)(256 - Inlines.silk_RSHIFT(256, (psEnc.state_Fxx[0].nFramesPerPacket + 1) * encControl.nChannelsInternal)),
						0
					}, 8u);
					for (int i = 0; i < encControl.nChannelsInternal; i++)
					{
						int num8 = 0;
						for (int j = 0; j < psEnc.state_Fxx[i].nFramesPerPacket; j++)
						{
							num8 |= Inlines.silk_LSHIFT(psEnc.state_Fxx[i].LBRR_flags[j], j);
						}
						psEnc.state_Fxx[i].LBRR_flag = ((num8 > 0) ? ((sbyte)1) : ((sbyte)0));
						if (num8 != 0 && psEnc.state_Fxx[i].nFramesPerPacket > 1)
						{
							psRangeEnc.enc_icdf(num8 - 1, Tables.silk_LBRR_flags_iCDF_ptr[psEnc.state_Fxx[i].nFramesPerPacket - 2], 8u);
						}
					}
					for (int j = 0; j < psEnc.state_Fxx[0].nFramesPerPacket; j++)
					{
						for (int i = 0; i < encControl.nChannelsInternal; i++)
						{
							if (psEnc.state_Fxx[i].LBRR_flags[j] == 0)
							{
								continue;
							}
							if (encControl.nChannelsInternal == 2 && i == 0)
							{
								Stereo.silk_stereo_encode_pred(psRangeEnc, psEnc.sStereo.predIx[j]);
								if (psEnc.state_Fxx[1].LBRR_flags[j] == 0)
								{
									Stereo.silk_stereo_encode_mid_only(psRangeEnc, psEnc.sStereo.mid_only_flags[j]);
								}
							}
							EncodeIndices.silk_encode_indices(condCoding: (j > 0 && psEnc.state_Fxx[i].LBRR_flags[j - 1] != 0) ? 2 : 0, psEncC: psEnc.state_Fxx[i], psRangeEnc: psRangeEnc, FrameIndex: j, encode_LBRR: 1);
							EncodePulses.silk_encode_pulses(psRangeEnc, psEnc.state_Fxx[i].indices_LBRR[j].signalType, psEnc.state_Fxx[i].indices_LBRR[j].quantOffsetType, psEnc.state_Fxx[i].pulses_LBRR[j], psEnc.state_Fxx[i].frame_length);
						}
					}
					for (int i = 0; i < encControl.nChannelsInternal; i++)
					{
						Arrays.MemSetInt(psEnc.state_Fxx[i].LBRR_flags, 0, 3);
					}
					psEnc.nBitsUsedLBRR = psRangeEnc.tell();
				}
				HPVariableCutoff.silk_HP_variable_cutoff(psEnc.state_Fxx);
				int num9 = Inlines.silk_DIV32_16(Inlines.silk_MUL(encControl.bitRate, encControl.payloadSize_ms), 1000);
				if (prefillFlag == 0)
				{
					num9 -= psEnc.nBitsUsedLBRR;
				}
				num9 = Inlines.silk_DIV32_16(num9, psEnc.state_Fxx[0].nFramesPerPacket);
				targetRate_bps = ((encControl.payloadSize_ms != 10) ? Inlines.silk_SMULBB(num9, 50) : Inlines.silk_SMULBB(num9, 100));
				targetRate_bps -= Inlines.silk_DIV32_16(Inlines.silk_MUL(psEnc.nBitsExceeded, 1000), 500);
				if (prefillFlag == 0 && psEnc.state_Fxx[0].nFramesEncoded > 0)
				{
					int a3 = psRangeEnc.tell() - psEnc.nBitsUsedLBRR - num9 * psEnc.state_Fxx[0].nFramesEncoded;
					targetRate_bps -= Inlines.silk_DIV32_16(Inlines.silk_MUL(a3, 1000), 500);
				}
				targetRate_bps = Inlines.silk_LIMIT(targetRate_bps, encControl.bitRate, 5000);
				if (encControl.nChannelsInternal == 2)
				{
					BoxedValueSbyte boxedValueSbyte = new BoxedValueSbyte(psEnc.sStereo.mid_only_flags[psEnc.state_Fxx[0].nFramesEncoded]);
					Stereo.silk_stereo_LR_to_MS(psEnc.sStereo, psEnc.state_Fxx[0].inputBuf, 2, psEnc.state_Fxx[1].inputBuf, 2, psEnc.sStereo.predIx[psEnc.state_Fxx[0].nFramesEncoded], boxedValueSbyte, array, targetRate_bps, psEnc.state_Fxx[0].speech_activity_Q8, encControl.toMono, psEnc.state_Fxx[0].fs_kHz, psEnc.state_Fxx[0].frame_length);
					psEnc.sStereo.mid_only_flags[psEnc.state_Fxx[0].nFramesEncoded] = boxedValueSbyte.Val;
					if (boxedValueSbyte.Val == 0)
					{
						if (psEnc.prev_decode_only_middle == 1)
						{
							psEnc.state_Fxx[1].sShape.Reset();
							psEnc.state_Fxx[1].sPrefilt.Reset();
							psEnc.state_Fxx[1].sNSQ.Reset();
							Arrays.MemSetShort(psEnc.state_Fxx[1].prev_NLSFq_Q15, 0, 16);
							Arrays.MemSetInt(psEnc.state_Fxx[1].sLP.In_LP_State, 0, 2);
							psEnc.state_Fxx[1].prevLag = 100;
							psEnc.state_Fxx[1].sNSQ.lagPrev = 100;
							psEnc.state_Fxx[1].sShape.LastGainIndex = 10;
							psEnc.state_Fxx[1].prevSignalType = 0;
							psEnc.state_Fxx[1].sNSQ.prev_gain_Q16 = 65536;
							psEnc.state_Fxx[1].first_frame_after_reset = 1;
						}
						psEnc.state_Fxx[1].silk_encode_do_VAD();
					}
					else
					{
						psEnc.state_Fxx[1].VAD_flags[psEnc.state_Fxx[0].nFramesEncoded] = 0;
					}
					if (prefillFlag == 0)
					{
						Stereo.silk_stereo_encode_pred(psRangeEnc, psEnc.sStereo.predIx[psEnc.state_Fxx[0].nFramesEncoded]);
						if (psEnc.state_Fxx[1].VAD_flags[psEnc.state_Fxx[0].nFramesEncoded] == 0)
						{
							Stereo.silk_stereo_encode_mid_only(psRangeEnc, psEnc.sStereo.mid_only_flags[psEnc.state_Fxx[0].nFramesEncoded]);
						}
					}
				}
				else
				{
					Array.Copy(psEnc.sStereo.sMid, psEnc.state_Fxx[0].inputBuf, 2);
					Array.Copy(psEnc.state_Fxx[0].inputBuf, psEnc.state_Fxx[0].frame_length, psEnc.sStereo.sMid, 0, 2);
				}
				psEnc.state_Fxx[0].silk_encode_do_VAD();
				for (int i = 0; i < encControl.nChannelsInternal; i++)
				{
					int num10 = encControl.maxBits;
					if (num4 == 2 && num5 == 0)
					{
						num10 = num10 * 3 / 5;
					}
					else if (num4 == 3)
					{
						switch (num5)
						{
						case 0:
							num10 = num10 * 2 / 5;
							break;
						case 1:
							num10 = num10 * 3 / 4;
							break;
						}
					}
					int useCBR = ((encControl.useCBR != 0 && num5 == num4 - 1) ? 1 : 0);
					int num11;
					if (encControl.nChannelsInternal == 1)
					{
						num11 = targetRate_bps;
					}
					else
					{
						num11 = array[i];
						if (i == 0 && array[1] > 0)
						{
							useCBR = 0;
							num10 -= encControl.maxBits / (num4 * 2);
						}
					}
					if (num11 > 0)
					{
						psEnc.state_Fxx[i].silk_control_SNR(num11);
						int condCoding = ((psEnc.state_Fxx[0].nFramesEncoded - i > 0) ? ((i > 0 && psEnc.prev_decode_only_middle != 0) ? 1 : 2) : 0);
						sILK_NO_ERROR += psEnc.state_Fxx[i].silk_encode_frame(nBytesOut, psRangeEnc, condCoding, num10, useCBR);
					}
					psEnc.state_Fxx[i].controlled_since_last_payload = 0;
					psEnc.state_Fxx[i].inputBufIx = 0;
					psEnc.state_Fxx[i].nFramesEncoded++;
				}
				psEnc.prev_decode_only_middle = psEnc.sStereo.mid_only_flags[psEnc.state_Fxx[0].nFramesEncoded - 1];
				if (nBytesOut.Val > 0 && psEnc.state_Fxx[0].nFramesEncoded == psEnc.state_Fxx[0].nFramesPerPacket)
				{
					int num12 = 0;
					for (int i = 0; i < encControl.nChannelsInternal; i++)
					{
						for (int j = 0; j < psEnc.state_Fxx[i].nFramesPerPacket; j++)
						{
							num12 = Inlines.silk_LSHIFT(num12, 1);
							num12 |= psEnc.state_Fxx[i].VAD_flags[j];
						}
						num12 = Inlines.silk_LSHIFT(num12, 1);
						num12 |= psEnc.state_Fxx[i].LBRR_flag;
					}
					if (prefillFlag == 0)
					{
						psRangeEnc.enc_patch_initial_bits((uint)num12, (uint)((psEnc.state_Fxx[0].nFramesPerPacket + 1) * encControl.nChannelsInternal));
					}
					if (psEnc.state_Fxx[0].inDTX != 0 && (encControl.nChannelsInternal == 1 || psEnc.state_Fxx[1].inDTX != 0))
					{
						nBytesOut.Val = 0;
					}
					psEnc.nBitsExceeded += nBytesOut.Val * 8;
					psEnc.nBitsExceeded -= Inlines.silk_DIV32_16(Inlines.silk_MUL(encControl.bitRate, encControl.payloadSize_ms), 1000);
					psEnc.nBitsExceeded = Inlines.silk_LIMIT(psEnc.nBitsExceeded, 0, 10000);
					int num13 = Inlines.silk_SMLAWB(13, 3188, psEnc.timeSinceSwitchAllowed_ms);
					if (psEnc.state_Fxx[0].speech_activity_Q8 < num13)
					{
						psEnc.allowBandwidthSwitch = 1;
						psEnc.timeSinceSwitchAllowed_ms = 0;
					}
					else
					{
						psEnc.allowBandwidthSwitch = 0;
						psEnc.timeSinceSwitchAllowed_ms += encControl.payloadSize_ms;
					}
				}
				if (nSamplesIn == 0)
				{
					break;
				}
				num5++;
			}
			psEnc.nPrevChannelsInternal = encControl.nChannelsInternal;
			encControl.allowBandwidthSwitch = psEnc.allowBandwidthSwitch;
			encControl.inWBmodeWithoutVariableLP = ((psEnc.state_Fxx[0].fs_kHz == 16 && psEnc.state_Fxx[0].sLP.mode == 0) ? 1 : 0);
			encControl.internalSampleRate = Inlines.silk_SMULBB(psEnc.state_Fxx[0].fs_kHz, 1000);
			encControl.stereoWidth_Q14 = ((encControl.toMono == 0) ? psEnc.sStereo.smth_width_Q14 : 0);
			if (prefillFlag != 0)
			{
				encControl.payloadSize_ms = payloadSize_ms;
				encControl.complexity = complexity;
				for (int i = 0; i < encControl.nChannelsInternal; i++)
				{
					psEnc.state_Fxx[i].controlled_since_last_payload = 0;
					psEnc.state_Fxx[i].prefillFlag = 0;
				}
			}
			return sILK_NO_ERROR;
		}
	}
	internal static class EncodeIndices
	{
		internal static void silk_encode_indices(SilkChannelEncoder psEncC, EntropyCoder psRangeEnc, int FrameIndex, int encode_LBRR, int condCoding)
		{
			short[] array = new short[16];
			byte[] pred_Q = new byte[16];
			SideInfoIndices sideInfoIndices = ((encode_LBRR == 0) ? psEncC.indices : psEncC.indices_LBRR[FrameIndex]);
			int num = 2 * sideInfoIndices.signalType + sideInfoIndices.quantOffsetType;
			if (encode_LBRR != 0 || num >= 2)
			{
				psRangeEnc.enc_icdf(num - 2, Tables.silk_type_offset_VAD_iCDF, 8u);
			}
			else
			{
				psRangeEnc.enc_icdf(num, Tables.silk_type_offset_no_VAD_iCDF, 8u);
			}
			if (condCoding == 2)
			{
				psRangeEnc.enc_icdf(sideInfoIndices.GainsIndices[0], Tables.silk_delta_gain_iCDF, 8u);
			}
			else
			{
				psRangeEnc.enc_icdf(Inlines.silk_RSHIFT(sideInfoIndices.GainsIndices[0], 3), Tables.silk_gain_iCDF[sideInfoIndices.signalType], 8u);
				psRangeEnc.enc_icdf(sideInfoIndices.GainsIndices[0] & 7, Tables.silk_uniform8_iCDF, 8u);
			}
			for (int i = 1; i < psEncC.nb_subfr; i++)
			{
				psRangeEnc.enc_icdf(sideInfoIndices.GainsIndices[i], Tables.silk_delta_gain_iCDF, 8u);
			}
			psRangeEnc.enc_icdf(sideInfoIndices.NLSFIndices[0], psEncC.psNLSF_CB.CB1_iCDF, (sideInfoIndices.signalType >> 1) * psEncC.psNLSF_CB.nVectors, 8u);
			NLSF.silk_NLSF_unpack(array, pred_Q, psEncC.psNLSF_CB, sideInfoIndices.NLSFIndices[0]);
			for (int i = 0; i < psEncC.psNLSF_CB.order; i++)
			{
				if (sideInfoIndices.NLSFIndices[i + 1] >= 4)
				{
					psRangeEnc.enc_icdf(8, psEncC.psNLSF_CB.ec_iCDF, array[i], 8u);
					psRangeEnc.enc_icdf(sideInfoIndices.NLSFIndices[i + 1] - 4, Tables.silk_NLSF_EXT_iCDF, 8u);
				}
				else if (sideInfoIndices.NLSFIndices[i + 1] <= -4)
				{
					psRangeEnc.enc_icdf(0, psEncC.psNLSF_CB.ec_iCDF, array[i], 8u);
					psRangeEnc.enc_icdf(-sideInfoIndices.NLSFIndices[i + 1] - 4, Tables.silk_NLSF_EXT_iCDF, 8u);
				}
				else
				{
					psRangeEnc.enc_icdf(sideInfoIndices.NLSFIndices[i + 1] + 4, psEncC.psNLSF_CB.ec_iCDF, array[i], 8u);
				}
			}
			if (psEncC.nb_subfr == 4)
			{
				psRangeEnc.enc_icdf(sideInfoIndices.NLSFInterpCoef_Q2, Tables.silk_NLSF_interpolation_factor_iCDF, 8u);
			}
			if (sideInfoIndices.signalType == 2)
			{
				int num2 = 1;
				if (condCoding == 2 && psEncC.ec_prevSignalType == 2)
				{
					int num3 = sideInfoIndices.lagIndex - psEncC.ec_prevLagIndex;
					if (num3 < -8 || num3 > 11)
					{
						num3 = 0;
					}
					else
					{
						num3 += 9;
						num2 = 0;
					}
					psRangeEnc.enc_icdf(num3, Tables.silk_pitch_delta_iCDF, 8u);
				}
				if (num2 != 0)
				{
					int num4 = Inlines.silk_DIV32_16(sideInfoIndices.lagIndex, Inlines.silk_RSHIFT(psEncC.fs_kHz, 1));
					int s = sideInfoIndices.lagIndex - Inlines.silk_SMULBB(num4, Inlines.silk_RSHIFT(psEncC.fs_kHz, 1));
					psRangeEnc.enc_icdf(num4, Tables.silk_pitch_lag_iCDF, 8u);
					psRangeEnc.enc_icdf(s, psEncC.pitch_lag_low_bits_iCDF, 8u);
				}
				psEncC.ec_prevLagIndex = sideInfoIndices.lagIndex;
				psRangeEnc.enc_icdf(sideInfoIndices.contourIndex, psEncC.pitch_contour_iCDF, 8u);
				psRangeEnc.enc_icdf(sideInfoIndices.PERIndex, Tables.silk_LTP_per_index_iCDF, 8u);
				for (int j = 0; j < psEncC.nb_subfr; j++)
				{
					psRangeEnc.enc_icdf(sideInfoIndices.LTPIndex[j], Tables.silk_LTP_gain_iCDF_ptrs[sideInfoIndices.PERIndex], 8u);
				}
				if (condCoding == 0)
				{
					psRangeEnc.enc_icdf(sideInfoIndices.LTP_scaleIndex, Tables.silk_LTPscale_iCDF, 8u);
				}
			}
			psEncC.ec_prevSignalType = sideInfoIndices.signalType;
			psRangeEnc.enc_icdf(sideInfoIndices.Seed, Tables.silk_uniform4_iCDF, 8u);
		}
	}
	internal static class EncodePulses
	{
		internal static int combine_and_check(int[] pulses_comb, int pulses_comb_ptr, int[] pulses_in, int pulses_in_ptr, int max_pulses, int len)
		{
			for (int i = 0; i < len; i++)
			{
				int num = 2 * i + pulses_in_ptr;
				int num2 = pulses_in[num] + pulses_in[num + 1];
				if (num2 > max_pulses)
				{
					return 1;
				}
				pulses_comb[pulses_comb_ptr + i] = num2;
			}
			return 0;
		}

		internal static int combine_and_check(int[] pulses_comb, int[] pulses_in, int max_pulses, int len)
		{
			for (int i = 0; i < len; i++)
			{
				int num = pulses_in[2 * i] + pulses_in[2 * i + 1];
				if (num > max_pulses)
				{
					return 1;
				}
				pulses_comb[i] = num;
			}
			return 0;
		}

		internal static void silk_encode_pulses(EntropyCoder psRangeEnc, int signalType, int quantOffsetType, sbyte[] pulses, int frame_length)
		{
			int num = 0;
			int[] array = new int[8];
			Arrays.MemSetInt(array, 0, 8);
			int num2 = Inlines.silk_RSHIFT(frame_length, 4);
			if (num2 * 16 < frame_length)
			{
				num2++;
				Arrays.MemSetWithOffset(pulses, (sbyte)0, frame_length, 16);
			}
			int[] array2 = new int[num2 * 16];
			for (int i = 0; i < num2 * 16; i += 4)
			{
				array2[i] = Inlines.silk_abs(pulses[i]);
				array2[i + 1] = Inlines.silk_abs(pulses[i + 1]);
				array2[i + 2] = Inlines.silk_abs(pulses[i + 2]);
				array2[i + 3] = Inlines.silk_abs(pulses[i + 3]);
			}
			int[] array3 = new int[num2];
			int[] array4 = new int[num2];
			int num3 = 0;
			for (int i = 0; i < num2; i++)
			{
				array4[i] = 0;
				while (combine_and_check(array, 0, array2, num3, Tables.silk_max_pulses_table[0], 8) + combine_and_check(array, array, Tables.silk_max_pulses_table[1], 4) + combine_and_check(array, array, Tables.silk_max_pulses_table[2], 2) + combine_and_check(array3, i, array, 0, Tables.silk_max_pulses_table[3], 1) != 0)
				{
					array4[i]++;
					for (int j = num3; j < num3 + 16; j++)
					{
						array2[j] = Inlines.silk_RSHIFT(array2[j], 1);
					}
				}
				num3 += 16;
			}
			int num4 = int.MaxValue;
			for (int j = 0; j < 9; j++)
			{
				byte[] array5 = Tables.silk_pulses_per_block_BITS_Q5[j];
				int num5 = Tables.silk_rate_levels_BITS_Q5[signalType >> 1][j];
				for (int i = 0; i < num2; i++)
				{
					num5 = ((array4[i] <= 0) ? (num5 + array5[array3[i]]) : (num5 + array5[17]));
				}
				if (num5 < num4)
				{
					num4 = num5;
					num = j;
				}
			}
			psRangeEnc.enc_icdf(num, Tables.silk_rate_levels_iCDF[signalType >> 1], 8u);
			for (int i = 0; i < num2; i++)
			{
				if (array4[i] == 0)
				{
					psRangeEnc.enc_icdf(array3[i], Tables.silk_pulses_per_block_iCDF[num], 8u);
					continue;
				}
				psRangeEnc.enc_icdf(17, Tables.silk_pulses_per_block_iCDF[num], 8u);
				for (int j = 0; j < array4[i] - 1; j++)
				{
					psRangeEnc.enc_icdf(17, Tables.silk_pulses_per_block_iCDF[9], 8u);
				}
				psRangeEnc.enc_icdf(array3[i], Tables.silk_pulses_per_block_iCDF[9], 8u);
			}
			for (int i = 0; i < num2; i++)
			{
				if (array3[i] > 0)
				{
					ShellCoder.silk_shell_encoder(psRangeEnc, array2, i * 16);
				}
			}
			for (int i = 0; i < num2; i++)
			{
				if (array4[i] <= 0)
				{
					continue;
				}
				int num6 = i * 16;
				int num7 = array4[i] - 1;
				for (int j = 0; j < 16; j++)
				{
					int num8 = (sbyte)Inlines.silk_abs(pulses[num6 + j]);
					int s;
					for (int num9 = num7; num9 > 0; num9--)
					{
						s = Inlines.silk_RSHIFT(num8, num9) & 1;
						psRangeEnc.enc_icdf(s, Tables.silk_lsb_iCDF, 8u);
					}
					s = num8 & 1;
					psRangeEnc.enc_icdf(s, Tables.silk_lsb_iCDF, 8u);
				}
			}
			CodeSigns.silk_encode_signs(psRangeEnc, pulses, frame_length, signalType, quantOffsetType, array3);
		}
	}
	internal static class Filters
	{
		private static readonly short A_fb1_20 = 10788;

		private static readonly short A_fb1_21 = -24290;

		private const int QA = 24;

		private static readonly int A_LIMIT = 16773022;

		internal static void silk_warped_LPC_analysis_filter(int[] state, int[] res_Q2, short[] coef_Q13, int coef_Q13_ptr, short[] input, int input_ptr, short lambda_Q16, int length, int order)
		{
			for (int i = 0; i < length; i++)
			{
				int num = Inlines.silk_SMLAWB(state[0], state[1], lambda_Q16);
				state[0] = Inlines.silk_LSHIFT(input[input_ptr + i], 14);
				int num2 = Inlines.silk_SMLAWB(state[1], state[2] - num, lambda_Q16);
				state[1] = num;
				int a = Inlines.silk_RSHIFT(order, 1);
				a = Inlines.silk_SMLAWB(a, num, coef_Q13[coef_Q13_ptr]);
				for (int j = 2; j < order; j += 2)
				{
					num = Inlines.silk_SMLAWB(state[j], state[j + 1] - num2, lambda_Q16);
					state[j] = num2;
					a = Inlines.silk_SMLAWB(a, num2, coef_Q13[coef_Q13_ptr + j - 1]);
					num2 = Inlines.silk_SMLAWB(state[j + 1], state[j + 2] - num, lambda_Q16);
					state[j + 1] = num;
					a = Inlines.silk_SMLAWB(a, num, coef_Q13[coef_Q13_ptr + j]);
				}
				state[order] = num2;
				a = Inlines.silk_SMLAWB(a, num2, coef_Q13[coef_Q13_ptr + order - 1]);
				res_Q2[i] = Inlines.silk_LSHIFT(input[input_ptr + i], 2) - Inlines.silk_RSHIFT_ROUND(a, 9);
			}
		}

		internal static void silk_prefilter(SilkChannelEncoder psEnc, SilkEncoderControl psEncCtrl, int[] xw_Q3, short[] x, int x_ptr)
		{
			SilkPrefilterState sPrefilt = psEnc.sPrefilt;
			short[] array = new short[2];
			int num = x_ptr;
			int num2 = 0;
			int lag = sPrefilt.lagPrev;
			int[] array2 = new int[psEnc.subfr_length];
			int[] array3 = new int[psEnc.subfr_length];
			for (int i = 0; i < psEnc.nb_subfr; i++)
			{
				if (psEnc.indices.signalType == 2)
				{
					lag = psEncCtrl.pitchL[i];
				}
				int num3 = Inlines.silk_SMULWB(psEncCtrl.HarmShapeGain_Q14[i], 16384 - psEncCtrl.HarmBoost_Q14[i]);
				int num4 = Inlines.silk_RSHIFT(num3, 2);
				num4 |= Inlines.silk_LSHIFT(Inlines.silk_RSHIFT(num3, 1), 16);
				int tilt_Q = psEncCtrl.Tilt_Q14[i];
				int lF_shp_Q = psEncCtrl.LF_shp_Q14[i];
				int coef_Q13_ptr = i * 16;
				silk_warped_LPC_analysis_filter(sPrefilt.sAR_shp, array3, psEncCtrl.AR1_Q13, coef_Q13_ptr, x, num, (short)psEnc.warping_Q16, psEnc.subfr_length, psEnc.shapingLPCOrder);
				array[0] = (short)Inlines.silk_RSHIFT_ROUND(psEncCtrl.GainsPre_Q14[i], 4);
				int a = Inlines.silk_SMLABB(3355443, psEncCtrl.HarmBoost_Q14[i], num3);
				a = Inlines.silk_SMLABB(a, psEncCtrl.coding_quality_Q14, 410);
				a = Inlines.silk_SMULWB(a, -psEncCtrl.GainsPre_Q14[i]);
				a = Inlines.silk_RSHIFT_ROUND(a, 14);
				array[1] = (short)Inlines.silk_SAT16(a);
				array2[0] = Inlines.silk_MLA(Inlines.silk_MUL(array3[0], array[0]), sPrefilt.sHarmHP_Q2, array[1]);
				for (int j = 1; j < psEnc.subfr_length; j++)
				{
					array2[j] = Inlines.silk_MLA(Inlines.silk_MUL(array3[j], array[0]), array3[j - 1], array[1]);
				}
				sPrefilt.sHarmHP_Q2 = array3[psEnc.subfr_length - 1];
				silk_prefilt(sPrefilt, array2, xw_Q3, num2, num4, tilt_Q, lF_shp_Q, lag, psEnc.subfr_length);
				num += psEnc.subfr_length;
				num2 += psEnc.subfr_length;
			}
			sPrefilt.lagPrev = psEncCtrl.pitchL[psEnc.nb_subfr - 1];
		}

		private static void silk_prefilt(SilkPrefilterState P, int[] st_res_Q12, int[] xw_Q3, int xw_Q3_ptr, int HarmShapeFIRPacked_Q12, int Tilt_Q14, int LF_shp_Q14, int lag, int length)
		{
			short[] sLTP_shp = P.sLTP_shp;
			int num = P.sLTP_shp_buf_idx;
			int num2 = P.sLF_AR_shp_Q12;
			int num3 = P.sLF_MA_shp_Q12;
			for (int i = 0; i < length; i++)
			{
				int a;
				if (lag > 0)
				{
					int num4 = lag + num;
					a = Inlines.silk_SMULBB(sLTP_shp[(num4 - 1 - 1) & 0x1FF], HarmShapeFIRPacked_Q12);
					a = Inlines.silk_SMLABT(a, sLTP_shp[(num4 - 1) & 0x1FF], HarmShapeFIRPacked_Q12);
					a = Inlines.silk_SMLABB(a, sLTP_shp[(num4 - 1 + 1) & 0x1FF], HarmShapeFIRPacked_Q12);
				}
				else
				{
					a = 0;
				}
				int a2 = Inlines.silk_SMULWB(num2, Tilt_Q14);
				int a3 = Inlines.silk_SMLAWB(Inlines.silk_SMULWT(num2, LF_shp_Q14), num3, LF_shp_Q14);
				num2 = Inlines.silk_SUB32(st_res_Q12[i], Inlines.silk_LSHIFT(a2, 2));
				num3 = Inlines.silk_SUB32(num2, Inlines.silk_LSHIFT(a3, 2));
				num = (num - 1) & 0x1FF;
				sLTP_shp[num] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(num3, 12));
				xw_Q3[xw_Q3_ptr + i] = Inlines.silk_RSHIFT_ROUND(Inlines.silk_SUB32(num3, a), 9);
			}
			P.sLF_AR_shp_Q12 = num2;
			P.sLF_MA_shp_Q12 = num3;
			P.sLTP_shp_buf_idx = num;
		}

		internal static void silk_biquad_alt(short[] input, int input_ptr, int[] B_Q28, int[] A_Q28, int[] S, short[] output, int output_ptr, int len, int stride)
		{
			int b = -A_Q28[0] & 0x3FFF;
			int c = Inlines.silk_RSHIFT(-A_Q28[0], 14);
			int b2 = -A_Q28[1] & 0x3FFF;
			int c2 = Inlines.silk_RSHIFT(-A_Q28[1], 14);
			for (int i = 0; i < len; i++)
			{
				int c3 = input[input_ptr + i * stride];
				int num = Inlines.silk_LSHIFT(Inlines.silk_SMLAWB(S[0], B_Q28[0], c3), 2);
				S[0] = S[1] + Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULWB(num, b), 14);
				S[0] = Inlines.silk_SMLAWB(S[0], num, c);
				S[0] = Inlines.silk_SMLAWB(S[0], B_Q28[1], c3);
				S[1] = Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULWB(num, b2), 14);
				S[1] = Inlines.silk_SMLAWB(S[1], num, c2);
				S[1] = Inlines.silk_SMLAWB(S[1], B_Q28[2], c3);
				output[output_ptr + i * stride] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT(num + 16384 - 1, 14));
			}
		}

		internal static void silk_biquad_alt(short[] input, int input_ptr, int[] B_Q28, int[] A_Q28, int[] S, int S_ptr, short[] output, int output_ptr, int len, int stride)
		{
			int b = -A_Q28[0] & 0x3FFF;
			int c = Inlines.silk_RSHIFT(-A_Q28[0], 14);
			int b2 = -A_Q28[1] & 0x3FFF;
			int c2 = Inlines.silk_RSHIFT(-A_Q28[1], 14);
			for (int i = 0; i < len; i++)
			{
				int num = S_ptr + 1;
				int c3 = input[input_ptr + i * stride];
				int num2 = Inlines.silk_LSHIFT(Inlines.silk_SMLAWB(S[S_ptr], B_Q28[0], c3), 2);
				S[S_ptr] = S[num] + Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULWB(num2, b), 14);
				S[S_ptr] = Inlines.silk_SMLAWB(S[S_ptr], num2, c);
				S[S_ptr] = Inlines.silk_SMLAWB(S[S_ptr], B_Q28[1], c3);
				S[num] = Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULWB(num2, b2), 14);
				S[num] = Inlines.silk_SMLAWB(S[num], num2, c2);
				S[num] = Inlines.silk_SMLAWB(S[num], B_Q28[2], c3);
				output[output_ptr + i * stride] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT(num2 + 16384 - 1, 14));
			}
		}

		internal static void silk_ana_filt_bank_1(short[] input, int input_ptr, int[] S, short[] outL, short[] outH, int outH_ptr, int N)
		{
			int num = Inlines.silk_RSHIFT(N, 1);
			for (int i = 0; i < num; i++)
			{
				int a = Inlines.silk_LSHIFT(input[input_ptr + 2 * i], 10);
				int num2 = Inlines.silk_SUB32(a, S[0]);
				int b = Inlines.silk_SMLAWB(num2, num2, A_fb1_21);
				int b2 = Inlines.silk_ADD32(S[0], b);
				S[0] = Inlines.silk_ADD32(a, b);
				a = Inlines.silk_LSHIFT(input[input_ptr + 2 * i + 1], 10);
				b = Inlines.silk_SMULWB(Inlines.silk_SUB32(a, S[1]), A_fb1_20);
				int a2 = Inlines.silk_ADD32(S[1], b);
				S[1] = Inlines.silk_ADD32(a, b);
				outL[i] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(Inlines.silk_ADD32(a2, b2), 11));
				outH[outH_ptr + i] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(Inlines.silk_SUB32(a2, b2), 11));
			}
		}

		internal static void silk_bwexpander_32(int[] ar, int d, int chirp_Q16)
		{
			int b = chirp_Q16 - 65536;
			for (int i = 0; i < d - 1; i++)
			{
				ar[i] = Inlines.silk_SMULWW(chirp_Q16, ar[i]);
				chirp_Q16 += Inlines.silk_RSHIFT_ROUND(Inlines.silk_MUL(chirp_Q16, b), 16);
			}
			ar[d - 1] = Inlines.silk_SMULWW(chirp_Q16, ar[d - 1]);
		}

		internal static void silk_LP_interpolate_filter_taps(int[] B_Q28, int[] A_Q28, int ind, int fac_Q16)
		{
			if (ind < 4)
			{
				if (fac_Q16 > 0)
				{
					if (fac_Q16 < 32768)
					{
						for (int i = 0; i < 3; i++)
						{
							B_Q28[i] = Inlines.silk_SMLAWB(Tables.silk_Transition_LP_B_Q28[ind][i], Tables.silk_Transition_LP_B_Q28[ind + 1][i] - Tables.silk_Transition_LP_B_Q28[ind][i], fac_Q16);
						}
						for (int j = 0; j < 2; j++)
						{
							A_Q28[j] = Inlines.silk_SMLAWB(Tables.silk_Transition_LP_A_Q28[ind][j], Tables.silk_Transition_LP_A_Q28[ind + 1][j] - Tables.silk_Transition_LP_A_Q28[ind][j], fac_Q16);
						}
					}
					else
					{
						for (int i = 0; i < 3; i++)
						{
							B_Q28[i] = Inlines.silk_SMLAWB(Tables.silk_Transition_LP_B_Q28[ind + 1][i], Tables.silk_Transition_LP_B_Q28[ind + 1][i] - Tables.silk_Transition_LP_B_Q28[ind][i], fac_Q16 - 65536);
						}
						for (int j = 0; j < 2; j++)
						{
							A_Q28[j] = Inlines.silk_SMLAWB(Tables.silk_Transition_LP_A_Q28[ind + 1][j], Tables.silk_Transition_LP_A_Q28[ind + 1][j] - Tables.silk_Transition_LP_A_Q28[ind][j], fac_Q16 - 65536);
						}
					}
				}
				else
				{
					Array.Copy(Tables.silk_Transition_LP_B_Q28[ind], 0, B_Q28, 0, 3);
					Array.Copy(Tables.silk_Transition_LP_A_Q28[ind], 0, A_Q28, 0, 2);
				}
			}
			else
			{
				Array.Copy(Tables.silk_Transition_LP_B_Q28[4], 0, B_Q28, 0, 3);
				Array.Copy(Tables.silk_Transition_LP_A_Q28[4], 0, A_Q28, 0, 2);
			}
		}

		internal static void silk_LPC_analysis_filter(short[] output, int output_ptr, short[] input, int input_ptr, short[] B, int B_ptr, int len, int d)
		{
			short[] array = new short[16];
			short[] array2 = new short[16];
			for (int i = 0; i < d; i++)
			{
				array2[i] = (short)(-B[B_ptr + i]);
			}
			for (int i = 0; i < d; i++)
			{
				array[i] = input[input_ptr + d - i - 1];
			}
			Kernels.celt_fir(input, input_ptr + d, array2, output, output_ptr + d, len - d, d, array);
			for (int i = output_ptr; i < output_ptr + d; i++)
			{
				output[i] = 0;
			}
		}

		internal static int LPC_inverse_pred_gain_QA(int[][] A_QA, int order)
		{
			int[] array = A_QA[order & 1];
			int a = 1073741824;
			int num2;
			int num3;
			for (int num = order - 1; num > 0; num--)
			{
				if (array[num] > A_LIMIT || array[num] < -A_LIMIT)
				{
					return 0;
				}
				num2 = -Inlines.silk_LSHIFT(array[num], 7);
				num3 = 1073741824 - Inlines.silk_SMMUL(num2, num2);
				int num4 = 32 - Inlines.silk_CLZ32(Inlines.silk_abs(num3));
				int b = Inlines.silk_INVERSE32_varQ(num3, num4 + 30);
				a = Inlines.silk_LSHIFT(Inlines.silk_SMMUL(a, num3), 2);
				int[] array2 = array;
				array = A_QA[num & 1];
				for (int i = 0; i < num; i++)
				{
					int a2 = array2[i] - Inlines.MUL32_FRAC_Q(array2[num - i - 1], num2, 31);
					array[i] = Inlines.MUL32_FRAC_Q(a2, b, num4);
				}
			}
			if (array[0] > A_LIMIT || array[0] < -A_LIMIT)
			{
				return 0;
			}
			num2 = -Inlines.silk_LSHIFT(array[0], 7);
			num3 = 1073741824 - Inlines.silk_SMMUL(num2, num2);
			return Inlines.silk_LSHIFT(Inlines.silk_SMMUL(a, num3), 2);
		}

		internal static int silk_LPC_inverse_pred_gain(short[] A_Q12, int order)
		{
			int[][] array = new int[2][]
			{
				new int[order],
				new int[order]
			};
			int num = 0;
			int[] array2 = array[order & 1];
			for (int i = 0; i < order; i++)
			{
				num += A_Q12[i];
				array2[i] = Inlines.silk_LSHIFT32(A_Q12[i], 12);
			}
			if (num >= 4096)
			{
				return 0;
			}
			return LPC_inverse_pred_gain_QA(array, order);
		}
	}
	internal static class FindLPC
	{
		internal static void silk_find_LPC(SilkChannelEncoder psEncC, short[] NLSF_Q15, short[] x, int minInvGain_Q30)
		{
			int[] a_Q = new int[16];
			BoxedValueInt boxedValueInt = new BoxedValueInt();
			BoxedValueInt boxedValueInt2 = new BoxedValueInt();
			int[] a_Q2 = new int[16];
			short[] array = new short[16];
			short[] array2 = new short[16];
			int num = psEncC.subfr_length + psEncC.predictLPCOrder;
			psEncC.indices.NLSFInterpCoef_Q2 = 4;
			BurgModified.silk_burg_modified(boxedValueInt, boxedValueInt2, a_Q, x, 0, minInvGain_Q30, num, psEncC.nb_subfr, psEncC.predictLPCOrder);
			int num2 = boxedValueInt.Val;
			int num3 = boxedValueInt2.Val;
			if (psEncC.useInterpolatedNLSFs != 0 && psEncC.first_frame_after_reset == 0 && psEncC.nb_subfr == 4)
			{
				BurgModified.silk_burg_modified(boxedValueInt, boxedValueInt2, a_Q2, x, 2 * num, minInvGain_Q30, num, 2, psEncC.predictLPCOrder);
				int val = boxedValueInt.Val;
				int val2 = boxedValueInt2.Val;
				int num4 = val2 - num3;
				if (num4 >= 0)
				{
					if (num4 < 32)
					{
						num2 -= Inlines.silk_RSHIFT(val, num4);
					}
				}
				else
				{
					num2 = Inlines.silk_RSHIFT(num2, -num4) - val;
					num3 = val2;
				}
				NLSF.silk_A2NLSF(NLSF_Q15, a_Q2, psEncC.predictLPCOrder);
				short[] array3 = new short[2 * num];
				for (int num5 = 3; num5 >= 0; num5--)
				{
					Inlines.silk_interpolate(array2, psEncC.prev_NLSFq_Q15, NLSF_Q15, num5, psEncC.predictLPCOrder);
					NLSF.silk_NLSF2A(array, array2, psEncC.predictLPCOrder);
					Filters.silk_LPC_analysis_filter(array3, 0, x, 0, array, 0, 2 * num, psEncC.predictLPCOrder);
					SumSqrShift.silk_sum_sqr_shift(out var energy, out var shift, array3, psEncC.predictLPCOrder, num - psEncC.predictLPCOrder);
					SumSqrShift.silk_sum_sqr_shift(out var energy2, out var shift2, array3, psEncC.predictLPCOrder + num, num - psEncC.predictLPCOrder);
					num4 = shift - shift2;
					int num6;
					if (num4 >= 0)
					{
						energy2 = Inlines.silk_RSHIFT(energy2, num4);
						num6 = -shift;
					}
					else
					{
						energy = Inlines.silk_RSHIFT(energy, -num4);
						num6 = -shift2;
					}
					int num7 = Inlines.silk_ADD32(energy, energy2);
					num4 = num6 - num3;
					int num8 = ((num4 >= 0) ? ((Inlines.silk_RSHIFT(num7, num4) < num2) ? 1 : 0) : ((-num4 < 32) ? ((num7 < Inlines.silk_RSHIFT(num2, -num4)) ? 1 : 0) : 0));
					if (num8 == 1)
					{
						num2 = num7;
						num3 = num6;
						psEncC.indices.NLSFInterpCoef_Q2 = (sbyte)num5;
					}
				}
			}
			if (psEncC.indices.NLSFInterpCoef_Q2 == 4)
			{
				NLSF.silk_A2NLSF(NLSF_Q15, a_Q, psEncC.predictLPCOrder);
			}
		}
	}
	internal static class FindLTP
	{
		private const int LTP_CORRS_HEAD_ROOM = 2;

		internal static void silk_find_LTP(short[] b_Q14, int[] WLTP, BoxedValueInt LTPredCodGain_Q7, short[] r_lpc, int[] lag, int[] Wght_Q15, int subfr_length, int nb_subfr, int mem_offset, int[] corr_rshifts)
		{
			int[] array = new int[5];
			int[] array2 = new int[5];
			int[] array3 = new int[4];
			int[] array4 = new int[4];
			int[] array5 = new int[4];
			int[] array6 = new int[5];
			int[] array7 = new int[4];
			int num = 0;
			int num2 = 0;
			int num3 = mem_offset;
			int num5;
			int a3;
			for (int i = 0; i < nb_subfr; i++)
			{
				int x_ptr = num3 - (lag[i] + 2);
				SumSqrShift.silk_sum_sqr_shift(out array7[i], out var shift, r_lpc, num3, subfr_length);
				int num4 = Inlines.silk_CLZ32(array7[i]);
				if (num4 < 2)
				{
					array7[i] = Inlines.silk_RSHIFT_ROUND(array7[i], 2 - num4);
					shift += 2 - num4;
				}
				corr_rshifts[i] = shift;
				BoxedValueInt boxedValueInt = new BoxedValueInt(corr_rshifts[i]);
				CorrelateMatrix.silk_corrMatrix(r_lpc, x_ptr, subfr_length, 5, 2, WLTP, num2, boxedValueInt);
				corr_rshifts[i] = boxedValueInt.Val;
				CorrelateMatrix.silk_corrVector(r_lpc, x_ptr, r_lpc, num3, subfr_length, 5, array6, corr_rshifts[i]);
				if (corr_rshifts[i] > shift)
				{
					array7[i] = Inlines.silk_RSHIFT(array7[i], corr_rshifts[i] - shift);
				}
				int a = 1;
				a = Inlines.silk_SMLAWB(a, array7[i], 1092);
				a = Inlines.silk_SMLAWB(a, Inlines.MatrixGet(WLTP, num2, 0, 0, 5), 1092);
				a = Inlines.silk_SMLAWB(a, Inlines.MatrixGet(WLTP, num2, 4, 4, 5), 1092);
				RegularizeCorrelations.silk_regularize_correlations(WLTP, num2, array7, i, a, 5);
				LinearAlgebra.silk_solve_LDL(WLTP, num2, 5, array6, array);
				silk_fit_LTP(array, b_Q14, num);
				array4[i] = ResidualEnergy.silk_residual_energy16_covar(b_Q14, num, WLTP, num2, array6, array7[i], 5, 14);
				num5 = Inlines.silk_min_int(corr_rshifts[i], 2);
				int a2 = Inlines.silk_LSHIFT_SAT32(Inlines.silk_SMULWB(array4[i], Wght_Q15[i]), 1 + num5) + Inlines.silk_RSHIFT(Inlines.silk_SMULWB(subfr_length, 655), corr_rshifts[i] - num5);
				a2 = Inlines.silk_max(a2, 1);
				a3 = Inlines.silk_DIV32(Inlines.silk_LSHIFT(Wght_Q15[i], 16), a2);
				a3 = Inlines.silk_RSHIFT(a3, 31 + corr_rshifts[i] - num5 - 26);
				int num6 = 0;
				for (int j = num2; j < num2 + 25; j++)
				{
					num6 = Inlines.silk_max(WLTP[j], num6);
				}
				int num7 = Inlines.silk_CLZ32(num6) - 1 - 3;
				if (8 + num7 < 31)
				{
					a3 = Inlines.silk_min_32(a3, Inlines.silk_LSHIFT(1, 8 + num7));
				}
				Inlines.silk_scale_vector32_Q26_lshift_18(WLTP, num2, a3, 25);
				array5[i] = Inlines.MatrixGet(WLTP, num2, 2, 2, 5);
				num3 += subfr_length;
				num += 5;
				num2 += 25;
			}
			int num8 = 0;
			for (int i = 0; i < nb_subfr; i++)
			{
				num8 = Inlines.silk_max_int(corr_rshifts[i], num8);
			}
			if (LTPredCodGain_Q7 != null)
			{
				int a4 = 0;
				int num9 = 0;
				for (int i = 0; i < nb_subfr; i++)
				{
					num9 = Inlines.silk_ADD32(num9, Inlines.silk_RSHIFT(Inlines.silk_ADD32(Inlines.silk_SMULWB(array7[i], Wght_Q15[i]), 1), 1 + (num8 - corr_rshifts[i])));
					a4 = Inlines.silk_ADD32(a4, Inlines.silk_RSHIFT(Inlines.silk_ADD32(Inlines.silk_SMULWB(array4[i], Wght_Q15[i]), 1), 1 + (num8 - corr_rshifts[i])));
				}
				a4 = Inlines.silk_max(a4, 1);
				int inLin = Inlines.silk_DIV32_varQ(num9, a4, 16);
				LTPredCodGain_Q7.Val = Inlines.silk_SMULBB(3, Inlines.silk_lin2log(inLin) - 2048);
			}
			num = 0;
			for (int i = 0; i < nb_subfr; i++)
			{
				array3[i] = 0;
				for (int j = num; j < num + 5; j++)
				{
					array3[i] += b_Q14[j];
				}
				num += 5;
			}
			int num10 = 0;
			int num11 = 0;
			for (int i = 0; i < nb_subfr; i++)
			{
				num10 = Inlines.silk_max_32(num10, Inlines.silk_abs(array3[i]));
				num11 = Inlines.silk_max_32(num11, 32 - Inlines.silk_CLZ32(array5[i]) + corr_rshifts[i] - num8);
			}
			num5 = num11 + 32 - Inlines.silk_CLZ32(num10) - 14;
			num5 -= 29 + num8;
			num5 = Inlines.silk_max_int(num5, 0);
			int num12 = num8 + num5;
			a3 = Inlines.silk_RSHIFT(262, num8 + num5) + 1;
			int num13 = 0;
			for (int i = 0; i < nb_subfr; i++)
			{
				a3 = Inlines.silk_ADD32(a3, Inlines.silk_RSHIFT(array5[i], num12 - corr_rshifts[i]));
				num13 = Inlines.silk_ADD32(num13, Inlines.silk_LSHIFT(Inlines.silk_SMULWW(Inlines.silk_RSHIFT(array5[i], num12 - corr_rshifts[i]), array3[i]), 2));
			}
			int a5 = Inlines.silk_DIV32_varQ(num13, a3, 12);
			num = 0;
			for (int i = 0; i < nb_subfr; i++)
			{
				a3 = ((2 - corr_rshifts[i] <= 0) ? Inlines.silk_LSHIFT_SAT32(array5[i], corr_rshifts[i] - 2) : Inlines.silk_RSHIFT(array5[i], 2 - corr_rshifts[i]));
				int a6 = Inlines.silk_MUL(Inlines.silk_DIV32(6710887, Inlines.silk_RSHIFT(6710887, 10) + a3), Inlines.silk_LSHIFT_SAT32(Inlines.silk_SUB_SAT32(a5, Inlines.silk_RSHIFT(array3[i], 2)), 4));
				a3 = 0;
				for (int j = 0; j < 5; j++)
				{
					array2[j] = Inlines.silk_max_16(b_Q14[num + j], 1638);
					a3 += array2[j];
				}
				a3 = Inlines.silk_DIV32(a6, a3);
				for (int j = 0; j < 5; j++)
				{
					b_Q14[num + j] = (short)Inlines.silk_LIMIT_32(b_Q14[num + j] + Inlines.silk_SMULWB(Inlines.silk_LSHIFT_SAT32(a3, 4), array2[j]), -16000, 28000);
				}
				num += 5;
			}
		}

		internal static void silk_fit_LTP(int[] LTP_coefs_Q16, short[] LTP_coefs_Q14, int LTP_coefs_Q14_ptr)
		{
			for (int i = 0; i < 5; i++)
			{
				LTP_coefs_Q14[LTP_coefs_Q14_ptr + i] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(LTP_coefs_Q16[i], 2));
			}
		}
	}
	internal static class FindPitchLags
	{
		internal static void silk_find_pitch_lags(SilkChannelEncoder psEnc, SilkEncoderControl psEncCtrl, short[] res, short[] x, int x_ptr)
		{
			int[] array = new int[17];
			short[] rc_Q = new short[16];
			int[] array2 = new int[16];
			short[] array3 = new short[16];
			int num = psEnc.la_pitch + psEnc.frame_length + psEnc.ltp_mem_length;
			int num2 = x_ptr - psEnc.ltp_mem_length;
			short[] array4 = new short[psEnc.pitch_LPC_win_length];
			int num3 = num2 + num - psEnc.pitch_LPC_win_length;
			int num4 = 0;
			ApplySineWindow.silk_apply_sine_window(array4, num4, x, num3, 1, psEnc.la_pitch);
			num4 += psEnc.la_pitch;
			num3 += psEnc.la_pitch;
			Array.Copy(x, num3, array4, num4, psEnc.pitch_LPC_win_length - Inlines.silk_LSHIFT(psEnc.la_pitch, 1));
			num4 += psEnc.pitch_LPC_win_length - Inlines.silk_LSHIFT(psEnc.la_pitch, 1);
			num3 += psEnc.pitch_LPC_win_length - Inlines.silk_LSHIFT(psEnc.la_pitch, 1);
			ApplySineWindow.silk_apply_sine_window(array4, num4, x, num3, 2, psEnc.la_pitch);
			BoxedValueInt boxedValueInt = new BoxedValueInt();
			Autocorrelation.silk_autocorr(array, boxedValueInt, array4, psEnc.pitch_LPC_win_length, psEnc.pitchEstimationLPCOrder + 1);
			_ = boxedValueInt.Val;
			array[0] = Inlines.silk_SMLAWB(array[0], array[0], 66) + 1;
			int a = Schur.silk_schur(rc_Q, array, psEnc.pitchEstimationLPCOrder);
			psEncCtrl.predGain_Q16 = Inlines.silk_DIV32_varQ(array[0], Inlines.silk_max_int(a, 1), 16);
			K2A.silk_k2a(array2, rc_Q, psEnc.pitchEstimationLPCOrder);
			for (int i = 0; i < psEnc.pitchEstimationLPCOrder; i++)
			{
				array3[i] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT(array2[i], 12));
			}
			BWExpander.silk_bwexpander(array3, psEnc.pitchEstimationLPCOrder, 64881);
			Filters.silk_LPC_analysis_filter(res, 0, x, num2, array3, 0, num, psEnc.pitchEstimationLPCOrder);
			if (psEnc.indices.signalType != 0 && psEnc.first_frame_after_reset == 0)
			{
				int a2 = 4915;
				a2 = Inlines.silk_SMLABB(a2, -32, psEnc.pitchEstimationLPCOrder);
				a2 = Inlines.silk_SMLAWB(a2, -209714, psEnc.speech_activity_Q8);
				a2 = Inlines.silk_SMLABB(a2, -1228, Inlines.silk_RSHIFT(psEnc.prevSignalType, 1));
				a2 = Inlines.silk_SMLAWB(a2, -1637, psEnc.input_tilt_Q15);
				a2 = Inlines.silk_SAT16(a2);
				BoxedValueShort boxedValueShort = new BoxedValueShort(psEnc.indices.lagIndex);
				BoxedValueSbyte boxedValueSbyte = new BoxedValueSbyte(psEnc.indices.contourIndex);
				BoxedValueInt boxedValueInt2 = new BoxedValueInt(psEnc.LTPCorr_Q15);
				if (PitchAnalysisCore.silk_pitch_analysis_core(res, psEncCtrl.pitchL, boxedValueShort, boxedValueSbyte, boxedValueInt2, psEnc.prevLag, psEnc.pitchEstimationThreshold_Q16, a2, psEnc.fs_kHz, psEnc.pitchEstimationComplexity, psEnc.nb_subfr) == 0)
				{
					psEnc.indices.signalType = 2;
				}
				else
				{
					psEnc.indices.signalType = 1;
				}
				psEnc.indices.lagIndex = boxedValueShort.Val;
				psEnc.indices.contourIndex = boxedValueSbyte.Val;
				psEnc.LTPCorr_Q15 = boxedValueInt2.Val;
			}
			else
			{
				Arrays.MemSetInt(psEncCtrl.pitchL, 0, 4);
				psEnc.indices.lagIndex = 0;
				psEnc.indices.contourIndex = 0;
				psEnc.LTPCorr_Q15 = 0;
			}
		}
	}
	internal static class FindPredCoefs
	{
		internal static void silk_find_pred_coefs(SilkChannelEncoder psEnc, SilkEncoderControl psEncCtrl, short[] res_pitch, short[] x, int x_ptr, int condCoding)
		{
			int[] array = new int[4];
			int[] array2 = new int[4];
			int[] array3 = new int[4];
			short[] array4 = new short[16];
			int[] corr_rshifts = new int[4];
			int num = 33554431;
			for (int i = 0; i < psEnc.nb_subfr; i++)
			{
				num = Inlines.silk_min(num, psEncCtrl.Gains_Q16[i]);
			}
			for (int i = 0; i < psEnc.nb_subfr; i++)
			{
				array[i] = Inlines.silk_DIV32_varQ(num, psEncCtrl.Gains_Q16[i], 14);
				array[i] = Inlines.silk_max(array[i], 363);
				int a = Inlines.silk_SMULWB(array[i], array[i]);
				array3[i] = Inlines.silk_RSHIFT(a, 1);
				array2[i] = Inlines.silk_DIV32(65536, array[i]);
			}
			short[] array5 = new short[psEnc.nb_subfr * psEnc.predictLPCOrder + psEnc.frame_length];
			if (psEnc.indices.signalType == 2)
			{
				int[] array6 = new int[psEnc.nb_subfr * 5 * 5];
				BoxedValueInt boxedValueInt = new BoxedValueInt(psEncCtrl.LTPredCodGain_Q7);
				FindLTP.silk_find_LTP(psEncCtrl.LTPCoef_Q14, array6, boxedValueInt, res_pitch, psEncCtrl.pitchL, array3, psEnc.subfr_length, psEnc.nb_subfr, psEnc.ltp_mem_length, corr_rshifts);
				psEncCtrl.LTPredCodGain_Q7 = boxedValueInt.Val;
				BoxedValueSbyte boxedValueSbyte = new BoxedValueSbyte(psEnc.indices.PERIndex);
				BoxedValueInt boxedValueInt2 = new BoxedValueInt(psEnc.sum_log_gain_Q7);
				QuantizeLTPGains.silk_quant_LTP_gains(psEncCtrl.LTPCoef_Q14, psEnc.indices.LTPIndex, boxedValueSbyte, boxedValueInt2, array6, psEnc.mu_LTP_Q9, psEnc.LTPQuantLowComplexity, psEnc.nb_subfr);
				psEnc.indices.PERIndex = boxedValueSbyte.Val;
				psEnc.sum_log_gain_Q7 = boxedValueInt2.Val;
				LTPScaleControl.silk_LTP_scale_ctrl(psEnc, psEncCtrl, condCoding);
				LTPAnalysisFilter.silk_LTP_analysis_filter(array5, x, x_ptr - psEnc.predictLPCOrder, psEncCtrl.LTPCoef_Q14, psEncCtrl.pitchL, array, psEnc.subfr_length, psEnc.nb_subfr, psEnc.predictLPCOrder);
			}
			else
			{
				int num2 = x_ptr - psEnc.predictLPCOrder;
				int num3 = 0;
				for (int i = 0; i < psEnc.nb_subfr; i++)
				{
					Inlines.silk_scale_copy_vector16(array5, num3, x, num2, array[i], psEnc.subfr_length + psEnc.predictLPCOrder);
					num3 += psEnc.subfr_length + psEnc.predictLPCOrder;
					num2 += psEnc.subfr_length;
				}
				Arrays.MemSetShort(psEncCtrl.LTPCoef_Q14, 0, psEnc.nb_subfr * 5);
				psEncCtrl.LTPredCodGain_Q7 = 0;
				psEnc.sum_log_gain_Q7 = 0;
			}
			int minInvGain_Q;
			if (psEnc.first_frame_after_reset != 0)
			{
				minInvGain_Q = 10737418;
			}
			else
			{
				minInvGain_Q = Inlines.silk_log2lin(Inlines.silk_SMLAWB(2048, psEncCtrl.LTPredCodGain_Q7, 21845));
				minInvGain_Q = Inlines.silk_DIV32_varQ(minInvGain_Q, Inlines.silk_SMULWW(10000, Inlines.silk_SMLAWB(65536, 196608, psEncCtrl.coding_quality_Q14)), 14);
			}
			FindLPC.silk_find_LPC(psEnc, array4, array5, minInvGain_Q);
			NLSF.silk_process_NLSFs(psEnc, psEncCtrl.PredCoef_Q12, array4, psEnc.prev_NLSFq_Q15);
			ResidualEnergy.silk_residual_energy(psEncCtrl.ResNrg, psEncCtrl.ResNrgQ, array5, psEncCtrl.PredCoef_Q12, array2, psEnc.subfr_length, psEnc.nb_subfr, psEnc.predictLPCOrder);
			Array.Copy(array4, psEnc.prev_NLSFq_Q15, 16);
		}
	}
	internal static class GainQuantization
	{
		private static readonly int OFFSET = 2090;

		private static readonly int SCALE_Q16 = 2251;

		private static readonly int INV_SCALE_Q16 = 1907825;

		internal static void silk_gains_quant(sbyte[] ind, int[] gain_Q16, BoxedValueSbyte prev_ind, int conditional, int nb_subfr)
		{
			for (int i = 0; i < nb_subfr; i++)
			{
				ind[i] = (sbyte)Inlines.silk_SMULWB(SCALE_Q16, Inlines.silk_lin2log(gain_Q16[i]) - OFFSET);
				if (ind[i] < prev_ind.Val)
				{
					ind[i]++;
				}
				ind[i] = (sbyte)Inlines.silk_LIMIT_int(ind[i], 0, 63);
				if (i == 0 && conditional == 0)
				{
					ind[i] = (sbyte)Inlines.silk_LIMIT_int(ind[i], prev_ind.Val + -4, 63);
					prev_ind.Val = ind[i];
				}
				else
				{
					ind[i] -= prev_ind.Val;
					int num = 8 + prev_ind.Val;
					if (ind[i] > num)
					{
						ind[i] = (sbyte)(num + Inlines.silk_RSHIFT(ind[i] - num + 1, 1));
					}
					ind[i] = (sbyte)Inlines.silk_LIMIT_int(ind[i], -4, 36);
					if (ind[i] > num)
					{
						prev_ind.Val += (sbyte)(Inlines.silk_LSHIFT(ind[i], 1) - num);
					}
					else
					{
						prev_ind.Val += ind[i];
					}
					ind[i] -= -4;
				}
				gain_Q16[i] = Inlines.silk_log2lin(Inlines.silk_min_32(Inlines.silk_SMULWB(INV_SCALE_Q16, prev_ind.Val) + OFFSET, 3967));
			}
		}

		internal static void silk_gains_dequant(int[] gain_Q16, sbyte[] ind, BoxedValueSbyte prev_ind, int conditional, int nb_subfr)
		{
			for (int i = 0; i < nb_subfr; i++)
			{
				if (i == 0 && conditional == 0)
				{
					prev_ind.Val = (sbyte)Inlines.silk_max_int(ind[i], prev_ind.Val - 16);
				}
				else
				{
					int num = ind[i] + -4;
					int num2 = 8 + prev_ind.Val;
					if (num > num2)
					{
						prev_ind.Val += (sbyte)(Inlines.silk_LSHIFT(num, 1) - num2);
					}
					else
					{
						prev_ind.Val += (sbyte)num;
					}
				}
				prev_ind.Val = (sbyte)Inlines.silk_LIMIT_int(prev_ind.Val, 0, 63);
				gain_Q16[i] = Inlines.silk_log2lin(Inlines.silk_min_32(Inlines.silk_SMULWB(INV_SCALE_Q16, prev_ind.Val) + OFFSET, 3967));
			}
		}

		internal static int silk_gains_ID(sbyte[] ind, int nb_subfr)
		{
			int num = 0;
			for (int i = 0; i < nb_subfr; i++)
			{
				num = Inlines.silk_ADD_LSHIFT32(ind[i], num, 8);
			}
			return num;
		}
	}
	internal static class HPVariableCutoff
	{
		internal static void silk_HP_variable_cutoff(SilkChannelEncoder[] state_Fxx)
		{
			SilkChannelEncoder silkChannelEncoder = state_Fxx[0];
			if (silkChannelEncoder.prevSignalType == 2)
			{
				int num = Inlines.silk_lin2log(Inlines.silk_DIV32_16(Inlines.silk_LSHIFT(Inlines.silk_MUL(silkChannelEncoder.fs_kHz, 1000), 16), silkChannelEncoder.prevLag)) - 2048;
				int num2 = silkChannelEncoder.input_quality_bands_Q15[0];
				num = Inlines.silk_SMLAWB(num, Inlines.silk_SMULWB(Inlines.silk_LSHIFT(-num2, 2), num2), num - (Inlines.silk_lin2log(3932160) - 2048));
				int num3 = num - Inlines.silk_RSHIFT(silkChannelEncoder.variable_HP_smth1_Q15, 8);
				if (num3 < 0)
				{
					num3 = Inlines.silk_MUL(num3, 3);
				}
				num3 = Inlines.silk_LIMIT_32(num3, -51, 51);
				silkChannelEncoder.variable_HP_smth1_Q15 = Inlines.silk_SMLAWB(silkChannelEncoder.variable_HP_smth1_Q15, Inlines.silk_SMULBB(silkChannelEncoder.speech_activity_Q8, num3), 6554);
				silkChannelEncoder.variable_HP_smth1_Q15 = Inlines.silk_LIMIT_32(silkChannelEncoder.variable_HP_smth1_Q15, Inlines.silk_LSHIFT(Inlines.silk_lin2log(60), 8), Inlines.silk_LSHIFT(Inlines.silk_lin2log(100), 8));
			}
		}
	}
	internal static class K2A
	{
		internal static void silk_k2a(int[] A_Q24, short[] rc_Q15, int order)
		{
			int[] array = new int[16];
			for (int i = 0; i < order; i++)
			{
				for (int j = 0; j < i; j++)
				{
					array[j] = A_Q24[j];
				}
				for (int j = 0; j < i; j++)
				{
					A_Q24[j] = Inlines.silk_SMLAWB(A_Q24[j], Inlines.silk_LSHIFT(array[i - j - 1], 1), rc_Q15[i]);
				}
				A_Q24[i] = -Inlines.silk_LSHIFT(rc_Q15[i], 9);
			}
		}

		internal static void silk_k2a_Q16(int[] A_Q24, int[] rc_Q16, int order)
		{
			int[] array = new int[16];
			for (int i = 0; i < order; i++)
			{
				for (int j = 0; j < i; j++)
				{
					array[j] = A_Q24[j];
				}
				for (int j = 0; j < i; j++)
				{
					A_Q24[j] = Inlines.silk_SMLAWW(A_Q24[j], array[i - j - 1], rc_Q16[i]);
				}
				A_Q24[i] = -Inlines.silk_LSHIFT(rc_Q16[i], 8);
			}
		}
	}
	internal static class LinearAlgebra
	{
		internal static void silk_solve_LDL(int[] A, int A_ptr, int M, int[] b, int[] x_Q16)
		{
			int[] l_Q = new int[M * M];
			int[] array = new int[16];
			int[] inv_D = new int[32];
			silk_LDL_factorize(A, A_ptr, M, l_Q, inv_D);
			silk_LS_SolveFirst(l_Q, M, b, array);
			silk_LS_divide_Q16(array, inv_D, M);
			silk_LS_SolveLast(l_Q, M, array, x_Q16);
		}

		private static void silk_LDL_factorize(int[] A, int A_ptr, int M, int[] L_Q16, int[] inv_D)
		{
			int[] array = new int[M];
			int[] array2 = new int[M];
			int num = 1;
			int num2 = Inlines.silk_max_32(Inlines.silk_SMMUL(Inlines.silk_ADD_SAT32(A[A_ptr], A[A_ptr + Inlines.silk_SMULBB(M, M) - 1]), 21475), 512);
			for (int i = 0; i < M; i++)
			{
				if (num != 1)
				{
					break;
				}
				num = 0;
				for (int j = 0; j < M; j++)
				{
					int[] array3 = L_Q16;
					int num3 = Inlines.MatrixGetPointer(j, 0, M);
					int num4 = 0;
					for (int k = 0; k < j; k++)
					{
						array[k] = Inlines.silk_SMULWW(array2[k], array3[num3 + k]);
						num4 = Inlines.silk_SMLAWW(num4, array[k], array3[num3 + k]);
					}
					num4 = Inlines.silk_SUB32(Inlines.MatrixGet(A, A_ptr, j, j, M), num4);
					if (num4 < num2)
					{
						num4 = Inlines.silk_SUB32(Inlines.silk_SMULBB(i + 1, num2), num4);
						for (int k = 0; k < M; k++)
						{
							Inlines.MatrixSet(A, A_ptr, k, k, M, Inlines.silk_ADD32(Inlines.MatrixGet(A, A_ptr, k, k, M), num4));
						}
						num = 1;
						break;
					}
					array2[j] = num4;
					int num5 = Inlines.silk_INVERSE32_varQ(num4, 36);
					int b = Inlines.silk_LSHIFT(num5, 4);
					int num6 = Inlines.silk_SMULWW(Inlines.silk_SUB32(16777216, Inlines.silk_SMULWW(num4, b)), b);
					inv_D[j * 2] = num5;
					inv_D[j * 2 + 1] = num6;
					Inlines.MatrixSet(L_Q16, j, j, M, 65536);
					array3 = A;
					num3 = Inlines.MatrixGetPointer(j, 0, M) + A_ptr;
					int num7 = Inlines.MatrixGetPointer(j + 1, 0, M);
					for (int k = j + 1; k < M; k++)
					{
						num4 = 0;
						for (int l = 0; l < j; l++)
						{
							num4 = Inlines.silk_SMLAWW(num4, array[l], L_Q16[num7 + l]);
						}
						num4 = Inlines.silk_SUB32(array3[num3 + k], num4);
						Inlines.MatrixSet(L_Q16, k, j, M, Inlines.silk_ADD32(Inlines.silk_SMMUL(num4, num6), Inlines.silk_RSHIFT(Inlines.silk_SMULWW(num4, num5), 4)));
						num7 += M;
					}
				}
			}
		}

		private static void silk_LS_divide_Q16(int[] T, int[] inv_D, int M)
		{
			for (int i = 0; i < M; i++)
			{
				int b = inv_D[i * 2];
				int b2 = inv_D[i * 2 + 1];
				int a = T[i];
				T[i] = Inlines.silk_ADD32(Inlines.silk_SMMUL(a, b2), Inlines.silk_RSHIFT(Inlines.silk_SMULWW(a, b), 4));
			}
		}

		private static void silk_LS_SolveFirst(int[] L_Q16, int M, int[] b, int[] x_Q16)
		{
			for (int i = 0; i < M; i++)
			{
				int num = Inlines.MatrixGetPointer(i, 0, M);
				int num2 = 0;
				for (int j = 0; j < i; j++)
				{
					num2 = Inlines.silk_SMLAWW(num2, L_Q16[num + j], x_Q16[j]);
				}
				x_Q16[i] = Inlines.silk_SUB32(b[i], num2);
			}
		}

		private static void silk_LS_SolveLast(int[] L_Q16, int M, int[] b, int[] x_Q16)
		{
			for (int num = M - 1; num >= 0; num--)
			{
				int num2 = Inlines.MatrixGetPointer(0, num, M);
				int num3 = 0;
				for (int num4 = M - 1; num4 > num; num4--)
				{
					num3 = Inlines.silk_SMLAWW(num3, L_Q16[num2 + Inlines.silk_SMULBB(num4, M)], x_Q16[num4]);
				}
				x_Q16[num] = Inlines.silk_SUB32(b[num], num3);
			}
		}
	}
	internal static class LPCInversePredGain
	{
		private const float RC_THRESHOLD = 0.9999f;

		private const int QA = 24;

		private static readonly int A_LIMIT = 16773022;

		internal static int LPC_inverse_pred_gain_QA(int[][] A_QA, int order)
		{
			int[] array = A_QA[order & 1];
			int a = 1073741824;
			int num2;
			int num3;
			for (int num = order - 1; num > 0; num--)
			{
				if (array[num] > A_LIMIT || array[num] < -A_LIMIT)
				{
					return 0;
				}
				num2 = -Inlines.silk_LSHIFT(array[num], 7);
				num3 = 1073741824 - Inlines.silk_SMMUL(num2, num2);
				int num4 = 32 - Inlines.silk_CLZ32(Inlines.silk_abs(num3));
				int b = Inlines.silk_INVERSE32_varQ(num3, num4 + 30);
				a = Inlines.silk_LSHIFT(Inlines.silk_SMMUL(a, num3), 2);
				int[] array2 = array;
				array = A_QA[num & 1];
				for (int i = 0; i < num; i++)
				{
					int a2 = array2[i] - Inlines.MUL32_FRAC_Q(array2[num - i - 1], num2, 31);
					array[i] = Inlines.MUL32_FRAC_Q(a2, b, num4);
				}
			}
			if (array[0] > A_LIMIT || array[0] < -A_LIMIT)
			{
				return 0;
			}
			num2 = -Inlines.silk_LSHIFT(array[0], 7);
			num3 = 1073741824 - Inlines.silk_SMMUL(num2, num2);
			return Inlines.silk_LSHIFT(Inlines.silk_SMMUL(a, num3), 2);
		}

		internal static int silk_LPC_inverse_pred_gain(short[] A_Q12, int order)
		{
			int[][] array = Arrays.InitTwoDimensionalArray<int>(2, 16);
			int num = 0;
			int[] array2 = array[order & 1];
			for (int i = 0; i < order; i++)
			{
				num += A_Q12[i];
				array2[i] = Inlines.silk_LSHIFT32(A_Q12[i], 12);
			}
			if (num >= 4096)
			{
				return 0;
			}
			return LPC_inverse_pred_gain_QA(array, order);
		}

		internal static int silk_LPC_inverse_pred_gain_Q24(int[] A_Q24, int order)
		{
			int[][] array = Arrays.InitTwoDimensionalArray<int>(2, 16);
			int[] array2 = array[order & 1];
			for (int i = 0; i < order; i++)
			{
				array2[i] = Inlines.silk_RSHIFT32(A_Q24[i], 0);
			}
			return LPC_inverse_pred_gain_QA(array, order);
		}
	}
	internal static class LTPAnalysisFilter
	{
		internal static void silk_LTP_analysis_filter(short[] LTP_res, short[] x, int x_ptr, short[] LTPCoef_Q14, int[] pitchL, int[] invGains_Q16, int subfr_length, int nb_subfr, int pre_length)
		{
			short[] array = new short[5];
			int num = x_ptr;
			int num2 = 0;
			for (int i = 0; i < nb_subfr; i++)
			{
				int num3 = num - pitchL[i];
				array[0] = LTPCoef_Q14[i * 5];
				array[1] = LTPCoef_Q14[i * 5 + 1];
				array[2] = LTPCoef_Q14[i * 5 + 2];
				array[3] = LTPCoef_Q14[i * 5 + 3];
				array[4] = LTPCoef_Q14[i * 5 + 4];
				for (int j = 0; j < subfr_length + pre_length; j++)
				{
					int num4 = num2 + j;
					LTP_res[num4] = x[num + j];
					int a = Inlines.silk_SMULBB(x[num3 + 2], array[0]);
					a = Inlines.silk_SMLABB_ovflw(a, x[num3 + 1], array[1]);
					a = Inlines.silk_SMLABB_ovflw(a, x[num3], array[2]);
					a = Inlines.silk_SMLABB_ovflw(a, x[num3 - 1], array[3]);
					a = Inlines.silk_SMLABB_ovflw(a, x[num3 - 2], array[4]);
					a = Inlines.silk_RSHIFT_ROUND(a, 14);
					LTP_res[num4] = (short)Inlines.silk_SAT16(x[num + j] - a);
					LTP_res[num4] = (short)Inlines.silk_SMULWB(invGains_Q16[i], LTP_res[num4]);
					num3++;
				}
				num2 += subfr_length + pre_length;
				num += subfr_length;
			}
		}
	}
	internal static class LTPScaleControl
	{
		internal static void silk_LTP_scale_ctrl(SilkChannelEncoder psEnc, SilkEncoderControl psEncCtrl, int condCoding)
		{
			if (condCoding == 0)
			{
				int a = psEnc.PacketLoss_perc + psEnc.nFramesPerPacket;
				psEnc.indices.LTP_scaleIndex = (sbyte)Inlines.silk_LIMIT(Inlines.silk_SMULWB(Inlines.silk_SMULBB(a, psEncCtrl.LTPredCodGain_Q7), 51), 0, 2);
			}
			else
			{
				psEnc.indices.LTP_scaleIndex = 0;
			}
			psEncCtrl.LTP_scale_Q14 = Tables.silk_LTPScales_table_Q14[psEnc.indices.LTP_scaleIndex];
		}
	}
	internal static class NLSF
	{
		private const int MAX_STABILIZE_LOOPS = 20;

		private const int QA = 16;

		private const int BIN_DIV_STEPS_A2NLSF = 3;

		private const int MAX_ITERATIONS_A2NLSF = 30;

		private static readonly byte[] ordering16 = new byte[16]
		{
			0, 15, 8, 7, 4, 11, 12, 3, 2, 13,
			10, 5, 6, 9, 14, 1
		};

		private static readonly byte[] ordering10 = new byte[10] { 0, 9, 6, 3, 4, 5, 8, 1, 2, 7 };

		internal static void silk_NLSF_VQ(int[] err_Q26, short[] in_Q15, byte[] pCB_Q8, int K, int LPC_order)
		{
			int num = 0;
			for (int i = 0; i < K; i++)
			{
				int num2 = 0;
				for (int j = 0; j < LPC_order; j += 2)
				{
					int num3 = Inlines.silk_SUB_LSHIFT32(in_Q15[j], pCB_Q8[num++], 7);
					int a = Inlines.silk_SMULBB(num3, num3);
					num3 = Inlines.silk_SUB_LSHIFT32(in_Q15[j + 1], pCB_Q8[num++], 7);
					a = Inlines.silk_SMLABB(a, num3, num3);
					num2 = Inlines.silk_ADD_RSHIFT32(num2, a, 4);
				}
				err_Q26[i] = num2;
			}
		}

		internal static void silk_NLSF_VQ_weights_laroia(short[] pNLSFW_Q_OUT, short[] pNLSF_Q15, int D)
		{
			int b = Inlines.silk_max_int(pNLSF_Q15[0], 1);
			b = Inlines.silk_DIV32(131072, b);
			int b2 = Inlines.silk_max_int(pNLSF_Q15[1] - pNLSF_Q15[0], 1);
			b2 = Inlines.silk_DIV32(131072, b2);
			pNLSFW_Q_OUT[0] = (short)Inlines.silk_min_int(b + b2, 32767);
			for (int i = 1; i < D - 1; i += 2)
			{
				b = Inlines.silk_max_int(pNLSF_Q15[i + 1] - pNLSF_Q15[i], 1);
				b = Inlines.silk_DIV32(131072, b);
				pNLSFW_Q_OUT[i] = (short)Inlines.silk_min_int(b + b2, 32767);
				b2 = Inlines.silk_max_int(pNLSF_Q15[i + 2] - pNLSF_Q15[i + 1], 1);
				b2 = Inlines.silk_DIV32(131072, b2);
				pNLSFW_Q_OUT[i + 1] = (short)Inlines.silk_min_int(b + b2, 32767);
			}
			b = Inlines.silk_max_int(32768 - pNLSF_Q15[D - 1], 1);
			b = Inlines.silk_DIV32(131072, b);
			pNLSFW_Q_OUT[D - 1] = (short)Inlines.silk_min_int(b + b2, 32767);
		}

		internal static void silk_NLSF_residual_dequant(short[] x_Q10, sbyte[] indices, int indices_ptr, byte[] pred_coef_Q8, int quant_step_size_Q16, short order)
		{
			short a = 0;
			for (int num = order - 1; num >= 0; num--)
			{
				int a2 = Inlines.silk_RSHIFT(Inlines.silk_SMULBB(a, pred_coef_Q8[num]), 8);
				a = Inlines.silk_LSHIFT16(indices[indices_ptr + num], 10);
				if (a > 0)
				{
					a = Inlines.silk_SUB16(a, 102);
				}
				else if (a < 0)
				{
					a = Inlines.silk_ADD16(a, 102);
				}
				a = (x_Q10[num] = (short)Inlines.silk_SMLAWB(a2, a, quant_step_size_Q16));
			}
		}

		internal static void silk_NLSF_unpack(short[] ec_ix, byte[] pred_Q8, NLSFCodebook psNLSF_CB, int CB1_index)
		{
			byte[] ec_sel = psNLSF_CB.ec_sel;
			int num = CB1_index * psNLSF_CB.order / 2;
			for (int i = 0; i < psNLSF_CB.order; i += 2)
			{
				byte b = ec_sel[num];
				num++;
				ec_ix[i] = (short)Inlines.silk_SMULBB(Inlines.silk_RSHIFT(b, 1) & 7, 9);
				pred_Q8[i] = psNLSF_CB.pred_Q8[i + (b & 1) * (psNLSF_CB.order - 1)];
				ec_ix[i + 1] = (short)Inlines.silk_SMULBB(Inlines.silk_RSHIFT(b, 5) & 7, 9);
				pred_Q8[i + 1] = psNLSF_CB.pred_Q8[i + (Inlines.silk_RSHIFT(b, 4) & 1) * (psNLSF_CB.order - 1) + 1];
			}
		}

		internal static void silk_NLSF_stabilize(short[] NLSF_Q15, short[] NDeltaMin_Q15, int L)
		{
			int num = 0;
			int i;
			for (i = 0; i < 20; i++)
			{
				int num2 = NLSF_Q15[0] - NDeltaMin_Q15[0];
				num = 0;
				int num3;
				for (int j = 1; j <= L - 1; j++)
				{
					num3 = NLSF_Q15[j] - (NLSF_Q15[j - 1] + NDeltaMin_Q15[j]);
					if (num3 < num2)
					{
						num2 = num3;
						num = j;
					}
				}
				num3 = 32768 - (NLSF_Q15[L - 1] + NDeltaMin_Q15[L]);
				if (num3 < num2)
				{
					num2 = num3;
					num = L;
				}
				if (num2 >= 0)
				{
					return;
				}
				if (num == 0)
				{
					NLSF_Q15[0] = NDeltaMin_Q15[0];
					continue;
				}
				if (num == L)
				{
					NLSF_Q15[L - 1] = (short)(32768 - NDeltaMin_Q15[L]);
					continue;
				}
				int num4 = 0;
				for (int k = 0; k < num; k++)
				{
					num4 += NDeltaMin_Q15[k];
				}
				num4 += Inlines.silk_RSHIFT(NDeltaMin_Q15[num], 1);
				int num5 = 32768;
				for (int k = L; k > num; k--)
				{
					num5 -= NDeltaMin_Q15[k];
				}
				num5 -= Inlines.silk_RSHIFT(NDeltaMin_Q15[num], 1);
				short num6 = (short)Inlines.silk_LIMIT_32(Inlines.silk_RSHIFT_ROUND(NLSF_Q15[num - 1] + NLSF_Q15[num], 1), num4, num5);
				NLSF_Q15[num - 1] = (short)(num6 - Inlines.silk_RSHIFT(NDeltaMin_Q15[num], 1));
				NLSF_Q15[num] = (short)(NLSF_Q15[num - 1] + NDeltaMin_Q15[num]);
			}
			if (i == 20)
			{
				Sort.silk_insertion_sort_increasing_all_values_int16(NLSF_Q15, L);
				NLSF_Q15[0] = (short)Inlines.silk_max_int(NLSF_Q15[0], NDeltaMin_Q15[0]);
				for (int j = 1; j < L; j++)
				{
					NLSF_Q15[j] = (short)Inlines.silk_max_int(NLSF_Q15[j], NLSF_Q15[j - 1] + NDeltaMin_Q15[j]);
				}
				NLSF_Q15[L - 1] = (short)Inlines.silk_min_int(NLSF_Q15[L - 1], 32768 - NDeltaMin_Q15[L]);
				for (int j = L - 2; j >= 0; j--)
				{
					NLSF_Q15[j] = (short)Inlines.silk_min_int(NLSF_Q15[j], NLSF_Q15[j + 1] - NDeltaMin_Q15[j + 1]);
				}
			}
		}

		internal static void silk_NLSF_decode(short[] pNLSF_Q15, sbyte[] NLSFIndices, NLSFCodebook psNLSF_CB)
		{
			byte[] array = new byte[psNLSF_CB.order];
			short[] ec_ix = new short[psNLSF_CB.order];
			short[] array2 = new short[psNLSF_CB.order];
			short[] array3 = new short[psNLSF_CB.order];
			byte[] cB1_NLSF_Q = psNLSF_CB.CB1_NLSF_Q8;
			int num = NLSFIndices[0] * psNLSF_CB.order;
			for (int i = 0; i < psNLSF_CB.order; i++)
			{
				pNLSF_Q15[i] = Inlines.silk_LSHIFT16(cB1_NLSF_Q[num + i], 7);
			}
			silk_NLSF_unpack(ec_ix, array, psNLSF_CB, NLSFIndices[0]);
			silk_NLSF_residual_dequant(array2, NLSFIndices, 1, array, psNLSF_CB.quantStepSize_Q16, psNLSF_CB.order);
			silk_NLSF_VQ_weights_laroia(array3, pNLSF_Q15, psNLSF_CB.order);
			for (int i = 0; i < psNLSF_CB.order; i++)
			{
				int num2 = Inlines.silk_SQRT_APPROX(Inlines.silk_LSHIFT(array3[i], 16));
				int a = Inlines.silk_ADD32(pNLSF_Q15[i], Inlines.silk_DIV32_16(Inlines.silk_LSHIFT(array2[i], 14), (short)num2));
				pNLSF_Q15[i] = (short)Inlines.silk_LIMIT(a, 0, 32767);
			}
			silk_NLSF_stabilize(pNLSF_Q15, psNLSF_CB.deltaMin_Q15, psNLSF_CB.order);
		}

		internal static int silk_NLSF_del_dec_quant(sbyte[] indices, short[] x_Q10, short[] w_Q5, byte[] pred_coef_Q8, short[] ec_ix, byte[] ec_rates_Q5, int quant_step_size_Q16, short inv_quant_step_size_Q6, int mu_Q20, short order)
		{
			int[] array = new int[4];
			sbyte[][] array2 = new sbyte[4][];
			int i;
			for (i = 0; i < 4; i++)
			{
				array2[i] = new sbyte[16];
			}
			short[] array3 = new short[8];
			int[] array4 = new int[8];
			int[] array5 = new int[4];
			int[] array6 = new int[4];
			int[] array7 = new int[20];
			int[] array8 = new int[20];
			for (i = -10; i <= 9; i++)
			{
				int num = Inlines.silk_LSHIFT(i, 10);
				int num2 = Inlines.silk_ADD16((short)num, 1024);
				if (i > 0)
				{
					num = Inlines.silk_SUB16((short)num, 102);
					num2 = Inlines.silk_SUB16((short)num2, 102);
				}
				else
				{
					switch (i)
					{
					case 0:
						num2 = Inlines.silk_SUB16((short)num2, 102);
						break;
					case -1:
						num = Inlines.silk_ADD16((short)num, 102);
						break;
					default:
						num = Inlines.silk_ADD16((short)num, 102);
						num2 = Inlines.silk_ADD16((short)num2, 102);
						break;
					}
				}
				array7[i + 10] = Inlines.silk_SMULWB(num, quant_step_size_Q16);
				array8[i + 10] = Inlines.silk_SMULWB(num2, quant_step_size_Q16);
			}
			int num3 = 1;
			array4[0] = 0;
			array3[0] = 0;
			i = order - 1;
			int a2;
			while (true)
			{
				int a = Inlines.silk_LSHIFT(pred_coef_Q8[i], 8);
				int num4 = x_Q10[i];
				for (int j = 0; j < num3; j++)
				{
					int num5 = Inlines.silk_SMULWB(a, array3[j]);
					int b = Inlines.silk_SUB16((short)num4, (short)num5);
					a2 = Inlines.silk_SMULWB(inv_quant_step_size_Q6, b);
					a2 = Inlines.silk_LIMIT(a2, -10, 9);
					array2[j][i] = (sbyte)a2;
					int num6 = ec_ix[i] + a2;
					int num = array7[a2 + 10];
					int num2 = array8[a2 + 10];
					num = Inlines.silk_ADD16((short)num, (short)num5);
					num2 = Inlines.silk_ADD16((short)num2, (short)num5);
					array3[j] = (short)num;
					array3[j + num3] = (short)num2;
					int num7;
					int c;
					if (a2 + 1 >= 4)
					{
						if (a2 + 1 == 4)
						{
							num7 = ec_rates_Q5[num6 + 4];
							c = 280;
						}
						else
						{
							num7 = Inlines.silk_SMLABB(108, 43, a2);
							c = Inlines.silk_ADD16((short)num7, 43);
						}
					}
					else if (a2 <= -4)
					{
						if (a2 == -4)
						{
							num7 = 280;
							c = ec_rates_Q5[num6 + 1 + 4];
						}
						else
						{
							num7 = Inlines.silk_SMLABB(108, -43, a2);
							c = Inlines.silk_SUB16((short)num7, 43);
						}
					}
					else
					{
						num7 = ec_rates_Q5[num6 + 4];
						c = ec_rates_Q5[num6 + 1 + 4];
					}
					int a3 = array4[j];
					int num8 = Inlines.silk_SUB16((short)num4, (short)num);
					array4[j] = Inlines.silk_SMLABB(Inlines.silk_MLA(a3, Inlines.silk_SMULBB(num8, num8), w_Q5[i]), mu_Q20, num7);
					num8 = Inlines.silk_SUB16((short)num4, (short)num2);
					array4[j + num3] = Inlines.silk_SMLABB(Inlines.silk_MLA(a3, Inlines.silk_SMULBB(num8, num8), w_Q5[i]), mu_Q20, c);
				}
				if (num3 <= 2)
				{
					for (int j = 0; j < num3; j++)
					{
						array2[j + num3][i] = (sbyte)(array2[j][i] + 1);
					}
					num3 = Inlines.silk_LSHIFT(num3, 1);
					for (int j = num3; j < 4; j++)
					{
						array2[j][i] = array2[j - num3][i];
					}
				}
				else
				{
					if (i <= 0)
					{
						break;
					}
					for (int j = 0; j < 4; j++)
					{
						if (array4[j] > array4[j + 4])
						{
							array6[j] = array4[j];
							array5[j] = array4[j + 4];
							array4[j] = array5[j];
							array4[j + 4] = array6[j];
							int num = array3[j];
							array3[j] = array3[j + 4];
							array3[j + 4] = (short)num;
							array[j] = j + 4;
						}
						else
						{
							array5[j] = array4[j];
							array6[j] = array4[j + 4];
							array[j] = j;
						}
					}
					while (true)
					{
						int num9 = int.MaxValue;
						int num10 = 0;
						int num11 = 0;
						int num12 = 0;
						for (int j = 0; j < 4; j++)
						{
							if (num9 > array6[j])
							{
								num9 = array6[j];
								num11 = j;
							}
							if (num10 < array5[j])
							{
								num10 = array5[j];
								num12 = j;
							}
						}
						if (num9 >= num10)
						{
							break;
						}
						array[num12] = array[num11] ^ 4;
						array4[num12] = array4[num11 + 4];
						array3[num12] = array3[num11 + 4];
						array5[num12] = 0;
						array6[num11] = int.MaxValue;
						Buffer.BlockCopy(array2[num11], 0, array2[num12], 0, order);
					}
					for (int j = 0; j < 4; j++)
					{
						sbyte b2 = (sbyte)Inlines.silk_RSHIFT(array[j], 2);
						array2[j][i] += b2;
					}
				}
				i--;
			}
			a2 = 0;
			int num13 = int.MaxValue;
			for (int j = 0; j < 8; j++)
			{
				if (num13 > array4[j])
				{
					num13 = array4[j];
					a2 = j;
				}
			}
			for (int j = 0; j < order; j++)
			{
				indices[j] = array2[a2 & 3][j];
			}
			indices[0] = (sbyte)(indices[0] + Inlines.silk_RSHIFT(a2, 2));
			return num13;
		}

		internal static int silk_NLSF_encode(sbyte[] NLSFIndices, short[] pNLSF_Q15, NLSFCodebook psNLSF_CB, short[] pW_QW, int NLSF_mu_Q20, int nSurvivors, int signalType)
		{
			short[] array = new short[psNLSF_CB.order];
			short[] array2 = new short[psNLSF_CB.order];
			short[] array3 = new short[psNLSF_CB.order];
			short[] array4 = new short[psNLSF_CB.order];
			short[] array5 = new short[psNLSF_CB.order];
			byte[] array6 = new byte[psNLSF_CB.order];
			short[] ec_ix = new short[psNLSF_CB.order];
			byte[] cB1_NLSF_Q = psNLSF_CB.CB1_NLSF_Q8;
			silk_NLSF_stabilize(pNLSF_Q15, psNLSF_CB.deltaMin_Q15, psNLSF_CB.order);
			int[] array7 = new int[psNLSF_CB.nVectors];
			silk_NLSF_VQ(array7, pNLSF_Q15, psNLSF_CB.CB1_NLSF_Q8, psNLSF_CB.nVectors, psNLSF_CB.order);
			int[] array8 = new int[nSurvivors];
			Sort.silk_insertion_sort_increasing(array7, array8, psNLSF_CB.nVectors, nSurvivors);
			int[] array9 = new int[nSurvivors];
			sbyte[][] array10 = Arrays.InitTwoDimensionalArray<sbyte>(nSurvivors, 16);
			for (int i = 0; i < nSurvivors; i++)
			{
				int num = array8[i];
				int num2 = num * psNLSF_CB.order;
				for (int j = 0; j < psNLSF_CB.order; j++)
				{
					array3[j] = Inlines.silk_LSHIFT16(cB1_NLSF_Q[num2 + j], 7);
					array[j] = (short)(pNLSF_Q15[j] - array3[j]);
				}
				silk_NLSF_VQ_weights_laroia(array4, array3, psNLSF_CB.order);
				for (int j = 0; j < psNLSF_CB.order; j++)
				{
					int b = Inlines.silk_SQRT_APPROX(Inlines.silk_LSHIFT(array4[j], 16));
					array2[j] = (short)Inlines.silk_RSHIFT(Inlines.silk_SMULBB(array[j], b), 14);
				}
				for (int j = 0; j < psNLSF_CB.order; j++)
				{
					array5[j] = (short)Inlines.silk_DIV32_16(Inlines.silk_LSHIFT(pW_QW[j], 5), array4[j]);
				}
				silk_NLSF_unpack(ec_ix, array6, psNLSF_CB, num);
				array9[i] = silk_NLSF_del_dec_quant(array10[i], array2, array5, array6, ec_ix, psNLSF_CB.ec_Rates_Q5, psNLSF_CB.quantStepSize_Q16, psNLSF_CB.invQuantStepSize_Q6, NLSF_mu_Q20, psNLSF_CB.order);
				int num3 = (signalType >> 1) * psNLSF_CB.nVectors;
				int inLin = ((num != 0) ? (psNLSF_CB.CB1_iCDF[num3 + num - 1] - psNLSF_CB.CB1_iCDF[num3 + num]) : (256 - psNLSF_CB.CB1_iCDF[num3 + num]));
				int b2 = 1024 - Inlines.silk_lin2log(inLin);
				array9[i] = Inlines.silk_SMLABB(array9[i], b2, Inlines.silk_RSHIFT(NLSF_mu_Q20, 2));
			}
			int[] array11 = new int[1];
			Sort.silk_insertion_sort_increasing(array9, array11, nSurvivors, 1);
			NLSFIndices[0] = (sbyte)array8[array11[0]];
			Array.Copy(array10[array11[0]], 0, NLSFIndices, 1, psNLSF_CB.order);
			silk_NLSF_decode(pNLSF_Q15, NLSFIndices, psNLSF_CB);
			return array9[0];
		}

		internal static void silk_NLSF2A_find_poly(int[] o, int[] cLSF, int cLSF_ptr, int dd)
		{
			o[0] = Inlines.silk_LSHIFT(1, 16);
			o[1] = -cLSF[cLSF_ptr];
			for (int i = 1; i < dd; i++)
			{
				int num = cLSF[cLSF_ptr + 2 * i];
				o[i + 1] = Inlines.silk_LSHIFT(o[i - 1], 1) - (int)Inlines.silk_RSHIFT_ROUND64(Inlines.silk_SMULL(num, o[i]), 16);
				for (int num2 = i; num2 > 1; num2--)
				{
					o[num2] += o[num2 - 2] - (int)Inlines.silk_RSHIFT_ROUND64(Inlines.silk_SMULL(num, o[num2 - 1]), 16);
				}
				o[1] -= num;
			}
		}

		internal static void silk_NLSF2A(short[] a_Q12, short[] NLSF, int d)
		{
			int[] array = new int[d];
			int[] array2 = new int[d / 2 + 1];
			int[] array3 = new int[d / 2 + 1];
			int[] array4 = new int[d];
			int num = 0;
			byte[] array5 = ((d == 16) ? ordering16 : ordering10);
			for (int i = 0; i < d; i++)
			{
				int num2 = Inlines.silk_RSHIFT(NLSF[i], 8);
				int b = NLSF[i] - Inlines.silk_LSHIFT(num2, 8);
				int num3 = Tables.silk_LSFCosTab_Q12[num2];
				int a = Tables.silk_LSFCosTab_Q12[num2 + 1] - num3;
				array[array5[i]] = Inlines.silk_RSHIFT_ROUND(Inlines.silk_LSHIFT(num3, 8) + Inlines.silk_MUL(a, b), 4);
			}
			int num4 = Inlines.silk_RSHIFT(d, 1);
			silk_NLSF2A_find_poly(array2, array, 0, num4);
			silk_NLSF2A_find_poly(array3, array, 1, num4);
			for (int i = 0; i < num4; i++)
			{
				int num5 = array2[i + 1] + array2[i];
				int num6 = array3[i + 1] - array3[i];
				array4[i] = -num6 - num5;
				array4[d - i - 1] = num6 - num5;
			}
			int j;
			for (j = 0; j < 10; j++)
			{
				int num7 = 0;
				for (int i = 0; i < d; i++)
				{
					int num8 = Inlines.silk_abs(array4[i]);
					if (num8 > num7)
					{
						num7 = num8;
						num = i;
					}
				}
				num7 = Inlines.silk_RSHIFT_ROUND(num7, 5);
				if (num7 <= 32767)
				{
					break;
				}
				num7 = Inlines.silk_min(num7, 163838);
				int chirp_Q = 65470 - Inlines.silk_DIV32(Inlines.silk_LSHIFT(num7 - 32767, 14), Inlines.silk_RSHIFT32(Inlines.silk_MUL(num7, num + 1), 2));
				Filters.silk_bwexpander_32(array4, d, chirp_Q);
			}
			if (j == 10)
			{
				for (int i = 0; i < d; i++)
				{
					a_Q12[i] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(array4[i], 5));
					array4[i] = Inlines.silk_LSHIFT(a_Q12[i], 5);
				}
			}
			else
			{
				for (int i = 0; i < d; i++)
				{
					a_Q12[i] = (short)Inlines.silk_RSHIFT_ROUND(array4[i], 5);
				}
			}
			for (j = 0; j < 16; j++)
			{
				if (Filters.silk_LPC_inverse_pred_gain(a_Q12, d) >= 107374)
				{
					break;
				}
				Filters.silk_bwexpander_32(array4, d, 65536 - Inlines.silk_LSHIFT(2, j));
				for (int i = 0; i < d; i++)
				{
					a_Q12[i] = (short)Inlines.silk_RSHIFT_ROUND(array4[i], 5);
				}
			}
		}

		internal static void silk_A2NLSF_trans_poly(int[] p, int dd)
		{
			for (int i = 2; i <= dd; i++)
			{
				for (int num = dd; num > i; num--)
				{
					p[num - 2] -= p[num];
				}
				p[i - 2] -= Inlines.silk_LSHIFT(p[i], 1);
			}
		}

		internal static int silk_A2NLSF_eval_poly(int[] p, int x, int dd)
		{
			int num = p[dd];
			int c = Inlines.silk_LSHIFT(x, 4);
			if (8 == dd)
			{
				num = Inlines.silk_SMLAWW(p[7], num, c);
				num = Inlines.silk_SMLAWW(p[6], num, c);
				num = Inlines.silk_SMLAWW(p[5], num, c);
				num = Inlines.silk_SMLAWW(p[4], num, c);
				num = Inlines.silk_SMLAWW(p[3], num, c);
				num = Inlines.silk_SMLAWW(p[2], num, c);
				num = Inlines.silk_SMLAWW(p[1], num, c);
				num = Inlines.silk_SMLAWW(p[0], num, c);
			}
			else
			{
				for (int num2 = dd - 1; num2 >= 0; num2--)
				{
					num = Inlines.silk_SMLAWW(p[num2], num, c);
				}
			}
			return num;
		}

		internal static void silk_A2NLSF_init(int[] a_Q16, int[] P, int[] Q, int dd)
		{
			P[dd] = Inlines.silk_LSHIFT(1, 16);
			Q[dd] = Inlines.silk_LSHIFT(1, 16);
			for (int i = 0; i < dd; i++)
			{
				P[i] = -a_Q16[dd - i - 1] - a_Q16[dd + i];
				Q[i] = -a_Q16[dd - i - 1] + a_Q16[dd + i];
			}
			for (int i = dd; i > 0; i--)
			{
				P[i - 1] -= P[i];
				Q[i - 1] += Q[i];
			}
			silk_A2NLSF_trans_poly(P, dd);
			silk_A2NLSF_trans_poly(Q, dd);
		}

		internal static void silk_A2NLSF(short[] NLSF, int[] a_Q16, int d)
		{
			int[] array = new int[9];
			int[] array2 = new int[9];
			int[][] array3 = new int[2][] { array, array2 };
			int dd = Inlines.silk_RSHIFT(d, 1);
			silk_A2NLSF_init(a_Q16, array, array2, dd);
			int[] p = array;
			int num = Tables.silk_LSFCosTab_Q12[0];
			int num2 = silk_A2NLSF_eval_poly(p, num, dd);
			int num3;
			if (num2 < 0)
			{
				NLSF[0] = 0;
				p = array2;
				num2 = silk_A2NLSF_eval_poly(p, num, dd);
				num3 = 1;
			}
			else
			{
				num3 = 0;
			}
			int num4 = 1;
			int num5 = 0;
			int num6 = 0;
			while (true)
			{
				int num7 = Tables.silk_LSFCosTab_Q12[num4];
				int num8 = silk_A2NLSF_eval_poly(p, num7, dd);
				if ((num2 <= 0 && num8 >= num6) || (num2 >= 0 && num8 <= -num6))
				{
					num6 = ((num8 == 0) ? 1 : 0);
					int num9 = -256;
					for (int i = 0; i < 3; i++)
					{
						int num10 = Inlines.silk_RSHIFT_ROUND(num + num7, 1);
						int num11 = silk_A2NLSF_eval_poly(p, num10, dd);
						if ((num2 <= 0 && num11 >= 0) || (num2 >= 0 && num11 <= 0))
						{
							num7 = num10;
							num8 = num11;
						}
						else
						{
							num = num10;
							num2 = num11;
							num9 = Inlines.silk_ADD_RSHIFT(num9, 128, i);
						}
					}
					if (Inlines.silk_abs(num2) < 65536)
					{
						int num12 = num2 - num8;
						int a = Inlines.silk_LSHIFT(num2, 5) + Inlines.silk_RSHIFT(num12, 1);
						if (num12 != 0)
						{
							num9 += Inlines.silk_DIV32(a, num12);
						}
					}
					else
					{
						num9 += Inlines.silk_DIV32(num2, Inlines.silk_RSHIFT(num2 - num8, 5));
					}
					NLSF[num3] = (short)Inlines.silk_min_32(Inlines.silk_LSHIFT(num4, 8) + num9, 32767);
					num3++;
					if (num3 < d)
					{
						p = array3[num3 & 1];
						num = Tables.silk_LSFCosTab_Q12[num4 - 1];
						num2 = Inlines.silk_LSHIFT(1 - (num3 & 2), 12);
						continue;
					}
					break;
				}
				num4++;
				num = num7;
				num2 = num8;
				num6 = 0;
				if (num4 <= 128)
				{
					continue;
				}
				num5++;
				if (num5 > 30)
				{
					NLSF[0] = (short)Inlines.silk_DIV32_16(32768, (short)(d + 1));
					for (num4 = 1; num4 < d; num4++)
					{
						NLSF[num4] = (short)Inlines.silk_SMULBB(num4 + 1, NLSF[0]);
					}
					break;
				}
				Filters.silk_bwexpander_32(a_Q16, d, 65536 - Inlines.silk_SMULBB(10 + num5, num5));
				silk_A2NLSF_init(a_Q16, array, array2, dd);
				p = array;
				num = Tables.silk_LSFCosTab_Q12[0];
				num2 = silk_A2NLSF_eval_poly(p, num, dd);
				if (num2 < 0)
				{
					NLSF[0] = 0;
					p = array2;
					num2 = silk_A2NLSF_eval_poly(p, num, dd);
					num3 = 1;
				}
				else
				{
					num3 = 0;
				}
				num4 = 1;
			}
		}

		internal static void silk_process_NLSFs(SilkChannelEncoder psEncC, short[][] PredCoef_Q12, short[] pNLSF_Q15, short[] prev_NLSFq_Q15)
		{
			short[] array = new short[16];
			short[] array2 = new short[16];
			short[] array3 = new short[16];
			int num = Inlines.silk_SMLAWB(3146, -268434, psEncC.speech_activity_Q8);
			if (psEncC.nb_subfr == 2)
			{
				num = Inlines.silk_ADD_RSHIFT(num, num, 1);
			}
			silk_NLSF_VQ_weights_laroia(array2, pNLSF_Q15, psEncC.predictLPCOrder);
			bool flag = psEncC.useInterpolatedNLSFs == 1 && psEncC.indices.NLSFInterpCoef_Q2 < 4;
			if (flag)
			{
				Inlines.silk_interpolate(array, prev_NLSFq_Q15, pNLSF_Q15, psEncC.indices.NLSFInterpCoef_Q2, psEncC.predictLPCOrder);
				silk_NLSF_VQ_weights_laroia(array3, array, psEncC.predictLPCOrder);
				int c = Inlines.silk_LSHIFT(Inlines.silk_SMULBB(psEncC.indices.NLSFInterpCoef_Q2, psEncC.indices.NLSFInterpCoef_Q2), 11);
				for (int i = 0; i < psEncC.predictLPCOrder; i++)
				{
					array2[i] = (short)Inlines.silk_SMLAWB(Inlines.silk_RSHIFT(array2[i], 1), array3[i], c);
				}
			}
			silk_NLSF_encode(psEncC.indices.NLSFIndices, pNLSF_Q15, psEncC.psNLSF_CB, array2, num, psEncC.NLSF_MSVQ_Survivors, psEncC.indices.signalType);
			silk_NLSF2A(PredCoef_Q12[1], pNLSF_Q15, psEncC.predictLPCOrder);
			if (flag)
			{
				Inlines.silk_interpolate(array, prev_NLSFq_Q15, pNLSF_Q15, psEncC.indices.NLSFInterpCoef_Q2, psEncC.predictLPCOrder);
				silk_NLSF2A(PredCoef_Q12[0], array, psEncC.predictLPCOrder);
			}
			else
			{
				Array.Copy(PredCoef_Q12[1], 0, PredCoef_Q12[0], 0, psEncC.predictLPCOrder);
			}
		}
	}
	internal static class NoiseShapeAnalysis
	{
		internal static int warped_gain(int[] coefs_Q24, int lambda_Q16, int order)
		{
			lambda_Q16 = -lambda_Q16;
			int b = coefs_Q24[order - 1];
			for (int num = order - 2; num >= 0; num--)
			{
				b = Inlines.silk_SMLAWB(coefs_Q24[num], b, lambda_Q16);
			}
			b = Inlines.silk_SMLAWB(16777216, b, -lambda_Q16);
			return Inlines.silk_INVERSE32_varQ(b, 40);
		}

		internal static void limit_warped_coefs(int[] coefs_syn_Q24, int[] coefs_ana_Q24, int lambda_Q16, int limit_Q24, int order)
		{
			int num = 0;
			lambda_Q16 = -lambda_Q16;
			for (int num2 = order - 1; num2 > 0; num2--)
			{
				coefs_syn_Q24[num2 - 1] = Inlines.silk_SMLAWB(coefs_syn_Q24[num2 - 1], coefs_syn_Q24[num2], lambda_Q16);
				coefs_ana_Q24[num2 - 1] = Inlines.silk_SMLAWB(coefs_ana_Q24[num2 - 1], coefs_ana_Q24[num2], lambda_Q16);
			}
			lambda_Q16 = -lambda_Q16;
			int a = Inlines.silk_SMLAWB(65536, -lambda_Q16, lambda_Q16);
			int b = Inlines.silk_SMLAWB(16777216, coefs_syn_Q24[0], lambda_Q16);
			int num3 = Inlines.silk_DIV32_varQ(a, b, 24);
			b = Inlines.silk_SMLAWB(16777216, coefs_ana_Q24[0], lambda_Q16);
			int num4 = Inlines.silk_DIV32_varQ(a, b, 24);
			for (int num2 = 0; num2 < order; num2++)
			{
				coefs_syn_Q24[num2] = Inlines.silk_SMULWW(num3, coefs_syn_Q24[num2]);
				coefs_ana_Q24[num2] = Inlines.silk_SMULWW(num4, coefs_ana_Q24[num2]);
			}
			for (int i = 0; i < 10; i++)
			{
				int num5 = -1;
				for (int num2 = 0; num2 < order; num2++)
				{
					int num6 = Inlines.silk_max(Inlines.silk_abs_int32(coefs_syn_Q24[num2]), Inlines.silk_abs_int32(coefs_ana_Q24[num2]));
					if (num6 > num5)
					{
						num5 = num6;
						num = num2;
					}
				}
				if (num5 <= limit_Q24)
				{
					break;
				}
				for (int num2 = 1; num2 < order; num2++)
				{
					coefs_syn_Q24[num2 - 1] = Inlines.silk_SMLAWB(coefs_syn_Q24[num2 - 1], coefs_syn_Q24[num2], lambda_Q16);
					coefs_ana_Q24[num2 - 1] = Inlines.silk_SMLAWB(coefs_ana_Q24[num2 - 1], coefs_ana_Q24[num2], lambda_Q16);
				}
				num3 = Inlines.silk_INVERSE32_varQ(num3, 32);
				num4 = Inlines.silk_INVERSE32_varQ(num4, 32);
				for (int num2 = 0; num2 < order; num2++)
				{
					coefs_syn_Q24[num2] = Inlines.silk_SMULWW(num3, coefs_syn_Q24[num2]);
					coefs_ana_Q24[num2] = Inlines.silk_SMULWW(num4, coefs_ana_Q24[num2]);
				}
				int chirp_Q = 64881 - Inlines.silk_DIV32_varQ(Inlines.silk_SMULWB(num5 - limit_Q24, Inlines.silk_SMLABB(819, 102, i)), Inlines.silk_MUL(num5, num + 1), 22);
				BWExpander.silk_bwexpander_32(coefs_syn_Q24, order, chirp_Q);
				BWExpander.silk_bwexpander_32(coefs_ana_Q24, order, chirp_Q);
				lambda_Q16 = -lambda_Q16;
				for (int num2 = order - 1; num2 > 0; num2--)
				{
					coefs_syn_Q24[num2 - 1] = Inlines.silk_SMLAWB(coefs_syn_Q24[num2 - 1], coefs_syn_Q24[num2], lambda_Q16);
					coefs_ana_Q24[num2 - 1] = Inlines.silk_SMLAWB(coefs_ana_Q24[num2 - 1], coefs_ana_Q24[num2], lambda_Q16);
				}
				lambda_Q16 = -lambda_Q16;
				int a2 = Inlines.silk_SMLAWB(65536, -lambda_Q16, lambda_Q16);
				b = Inlines.silk_SMLAWB(16777216, coefs_syn_Q24[0], lambda_Q16);
				num3 = Inlines.silk_DIV32_varQ(a2, b, 24);
				b = Inlines.silk_SMLAWB(16777216, coefs_ana_Q24[0], lambda_Q16);
				num4 = Inlines.silk_DIV32_varQ(a2, b, 24);
				for (int num2 = 0; num2 < order; num2++)
				{
					coefs_syn_Q24[num2] = Inlines.silk_SMULWW(num3, coefs_syn_Q24[num2]);
					coefs_ana_Q24[num2] = Inlines.silk_SMULWW(num4, coefs_ana_Q24[num2]);
				}
			}
		}

		internal static void silk_noise_shape_analysis(SilkChannelEncoder psEnc, SilkEncoderControl psEncCtrl, short[] pitch_res, int pitch_res_ptr, short[] x, int x_ptr)
		{
			SilkShapeState sShape = psEnc.sShape;
			int shift = 0;
			int[] array = new int[17];
			int[] rc_Q = new int[16];
			int[] array2 = new int[16];
			int[] array3 = new int[16];
			int num = x_ptr - psEnc.la_shape;
			int num2 = psEnc.SNR_dB_Q7;
			psEncCtrl.input_quality_Q14 = Inlines.silk_RSHIFT(psEnc.input_quality_bands_Q15[0] + psEnc.input_quality_bands_Q15[1], 2);
			psEncCtrl.coding_quality_Q14 = Inlines.silk_RSHIFT(Sigmoid.silk_sigm_Q15(Inlines.silk_RSHIFT_ROUND(num2 - 2560, 4)), 1);
			if (psEnc.useCBR == 0)
			{
				int num3 = 256 - psEnc.speech_activity_Q8;
				num3 = Inlines.silk_SMULWB(Inlines.silk_LSHIFT(num3, 8), num3);
				num2 = Inlines.silk_SMLAWB(num2, Inlines.silk_SMULBB(-8, num3), Inlines.silk_SMULWB(16384 + psEncCtrl.input_quality_Q14, psEncCtrl.coding_quality_Q14));
			}
			num2 = ((psEnc.indices.signalType != 2) ? Inlines.silk_SMLAWB(num2, Inlines.silk_SMLAWB(3072, -104858, psEnc.SNR_dB_Q7), 16384 - psEncCtrl.input_quality_Q14) : Inlines.silk_SMLAWB(num2, 512, psEnc.LTPCorr_Q15));
			if (psEnc.indices.signalType == 2)
			{
				psEnc.indices.quantOffsetType = 0;
				psEncCtrl.sparseness_Q8 = 0;
			}
			else
			{
				int num4 = Inlines.silk_LSHIFT(psEnc.fs_kHz, 1);
				int num5 = 0;
				int num6 = 0;
				int num7 = pitch_res_ptr;
				for (int i = 0; i < Inlines.silk_SMULBB(5, psEnc.nb_subfr) / 2; i++)
				{
					SumSqrShift.silk_sum_sqr_shift(out var energy, out shift, pitch_res, num7, num4);
					energy += Inlines.silk_RSHIFT(num4, shift);
					int num8 = Inlines.silk_lin2log(energy);
					if (i > 0)
					{
						num5 += Inlines.silk_abs(num8 - num6);
					}
					num6 = num8;
					num7 += num4;
				}
				psEncCtrl.sparseness_Q8 = Inlines.silk_RSHIFT(Sigmoid.silk_sigm_Q15(Inlines.silk_SMULWB(num5 - 640, 6554)), 7);
				if (psEncCtrl.sparseness_Q8 > 192)
				{
					psEnc.indices.quantOffsetType = 0;
				}
				else
				{
					psEnc.indices.quantOffsetType = 1;
				}
				num2 = Inlines.silk_SMLAWB(num2, 65536, psEncCtrl.sparseness_Q8 - 128);
			}
			int num9 = Inlines.silk_SMULWB(psEncCtrl.predGain_Q16, 66);
			int a2;
			int a = (a2 = Inlines.silk_DIV32_varQ(62259, Inlines.silk_SMLAWW(65536, num9, num9), 16));
			int b = Inlines.silk_SMULWB(65536 - Inlines.silk_SMULBB(3, psEncCtrl.coding_quality_Q14), 655);
			a = Inlines.silk_SUB32(a, b);
			a2 = Inlines.silk_ADD32(a2, b);
			a = Inlines.silk_DIV32_16(Inlines.silk_LSHIFT(a, 14), Inlines.silk_RSHIFT(a2, 2));
			int num10 = ((psEnc.warping_Q16 > 0) ? Inlines.silk_SMLAWB(psEnc.warping_Q16, psEncCtrl.coding_quality_Q14, 2621) : 0);
			short[] array4 = new short[psEnc.shapeWinLength];
			int b2;
			for (int i = 0; i < psEnc.nb_subfr; i++)
			{
				int num11 = psEnc.fs_kHz * 3;
				int num12 = Inlines.silk_RSHIFT(psEnc.shapeWinLength - num11, 1);
				ApplySineWindow.silk_apply_sine_window(array4, 0, x, num, 1, num12);
				int num13 = num12;
				Array.Copy(x, num + num13, array4, num13, num11);
				num13 += num11;
				ApplySineWindow.silk_apply_sine_window(array4, num13, x, num + num13, 2, num12);
				num += psEnc.subfr_length;
				BoxedValueInt boxedValueInt = new BoxedValueInt(shift);
				if (psEnc.warping_Q16 > 0)
				{
					Autocorrelation.silk_warped_autocorrelation(array, boxedValueInt, array4, num10, psEnc.shapeWinLength, psEnc.shapingLPCOrder);
				}
				else
				{
					Autocorrelation.silk_autocorr(array, boxedValueInt, array4, psEnc.shapeWinLength, psEnc.shapingLPCOrder + 1);
				}
				shift = boxedValueInt.Val;
				array[0] = Inlines.silk_ADD32(array[0], Inlines.silk_max_32(Inlines.silk_SMULWB(Inlines.silk_RSHIFT(array[0], 4), 52), 1));
				int energy = Schur.silk_schur64(rc_Q, array, psEnc.shapingLPCOrder);
				K2A.silk_k2a_Q16(array3, rc_Q, psEnc.shapingLPCOrder);
				int num14 = -shift;
				if ((num14 & 1) != 0)
				{
					num14--;
					energy >>= 1;
				}
				int a3 = Inlines.silk_SQRT_APPROX(energy);
				num14 >>= 1;
				psEncCtrl.Gains_Q16[i] = Inlines.silk_LSHIFT_SAT32(a3, 16 - num14);
				if (psEnc.warping_Q16 > 0)
				{
					b2 = warped_gain(array3, num10, psEnc.shapingLPCOrder);
					if (Inlines.silk_SMULWW(Inlines.silk_RSHIFT_ROUND(psEncCtrl.Gains_Q16[i], 1), b2) >= 1073741823)
					{
						psEncCtrl.Gains_Q16[i] = int.MaxValue;
					}
					else
					{
						psEncCtrl.Gains_Q16[i] = Inlines.silk_SMULWW(psEncCtrl.Gains_Q16[i], b2);
					}
				}
				BWExpander.silk_bwexpander_32(array3, psEnc.shapingLPCOrder, a2);
				Array.Copy(array3, array2, psEnc.shapingLPCOrder);
				BWExpander.silk_bwexpander_32(array2, psEnc.shapingLPCOrder, a);
				int a4 = LPCInversePredGain.silk_LPC_inverse_pred_gain_Q24(array3, psEnc.shapingLPCOrder);
				energy = LPCInversePredGain.silk_LPC_inverse_pred_gain_Q24(array2, psEnc.shapingLPCOrder);
				a4 = Inlines.silk_LSHIFT32(Inlines.silk_SMULWB(a4, 22938), 1);
				psEncCtrl.GainsPre_Q14[i] = 4915 + Inlines.silk_DIV32_varQ(a4, energy, 14);
				limit_warped_coefs(array3, array2, num10, 67092088, psEnc.shapingLPCOrder);
				for (int j = 0; j < psEnc.shapingLPCOrder; j++)
				{
					psEncCtrl.AR1_Q13[i * 16 + j] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(array2[j], 11));
					psEncCtrl.AR2_Q13[i * 16 + j] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(array3[j], 11));
				}
			}
			b2 = Inlines.silk_log2lin(-Inlines.silk_SMLAWB(-2048, num2, 10486));
			int b3 = Inlines.silk_log2lin(Inlines.silk_SMLAWB(2048, 256, 10486));
			for (int i = 0; i < psEnc.nb_subfr; i++)
			{
				psEncCtrl.Gains_Q16[i] = Inlines.silk_SMULWW(psEncCtrl.Gains_Q16[i], b2);
				psEncCtrl.Gains_Q16[i] = Inlines.silk_ADD_POS_SAT32(psEncCtrl.Gains_Q16[i], b3);
			}
			b2 = 65536 + Inlines.silk_RSHIFT_ROUND(Inlines.silk_MLA(3355443, psEncCtrl.coding_quality_Q14, 410), 10);
			for (int i = 0; i < psEnc.nb_subfr; i++)
			{
				psEncCtrl.GainsPre_Q14[i] = Inlines.silk_SMULWB(b2, psEncCtrl.GainsPre_Q14[i]);
			}
			num9 = Inlines.silk_MUL(64, Inlines.silk_SMLAWB(4096, 4096, psEnc.input_quality_bands_Q15[0] - 32768));
			num9 = Inlines.silk_RSHIFT(Inlines.silk_MUL(num9, psEnc.speech_activity_Q8), 8);
			int num17;
			if (psEnc.indices.signalType == 2)
			{
				int num15 = Inlines.silk_DIV32_16(3277, psEnc.fs_kHz);
				for (int i = 0; i < psEnc.nb_subfr; i++)
				{
					int num16 = num15 + Inlines.silk_DIV32_16(49152, psEncCtrl.pitchL[i]);
					psEncCtrl.LF_shp_Q14[i] = Inlines.silk_LSHIFT(16384 - num16 - Inlines.silk_SMULWB(num9, num16), 16);
					psEncCtrl.LF_shp_Q14[i] |= (num16 - 16384) & 0xFFFF;
				}
				num17 = -16384 - Inlines.silk_SMULWB(49152, Inlines.silk_SMULWB(5872026, psEnc.speech_activity_Q8));
			}
			else
			{
				int num16 = Inlines.silk_DIV32_16(21299, psEnc.fs_kHz);
				psEncCtrl.LF_shp_Q14[0] = Inlines.silk_LSHIFT(16384 - num16 - Inlines.silk_SMULWB(num9, Inlines.silk_SMULWB(39322, num16)), 16);
				psEncCtrl.LF_shp_Q14[0] |= (num16 - 16384) & 0xFFFF;
				for (int i = 1; i < psEnc.nb_subfr; i++)
				{
					psEncCtrl.LF_shp_Q14[i] = psEncCtrl.LF_shp_Q14[0];
				}
				num17 = -16384;
			}
			int a5 = Inlines.silk_SMULWB(Inlines.silk_SMULWB(131072 - Inlines.silk_LSHIFT(psEncCtrl.coding_quality_Q14, 3), psEnc.LTPCorr_Q15), 6554);
			a5 = Inlines.silk_SMLAWB(a5, 65536 - Inlines.silk_LSHIFT(psEncCtrl.input_quality_Q14, 2), 6554);
			int a6;
			if (psEnc.indices.signalType == 2)
			{
				a6 = Inlines.silk_SMLAWB(19661, 65536 - Inlines.silk_SMULWB(262144 - Inlines.silk_LSHIFT(psEncCtrl.coding_quality_Q14, 4), psEncCtrl.input_quality_Q14), 13107);
				a6 = Inlines.silk_SMULWB(Inlines.silk_LSHIFT(a6, 1), Inlines.silk_SQRT_APPROX(Inlines.silk_LSHIFT(psEnc.LTPCorr_Q15, 15)));
			}
			else
			{
				a6 = 0;
			}
			for (int i = 0; i < 4; i++)
			{
				sShape.HarmBoost_smth_Q16 = Inlines.silk_SMLAWB(sShape.HarmBoost_smth_Q16, a5 - sShape.HarmBoost_smth_Q16, 26214);
				sShape.HarmShapeGain_smth_Q16 = Inlines.silk_SMLAWB(sShape.HarmShapeGain_smth_Q16, a6 - sShape.HarmShapeGain_smth_Q16, 26214);
				sShape.Tilt_smth_Q16 = Inlines.silk_SMLAWB(sShape.Tilt_smth_Q16, num17 - sShape.Tilt_smth_Q16, 26214);
				psEncCtrl.HarmBoost_Q14[i] = Inlines.silk_RSHIFT_ROUND(sShape.HarmBoost_smth_Q16, 2);
				psEncCtrl.HarmShapeGain_Q14[i] = Inlines.silk_RSHIFT_ROUND(sShape.HarmShapeGain_smth_Q16, 2);
				psEncCtrl.Tilt_Q14[i] = Inlines.silk_RSHIFT_ROUND(sShape.Tilt_smth_Q16, 2);
			}
		}
	}
	internal static class PitchAnalysisCore
	{
		private class silk_pe_stage3_vals
		{
			public readonly int[] Values = new int[5];
		}

		private const int SCRATCH_SIZE = 22;

		private const int SF_LENGTH_4KHZ = 20;

		private const int SF_LENGTH_8KHZ = 40;

		private const int MIN_LAG_4KHZ = 8;

		private const int MIN_LAG_8KHZ = 16;

		private const int MAX_LAG_4KHZ = 72;

		private const int MAX_LAG_8KHZ = 143;

		private const int CSTRIDE_4KHZ = 65;

		private const int CSTRIDE_8KHZ = 132;

		private const int D_COMP_MIN = 13;

		private const int D_COMP_MAX = 147;

		private const int D_COMP_STRIDE = 134;

		internal static int silk_pitch_analysis_core(short[] frame, int[] pitch_out, BoxedValueShort lagIndex, BoxedValueSbyte contourIndex, BoxedValueInt LTPCorr_Q15, int prevLag, int search_thres1_Q16, int search_thres2_Q13, int Fs_kHz, int complexity, int nb_subfr)
		{
			int[] array = new int[6];
			int[] array2 = new int[24];
			int[] array3 = new int[11];
			int num = (20 + nb_subfr * 5) * Fs_kHz;
			int num2 = (20 + nb_subfr * 5) * 4;
			int num3 = (20 + nb_subfr * 5) * 8;
			int num4 = 5 * Fs_kHz;
			int num5 = 2 * Fs_kHz;
			int num6 = 18 * Fs_kHz - 1;
			short[] array4 = new short[num3];
			switch (Fs_kHz)
			{
			case 16:
				Arrays.MemSetInt(array, 0, 2);
				Resampler.silk_resampler_down2(array, array4, frame, num);
				break;
			case 12:
				Arrays.MemSetInt(array, 0, 6);
				Resampler.silk_resampler_down2_3(array, array4, frame, num);
				break;
			default:
				Array.Copy(frame, array4, num3);
				break;
			}
			Arrays.MemSetInt(array, 0, 2);
			short[] array5 = new short[num2];
			Resampler.silk_resampler_down2(array, array5, array4, num3);
			for (int num7 = num2 - 1; num7 > 0; num7--)
			{
				array5[num7] = Inlines.silk_ADD_SAT16(array5[num7], array5[num7 - 1]);
			}
			SumSqrShift.silk_sum_sqr_shift(out var energy, out var shift, array5, num2);
			if (shift > 0)
			{
				shift = Inlines.silk_RSHIFT(shift, 1);
				for (int num7 = 0; num7 < num2; num7++)
				{
					array5[num7] = Inlines.silk_RSHIFT16(array5[num7], shift);
				}
			}
			short[] array6 = new short[nb_subfr * 132];
			int[] array7 = new int[65];
			Arrays.MemSetShort(array6, 0, (nb_subfr >> 1) * 65);
			short[] array8 = array5;
			int num8 = Inlines.silk_LSHIFT(20, 2);
			for (int i = 0; i < nb_subfr >> 1; i++)
			{
				short[] array9 = array8;
				int num9 = num8 - 8;
				CeltPitchXCorr.pitch_xcorr(array8, num8, array8, num8 - 72, array7, 40, 65);
				int a = array7[64];
				int a2 = Inlines.silk_inner_prod_self(array8, num8, 40);
				a2 = Inlines.silk_ADD32(a2, Inlines.silk_inner_prod_self(array9, num9, 40));
				a2 = Inlines.silk_ADD32(a2, Inlines.silk_SMULBB(40, 4000));
				Inlines.MatrixSet(array6, i, 0, 65, (short)Inlines.silk_DIV32_varQ(a, a2, 14));
				for (int j = 9; j <= 72; j++)
				{
					num9--;
					a = array7[72 - j];
					a2 = Inlines.silk_ADD32(a2, Inlines.silk_SMULBB(array9[num9], array9[num9]) - Inlines.silk_SMULBB(array9[num9 + 40], array9[num9 + 40]));
					Inlines.MatrixSet(array6, i, j - 8, 65, (short)Inlines.silk_DIV32_varQ(a, a2, 14));
				}
				num8 += 40;
			}
			if (nb_subfr == 4)
			{
				for (int num7 = 72; num7 >= 8; num7--)
				{
					int num10 = Inlines.MatrixGet(array6, 0, num7 - 8, 65) + Inlines.MatrixGet(array6, 1, num7 - 8, 65);
					num10 = Inlines.silk_SMLAWB(num10, num10, Inlines.silk_LSHIFT(-num7, 4));
					array6[num7 - 8] = (short)num10;
				}
			}
			else
			{
				for (int num7 = 72; num7 >= 8; num7--)
				{
					int num10 = Inlines.silk_LSHIFT(array6[num7 - 8], 1);
					num10 = Inlines.silk_SMLAWB(num10, num10, Inlines.silk_LSHIFT(-num7, 4));
					array6[num7 - 8] = (short)num10;
				}
			}
			int num11 = Inlines.silk_ADD_LSHIFT32(4, complexity, 1);
			Sort.silk_insertion_sort_decreasing_int16(array6, array2, 65, num11);
			int num12 = array6[0];
			if (num12 < 3277)
			{
				Arrays.MemSetInt(pitch_out, 0, nb_subfr);
				LTPCorr_Q15.Val = 0;
				lagIndex.Val = 0;
				contourIndex.Val = 0;
				return 1;
			}
			int num13 = Inlines.silk_SMULWB(search_thres1_Q16, num12);
			for (int num7 = 0; num7 < num11; num7++)
			{
				if (array6[num7] > num13)
				{
					array2[num7] = Inlines.silk_LSHIFT(array2[num7] + 8, 1);
					continue;
				}
				num11 = num7;
				break;
			}
			short[] array10 = new short[134];
			for (int num7 = 13; num7 < 147; num7++)
			{
				array10[num7 - 13] = 0;
			}
			for (int num7 = 0; num7 < num11; num7++)
			{
				array10[array2[num7] - 13] = 1;
			}
			for (int num7 = 146; num7 >= 16; num7--)
			{
				array10[num7 - 13] += (short)(array10[num7 - 1 - 13] + array10[num7 - 2 - 13]);
			}
			num11 = 0;
			for (int num7 = 16; num7 < 144; num7++)
			{
				if (array10[num7 + 1 - 13] > 0)
				{
					array2[num11] = num7;
					num11++;
				}
			}
			for (int num7 = 146; num7 >= 16; num7--)
			{
				array10[num7 - 13] += (short)(array10[num7 - 1 - 13] + array10[num7 - 2 - 13] + array10[num7 - 3 - 13]);
			}
			int num14 = 0;
			for (int num7 = 16; num7 < 147; num7++)
			{
				if (array10[num7 - 13] > 0)
				{
					array10[num14] = (short)(num7 - 2);
					num14++;
				}
			}
			SumSqrShift.silk_sum_sqr_shift(out energy, out shift, array4, num3);
			if (shift > 0)
			{
				shift = Inlines.silk_RSHIFT(shift, 1);
				for (int num7 = 0; num7 < num3; num7++)
				{
					array4[num7] = Inlines.silk_RSHIFT16(array4[num7], shift);
				}
			}
			Arrays.MemSetShort(array6, 0, nb_subfr * 132);
			array8 = array4;
			num8 = 160;
			for (int i = 0; i < nb_subfr; i++)
			{
				int a3 = Inlines.silk_ADD32(Inlines.silk_inner_prod(array8, num8, array8, num8, 40), 1);
				for (int k = 0; k < num14; k++)
				{
					int j = array10[k];
					short[] array9 = array8;
					int num9 = num8 - j;
					int a = Inlines.silk_inner_prod(array8, num8, array9, num9, 40);
					if (a > 0)
					{
						int b = Inlines.silk_inner_prod_self(array9, num9, 40);
						Inlines.MatrixSet(array6, i, j - 14, 132, (short)Inlines.silk_DIV32_varQ(a, Inlines.silk_ADD32(a3, b), 14));
					}
					else
					{
						Inlines.MatrixSet(array6, i, j - 14, 132, (short)0);
					}
				}
				num8 += 40;
			}
			int a4 = int.MinValue;
			int num15 = int.MinValue;
			int num16 = 0;
			int num17 = -1;
			int num18;
			if (prevLag > 0)
			{
				switch (Fs_kHz)
				{
				case 12:
					prevLag = Inlines.silk_DIV32_16(Inlines.silk_LSHIFT(prevLag, 1), 3);
					break;
				case 16:
					prevLag = Inlines.silk_RSHIFT(prevLag, 1);
					break;
				}
				num18 = Inlines.silk_lin2log(prevLag);
			}
			else
			{
				num18 = 0;
			}
			int num19;
			sbyte[][] array11;
			if (nb_subfr == 4)
			{
				array11 = Tables.silk_CB_lags_stage2;
				num19 = ((Fs_kHz != 8 || complexity <= 0) ? 3 : 11);
			}
			else
			{
				array11 = Tables.silk_CB_lags_stage2_10_ms;
				num19 = 3;
			}
			for (int i = 0; i < num11; i++)
			{
				int j = array2[i];
				for (int k = 0; k < num19; k++)
				{
					array3[k] = 0;
					for (int num7 = 0; num7 < nb_subfr; num7++)
					{
						int num20 = j + array11[num7][k];
						array3[k] += Inlines.MatrixGet(array6, num7, num20 - 14, 132);
					}
				}
				int num21 = int.MinValue;
				int num22 = 0;
				for (int num7 = 0; num7 < num19; num7++)
				{
					if (array3[num7] > num21)
					{
						num21 = array3[num7];
						num22 = num7;
					}
				}
				int num23 = Inlines.silk_lin2log(j);
				int num24 = num21 - Inlines.silk_RSHIFT(Inlines.silk_SMULBB(nb_subfr * 1638, num23), 7);
				if (prevLag > 0)
				{
					int num25 = num23 - num18;
					num25 = Inlines.silk_RSHIFT(Inlines.silk_SMULBB(num25, num25), 7);
					int a5 = Inlines.silk_RSHIFT(Inlines.silk_SMULBB(nb_subfr * 1638, LTPCorr_Q15.Val), 15);
					a5 = Inlines.silk_DIV32(Inlines.silk_MUL(a5, num25), num25 + 64);
					num24 -= a5;
				}
				if (num24 > num15 && num21 > Inlines.silk_SMULBB(nb_subfr, search_thres2_Q13) && Tables.silk_CB_lags_stage2[0][num22] <= 16)
				{
					num15 = num24;
					a4 = num21;
					num17 = j;
					num16 = num22;
				}
			}
			if (num17 == -1)
			{
				Arrays.MemSetInt(pitch_out, 0, nb_subfr);
				LTPCorr_Q15.Val = 0;
				lagIndex.Val = 0;
				contourIndex.Val = 0;
				return 1;
			}
			LTPCorr_Q15.Val = Inlines.silk_LSHIFT(Inlines.silk_DIV32_16(a4, nb_subfr), 2);
			if (Fs_kHz > 8)
			{
				SumSqrShift.silk_sum_sqr_shift(out energy, out shift, frame, num);
				short[] array13;
				if (shift > 0)
				{
					short[] array12 = new short[num];
					shift = Inlines.silk_RSHIFT(shift, 1);
					for (int num7 = 0; num7 < num; num7++)
					{
						array12[num7] = Inlines.silk_RSHIFT16(frame[num7], shift);
					}
					array13 = array12;
				}
				else
				{
					array13 = frame;
				}
				int num26 = num16;
				num17 = Inlines.silk_LIMIT_int(Fs_kHz switch
				{
					12 => Inlines.silk_RSHIFT(Inlines.silk_SMULBB(num17, 3), 1), 
					16 => Inlines.silk_LSHIFT(num17, 1), 
					_ => Inlines.silk_SMULBB(num17, 3), 
				}, num5, num6);
				int num27 = Inlines.silk_max_int(num17 - 2, num5);
				int num28 = Inlines.silk_min_int(num17 + 2, num6);
				int num29 = num17;
				num16 = 0;
				a4 = int.MinValue;
				for (int i = 0; i < nb_subfr; i++)
				{
					pitch_out[i] = num17 + 2 * Tables.silk_CB_lags_stage2[i][num26];
				}
				if (nb_subfr == 4)
				{
					num19 = Tables.silk_nb_cbk_searchs_stage3[complexity];
					array11 = Tables.silk_CB_lags_stage3;
				}
				else
				{
					num19 = 12;
					array11 = Tables.silk_CB_lags_stage3_10_ms;
				}
				silk_pe_stage3_vals[] array14 = new silk_pe_stage3_vals[nb_subfr * num19];
				silk_pe_stage3_vals[] array15 = new silk_pe_stage3_vals[nb_subfr * num19];
				for (int l = 0; l < nb_subfr * num19; l++)
				{
					array14[l] = new silk_pe_stage3_vals();
					array15[l] = new silk_pe_stage3_vals();
				}
				silk_P_Ana_calc_corr_st3(array15, array13, num27, num4, nb_subfr, complexity);
				silk_P_Ana_calc_energy_st3(array14, array13, num27, num4, nb_subfr, complexity);
				int num30 = 0;
				int a6 = Inlines.silk_DIV32_16(1638, num17);
				array8 = array13;
				num8 = 20 * Fs_kHz;
				int a3 = Inlines.silk_ADD32(Inlines.silk_inner_prod_self(array8, num8, nb_subfr * num4), 1);
				for (int j = num27; j <= num28; j++)
				{
					for (int k = 0; k < num19; k++)
					{
						int a = 0;
						energy = a3;
						for (int i = 0; i < nb_subfr; i++)
						{
							a = Inlines.silk_ADD32(a, Inlines.MatrixGet(array15, i, k, num19).Values[num30]);
							energy = Inlines.silk_ADD32(energy, Inlines.MatrixGet(array14, i, k, num19).Values[num30]);
						}
						int num21;
						if (a > 0)
						{
							num21 = Inlines.silk_DIV32_varQ(a, energy, 14);
							int b2 = 32767 - Inlines.silk_MUL(a6, k);
							num21 = Inlines.silk_SMULWB(num21, b2);
						}
						else
						{
							num21 = 0;
						}
						if (num21 > a4 && j + Tables.silk_CB_lags_stage3[0][k] <= num6)
						{
							a4 = num21;
							num29 = j;
							num16 = k;
						}
					}
					num30++;
				}
				for (int i = 0; i < nb_subfr; i++)
				{
					pitch_out[i] = num29 + array11[i][num16];
					pitch_out[i] = Inlines.silk_LIMIT(pitch_out[i], num5, 18 * Fs_kHz);
				}
				lagIndex.Val = (short)(num29 - num5);
				contourIndex.Val = (sbyte)num16;
			}
			else
			{
				for (int i = 0; i < nb_subfr; i++)
				{
					pitch_out[i] = num17 + array11[i][num16];
					pitch_out[i] = Inlines.silk_LIMIT(pitch_out[i], 16, 144);
				}
				lagIndex.Val = (short)(num17 - 16);
				contourIndex.Val = (sbyte)num16;
			}
			return 0;
		}

		private static void silk_P_Ana_calc_corr_st3(silk_pe_stage3_vals[] cross_corr_st3, short[] frame, int start_lag, int sf_length, int nb_subfr, int complexity)
		{
			sbyte[][] array;
			sbyte[][] array2;
			int num;
			if (nb_subfr == 4)
			{
				array = Tables.silk_Lag_range_stage3[complexity];
				array2 = Tables.silk_CB_lags_stage3;
				num = Tables.silk_nb_cbk_searchs_stage3[complexity];
			}
			else
			{
				array = Tables.silk_Lag_range_stage3_10_ms;
				array2 = Tables.silk_CB_lags_stage3_10_ms;
				num = 12;
			}
			int[] array3 = new int[22];
			int[] array4 = new int[22];
			int num2 = Inlines.silk_LSHIFT(sf_length, 2);
			for (int i = 0; i < nb_subfr; i++)
			{
				int num3 = 0;
				int num4 = array[i][0];
				int num5 = array[i][1];
				CeltPitchXCorr.pitch_xcorr(frame, num2, frame, num2 - start_lag - num5, array4, sf_length, num5 - num4 + 1);
				for (int j = num4; j <= num5; j++)
				{
					array3[num3] = array4[num5 - j];
					num3++;
				}
				int num6 = array[i][0];
				for (int k = 0; k < num; k++)
				{
					int num7 = array2[i][k] - num6;
					for (int j = 0; j < 5; j++)
					{
						Inlines.MatrixGet(cross_corr_st3, i, k, num).Values[j] = array3[num7 + j];
					}
				}
				num2 += sf_length;
			}
		}

		private static void silk_P_Ana_calc_energy_st3(silk_pe_stage3_vals[] energies_st3, short[] frame, int start_lag, int sf_length, int nb_subfr, int complexity)
		{
			sbyte[][] array;
			sbyte[][] array2;
			int num;
			if (nb_subfr == 4)
			{
				array = Tables.silk_Lag_range_stage3[complexity];
				array2 = Tables.silk_CB_lags_stage3;
				num = Tables.silk_nb_cbk_searchs_stage3[complexity];
			}
			else
			{
				array = Tables.silk_Lag_range_stage3_10_ms;
				array2 = Tables.silk_CB_lags_stage3_10_ms;
				num = 12;
			}
			int[] array3 = new int[22];
			int num2 = Inlines.silk_LSHIFT(sf_length, 2);
			for (int i = 0; i < nb_subfr; i++)
			{
				int num3 = 0;
				int num4 = num2 - (start_lag + array[i][0]);
				int num5 = (array3[num3] = Inlines.silk_inner_prod_self(frame, num4, sf_length));
				num3++;
				int num6 = array[i][1] - array[i][0] + 1;
				for (int j = 1; j < num6; j++)
				{
					num5 -= Inlines.silk_SMULBB(frame[num4 + sf_length - j], frame[num4 + sf_length - j]);
					num5 = (array3[num3] = Inlines.silk_ADD_SAT32(num5, Inlines.silk_SMULBB(frame[num4 - j], frame[num4 - j])));
					num3++;
				}
				int num7 = array[i][0];
				for (int j = 0; j < num; j++)
				{
					int num8 = array2[i][j] - num7;
					for (int k = 0; k < 5; k++)
					{
						Inlines.MatrixGet(energies_st3, i, j, num).Values[k] = array3[num8 + k];
					}
				}
				num2 += sf_length;
			}
		}
	}
	internal static class PLC
	{
		private const int NB_ATT = 2;

		private static readonly short[] HARM_ATT_Q15 = new short[2] { 32440, 31130 };

		private static readonly short[] PLC_RAND_ATTENUATE_V_Q15 = new short[2] { 31130, 26214 };

		private static readonly short[] PLC_RAND_ATTENUATE_UV_Q15 = new short[2] { 32440, 29491 };

		internal static void silk_PLC_Reset(SilkChannelDecoder psDec)
		{
			psDec.sPLC.pitchL_Q8 = Inlines.silk_LSHIFT(psDec.frame_length, 7);
			psDec.sPLC.prevGain_Q16[0] = 65536;
			psDec.sPLC.prevGain_Q16[1] = 65536;
			psDec.sPLC.subfr_length = 20;
			psDec.sPLC.nb_subfr = 2;
		}

		internal static void silk_PLC(SilkChannelDecoder psDec, SilkDecoderControl psDecCtrl, short[] frame, int frame_ptr, int lost)
		{
			if (psDec.fs_kHz != psDec.sPLC.fs_kHz)
			{
				silk_PLC_Reset(psDec);
				psDec.sPLC.fs_kHz = psDec.fs_kHz;
			}
			if (lost != 0)
			{
				silk_PLC_conceal(psDec, psDecCtrl, frame, frame_ptr);
				psDec.lossCnt++;
			}
			else
			{
				silk_PLC_update(psDec, psDecCtrl);
			}
		}

		internal static void silk_PLC_update(SilkChannelDecoder psDec, SilkDecoderControl psDecCtrl)
		{
			PLCStruct sPLC = psDec.sPLC;
			psDec.prevSignalType = psDec.indices.signalType;
			int num = 0;
			if (psDec.indices.signalType == 2)
			{
				for (int i = 0; i * psDec.subfr_length < psDecCtrl.pitchL[psDec.nb_subfr - 1] && i != psDec.nb_subfr; i++)
				{
					int num2 = 0;
					for (int j = 0; j < 5; j++)
					{
						num2 += psDecCtrl.LTPCoef_Q14[(psDec.nb_subfr - 1 - i) * 5 + j];
					}
					if (num2 > num)
					{
						num = num2;
						Array.Copy(psDecCtrl.LTPCoef_Q14, Inlines.silk_SMULBB(psDec.nb_subfr - 1 - i, 5), sPLC.LTPCoef_Q14, 0, 5);
						sPLC.pitchL_Q8 = Inlines.silk_LSHIFT(psDecCtrl.pitchL[psDec.nb_subfr - 1 - i], 8);
					}
				}
				Arrays.MemSetShort(sPLC.LTPCoef_Q14, 0, 5);
				sPLC.LTPCoef_Q14[2] = (short)num;
				if (num < 11469)
				{
					int b = Inlines.silk_DIV32(Inlines.silk_LSHIFT(11469, 10), Inlines.silk_max(num, 1));
					for (int j = 0; j < 5; j++)
					{
						sPLC.LTPCoef_Q14[j] = (short)Inlines.silk_RSHIFT(Inlines.silk_SMULBB(sPLC.LTPCoef_Q14[j], b), 10);
					}
				}
				else if (num > 15565)
				{
					int b2 = Inlines.silk_DIV32(Inlines.silk_LSHIFT(15565, 14), Inlines.silk_max(num, 1));
					for (int j = 0; j < 5; j++)
					{
						sPLC.LTPCoef_Q14[j] = (short)Inlines.silk_RSHIFT(Inlines.silk_SMULBB(sPLC.LTPCoef_Q14[j], b2), 14);
					}
				}
			}
			else
			{
				sPLC.pitchL_Q8 = Inlines.silk_LSHIFT(Inlines.silk_SMULBB(psDec.fs_kHz, 18), 8);
				Arrays.MemSetShort(sPLC.LTPCoef_Q14, 0, 5);
			}
			Array.Copy(psDecCtrl.PredCoef_Q12[1], sPLC.prevLPC_Q12, psDec.LPC_order);
			sPLC.prevLTP_scale_Q14 = (short)psDecCtrl.LTP_scale_Q14;
			Array.Copy(psDecCtrl.Gains_Q16, psDec.nb_subfr - 2, sPLC.prevGain_Q16, 0, 2);
			sPLC.subfr_length = psDec.subfr_length;
			sPLC.nb_subfr = psDec.nb_subfr;
		}

		internal static void silk_PLC_energy(out int energy1, out int shift1, out int energy2, out int shift2, int[] exc_Q14, int[] prevGain_Q10, int subfr_length, int nb_subfr)
		{
			int num = 0;
			short[] array = new short[2 * subfr_length];
			for (int i = 0; i < 2; i++)
			{
				for (int j = 0; j < subfr_length; j++)
				{
					array[num + j] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT(Inlines.silk_SMULWW(exc_Q14[j + (i + nb_subfr - 2) * subfr_length], prevGain_Q10[i]), 8));
				}
				num += subfr_length;
			}
			SumSqrShift.silk_sum_sqr_shift(out energy1, out shift1, array, subfr_length);
			SumSqrShift.silk_sum_sqr_shift(out energy2, out shift2, array, subfr_length, subfr_length);
		}

		internal static void silk_PLC_conceal(SilkChannelDecoder psDec, SilkDecoderControl psDecCtrl, short[] frame, int frame_ptr)
		{
			short[] array = new short[psDec.ltp_mem_length];
			int[] array2 = new int[psDec.ltp_mem_length + psDec.frame_length];
			PLCStruct sPLC = psDec.sPLC;
			int[] array3 = new int[2]
			{
				Inlines.silk_RSHIFT(sPLC.prevGain_Q16[0], 6),
				Inlines.silk_RSHIFT(sPLC.prevGain_Q16[1], 6)
			};
			if (psDec.first_frame_after_reset != 0)
			{
				Arrays.MemSetShort(sPLC.prevLPC_Q12, 0, 16);
			}
			silk_PLC_energy(out var energy, out var shift, out var energy2, out var shift2, psDec.exc_Q14, array3, psDec.subfr_length, psDec.nb_subfr);
			int num = ((Inlines.silk_RSHIFT(energy, shift2) >= Inlines.silk_RSHIFT(energy2, shift)) ? Inlines.silk_max_int(0, sPLC.nb_subfr * sPLC.subfr_length - 128) : Inlines.silk_max_int(0, (sPLC.nb_subfr - 1) * sPLC.subfr_length - 128));
			short[] lTPCoef_Q = sPLC.LTPCoef_Q14;
			short num2 = sPLC.randScale_Q14;
			int a = HARM_ATT_Q15[Inlines.silk_min_int(1, psDec.lossCnt)];
			int b = ((psDec.prevSignalType != 2) ? PLC_RAND_ATTENUATE_UV_Q15[Inlines.silk_min_int(1, psDec.lossCnt)] : PLC_RAND_ATTENUATE_V_Q15[Inlines.silk_min_int(1, psDec.lossCnt)]);
			BWExpander.silk_bwexpander(sPLC.prevLPC_Q12, psDec.LPC_order, 64881);
			if (psDec.lossCnt == 0)
			{
				num2 = 16384;
				if (psDec.prevSignalType == 2)
				{
					for (int i = 0; i < 5; i++)
					{
						num2 -= lTPCoef_Q[i];
					}
					num2 = Inlines.silk_max_16(3277, num2);
					num2 = (short)Inlines.silk_RSHIFT(Inlines.silk_SMULBB(num2, sPLC.prevLTP_scale_Q14), 14);
				}
				else
				{
					int b2 = LPCInversePredGain.silk_LPC_inverse_pred_gain(sPLC.prevLPC_Q12, psDec.LPC_order);
					int b3 = Inlines.silk_min_32(Inlines.silk_RSHIFT(1073741824, 3), b2);
					b3 = Inlines.silk_max_32(Inlines.silk_RSHIFT(1073741824, 8), b3);
					b3 = Inlines.silk_LSHIFT(b3, 3);
					b = Inlines.silk_RSHIFT(Inlines.silk_SMULWB(b3, b), 14);
				}
			}
			int num3 = sPLC.rand_seed;
			int num4 = Inlines.silk_RSHIFT_ROUND(sPLC.pitchL_Q8, 8);
			int num5 = psDec.ltp_mem_length;
			int num6 = psDec.ltp_mem_length - num4 - psDec.LPC_order - 2;
			Filters.silk_LPC_analysis_filter(array, num6, psDec.outBuf, num6, sPLC.prevLPC_Q12, 0, psDec.ltp_mem_length - num6, psDec.LPC_order);
			int a2 = Inlines.silk_INVERSE32_varQ(sPLC.prevGain_Q16[1], 46);
			a2 = Inlines.silk_min(a2, 1073741823);
			for (int i = num6 + psDec.LPC_order; i < psDec.ltp_mem_length; i++)
			{
				array2[i] = Inlines.silk_SMULWB(a2, array[i]);
			}
			for (int j = 0; j < psDec.nb_subfr; j++)
			{
				int num7 = num5 - num4 + 2;
				for (int i = 0; i < psDec.subfr_length; i++)
				{
					int a3 = 2;
					a3 = Inlines.silk_SMLAWB(a3, array2[num7], lTPCoef_Q[0]);
					a3 = Inlines.silk_SMLAWB(a3, array2[num7 - 1], lTPCoef_Q[1]);
					a3 = Inlines.silk_SMLAWB(a3, array2[num7 - 2], lTPCoef_Q[2]);
					a3 = Inlines.silk_SMLAWB(a3, array2[num7 - 3], lTPCoef_Q[3]);
					a3 = Inlines.silk_SMLAWB(a3, array2[num7 - 4], lTPCoef_Q[4]);
					num7++;
					num3 = Inlines.silk_RAND(num3);
					num6 = Inlines.silk_RSHIFT(num3, 25) & 0x7F;
					array2[num5] = Inlines.silk_LSHIFT32(Inlines.silk_SMLAWB(a3, psDec.exc_Q14[num + num6], num2), 2);
					num5++;
				}
				for (int k = 0; k < 5; k++)
				{
					lTPCoef_Q[k] = (short)Inlines.silk_RSHIFT(Inlines.silk_SMULBB(a, lTPCoef_Q[k]), 15);
				}
				num2 = (short)Inlines.silk_RSHIFT(Inlines.silk_SMULBB(num2, b), 15);
				sPLC.pitchL_Q8 = Inlines.silk_SMLAWB(sPLC.pitchL_Q8, sPLC.pitchL_Q8, 655);
				sPLC.pitchL_Q8 = Inlines.silk_min_32(sPLC.pitchL_Q8, Inlines.silk_LSHIFT(Inlines.silk_SMULBB(18, psDec.fs_kHz), 8));
				num4 = Inlines.silk_RSHIFT_ROUND(sPLC.pitchL_Q8, 8);
			}
			int num8 = psDec.ltp_mem_length - 16;
			Array.Copy(psDec.sLPC_Q14_buf, 0, array2, num8, 16);
			for (int i = 0; i < psDec.frame_length; i++)
			{
				int num9 = num8 + 16 + i;
				int a4 = Inlines.silk_RSHIFT(psDec.LPC_order, 1);
				a4 = Inlines.silk_SMLAWB(a4, array2[num9 - 1], sPLC.prevLPC_Q12[0]);
				a4 = Inlines.silk_SMLAWB(a4, array2[num9 - 2], sPLC.prevLPC_Q12[1]);
				a4 = Inlines.silk_SMLAWB(a4, array2[num9 - 3], sPLC.prevLPC_Q12[2]);
				a4 = Inlines.silk_SMLAWB(a4, array2[num9 - 4], sPLC.prevLPC_Q12[3]);
				a4 = Inlines.silk_SMLAWB(a4, array2[num9 - 5], sPLC.prevLPC_Q12[4]);
				a4 = Inlines.silk_SMLAWB(a4, array2[num9 - 6], sPLC.prevLPC_Q12[5]);
				a4 = Inlines.silk_SMLAWB(a4, array2[num9 - 7], sPLC.prevLPC_Q12[6]);
				a4 = Inlines.silk_SMLAWB(a4, array2[num9 - 8], sPLC.prevLPC_Q12[7]);
				a4 = Inlines.silk_SMLAWB(a4, array2[num9 - 9], sPLC.prevLPC_Q12[8]);
				a4 = Inlines.silk_SMLAWB(a4, array2[num9 - 10], sPLC.prevLPC_Q12[9]);
				for (int k = 10; k < psDec.LPC_order; k++)
				{
					a4 = Inlines.silk_SMLAWB(a4, array2[num9 - k - 1], sPLC.prevLPC_Q12[k]);
				}
				array2[num9] = Inlines.silk_ADD_LSHIFT32(array2[num9], a4, 4);
				frame[frame_ptr + i] = (short)Inlines.silk_SAT16(Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULWW(array2[num9], array3[1]), 8)));
			}
			Array.Copy(array2, num8 + psDec.frame_length, psDec.sLPC_Q14_buf, 0, 16);
			sPLC.rand_seed = num3;
			sPLC.randScale_Q14 = num2;
			for (int i = 0; i < 4; i++)
			{
				psDecCtrl.pitchL[i] = num4;
			}
		}

		internal static void silk_PLC_glue_frames(SilkChannelDecoder psDec, short[] frame, int frame_ptr, int length)
		{
			PLCStruct sPLC = psDec.sPLC;
			if (psDec.lossCnt != 0)
			{
				SumSqrShift.silk_sum_sqr_shift(out sPLC.conc_energy, out sPLC.conc_energy_shift, frame, frame_ptr, length);
				sPLC.last_frame_lost = 1;
				return;
			}
			if (psDec.sPLC.last_frame_lost != 0)
			{
				SumSqrShift.silk_sum_sqr_shift(out var energy, out var shift, frame, frame_ptr, length);
				if (shift > sPLC.conc_energy_shift)
				{
					sPLC.conc_energy = Inlines.silk_RSHIFT(sPLC.conc_energy, shift - sPLC.conc_energy_shift);
				}
				else if (shift < sPLC.conc_energy_shift)
				{
					energy = Inlines.silk_RSHIFT(energy, sPLC.conc_energy_shift - shift);
				}
				if (energy > sPLC.conc_energy)
				{
					int num = Inlines.silk_CLZ32(sPLC.conc_energy);
					num--;
					sPLC.conc_energy = Inlines.silk_LSHIFT(sPLC.conc_energy, num);
					energy = Inlines.silk_RSHIFT(energy, Inlines.silk_max_32(24 - num, 0));
					int num2 = Inlines.silk_LSHIFT(Inlines.silk_SQRT_APPROX(Inlines.silk_DIV32(sPLC.conc_energy, Inlines.silk_max(energy, 1))), 4);
					int a = Inlines.silk_DIV32_16(65536 - num2, length);
					a = Inlines.silk_LSHIFT(a, 2);
					for (int i = frame_ptr; i < frame_ptr + length; i++)
					{
						frame[i] = (short)Inlines.silk_SMULWB(num2, frame[i]);
						num2 += a;
						if (num2 > 65536)
						{
							break;
						}
					}
				}
			}
			sPLC.last_frame_lost = 0;
		}
	}
	internal static class ProcessGains
	{
		internal static void silk_process_gains(SilkChannelEncoder psEnc, SilkEncoderControl psEncCtrl, int condCoding)
		{
			SilkShapeState sShape = psEnc.sShape;
			if (psEnc.indices.signalType == 2)
			{
				int c = -Sigmoid.silk_sigm_Q15(Inlines.silk_RSHIFT_ROUND(psEncCtrl.LTPredCodGain_Q7 - 1536, 4));
				for (int i = 0; i < psEnc.nb_subfr; i++)
				{
					psEncCtrl.Gains_Q16[i] = Inlines.silk_SMLAWB(psEncCtrl.Gains_Q16[i], psEncCtrl.Gains_Q16[i], c);
				}
			}
			int b = Inlines.silk_DIV32_16(Inlines.silk_log2lin(Inlines.silk_SMULWB(8894 - psEnc.SNR_dB_Q7, 21627)), psEnc.subfr_length);
			for (int i = 0; i < psEnc.nb_subfr; i++)
			{
				int num = Inlines.silk_SMULWW(psEncCtrl.ResNrg[i], b);
				num = ((psEncCtrl.ResNrgQ[i] > 0) ? Inlines.silk_RSHIFT_ROUND(num, psEncCtrl.ResNrgQ[i]) : ((num < Inlines.silk_RSHIFT(int.MaxValue, -psEncCtrl.ResNrgQ[i])) ? Inlines.silk_LSHIFT(num, -psEncCtrl.ResNrgQ[i]) : int.MaxValue));
				int num2 = psEncCtrl.Gains_Q16[i];
				int num3 = Inlines.silk_ADD_SAT32(num, Inlines.silk_SMMUL(num2, num2));
				if (num3 < 32767)
				{
					num3 = Inlines.silk_SMLAWW(Inlines.silk_LSHIFT(num, 16), num2, num2);
					num2 = Inlines.silk_SQRT_APPROX(num3);
					num2 = Inlines.silk_min(num2, 8388607);
					psEncCtrl.Gains_Q16[i] = Inlines.silk_LSHIFT_SAT32(num2, 8);
				}
				else
				{
					num2 = Inlines.silk_SQRT_APPROX(num3);
					num2 = Inlines.silk_min(num2, 32767);
					psEncCtrl.Gains_Q16[i] = Inlines.silk_LSHIFT_SAT32(num2, 16);
				}
			}
			Array.Copy(psEncCtrl.Gains_Q16, psEncCtrl.GainsUnq_Q16, psEnc.nb_subfr);
			psEncCtrl.lastGainIndexPrev = sShape.LastGainIndex;
			BoxedValueSbyte boxedValueSbyte = new BoxedValueSbyte(sShape.LastGainIndex);
			GainQuantization.silk_gains_quant(psEnc.indices.GainsIndices, psEncCtrl.Gains_Q16, boxedValueSbyte, (condCoding == 2) ? 1 : 0, psEnc.nb_subfr);
			sShape.LastGainIndex = boxedValueSbyte.Val;
			if (psEnc.indices.signalType == 2)
			{
				if (psEncCtrl.LTPredCodGain_Q7 + Inlines.silk_RSHIFT(psEnc.input_tilt_Q15, 8) > 128)
				{
					psEnc.indices.quantOffsetType = 0;
				}
				else
				{
					psEnc.indices.quantOffsetType = 1;
				}
			}
			int b2 = Tables.silk_Quantization_Offsets_Q10[psEnc.indices.signalType >> 1][psEnc.indices.quantOffsetType];
			psEncCtrl.Lambda_Q10 = 1229 + Inlines.silk_SMULBB(-50, psEnc.nStatesDelayedDecision) + Inlines.silk_SMULWB(-52428, psEnc.speech_activity_Q8) + Inlines.silk_SMULWB(-409, psEncCtrl.input_quality_Q14) + Inlines.silk_SMULWB(-818, psEncCtrl.coding_quality_Q14) + Inlines.silk_SMULWB(52429, b2);
		}
	}
	internal static class QuantizeLTPGains
	{
		internal static void silk_quant_LTP_gains(short[] B_Q14, sbyte[] cbk_index, BoxedValueSbyte periodicity_index, BoxedValueInt sum_log_gain_Q7, int[] W_Q18, int mu_Q9, int lowComplexity, int nb_subfr)
		{
			sbyte[] array = new sbyte[4];
			int num = int.MaxValue;
			int val = 0;
			sbyte[][] cb_Q;
			for (int i = 0; i < 3; i++)
			{
				int num2 = 51;
				byte[] cl_Q = Tables.silk_LTP_gain_BITS_Q5_ptrs[i];
				cb_Q = Tables.silk_LTP_vq_ptrs_Q7[i];
				byte[] cb_gain_Q = Tables.silk_LTP_vq_gain_ptrs_Q7[i];
				int l = Tables.silk_LTP_vq_sizes[i];
				int num3 = 0;
				int num4 = 0;
				int num5 = 0;
				int num6 = sum_log_gain_Q7.Val;
				for (int j = 0; j < nb_subfr; j++)
				{
					int max_gain_Q = Inlines.silk_log2lin(5333 - num6 + 896) - num2;
					BoxedValueSbyte boxedValueSbyte = new BoxedValueSbyte(array[j]);
					BoxedValueInt boxedValueInt = new BoxedValueInt();
					BoxedValueInt boxedValueInt2 = new BoxedValueInt();
					VQ_WMat_EC.silk_VQ_WMat_EC(boxedValueSbyte, boxedValueInt, boxedValueInt2, B_Q14, num4, W_Q18, num3, cb_Q, cb_gain_Q, cl_Q, mu_Q9, max_gain_Q, l);
					int val2 = boxedValueInt.Val;
					int val3 = boxedValueInt2.Val;
					array[j] = boxedValueSbyte.Val;
					num5 = Inlines.silk_ADD_POS_SAT32(num5, val2);
					num6 = Inlines.silk_max(0, num6 + Inlines.silk_lin2log(num2 + val3) - 896);
					num4 += 5;
					num3 += 25;
				}
				num5 = Inlines.silk_min(2147483646, num5);
				if (num5 < num)
				{
					num = num5;
					periodicity_index.Val = (sbyte)i;
					Array.Copy(array, 0, cbk_index, 0, nb_subfr);
					val = num6;
				}
				if (lowComplexity != 0 && num5 < Tables.silk_LTP_gain_middle_avg_RD_Q14)
				{
					break;
				}
			}
			cb_Q = Tables.silk_LTP_vq_ptrs_Q7[periodicity_index.Val];
			for (int j = 0; j < nb_subfr; j++)
			{
				for (int i = 0; i < 5; i++)
				{
					B_Q14[j * 5 + i] = (short)Inlines.silk_LSHIFT(cb_Q[cbk_index[j]][i], 7);
				}
			}
			sum_log_gain_Q7.Val = val;
		}
	}
	internal static class RegularizeCorrelations
	{
		internal static void silk_regularize_correlations(int[] XX, int XX_ptr, int[] xx, int xx_ptr, int noise, int D)
		{
			for (int i = 0; i < D; i++)
			{
				Inlines.MatrixSet(XX, XX_ptr, i, i, D, Inlines.silk_ADD32(Inlines.MatrixGet(XX, XX_ptr, i, i, D), noise));
			}
			xx[xx_ptr] += noise;
		}
	}
	internal static class Resampler
	{
		private const int USE_silk_resampler_copy = 0;

		private const int USE_silk_resampler_private_up2_HQ_wrapper = 1;

		private const int USE_silk_resampler_private_IIR_FIR = 2;

		private const int USE_silk_resampler_private_down_FIR = 3;

		private const int ORDER_FIR = 4;

		private static int rateID(int R)
		{
			return ((R >> 12) - ((R > 16000) ? 1 : 0) >> ((R > 24000) ? 1 : 0)) - 1;
		}

		internal static int silk_resampler_init(SilkResamplerState S, int Fs_Hz_in, int Fs_Hz_out, int forEnc)
		{
			S.Reset();
			if (forEnc != 0)
			{
				if ((Fs_Hz_in != 8000 && Fs_Hz_in != 12000 && Fs_Hz_in != 16000 && Fs_Hz_in != 24000 && Fs_Hz_in != 48000) || (Fs_Hz_out != 8000 && Fs_Hz_out != 12000 && Fs_Hz_out != 16000))
				{
					return -1;
				}
				S.inputDelay = Tables.delay_matrix_enc[rateID(Fs_Hz_in), rateID(Fs_Hz_out)];
			}
			else
			{
				if ((Fs_Hz_in != 8000 && Fs_Hz_in != 12000 && Fs_Hz_in != 16000) || (Fs_Hz_out != 8000 && Fs_Hz_out != 12000 && Fs_Hz_out != 16000 && Fs_Hz_out != 24000 && Fs_Hz_out != 48000))
				{
					return -1;
				}
				S.inputDelay = Tables.delay_matrix_dec[rateID(Fs_Hz_in), rateID(Fs_Hz_out)];
			}
			S.Fs_in_kHz = Inlines.silk_DIV32_16(Fs_Hz_in, 1000);
			S.Fs_out_kHz = Inlines.silk_DIV32_16(Fs_Hz_out, 1000);
			S.batchSize = S.Fs_in_kHz * 10;
			int num = 0;
			if (Fs_Hz_out > Fs_Hz_in)
			{
				if (Fs_Hz_out == Inlines.silk_MUL(Fs_Hz_in, 2))
				{
					S.resampler_function = 1;
				}
				else
				{
					S.resampler_function = 2;
					num = 1;
				}
			}
			else if (Fs_Hz_out < Fs_Hz_in)
			{
				S.resampler_function = 3;
				if (Inlines.silk_MUL(Fs_Hz_out, 4) == Inlines.silk_MUL(Fs_Hz_in, 3))
				{
					S.FIR_Fracs = 3;
					S.FIR_Order = 18;
					S.Coefs = Tables.silk_Resampler_3_4_COEFS;
				}
				else if (Inlines.silk_MUL(Fs_Hz_out, 3) == Inlines.silk_MUL(Fs_Hz_in, 2))
				{
					S.FIR_Fracs = 2;
					S.FIR_Order = 18;
					S.Coefs = Tables.silk_Resampler_2_3_COEFS;
				}
				else if (Inlines.silk_MUL(Fs_Hz_out, 2) == Fs_Hz_in)
				{
					S.FIR_Fracs = 1;
					S.FIR_Order = 24;
					S.Coefs = Tables.silk_Resampler_1_2_COEFS;
				}
				else if (Inlines.silk_MUL(Fs_Hz_out, 3) == Fs_Hz_in)
				{
					S.FIR_Fracs = 1;
					S.FIR_Order = 36;
					S.Coefs = Tables.silk_Resampler_1_3_COEFS;
				}
				else if (Inlines.silk_MUL(Fs_Hz_out, 4) == Fs_Hz_in)
				{
					S.FIR_Fracs = 1;
					S.FIR_Order = 36;
					S.Coefs = Tables.silk_Resampler_1_4_COEFS;
				}
				else
				{
					if (Inlines.silk_MUL(Fs_Hz_out, 6) != Fs_Hz_in)
					{
						return -1;
					}
					S.FIR_Fracs = 1;
					S.FIR_Order = 36;
					S.Coefs = Tables.silk_Resampler_1_6_COEFS;
				}
			}
			else
			{
				S.resampler_function = 0;
			}
			S.invRatio_Q16 = Inlines.silk_LSHIFT32(Inlines.silk_DIV32(Inlines.silk_LSHIFT32(Fs_Hz_in, 14 + num), Fs_Hz_out), 2);
			while (Inlines.silk_SMULWW(S.invRatio_Q16, Fs_Hz_out) < Inlines.silk_LSHIFT32(Fs_Hz_in, num))
			{
				S.invRatio_Q16++;
			}
			return 0;
		}

		internal static int silk_resampler(SilkResamplerState S, short[] output, int output_ptr, short[] input, int input_ptr, int inLen)
		{
			int num = S.Fs_in_kHz - S.inputDelay;
			short[] delayBuf = S.delayBuf;
			Array.Copy(input, input_ptr, delayBuf, S.inputDelay, num);
			switch (S.resampler_function)
			{
			case 1:
				silk_resampler_private_up2_HQ(S.sIIR, output, output_ptr, delayBuf, 0, S.Fs_in_kHz);
				silk_resampler_private_up2_HQ(S.sIIR, output, output_ptr + S.Fs_out_kHz, input, input_ptr + num, inLen - S.Fs_in_kHz);
				break;
			case 2:
				silk_resampler_private_IIR_FIR(S, output, output_ptr, delayBuf, 0, S.Fs_in_kHz);
				silk_resampler_private_IIR_FIR(S, output, output_ptr + S.Fs_out_kHz, input, input_ptr + num, inLen - S.Fs_in_kHz);
				break;
			case 3:
				silk_resampler_private_down_FIR(S, output, output_ptr, delayBuf, 0, S.Fs_in_kHz);
				silk_resampler_private_down_FIR(S, output, output_ptr + S.Fs_out_kHz, input, input_ptr + num, inLen - S.Fs_in_kHz);
				break;
			default:
				Array.Copy(delayBuf, 0, output, output_ptr, S.Fs_in_kHz);
				Array.Copy(input, input_ptr + num, output, output_ptr + S.Fs_out_kHz, inLen - S.Fs_in_kHz);
				break;
			}
			Array.Copy(input, input_ptr + inLen - S.inputDelay, delayBuf, 0, S.inputDelay);
			return SilkError.SILK_NO_ERROR;
		}

		internal static void silk_resampler_down2(int[] S, short[] output, short[] input, int inLen)
		{
			int num = Inlines.silk_RSHIFT32(inLen, 1);
			for (int i = 0; i < num; i++)
			{
				int a = Inlines.silk_LSHIFT(input[2 * i], 10);
				int num2 = Inlines.silk_SUB32(a, S[0]);
				int b = Inlines.silk_SMLAWB(num2, num2, -25727);
				int a2 = Inlines.silk_ADD32(S[0], b);
				S[0] = Inlines.silk_ADD32(a, b);
				a = Inlines.silk_LSHIFT(input[2 * i + 1], 10);
				b = Inlines.silk_SMULWB(Inlines.silk_SUB32(a, S[1]), 9872);
				a2 = Inlines.silk_ADD32(a2, S[1]);
				a2 = Inlines.silk_ADD32(a2, b);
				S[1] = Inlines.silk_ADD32(a, b);
				output[i] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(a2, 11));
			}
		}

		internal static void silk_resampler_down2_3(int[] S, short[] output, short[] input, int inLen)
		{
			int[] array = new int[484];
			int num = 0;
			int num2 = 0;
			Array.Copy(S, 0, array, 0, 4);
			int num3;
			while (true)
			{
				num3 = Inlines.silk_min(inLen, 480);
				silk_resampler_private_AR2(S, 4, array, 4, input, num, Tables.silk_Resampler_2_3_COEFS_LQ, num3);
				int num4 = 0;
				for (int num5 = num3; num5 > 2; num5 -= 3)
				{
					int a = Inlines.silk_SMULWB(array[num4], Tables.silk_Resampler_2_3_COEFS_LQ[2]);
					a = Inlines.silk_SMLAWB(a, array[num4 + 1], Tables.silk_Resampler_2_3_COEFS_LQ[3]);
					a = Inlines.silk_SMLAWB(a, array[num4 + 2], Tables.silk_Resampler_2_3_COEFS_LQ[5]);
					a = Inlines.silk_SMLAWB(a, array[num4 + 3], Tables.silk_Resampler_2_3_COEFS_LQ[4]);
					output[num2++] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(a, 6));
					a = Inlines.silk_SMULWB(array[num4 + 1], Tables.silk_Resampler_2_3_COEFS_LQ[4]);
					a = Inlines.silk_SMLAWB(a, array[num4 + 2], Tables.silk_Resampler_2_3_COEFS_LQ[5]);
					a = Inlines.silk_SMLAWB(a, array[num4 + 3], Tables.silk_Resampler_2_3_COEFS_LQ[3]);
					a = Inlines.silk_SMLAWB(a, array[num4 + 4], Tables.silk_Resampler_2_3_COEFS_LQ[2]);
					output[num2++] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(a, 6));
					num4 += 3;
				}
				num += num3;
				inLen -= num3;
				if (inLen <= 0)
				{
					break;
				}
				Array.Copy(array, num3, array, 0, 4);
			}
			Array.Copy(array, num3, S, 0, 4);
		}

		internal static void silk_resampler_private_AR2(int[] S, int S_ptr, int[] out_Q8, int out_Q8_ptr, short[] input, int input_ptr, short[] A_Q14, int len)
		{
			for (int i = 0; i < len; i++)
			{
				int num = Inlines.silk_LSHIFT(out_Q8[out_Q8_ptr + i] = Inlines.silk_ADD_LSHIFT32(S[S_ptr], input[input_ptr + i], 8), 2);
				S[S_ptr] = Inlines.silk_SMLAWB(S[S_ptr + 1], num, A_Q14[0]);
				S[S_ptr + 1] = Inlines.silk_SMULWB(num, A_Q14[1]);
			}
		}

		internal static int silk_resampler_private_down_FIR_INTERPOL(short[] output, int output_ptr, int[] buf, short[] FIR_Coefs, int FIR_Coefs_ptr, int FIR_Order, int FIR_Fracs, int max_index_Q16, int index_increment_Q16)
		{
			switch (FIR_Order)
			{
			case 18:
			{
				for (int i = 0; i < max_index_Q16; i += index_increment_Q16)
				{
					int num = Inlines.silk_RSHIFT(i, 16);
					int num2 = Inlines.silk_SMULWB(i & 0xFFFF, FIR_Fracs);
					int num3 = FIR_Coefs_ptr + 9 * num2;
					int a = Inlines.silk_SMULWB(buf[num], FIR_Coefs[num3]);
					a = Inlines.silk_SMLAWB(a, buf[num + 1], FIR_Coefs[num3 + 1]);
					a = Inlines.silk_SMLAWB(a, buf[num + 2], FIR_Coefs[num3 + 2]);
					a = Inlines.silk_SMLAWB(a, buf[num + 3], FIR_Coefs[num3 + 3]);
					a = Inlines.silk_SMLAWB(a, buf[num + 4], FIR_Coefs[num3 + 4]);
					a = Inlines.silk_SMLAWB(a, buf[num + 5], FIR_Coefs[num3 + 5]);
					a = Inlines.silk_SMLAWB(a, buf[num + 6], FIR_Coefs[num3 + 6]);
					a = Inlines.silk_SMLAWB(a, buf[num + 7], FIR_Coefs[num3 + 7]);
					a = Inlines.silk_SMLAWB(a, buf[num + 8], FIR_Coefs[num3 + 8]);
					num3 = FIR_Coefs_ptr + 9 * (FIR_Fracs - 1 - num2);
					a = Inlines.silk_SMLAWB(a, buf[num + 17], FIR_Coefs[num3]);
					a = Inlines.silk_SMLAWB(a, buf[num + 16], FIR_Coefs[num3 + 1]);
					a = Inlines.silk_SMLAWB(a, buf[num + 15], FIR_Coefs[num3 + 2]);
					a = Inlines.silk_SMLAWB(a, buf[num + 14], FIR_Coefs[num3 + 3]);
					a = Inlines.silk_SMLAWB(a, buf[num + 13], FIR_Coefs[num3 + 4]);
					a = Inlines.silk_SMLAWB(a, buf[num + 12], FIR_Coefs[num3 + 5]);
					a = Inlines.silk_SMLAWB(a, buf[num + 11], FIR_Coefs[num3 + 6]);
					a = Inlines.silk_SMLAWB(a, buf[num + 10], FIR_Coefs[num3 + 7]);
					a = Inlines.silk_SMLAWB(a, buf[num + 9], FIR_Coefs[num3 + 8]);
					output[output_ptr++] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(a, 6));
				}
				break;
			}
			case 24:
			{
				for (int i = 0; i < max_index_Q16; i += index_increment_Q16)
				{
					int num = Inlines.silk_RSHIFT(i, 16);
					int a = Inlines.silk_SMULWB(Inlines.silk_ADD32(buf[num], buf[num + 23]), FIR_Coefs[FIR_Coefs_ptr]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 1], buf[num + 22]), FIR_Coefs[FIR_Coefs_ptr + 1]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 2], buf[num + 21]), FIR_Coefs[FIR_Coefs_ptr + 2]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 3], buf[num + 20]), FIR_Coefs[FIR_Coefs_ptr + 3]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 4], buf[num + 19]), FIR_Coefs[FIR_Coefs_ptr + 4]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 5], buf[num + 18]), FIR_Coefs[FIR_Coefs_ptr + 5]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 6], buf[num + 17]), FIR_Coefs[FIR_Coefs_ptr + 6]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 7], buf[num + 16]), FIR_Coefs[FIR_Coefs_ptr + 7]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 8], buf[num + 15]), FIR_Coefs[FIR_Coefs_ptr + 8]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 9], buf[num + 14]), FIR_Coefs[FIR_Coefs_ptr + 9]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 10], buf[num + 13]), FIR_Coefs[FIR_Coefs_ptr + 10]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 11], buf[num + 12]), FIR_Coefs[FIR_Coefs_ptr + 11]);
					output[output_ptr++] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(a, 6));
				}
				break;
			}
			case 36:
			{
				for (int i = 0; i < max_index_Q16; i += index_increment_Q16)
				{
					int num = Inlines.silk_RSHIFT(i, 16);
					int a = Inlines.silk_SMULWB(Inlines.silk_ADD32(buf[num], buf[num + 35]), FIR_Coefs[FIR_Coefs_ptr]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 1], buf[num + 34]), FIR_Coefs[FIR_Coefs_ptr + 1]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 2], buf[num + 33]), FIR_Coefs[FIR_Coefs_ptr + 2]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 3], buf[num + 32]), FIR_Coefs[FIR_Coefs_ptr + 3]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 4], buf[num + 31]), FIR_Coefs[FIR_Coefs_ptr + 4]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 5], buf[num + 30]), FIR_Coefs[FIR_Coefs_ptr + 5]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 6], buf[num + 29]), FIR_Coefs[FIR_Coefs_ptr + 6]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 7], buf[num + 28]), FIR_Coefs[FIR_Coefs_ptr + 7]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 8], buf[num + 27]), FIR_Coefs[FIR_Coefs_ptr + 8]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 9], buf[num + 26]), FIR_Coefs[FIR_Coefs_ptr + 9]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 10], buf[num + 25]), FIR_Coefs[FIR_Coefs_ptr + 10]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 11], buf[num + 24]), FIR_Coefs[FIR_Coefs_ptr + 11]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 12], buf[num + 23]), FIR_Coefs[FIR_Coefs_ptr + 12]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 13], buf[num + 22]), FIR_Coefs[FIR_Coefs_ptr + 13]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 14], buf[num + 21]), FIR_Coefs[FIR_Coefs_ptr + 14]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 15], buf[num + 20]), FIR_Coefs[FIR_Coefs_ptr + 15]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 16], buf[num + 19]), FIR_Coefs[FIR_Coefs_ptr + 16]);
					a = Inlines.silk_SMLAWB(a, Inlines.silk_ADD32(buf[num + 17], buf[num + 18]), FIR_Coefs[FIR_Coefs_ptr + 17]);
					output[output_ptr++] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(a, 6));
				}
				break;
			}
			}
			return output_ptr;
		}

		internal static void silk_resampler_private_down_FIR(SilkResamplerState S, short[] output, int output_ptr, short[] input, int input_ptr, int inLen)
		{
			int[] array = new int[S.batchSize + S.FIR_Order];
			Array.Copy(S.sFIR_i32, array, S.FIR_Order);
			int invRatio_Q = S.invRatio_Q16;
			int num;
			while (true)
			{
				num = Inlines.silk_min(inLen, S.batchSize);
				silk_resampler_private_AR2(S.sIIR, 0, array, S.FIR_Order, input, input_ptr, S.Coefs, num);
				int max_index_Q = Inlines.silk_LSHIFT32(num, 16);
				output_ptr = silk_resampler_private_down_FIR_INTERPOL(output, output_ptr, array, S.Coefs, 2, S.FIR_Order, S.FIR_Fracs, max_index_Q, invRatio_Q);
				input_ptr += num;
				inLen -= num;
				if (inLen <= 1)
				{
					break;
				}
				Array.Copy(array, num, array, 0, S.FIR_Order);
			}
			Array.Copy(array, num, S.sFIR_i32, 0, S.FIR_Order);
		}

		internal static int silk_resampler_private_IIR_FIR_INTERPOL(short[] output, int output_ptr, short[] buf, int max_index_Q16, int index_increment_Q16)
		{
			for (int i = 0; i < max_index_Q16; i += index_increment_Q16)
			{
				int num = Inlines.silk_SMULWB(i & 0xFFFF, 12);
				int num2 = i >> 16;
				int a = Inlines.silk_SMULBB(buf[num2], Tables.silk_resampler_frac_FIR_12[num, 0]);
				a = Inlines.silk_SMLABB(a, buf[num2 + 1], Tables.silk_resampler_frac_FIR_12[num, 1]);
				a = Inlines.silk_SMLABB(a, buf[num2 + 2], Tables.silk_resampler_frac_FIR_12[num, 2]);
				a = Inlines.silk_SMLABB(a, buf[num2 + 3], Tables.silk_resampler_frac_FIR_12[num, 3]);
				a = Inlines.silk_SMLABB(a, buf[num2 + 4], Tables.silk_resampler_frac_FIR_12[11 - num, 3]);
				a = Inlines.silk_SMLABB(a, buf[num2 + 5], Tables.silk_resampler_frac_FIR_12[11 - num, 2]);
				a = Inlines.silk_SMLABB(a, buf[num2 + 6], Tables.silk_resampler_frac_FIR_12[11 - num, 1]);
				a = Inlines.silk_SMLABB(a, buf[num2 + 7], Tables.silk_resampler_frac_FIR_12[11 - num, 0]);
				output[output_ptr++] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(a, 15));
			}
			return output_ptr;
		}

		internal static void silk_resampler_private_IIR_FIR(SilkResamplerState S, short[] output, int output_ptr, short[] input, int input_ptr, int inLen)
		{
			short[] array = new short[2 * S.batchSize + 8];
			Array.Copy(S.sFIR_i16, 0, array, 0, 8);
			int invRatio_Q = S.invRatio_Q16;
			int num;
			while (true)
			{
				num = Inlines.silk_min(inLen, S.batchSize);
				silk_resampler_private_up2_HQ(S.sIIR, array, 8, input, input_ptr, num);
				int max_index_Q = Inlines.silk_LSHIFT32(num, 17);
				output_ptr = silk_resampler_private_IIR_FIR_INTERPOL(output, output_ptr, array, max_index_Q, invRatio_Q);
				input_ptr += num;
				inLen -= num;
				if (inLen <= 0)
				{
					break;
				}
				Array.Copy(array, num << 1, array, 0, 8);
			}
			Array.Copy(array, num << 1, S.sFIR_i16, 0, 8);
		}

		internal static void silk_resampler_private_up2_HQ(int[] S, short[] output, int output_ptr, short[] input, int input_ptr, int len)
		{
			for (int i = 0; i < len; i++)
			{
				int a = Inlines.silk_LSHIFT(input[input_ptr + i], 10);
				int b = Inlines.silk_SMULWB(Inlines.silk_SUB32(a, S[0]), Tables.silk_resampler_up2_hq_0[0]);
				int a2 = Inlines.silk_ADD32(S[0], b);
				S[0] = Inlines.silk_ADD32(a, b);
				b = Inlines.silk_SMULWB(Inlines.silk_SUB32(a2, S[1]), Tables.silk_resampler_up2_hq_0[1]);
				int a3 = Inlines.silk_ADD32(S[1], b);
				S[1] = Inlines.silk_ADD32(a2, b);
				int num = Inlines.silk_SUB32(a3, S[2]);
				b = Inlines.silk_SMLAWB(num, num, Tables.silk_resampler_up2_hq_0[2]);
				a2 = Inlines.silk_ADD32(S[2], b);
				S[2] = Inlines.silk_ADD32(a3, b);
				output[output_ptr + 2 * i] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(a2, 10));
				b = Inlines.silk_SMULWB(Inlines.silk_SUB32(a, S[3]), Tables.silk_resampler_up2_hq_1[0]);
				a2 = Inlines.silk_ADD32(S[3], b);
				S[3] = Inlines.silk_ADD32(a, b);
				b = Inlines.silk_SMULWB(Inlines.silk_SUB32(a2, S[4]), Tables.silk_resampler_up2_hq_1[1]);
				a3 = Inlines.silk_ADD32(S[4], b);
				S[4] = Inlines.silk_ADD32(a2, b);
				int num2 = Inlines.silk_SUB32(a3, S[5]);
				b = Inlines.silk_SMLAWB(num2, num2, Tables.silk_resampler_up2_hq_1[2]);
				a2 = Inlines.silk_ADD32(S[5], b);
				S[5] = Inlines.silk_ADD32(a3, b);
				output[output_ptr + 2 * i + 1] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(a2, 10));
			}
		}
	}
	internal static class ResidualEnergy
	{
		internal static void silk_residual_energy(int[] nrgs, int[] nrgsQ, short[] x, short[][] a_Q12, int[] gains, int subfr_length, int nb_subfr, int LPC_order)
		{
			int num = 0;
			int num2 = LPC_order + subfr_length;
			short[] array = new short[2 * num2];
			for (int i = 0; i < nb_subfr >> 1; i++)
			{
				Filters.silk_LPC_analysis_filter(array, 0, x, num, a_Q12[i], 0, 2 * num2, LPC_order);
				int num3 = LPC_order;
				for (int j = 0; j < 2; j++)
				{
					SumSqrShift.silk_sum_sqr_shift(out var energy, out var shift, array, num3, subfr_length);
					nrgs[i * 2 + j] = energy;
					nrgsQ[i * 2 + j] = -shift;
					num3 += num2;
				}
				num += 2 * num2;
			}
			for (int i = 0; i < nb_subfr; i++)
			{
				int num4 = Inlines.silk_CLZ32(nrgs[i]) - 1;
				int num5 = Inlines.silk_CLZ32(gains[i]) - 1;
				int num6 = Inlines.silk_LSHIFT32(gains[i], num5);
				num6 = Inlines.silk_SMMUL(num6, num6);
				nrgs[i] = Inlines.silk_SMMUL(num6, Inlines.silk_LSHIFT32(nrgs[i], num4));
				nrgsQ[i] += num4 + 2 * num5 - 32 - 32;
			}
		}

		internal static int silk_residual_energy16_covar(short[] c, int c_ptr, int[] wXX, int wXX_ptr, int[] wXx, int wxx, int D, int cQ)
		{
			int[] array = new int[D];
			int num = 16 - cQ;
			int a = num;
			int num2 = 0;
			for (int i = c_ptr; i < c_ptr + D; i++)
			{
				num2 = Inlines.silk_max_32(num2, Inlines.silk_abs(c[i]));
			}
			a = Inlines.silk_min_int(a, Inlines.silk_CLZ32(num2) - 17);
			int a2 = Inlines.silk_max_32(wXX[wXX_ptr], wXX[wXX_ptr + D * D - 1]);
			a = Inlines.silk_min_int(a, Inlines.silk_CLZ32(Inlines.silk_MUL(D, Inlines.silk_RSHIFT(Inlines.silk_SMULWB(a2, num2), 4))) - 5);
			a = Inlines.silk_max_int(a, 0);
			for (int i = 0; i < D; i++)
			{
				array[i] = Inlines.silk_LSHIFT(c[c_ptr + i], a);
			}
			num -= a;
			int num3 = 0;
			for (int i = 0; i < D; i++)
			{
				num3 = Inlines.silk_SMLAWB(num3, wXx[i], array[i]);
			}
			int a3 = Inlines.silk_RSHIFT(wxx, 1 + num) - num3;
			int num4 = 0;
			for (int i = 0; i < D; i++)
			{
				num3 = 0;
				int num5 = wXX_ptr + i * D;
				for (int j = i + 1; j < D; j++)
				{
					num3 = Inlines.silk_SMLAWB(num3, wXX[num5 + j], array[j]);
				}
				num3 = Inlines.silk_SMLAWB(num3, Inlines.silk_RSHIFT(wXX[num5 + i], 1), array[i]);
				num4 = Inlines.silk_SMLAWB(num4, num3, array[i]);
			}
			a3 = Inlines.silk_ADD_LSHIFT32(a3, num4, num);
			if (a3 < 1)
			{
				return 1;
			}
			if (a3 > Inlines.silk_RSHIFT(int.MaxValue, num + 2))
			{
				return 1073741823;
			}
			return Inlines.silk_LSHIFT(a3, num + 1);
		}
	}
	internal static class Schur
	{
		internal static int silk_schur(short[] rc_Q15, int[] c, int order)
		{
			int[][] array = Arrays.InitTwoDimensionalArray<int>(17, 2);
			int num = Inlines.silk_CLZ32(c[0]);
			int i;
			if (num < 2)
			{
				for (i = 0; i < order + 1; i++)
				{
					array[i][0] = (array[i][1] = Inlines.silk_RSHIFT(c[i], 1));
				}
			}
			else if (num > 2)
			{
				num -= 2;
				for (i = 0; i < order + 1; i++)
				{
					array[i][0] = (array[i][1] = Inlines.silk_LSHIFT(c[i], num));
				}
			}
			else
			{
				for (i = 0; i < order + 1; i++)
				{
					array[i][0] = (array[i][1] = c[i]);
				}
			}
			for (i = 0; i < order; i++)
			{
				if (Inlines.silk_abs_int32(array[i + 1][0]) >= array[0][1])
				{
					if (array[i + 1][0] > 0)
					{
						rc_Q15[i] = -32440;
					}
					else
					{
						rc_Q15[i] = 32440;
					}
					i++;
					break;
				}
				int a = -Inlines.silk_DIV32_16(array[i + 1][0], Inlines.silk_max_32(Inlines.silk_RSHIFT(array[0][1], 15), 1));
				a = Inlines.silk_SAT16(a);
				rc_Q15[i] = (short)a;
				for (int j = 0; j < order - i; j++)
				{
					int num2 = array[j + i + 1][0];
					int num3 = array[j][1];
					array[j + i + 1][0] = Inlines.silk_SMLAWB(num2, Inlines.silk_LSHIFT(num3, 1), a);
					array[j][1] = Inlines.silk_SMLAWB(num3, Inlines.silk_LSHIFT(num2, 1), a);
				}
			}
			for (; i < order; i++)
			{
				rc_Q15[i] = 0;
			}
			return Inlines.silk_max_32(1, array[0][1]);
		}

		internal static int silk_schur64(int[] rc_Q16, int[] c, int order)
		{
			int[][] array = Arrays.InitTwoDimensionalArray<int>(17, 2);
			if (c[0] <= 0)
			{
				Arrays.MemSetInt(rc_Q16, 0, order);
				return 0;
			}
			int i;
			for (i = 0; i < order + 1; i++)
			{
				array[i][0] = (array[i][1] = c[i]);
			}
			for (i = 0; i < order; i++)
			{
				if (Inlines.silk_abs_int32(array[i + 1][0]) >= array[0][1])
				{
					if (array[i + 1][0] > 0)
					{
						rc_Q16[i] = -64881;
					}
					else
					{
						rc_Q16[i] = 64881;
					}
					i++;
					break;
				}
				int num = Inlines.silk_DIV32_varQ(-array[i + 1][0], array[0][1], 31);
				rc_Q16[i] = Inlines.silk_RSHIFT_ROUND(num, 15);
				for (int j = 0; j < order - i; j++)
				{
					int num2 = array[j + i + 1][0];
					int num3 = array[j][1];
					array[j + i + 1][0] = num2 + Inlines.silk_SMMUL(Inlines.silk_LSHIFT(num3, 1), num);
					array[j][1] = num3 + Inlines.silk_SMMUL(Inlines.silk_LSHIFT(num2, 1), num);
				}
			}
			for (; i < order; i++)
			{
				rc_Q16[i] = 0;
			}
			return Inlines.silk_max_32(1, array[0][1]);
		}
	}
	internal static class ShellCoder
	{
		internal static void combine_pulses(int[] output, int[] input, int input_ptr, int len)
		{
			for (int i = 0; i < len; i++)
			{
				output[i] = input[input_ptr + 2 * i] + input[input_ptr + 2 * i + 1];
			}
		}

		internal static void combine_pulses(int[] output, int[] input, int len)
		{
			for (int i = 0; i < len; i++)
			{
				output[i] = input[2 * i] + input[2 * i + 1];
			}
		}

		internal static void encode_split(EntropyCoder psRangeEnc, int p_child1, int p, byte[] shell_table)
		{
			if (p > 0)
			{
				psRangeEnc.enc_icdf(p_child1, shell_table, Tables.silk_shell_code_table_offsets[p], 8u);
			}
		}

		internal static void decode_split(short[] p_child1, int child1_ptr, short[] p_child2, int p_child2_ptr, EntropyCoder psRangeDec, int p, byte[] shell_table)
		{
			if (p > 0)
			{
				p_child1[child1_ptr] = (short)psRangeDec.dec_icdf(shell_table, Tables.silk_shell_code_table_offsets[p], 8u);
				p_child2[p_child2_ptr] = (short)(p - p_child1[child1_ptr]);
			}
			else
			{
				p_child1[child1_ptr] = 0;
				p_child2[p_child2_ptr] = 0;
			}
		}

		internal static void silk_shell_encoder(EntropyCoder psRangeEnc, int[] pulses0, int pulses0_ptr)
		{
			int[] array = new int[8];
			int[] array2 = new int[4];
			int[] array3 = new int[2];
			int[] array4 = new int[1];
			combine_pulses(array, pulses0, pulses0_ptr, 8);
			combine_pulses(array2, array, 4);
			combine_pulses(array3, array2, 2);
			combine_pulses(array4, array3, 1);
			encode_split(psRangeEnc, array3[0], array4[0], Tables.silk_shell_code_table3);
			encode_split(psRangeEnc, array2[0], array3[0], Tables.silk_shell_code_table2);
			encode_split(psRangeEnc, array[0], array2[0], Tables.silk_shell_code_table1);
			encode_split(psRangeEnc, pulses0[pulses0_ptr], array[0], Tables.silk_shell_code_table0);
			encode_split(psRangeEnc, pulses0[pulses0_ptr + 2], array[1], Tables.silk_shell_code_table0);
			encode_split(psRangeEnc, array[2], array2[1], Tables.silk_shell_code_table1);
			encode_split(psRangeEnc, pulses0[pulses0_ptr + 4], array[2], Tables.silk_shell_code_table0);
			encode_split(psRangeEnc, pulses0[pulses0_ptr + 6], array[3], Tables.silk_shell_code_table0);
			encode_split(psRangeEnc, array2[2], array3[1], Tables.silk_shell_code_table2);
			encode_split(psRangeEnc, array[4], array2[2], Tables.silk_shell_code_table1);
			encode_split(psRangeEnc, pulses0[pulses0_ptr + 8], array[4], Tables.silk_shell_code_table0);
			encode_split(psRangeEnc, pulses0[pulses0_ptr + 10], array[5], Tables.silk_shell_code_table0);
			encode_split(psRangeEnc, array[6], array2[3], Tables.silk_shell_code_table1);
			encode_split(psRangeEnc, pulses0[pulses0_ptr + 12], array[6], Tables.silk_shell_code_table0);
			encode_split(psRangeEnc, pulses0[pulses0_ptr + 14], array[7], Tables.silk_shell_code_table0);
		}

		internal static void silk_shell_decoder(short[] pulses0, int pulses0_ptr, EntropyCoder psRangeDec, int pulses4)
		{
			short[] array = new short[8];
			short[] array2 = new short[4];
			short[] array3 = new short[2];
			decode_split(array3, 0, array3, 1, psRangeDec, pulses4, Tables.silk_shell_code_table3);
			decode_split(array2, 0, array2, 1, psRangeDec, array3[0], Tables.silk_shell_code_table2);
			decode_split(array, 0, array, 1, psRangeDec, array2[0], Tables.silk_shell_code_table1);
			decode_split(pulses0, pulses0_ptr, pulses0, pulses0_ptr + 1, psRangeDec, array[0], Tables.silk_shell_code_table0);
			decode_split(pulses0, pulses0_ptr + 2, pulses0, pulses0_ptr + 3, psRangeDec, array[1], Tables.silk_shell_code_table0);
			decode_split(array, 2, array, 3, psRangeDec, array2[1], Tables.silk_shell_code_table1);
			decode_split(pulses0, pulses0_ptr + 4, pulses0, pulses0_ptr + 5, psRangeDec, array[2], Tables.silk_shell_code_table0);
			decode_split(pulses0, pulses0_ptr + 6, pulses0, pulses0_ptr + 7, psRangeDec, array[3], Tables.silk_shell_code_table0);
			decode_split(array2, 2, array2, 3, psRangeDec, array3[1], Tables.silk_shell_code_table2);
			decode_split(array, 4, array, 5, psRangeDec, array2[2], Tables.silk_shell_code_table1);
			decode_split(pulses0, pulses0_ptr + 8, pulses0, pulses0_ptr + 9, psRangeDec, array[4], Tables.silk_shell_code_table0);
			decode_split(pulses0, pulses0_ptr + 10, pulses0, pulses0_ptr + 11, psRangeDec, array[5], Tables.silk_shell_code_table0);
			decode_split(array, 6, array, 7, psRangeDec, array2[3], Tables.silk_shell_code_table1);
			decode_split(pulses0, pulses0_ptr + 12, pulses0, pulses0_ptr + 13, psRangeDec, array[6], Tables.silk_shell_code_table0);
			decode_split(pulses0, pulses0_ptr + 14, pulses0, pulses0_ptr + 15, psRangeDec, array[7], Tables.silk_shell_code_table0);
		}
	}
	internal static class Sigmoid
	{
		private static readonly int[] sigm_LUT_slope_Q10 = new int[6] { 237, 153, 73, 30, 12, 7 };

		private static readonly int[] sigm_LUT_pos_Q15 = new int[6] { 16384, 23955, 28861, 31213, 32178, 32548 };

		private static readonly int[] sigm_LUT_neg_Q15 = new int[6] { 16384, 8812, 3906, 1554, 589, 219 };

		internal static int silk_sigm_Q15(int in_Q5)
		{
			int num;
			if (in_Q5 < 0)
			{
				in_Q5 = -in_Q5;
				if (in_Q5 >= 192)
				{
					return 0;
				}
				num = Inlines.silk_RSHIFT(in_Q5, 5);
				return sigm_LUT_neg_Q15[num] - Inlines.silk_SMULBB(sigm_LUT_slope_Q10[num], in_Q5 & 0x1F);
			}
			if (in_Q5 >= 192)
			{
				return 32767;
			}
			num = Inlines.silk_RSHIFT(in_Q5, 5);
			return sigm_LUT_pos_Q15[num] + Inlines.silk_SMULBB(sigm_LUT_slope_Q10[num], in_Q5 & 0x1F);
		}
	}
	internal static class SilkConstants
	{
		public const int ENCODER_NUM_CHANNELS = 2;

		public const int DECODER_NUM_CHANNELS = 2;

		public const int MAX_FRAMES_PER_PACKET = 3;

		public const int MIN_TARGET_RATE_BPS = 5000;

		public const int MAX_TARGET_RATE_BPS = 80000;

		public const int TARGET_RATE_TAB_SZ = 8;

		public const int LBRR_NB_MIN_RATE_BPS = 12000;

		public const int LBRR_MB_MIN_RATE_BPS = 14000;

		public const int LBRR_WB_MIN_RATE_BPS = 16000;

		public const int NB_SPEECH_FRAMES_BEFORE_DTX = 10;

		public const int MAX_CONSECUTIVE_DTX = 20;

		public const int MAX_FS_KHZ = 16;

		public const int MAX_API_FS_KHZ = 48;

		public const int TYPE_NO_VOICE_ACTIVITY = 0;

		public const int TYPE_UNVOICED = 1;

		public const int TYPE_VOICED = 2;

		public const int CODE_INDEPENDENTLY = 0;

		public const int CODE_INDEPENDENTLY_NO_LTP_SCALING = 1;

		public const int CODE_CONDITIONALLY = 2;

		public const int STEREO_QUANT_TAB_SIZE = 16;

		public const int STEREO_QUANT_SUB_STEPS = 5;

		public const int STEREO_INTERP_LEN_MS = 8;

		public const float STEREO_RATIO_SMOOTH_COEF = 0.01f;

		public const int PITCH_EST_MIN_LAG_MS = 2;

		public const int PITCH_EST_MAX_LAG_MS = 18;

		public const int MAX_NB_SUBFR = 4;

		public const int LTP_MEM_LENGTH_MS = 20;

		public const int SUB_FRAME_LENGTH_MS = 5;

		public const int MAX_SUB_FRAME_LENGTH = 80;

		public const int MAX_FRAME_LENGTH_MS = 20;

		public const int MAX_FRAME_LENGTH = 320;

		public const int LA_PITCH_MS = 2;

		public const int LA_PITCH_MAX = 32;

		public const int MAX_FIND_PITCH_LPC_ORDER = 16;

		public const int FIND_PITCH_LPC_WIN_MS = 24;

		public const int FIND_PITCH_LPC_WIN_MS_2_SF = 14;

		public const int FIND_PITCH_LPC_WIN_MAX = 384;

		public const int LA_SHAPE_MS = 5;

		public const int LA_SHAPE_MAX = 80;

		public const int SHAPE_LPC_WIN_MAX = 240;

		public const int MIN_QGAIN_DB = 2;

		public const int MAX_QGAIN_DB = 88;

		public const int N_LEVELS_QGAIN = 64;

		public const int MAX_DELTA_GAIN_QUANT = 36;

		public const int MIN_DELTA_GAIN_QUANT = -4;

		public const short OFFSET_VL_Q10 = 32;

		public const short OFFSET_VH_Q10 = 100;

		public const short OFFSET_UVL_Q10 = 100;

		public const short OFFSET_UVH_Q10 = 240;

		public const int QUANT_LEVEL_ADJUST_Q10 = 80;

		public const int MAX_LPC_STABILIZE_ITERATIONS = 16;

		public const float MAX_PREDICTION_POWER_GAIN = 10000f;

		public const float MAX_PREDICTION_POWER_GAIN_AFTER_RESET = 100f;

		public const int SILK_MAX_ORDER_LPC = 16;

		public const int MAX_LPC_ORDER = 16;

		public const int MIN_LPC_ORDER = 10;

		public const int LTP_ORDER = 5;

		public const int NB_LTP_CBKS = 3;

		public const int USE_HARM_SHAPING = 1;

		public const int MAX_SHAPE_LPC_ORDER = 16;

		public const int HARM_SHAPE_FIR_TAPS = 3;

		public const int MAX_DEL_DEC_STATES = 4;

		public const int LTP_BUF_LENGTH = 512;

		public const int LTP_MASK = 511;

		public const int DECISION_DELAY = 32;

		public const int DECISION_DELAY_MASK = 31;

		public const int SHELL_CODEC_FRAME_LENGTH = 16;

		public const int LOG2_SHELL_CODEC_FRAME_LENGTH = 4;

		public const int MAX_NB_SHELL_BLOCKS = 20;

		public const int N_RATE_LEVELS = 10;

		public const int SILK_MAX_PULSES = 16;

		public const int MAX_MATRIX_SIZE = 16;

		internal static readonly int NSQ_LPC_BUF_LENGTH = Math.Max(16, 32);

		public const int VAD_N_BANDS = 4;

		public const int VAD_INTERNAL_SUBFRAMES_LOG2 = 2;

		public const int VAD_INTERNAL_SUBFRAMES = 4;

		public const int VAD_NOISE_LEVEL_SMOOTH_COEF_Q16 = 1024;

		public const int VAD_NOISE_LEVELS_BIAS = 50;

		public const int VAD_NEGATIVE_OFFSET_Q5 = 128;

		public const int VAD_SNR_FACTOR_Q16 = 45000;

		public const int VAD_SNR_SMOOTH_COEF_Q18 = 4096;

		public const int LSF_COS_TAB_SZ = 128;

		public const int NLSF_W_Q = 2;

		public const int NLSF_VQ_MAX_VECTORS = 32;

		public const int NLSF_VQ_MAX_SURVIVORS = 32;

		public const int NLSF_QUANT_MAX_AMPLITUDE = 4;

		public const int NLSF_QUANT_MAX_AMPLITUDE_EXT = 10;

		public const float NLSF_QUANT_LEVEL_ADJ = 0.1f;

		public const int NLSF_QUANT_DEL_DEC_STATES_LOG2 = 2;

		public const int NLSF_QUANT_DEL_DEC_STATES = 4;

		public const int TRANSITION_TIME_MS = 5120;

		public const int TRANSITION_NB = 3;

		public const int TRANSITION_NA = 2;

		public const int TRANSITION_INT_NUM = 5;

		public const int TRANSITION_FRAMES = 256;

		public const int TRANSITION_INT_STEPS = 64;

		public const int BWE_AFTER_LOSS_Q16 = 63570;

		public const int CNG_BUF_MASK_MAX = 255;

		public const int CNG_GAIN_SMTH_Q16 = 4634;

		public const int CNG_NLSF_SMTH_Q16 = 16348;

		public const int PE_MAX_FS_KHZ = 16;

		public const int PE_MAX_NB_SUBFR = 4;

		public const int PE_SUBFR_LENGTH_MS = 5;

		public const int PE_LTP_MEM_LENGTH_MS = 20;

		public const int PE_MAX_FRAME_LENGTH_MS = 40;

		public const int PE_MAX_FRAME_LENGTH = 640;

		public const int PE_MAX_FRAME_LENGTH_ST_1 = 160;

		public const int PE_MAX_FRAME_LENGTH_ST_2 = 320;

		public const int PE_MAX_LAG_MS = 18;

		public const int PE_MIN_LAG_MS = 2;

		public const int PE_MAX_LAG = 288;

		public const int PE_MIN_LAG = 32;

		public const int PE_D_SRCH_LENGTH = 24;

		public const int PE_NB_STAGE3_LAGS = 5;

		public const int PE_NB_CBKS_STAGE2 = 3;

		public const int PE_NB_CBKS_STAGE2_EXT = 11;

		public const int PE_NB_CBKS_STAGE3_MAX = 34;

		public const int PE_NB_CBKS_STAGE3_MID = 24;

		public const int PE_NB_CBKS_STAGE3_MIN = 16;

		public const int PE_NB_CBKS_STAGE3_10MS = 12;

		public const int PE_NB_CBKS_STAGE2_10MS = 3;

		public const float PE_SHORTLAG_BIAS = 0.2f;

		public const float PE_PREVLAG_BIAS = 0.2f;

		public const float PE_FLATCONTOUR_BIAS = 0.05f;

		public const int SILK_PE_MIN_COMPLEX = 0;

		public const int SILK_PE_MID_COMPLEX = 1;

		public const int SILK_PE_MAX_COMPLEX = 2;

		public const float BWE_COEF = 0.99f;

		public const int V_PITCH_GAIN_START_MIN_Q14 = 11469;

		public const int V_PITCH_GAIN_START_MAX_Q14 = 15565;

		public const int MAX_PITCH_LAG_MS = 18;

		public const int RAND_BUF_SIZE = 128;

		public const int RAND_BUF_MASK = 127;

		public const int LOG2_INV_LPC_GAIN_HIGH_THRES = 3;

		public const int LOG2_INV_LPC_GAIN_LOW_THRES = 8;

		public const int PITCH_DRIFT_FAC_Q16 = 655;

		public const int SILK_RESAMPLER_MAX_FIR_ORDER = 36;

		public const int SILK_RESAMPLER_MAX_IIR_ORDER = 6;

		public const int RESAMPLER_DOWN_ORDER_FIR0 = 18;

		public const int RESAMPLER_DOWN_ORDER_FIR1 = 24;

		public const int RESAMPLER_DOWN_ORDER_FIR2 = 36;

		public const int RESAMPLER_ORDER_FIR_12 = 8;

		public const int RESAMPLER_MAX_BATCH_SIZE_MS = 10;

		public const int RESAMPLER_MAX_FS_KHZ = 48;

		public const int RESAMPLER_MAX_BATCH_SIZE_IN = 480;

		public const int SILK_MAX_FRAMES_PER_PACKET = 3;
	}
	internal static class Sort
	{
		internal static void silk_insertion_sort_increasing(int[] a, int[] idx, int L, int K)
		{
			for (int i = 0; i < K; i++)
			{
				idx[i] = i;
			}
			for (int i = 1; i < K; i++)
			{
				int num = a[i];
				int num2 = i - 1;
				while (num2 >= 0 && num < a[num2])
				{
					a[num2 + 1] = a[num2];
					idx[num2 + 1] = idx[num2];
					num2--;
				}
				a[num2 + 1] = num;
				idx[num2 + 1] = i;
			}
			for (int i = K; i < L; i++)
			{
				int num = a[i];
				if (num < a[K - 1])
				{
					int num2 = K - 2;
					while (num2 >= 0 && num < a[num2])
					{
						a[num2 + 1] = a[num2];
						idx[num2 + 1] = idx[num2];
						num2--;
					}
					a[num2 + 1] = num;
					idx[num2 + 1] = i;
				}
			}
		}

		internal static void silk_insertion_sort_increasing_all_values_int16(short[] a, int L)
		{
			for (int i = 1; i < L; i++)
			{
				short num = a[i];
				int num2 = i - 1;
				while (num2 >= 0 && num < a[num2])
				{
					a[num2 + 1] = a[num2];
					num2--;
				}
				a[num2 + 1] = num;
			}
		}

		internal static void silk_insertion_sort_decreasing_int16(short[] a, int[] idx, int L, int K)
		{
			for (int i = 0; i < K; i++)
			{
				idx[i] = i;
			}
			for (int i = 1; i < K; i++)
			{
				short num = a[i];
				int num2 = i - 1;
				while (num2 >= 0 && num > a[num2])
				{
					a[num2 + 1] = a[num2];
					idx[num2 + 1] = idx[num2];
					num2--;
				}
				a[num2 + 1] = num;
				idx[num2 + 1] = i;
			}
			for (int i = K; i < L; i++)
			{
				short num = a[i];
				if (num > a[K - 1])
				{
					int num2 = K - 2;
					while (num2 >= 0 && num > a[num2])
					{
						a[num2 + 1] = a[num2];
						idx[num2 + 1] = idx[num2];
						num2--;
					}
					a[num2 + 1] = num;
					idx[num2 + 1] = i;
				}
			}
		}
	}
	internal static class Stereo
	{
		internal static void silk_stereo_decode_pred(EntropyCoder psRangeDec, int[] pred_Q13)
		{
			int[][] array = Arrays.InitTwoDimensionalArray<int>(2, 3);
			int num = psRangeDec.dec_icdf(Tables.silk_stereo_pred_joint_iCDF, 8u);
			array[0][2] = Inlines.silk_DIV32_16(num, 5);
			array[1][2] = num - 5 * array[0][2];
			for (num = 0; num < 2; num++)
			{
				array[num][0] = psRangeDec.dec_icdf(Tables.silk_uniform3_iCDF, 8u);
				array[num][1] = psRangeDec.dec_icdf(Tables.silk_uniform5_iCDF, 8u);
			}
			for (num = 0; num < 2; num++)
			{
				array[num][0] += 3 * array[num][2];
				int num2 = Tables.silk_stereo_pred_quant_Q13[array[num][0]];
				int b = Inlines.silk_SMULWB(Tables.silk_stereo_pred_quant_Q13[array[num][0] + 1] - num2, 6554);
				pred_Q13[num] = Inlines.silk_SMLABB(num2, b, 2 * array[num][1] + 1);
			}
			pred_Q13[0] -= pred_Q13[1];
		}

		internal static void silk_stereo_decode_mid_only(EntropyCoder psRangeDec, BoxedValueInt decode_only_mid)
		{
			decode_only_mid.Val = psRangeDec.dec_icdf(Tables.silk_stereo_only_code_mid_iCDF, 8u);
		}

		internal static void silk_stereo_encode_pred(EntropyCoder psRangeEnc, sbyte[][] ix)
		{
			int s = 5 * ix[0][2] + ix[1][2];
			psRangeEnc.enc_icdf(s, Tables.silk_stereo_pred_joint_iCDF, 8u);
			for (s = 0; s < 2; s++)
			{
				psRangeEnc.enc_icdf(ix[s][0], Tables.silk_uniform3_iCDF, 8u);
				psRangeEnc.enc_icdf(ix[s][1], Tables.silk_uniform5_iCDF, 8u);
			}
		}

		internal static void silk_stereo_encode_mid_only(EntropyCoder psRangeEnc, sbyte mid_only_flag)
		{
			psRangeEnc.enc_icdf(mid_only_flag, Tables.silk_stereo_only_code_mid_iCDF, 8u);
		}

		internal static int silk_stereo_find_predictor(BoxedValueInt ratio_Q14, short[] x, short[] y, int[] mid_res_amp_Q0, int mid_res_amp_Q0_ptr, int length, int smooth_coef_Q16)
		{
			SumSqrShift.silk_sum_sqr_shift(out var energy, out var shift, x, length);
			SumSqrShift.silk_sum_sqr_shift(out var energy2, out var shift2, y, length);
			int num = Inlines.silk_max_int(shift, shift2);
			num += num & 1;
			energy2 = Inlines.silk_RSHIFT32(energy2, num - shift2);
			energy = Inlines.silk_RSHIFT32(energy, num - shift);
			energy = Inlines.silk_max_int(energy, 1);
			int a = Inlines.silk_inner_prod_aligned_scale(x, y, num, length);
			int a2 = Inlines.silk_DIV32_varQ(a, energy, 13);
			a2 = Inlines.silk_LIMIT(a2, -16384, 16384);
			int num2 = Inlines.silk_SMULWB(a2, a2);
			smooth_coef_Q16 = Inlines.silk_max_int(smooth_coef_Q16, Inlines.silk_abs(num2));
			num = Inlines.silk_RSHIFT(num, 1);
			mid_res_amp_Q0[mid_res_amp_Q0_ptr] = Inlines.silk_SMLAWB(mid_res_amp_Q0[mid_res_amp_Q0_ptr], Inlines.silk_LSHIFT(Inlines.silk_SQRT_APPROX(energy), num) - mid_res_amp_Q0[mid_res_amp_Q0_ptr], smooth_coef_Q16);
			energy2 = Inlines.silk_SUB_LSHIFT32(energy2, Inlines.silk_SMULWB(a, a2), 4);
			energy2 = Inlines.silk_ADD_LSHIFT32(energy2, Inlines.silk_SMULWB(energy, num2), 6);
			mid_res_amp_Q0[mid_res_amp_Q0_ptr + 1] = Inlines.silk_SMLAWB(mid_res_amp_Q0[mid_res_amp_Q0_ptr + 1], Inlines.silk_LSHIFT(Inlines.silk_SQRT_APPROX(energy2), num) - mid_res_amp_Q0[mid_res_amp_Q0_ptr + 1], smooth_coef_Q16);
			ratio_Q14.Val = Inlines.silk_DIV32_varQ(mid_res_amp_Q0[mid_res_amp_Q0_ptr + 1], Inlines.silk_max(mid_res_amp_Q0[mid_res_amp_Q0_ptr], 1), 14);
			ratio_Q14.Val = Inlines.silk_LIMIT(ratio_Q14.Val, 0, 32767);
			return a2;
		}

		internal static void silk_stereo_LR_to_MS(StereoEncodeState state, short[] x1, int x1_ptr, short[] x2, int x2_ptr, sbyte[][] ix, BoxedValueSbyte mid_only_flag, int[] mid_side_rates_bps, int total_rate_bps, int prev_speech_act_Q8, int toMono, int fs_kHz, int frame_length)
		{
			int[] array = new int[2];
			BoxedValueInt boxedValueInt = new BoxedValueInt();
			BoxedValueInt boxedValueInt2 = new BoxedValueInt();
			int num = x1_ptr - 2;
			short[] array2 = new short[frame_length + 2];
			for (int i = 0; i < frame_length + 2; i++)
			{
				int a = x1[x1_ptr + i - 2] + x2[x2_ptr + i - 2];
				int a2 = x1[x1_ptr + i - 2] - x2[x2_ptr + i - 2];
				x1[num + i] = (short)Inlines.silk_RSHIFT_ROUND(a, 1);
				array2[i] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(a2, 1));
			}
			Array.Copy(state.sMid, 0, x1, num, 2);
			Array.Copy(state.sSide, array2, 2);
			Array.Copy(x1, num + frame_length, state.sMid, 0, 2);
			Array.Copy(array2, frame_length, state.sSide, 0, 2);
			short[] array3 = new short[frame_length];
			short[] array4 = new short[frame_length];
			for (int i = 0; i < frame_length; i++)
			{
				int a = Inlines.silk_RSHIFT_ROUND(Inlines.silk_ADD_LSHIFT32(x1[num + i] + x1[num + i + 2], x1[num + i + 1], 1), 2);
				array3[i] = (short)a;
				array4[i] = (short)(x1[num + i + 1] - a);
			}
			short[] array5 = new short[frame_length];
			short[] array6 = new short[frame_length];
			for (int i = 0; i < frame_length; i++)
			{
				int a = Inlines.silk_RSHIFT_ROUND(Inlines.silk_ADD_LSHIFT32(array2[i] + array2[i + 2], array2[i + 1], 1), 2);
				array5[i] = (short)a;
				array6[i] = (short)(array2[i + 1] - a);
			}
			int num2 = ((frame_length == 10 * fs_kHz) ? 1 : 0);
			int b = ((num2 != 0) ? 328 : 655);
			b = Inlines.silk_SMULWB(Inlines.silk_SMULBB(prev_speech_act_Q8, prev_speech_act_Q8), b);
			array[0] = silk_stereo_find_predictor(boxedValueInt, array3, array5, state.mid_side_amp_Q0, 0, frame_length, b);
			array[1] = silk_stereo_find_predictor(boxedValueInt2, array4, array6, state.mid_side_amp_Q0, 2, frame_length, b);
			int a3 = Inlines.silk_SMLABB(boxedValueInt2.Val, boxedValueInt.Val, 3);
			a3 = Inlines.silk_min(a3, 65536);
			total_rate_bps -= ((num2 != 0) ? 1200 : 600);
			if (total_rate_bps < 1)
			{
				total_rate_bps = 1;
			}
			int num3 = Inlines.silk_SMLABB(2000, fs_kHz, 900);
			int num4 = Inlines.silk_MUL(3, a3);
			mid_side_rates_bps[0] = Inlines.silk_DIV32_varQ(total_rate_bps, 851968 + num4, 19);
			int a4;
			if (mid_side_rates_bps[0] < num3)
			{
				mid_side_rates_bps[0] = num3;
				mid_side_rates_bps[1] = total_rate_bps - mid_side_rates_bps[0];
				a4 = Inlines.silk_DIV32_varQ(Inlines.silk_LSHIFT(mid_side_rates_bps[1], 1) - num3, Inlines.silk_SMULWB(65536 + num4, num3), 16);
				a4 = Inlines.silk_LIMIT(a4, 0, 16384);
			}
			else
			{
				mid_side_rates_bps[1] = total_rate_bps - mid_side_rates_bps[0];
				a4 = 16384;
			}
			state.smth_width_Q14 = (short)Inlines.silk_SMLAWB(state.smth_width_Q14, a4 - state.smth_width_Q14, b);
			mid_only_flag.Val = 0;
			if (toMono != 0)
			{
				a4 = 0;
				array[0] = 0;
				array[1] = 0;
				silk_stereo_quant_pred(array, ix);
			}
			else if (state.width_prev_Q14 == 0 && (8 * total_rate_bps < 13 * num3 || Inlines.silk_SMULWB(a3, state.smth_width_Q14) < 819))
			{
				array[0] = Inlines.silk_RSHIFT(Inlines.silk_SMULBB(state.smth_width_Q14, array[0]), 14);
				array[1] = Inlines.silk_RSHIFT(Inlines.silk_SMULBB(state.smth_width_Q14, array[1]), 14);
				silk_stereo_quant_pred(array, ix);
				a4 = 0;
				array[0] = 0;
				array[1] = 0;
				mid_side_rates_bps[0] = total_rate_bps;
				mid_side_rates_bps[1] = 0;
				mid_only_flag.Val = 1;
			}
			else if (state.width_prev_Q14 != 0 && (8 * total_rate_bps < 11 * num3 || Inlines.silk_SMULWB(a3, state.smth_width_Q14) < 328))
			{
				array[0] = Inlines.silk_RSHIFT(Inlines.silk_SMULBB(state.smth_width_Q14, array[0]), 14);
				array[1] = Inlines.silk_RSHIFT(Inlines.silk_SMULBB(state.smth_width_Q14, array[1]), 14);
				silk_stereo_quant_pred(array, ix);
				a4 = 0;
				array[0] = 0;
				array[1] = 0;
			}
			else if (state.smth_width_Q14 > 15565)
			{
				silk_stereo_quant_pred(array, ix);
				a4 = 16384;
			}
			else
			{
				array[0] = Inlines.silk_RSHIFT(Inlines.silk_SMULBB(state.smth_width_Q14, array[0]), 14);
				array[1] = Inlines.silk_RSHIFT(Inlines.silk_SMULBB(state.smth_width_Q14, array[1]), 14);
				silk_stereo_quant_pred(array, ix);
				a4 = state.smth_width_Q14;
			}
			if (mid_only_flag.Val == 1)
			{
				state.silent_side_len += (short)(frame_length - 8 * fs_kHz);
				if (state.silent_side_len < 5 * fs_kHz)
				{
					mid_only_flag.Val = 0;
				}
				else
				{
					state.silent_side_len = 10000;
				}
			}
			else
			{
				state.silent_side_len = 0;
			}
			if (mid_only_flag.Val == 0 && mid_side_rates_bps[1] < 1)
			{
				mid_side_rates_bps[1] = 1;
				mid_side_rates_bps[0] = Inlines.silk_max_int(1, total_rate_bps - mid_side_rates_bps[1]);
			}
			int num5 = -state.pred_prev_Q13[0];
			int num6 = -state.pred_prev_Q13[1];
			int num7 = Inlines.silk_LSHIFT(state.width_prev_Q14, 10);
			int b2 = Inlines.silk_DIV32_16(65536, 8 * fs_kHz);
			int num8 = -Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULBB(array[0] - state.pred_prev_Q13[0], b2), 16);
			int num9 = -Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULBB(array[1] - state.pred_prev_Q13[1], b2), 16);
			int num10 = Inlines.silk_LSHIFT(Inlines.silk_SMULWB(a4 - state.width_prev_Q14, b2), 10);
			for (int i = 0; i < 8 * fs_kHz; i++)
			{
				num5 += num8;
				num6 += num9;
				num7 += num10;
				int a = Inlines.silk_LSHIFT(Inlines.silk_ADD_LSHIFT(x1[num + i] + x1[num + i + 2], x1[num + i + 1], 1), 9);
				a = Inlines.silk_SMLAWB(Inlines.silk_SMULWB(num7, array2[i + 1]), a, num5);
				a = Inlines.silk_SMLAWB(a, Inlines.silk_LSHIFT(x1[num + i + 1], 11), num6);
				x2[x2_ptr + i - 1] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(a, 8));
			}
			num5 = -array[0];
			num6 = -array[1];
			num7 = Inlines.silk_LSHIFT(a4, 10);
			for (int i = 8 * fs_kHz; i < frame_length; i++)
			{
				int a = Inlines.silk_LSHIFT(Inlines.silk_ADD_LSHIFT(x1[num + i] + x1[num + i + 2], x1[num + i + 1], 1), 9);
				a = Inlines.silk_SMLAWB(Inlines.silk_SMULWB(num7, array2[i + 1]), a, num5);
				a = Inlines.silk_SMLAWB(a, Inlines.silk_LSHIFT(x1[num + i + 1], 11), num6);
				x2[x2_ptr + i - 1] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(a, 8));
			}
			state.pred_prev_Q13[0] = (short)array[0];
			state.pred_prev_Q13[1] = (short)array[1];
			state.width_prev_Q14 = (short)a4;
		}

		internal static void silk_stereo_MS_to_LR(StereoDecodeState state, short[] x1, int x1_ptr, short[] x2, int x2_ptr, int[] pred_Q13, int fs_kHz, int frame_length)
		{
			Array.Copy(state.sMid, 0, x1, x1_ptr, 2);
			Array.Copy(state.sSide, 0, x2, x2_ptr, 2);
			Array.Copy(x1, x1_ptr + frame_length, state.sMid, 0, 2);
			Array.Copy(x2, x2_ptr + frame_length, state.sSide, 0, 2);
			int num = state.pred_prev_Q13[0];
			int num2 = state.pred_prev_Q13[1];
			int b = Inlines.silk_DIV32_16(65536, 8 * fs_kHz);
			int num3 = Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULBB(pred_Q13[0] - state.pred_prev_Q13[0], b), 16);
			int num4 = Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULBB(pred_Q13[1] - state.pred_prev_Q13[1], b), 16);
			for (int i = 0; i < 8 * fs_kHz; i++)
			{
				num += num3;
				num2 += num4;
				int b2 = Inlines.silk_LSHIFT(Inlines.silk_ADD_LSHIFT(x1[x1_ptr + i] + x1[x1_ptr + i + 2], x1[x1_ptr + i + 1], 1), 9);
				b2 = Inlines.silk_SMLAWB(Inlines.silk_LSHIFT(x2[x2_ptr + i + 1], 8), b2, num);
				b2 = Inlines.silk_SMLAWB(b2, Inlines.silk_LSHIFT(x1[x1_ptr + i + 1], 11), num2);
				x2[x2_ptr + i + 1] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(b2, 8));
			}
			num = pred_Q13[0];
			num2 = pred_Q13[1];
			for (int i = 8 * fs_kHz; i < frame_length; i++)
			{
				int b2 = Inlines.silk_LSHIFT(Inlines.silk_ADD_LSHIFT(x1[x1_ptr + i] + x1[x1_ptr + i + 2], x1[x1_ptr + i + 1], 1), 9);
				b2 = Inlines.silk_SMLAWB(Inlines.silk_LSHIFT(x2[x2_ptr + i + 1], 8), b2, num);
				b2 = Inlines.silk_SMLAWB(b2, Inlines.silk_LSHIFT(x1[x1_ptr + i + 1], 11), num2);
				x2[x2_ptr + i + 1] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(b2, 8));
			}
			state.pred_prev_Q13[0] = (short)pred_Q13[0];
			state.pred_prev_Q13[1] = (short)pred_Q13[1];
			for (int i = 0; i < frame_length; i++)
			{
				int b2 = x1[x1_ptr + i + 1] + x2[x2_ptr + i + 1];
				int a = x1[x1_ptr + i + 1] - x2[x2_ptr + i + 1];
				x1[x1_ptr + i + 1] = (short)Inlines.silk_SAT16(b2);
				x2[x2_ptr + i + 1] = (short)Inlines.silk_SAT16(a);
			}
		}

		internal static void silk_stereo_quant_pred(int[] pred_Q13, sbyte[][] ix)
		{
			int num = 0;
			Arrays.MemSetSbyte(ix[0], 0, 3);
			Arrays.MemSetSbyte(ix[1], 0, 3);
			for (int i = 0; i < 2; i++)
			{
				int num2 = int.MaxValue;
				sbyte b = 0;
				while (b < 15)
				{
					int num3 = Tables.silk_stereo_pred_quant_Q13[b];
					int b2 = Inlines.silk_SMULWB(Tables.silk_stereo_pred_quant_Q13[b + 1] - num3, 6554);
					for (sbyte b3 = 0; b3 < 5; b3++)
					{
						int num4 = Inlines.silk_SMLABB(num3, b2, 2 * b3 + 1);
						int num5 = Inlines.silk_abs(pred_Q13[i] - num4);
						if (num5 >= num2)
						{
							goto end_IL_0090;
						}
						num2 = num5;
						num = num4;
						ix[i][0] = b;
						ix[i][1] = b3;
					}
					b++;
					continue;
					end_IL_0090:
					break;
				}
				ix[i][2] = (sbyte)Inlines.silk_DIV32_16(ix[i][0], 3);
				ix[i][0] = (sbyte)(ix[i][0] - (sbyte)(ix[i][2] * 3));
				pred_Q13[i] = num;
			}
			pred_Q13[0] -= pred_Q13[1];
		}
	}
	internal static class SumSqrShift
	{
		internal static void silk_sum_sqr_shift(out int energy, out int shift, short[] x, int x_ptr, int len)
		{
			int num = 0;
			int num2 = 0;
			len--;
			int i;
			for (i = 0; i < len; i += 2)
			{
				num = Inlines.silk_SMLABB_ovflw(num, x[x_ptr + i], x[x_ptr + i]);
				num = Inlines.silk_SMLABB_ovflw(num, x[x_ptr + i + 1], x[x_ptr + i + 1]);
				if (num < 0)
				{
					num = (int)Inlines.silk_RSHIFT_uint((uint)num, 2);
					num2 = 2;
					i += 2;
					break;
				}
			}
			for (; i < len; i += 2)
			{
				int a = Inlines.silk_SMULBB(x[x_ptr + i], x[x_ptr + i]);
				a = Inlines.silk_SMLABB_ovflw(a, x[x_ptr + i + 1], x[x_ptr + i + 1]);
				num = (int)Inlines.silk_ADD_RSHIFT_uint((uint)num, (uint)a, num2);
				if (num < 0)
				{
					num = (int)Inlines.silk_RSHIFT_uint((uint)num, 2);
					num2 += 2;
				}
			}
			if (i == len)
			{
				int a = Inlines.silk_SMULBB(x[x_ptr + i], x[x_ptr + i]);
				num = (int)Inlines.silk_ADD_RSHIFT_uint((uint)num, (uint)a, num2);
			}
			if ((num & 0xC0000000u) != 0L)
			{
				num = (int)Inlines.silk_RSHIFT_uint((uint)num, 2);
				num2 += 2;
			}
			shift = num2;
			energy = num;
		}

		internal static void silk_sum_sqr_shift(out int energy, out int shift, short[] x, int len)
		{
			int num = 0;
			int num2 = 0;
			len--;
			int i;
			for (i = 0; i < len; i += 2)
			{
				num = Inlines.silk_SMLABB_ovflw(num, x[i], x[i]);
				num = Inlines.silk_SMLABB_ovflw(num, x[i + 1], x[i + 1]);
				if (num < 0)
				{
					num = (int)Inlines.silk_RSHIFT_uint((uint)num, 2);
					num2 = 2;
					i += 2;
					break;
				}
			}
			for (; i < len; i += 2)
			{
				int a = Inlines.silk_SMULBB(x[i], x[i]);
				a = Inlines.silk_SMLABB_ovflw(a, x[i + 1], x[i + 1]);
				num = (int)Inlines.silk_ADD_RSHIFT_uint((uint)num, (uint)a, num2);
				if (num < 0)
				{
					num = (int)Inlines.silk_RSHIFT_uint((uint)num, 2);
					num2 += 2;
				}
			}
			if (i == len)
			{
				int a = Inlines.silk_SMULBB(x[i], x[i]);
				num = (int)Inlines.silk_ADD_RSHIFT_uint((uint)num, (uint)a, num2);
			}
			if ((num & 0xC0000000u) != 0L)
			{
				num = (int)Inlines.silk_RSHIFT_uint((uint)num, 2);
				num2 += 2;
			}
			shift = num2;
			energy = num;
		}
	}
	internal static class Tables
	{
		internal static readonly short[] silk_LSFCosTab_Q12 = new short[129]
		{
			8192, 8190, 8182, 8170, 8152, 8130, 8104, 8072, 8034, 7994,
			7946, 7896, 7840, 7778, 7714, 7644, 7568, 7490, 7406, 7318,
			7226, 7128, 7026, 6922, 6812, 6698, 6580, 6458, 6332, 6204,
			6070, 5934, 5792, 5648, 5502, 5352, 5198, 5040, 4880, 4718,
			4552, 4382, 4212, 4038, 3862, 3684, 3502, 3320, 3136, 2948,
			2760, 2570, 2378, 2186, 1990, 1794, 1598, 1400, 1202, 1002,
			802, 602, 402, 202, 0, -202, -402, -602, -802, -1002,
			-1202, -1400, -1598, -1794, -1990, -2186, -2378, -2570, -2760, -2948,
			-3136, -3320, -3502, -3684, -3862, -4038, -4212, -4382, -4552, -4718,
			-4880, -5040, -5198, -5352, -5502, -5648, -5792, -5934, -6070, -6204,
			-6332, -6458, -6580, -6698, -6812, -6922, -7026, -7128, -7226, -7318,
			-7406, -7490, -7568, -7644, -7714, -7778, -7840, -7896, -7946, -7994,
			-8034, -8072, -8104, -8130, -8152, -8170, -8182, -8190, -8192
		};

		internal static readonly byte[][] silk_gain_iCDF = new byte[3][]
		{
			new byte[8] { 224, 112, 44, 15, 3, 2, 1, 0 },
			new byte[8] { 254, 237, 192, 132, 70, 23, 4, 0 },
			new byte[8] { 255, 252, 226, 155, 61, 11, 2, 0 }
		};

		internal static readonly byte[] silk_delta_gain_iCDF = new byte[41]
		{
			250, 245, 234, 203, 71, 50, 42, 38, 35, 33,
			31, 29, 28, 27, 26, 25, 24, 23, 22, 21,
			20, 19, 18, 17, 16, 15, 14, 13, 12, 11,
			10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
			0
		};

		internal static readonly byte[] silk_LTP_per_index_iCDF = new byte[3] { 179, 99, 0 };

		internal static readonly byte[] silk_LTP_gain_iCDF_0 = new byte[8] { 71, 56, 43, 30, 21, 12, 6, 0 };

		internal static readonly byte[] silk_LTP_gain_iCDF_1 = new byte[16]
		{
			199, 165, 144, 124, 109, 96, 84, 71, 61, 51,
			42, 32, 23, 15, 8, 0
		};

		internal static readonly byte[] silk_LTP_gain_iCDF_2 = new byte[32]
		{
			241, 225, 211, 199, 187, 175, 164, 153, 142, 132,
			123, 114, 105, 96, 88, 80, 72, 64, 57, 50,
			44, 38, 33, 29, 24, 20, 16, 12, 9, 5,
			2, 0
		};

		internal static readonly short silk_LTP_gain_middle_avg_RD_Q14 = 12304;

		internal static readonly byte[] silk_LTP_gain_BITS_Q5_0 = new byte[8] { 15, 131, 138, 138, 155, 155, 173, 173 };

		internal static readonly byte[] silk_LTP_gain_BITS_Q5_1 = new byte[16]
		{
			69, 93, 115, 118, 131, 138, 141, 138, 150, 150,
			155, 150, 155, 160, 166, 160
		};

		internal static readonly byte[] silk_LTP_gain_BITS_Q5_2 = new byte[32]
		{
			131, 128, 134, 141, 141, 141, 145, 145, 145, 150,
			155, 155, 155, 155, 160, 160, 160, 160, 166, 166,
			173, 173, 182, 192, 182, 192, 192, 192, 205, 192,
			205, 224
		};

		internal static readonly byte[][] silk_LTP_gain_iCDF_ptrs = new byte[3][] { silk_LTP_gain_iCDF_0, silk_LTP_gain_iCDF_1, silk_LTP_gain_iCDF_2 };

		internal static readonly byte[][] silk_LTP_gain_BITS_Q5_ptrs = new byte[3][] { silk_LTP_gain_BITS_Q5_0, silk_LTP_gain_BITS_Q5_1, silk_LTP_gain_BITS_Q5_2 };

		internal static readonly sbyte[][] silk_LTP_gain_vq_0 = new sbyte[8][]
		{
			new sbyte[5] { 4, 6, 24, 7, 5 },
			new sbyte[5] { 0, 0, 2, 0, 0 },
			new sbyte[5] { 12, 28, 41, 13, -4 },
			new sbyte[5] { -9, 15, 42, 25, 14 },
			new sbyte[5] { 1, -2, 62, 41, -9 },
			new sbyte[5] { -10, 37, 65, -4, 3 },
			new sbyte[5] { -6, 4, 66, 7, -8 },
			new sbyte[5] { 16, 14, 38, -3, 33 }
		};

		internal static readonly sbyte[][] silk_LTP_gain_vq_1 = new sbyte[16][]
		{
			new sbyte[5] { 13, 22, 39, 23, 12 },
			new sbyte[5] { -1, 36, 64, 27, -6 },
			new sbyte[5] { -7, 10, 55, 43, 17 },
			new sbyte[5] { 1, 1, 8, 1, 1 },
			new sbyte[5] { 6, -11, 74, 53, -9 },
			new sbyte[5] { -12, 55, 76, -12, 8 },
			new sbyte[5] { -3, 3, 93, 27, -4 },
			new sbyte[5] { 26, 39, 59, 3, -8 },
			new sbyte[5] { 2, 0, 77, 11, 9 },
			new sbyte[5] { -8, 22, 44, -6, 7 },
			new sbyte[5] { 40, 9, 26, 3, 9 },
			new sbyte[5] { -7, 20, 101, -7, 4 },
			new sbyte[5] { 3, -8, 42, 26, 0 },
			new sbyte[5] { -15, 33, 68, 2, 23 },
			new sbyte[5] { -2, 55, 46, -2, 15 },
			new sbyte[5] { 3, -1, 21, 16, 41 }
		};

		internal static readonly sbyte[][] silk_LTP_gain_vq_2 = new sbyte[32][]
		{
			new sbyte[5] { -6, 27, 61, 39, 5 },
			new sbyte[5] { -11, 42, 88, 4, 1 },
			new sbyte[5] { -2, 60, 65, 6, -4 },
			new sbyte[5] { -1, -5, 73, 56, 1 },
			new sbyte[5] { -9, 19, 94, 29, -9 },
			new sbyte[5] { 0, 12, 99, 6, 4 },
			new sbyte[5] { 8, -19, 102, 46, -13 },
			new sbyte[5] { 3, 2, 13, 3, 2 },
			new sbyte[5] { 9, -21, 84, 72, -18 },
			new sbyte[5] { -11, 46, 104, -22, 8 },
			new sbyte[5] { 18, 38, 48, 23, 0 },
			new sbyte[5] { -16, 70, 83, -21, 11 },
			new sbyte[5] { 5, -11, 117, 22, -8 },
			new sbyte[5] { -6, 23, 117, -12, 3 },
			new sbyte[5] { 3, -8, 95, 28, 4 },
			new sbyte[5] { -10, 15, 77, 60, -15 },
			new sbyte[5] { -1, 4, 124, 2, -4 },
			new sbyte[5] { 3, 38, 84, 24, -25 },
			new sbyte[5] { 2, 13, 42, 13, 31 },
			new sbyte[5] { 21, -4, 56, 46, -1 },
			new sbyte[5] { -1, 35, 79, -13, 19 },
			new sbyte[5] { -7, 65, 88, -9, -14 },
			new sbyte[5] { 20, 4, 81, 49, -29 },
			new sbyte[5] { 20, 0, 75, 3, -17 },
			new sbyte[5] { 5, -9, 44, 92, -8 },
			new sbyte[5] { 1, -3, 22, 69, 31 },
			new sbyte[5] { -6, 95, 41, -12, 5 },
			new sbyte[5] { 39, 67, 16, -4, 1 },
			new sbyte[5] { 0, -6, 120, 55, -36 },
			new sbyte[5] { -13, 44, 122, 4, -24 },
			new sbyte[5] { 81, 5, 11, 3, 7 },
			new sbyte[5] { 2, 0, 9, 10, 88 }
		};

		internal static readonly sbyte[][][] silk_LTP_vq_ptrs_Q7 = new sbyte[3][][] { silk_LTP_gain_vq_0, silk_LTP_gain_vq_1, silk_LTP_gain_vq_2 };

		internal static readonly byte[] silk_LTP_gain_vq_0_gain = new byte[8] { 46, 2, 90, 87, 93, 91, 82, 98 };

		internal static readonly byte[] silk_LTP_gain_vq_1_gain = new byte[16]
		{
			109, 120, 118, 12, 113, 115, 117, 119, 99, 59,
			87, 111, 63, 111, 112, 80
		};

		internal static readonly byte[] silk_LTP_gain_vq_2_gain = new byte[32]
		{
			126, 124, 125, 124, 129, 121, 126, 23, 132, 127,
			127, 127, 126, 127, 122, 133, 130, 134, 101, 118,
			119, 145, 126, 86, 124, 120, 123, 119, 170, 173,
			107, 109
		};

		internal static readonly byte[][] silk_LTP_vq_gain_ptrs_Q7 = new byte[3][] { silk_LTP_gain_vq_0_gain, silk_LTP_gain_vq_1_gain, silk_LTP_gain_vq_2_gain };

		internal static readonly sbyte[] silk_LTP_vq_sizes = new sbyte[3] { 8, 16, 32 };

		internal static readonly byte[] silk_NLSF_CB1_NB_MB_Q8 = new byte[320]
		{
			12, 35, 60, 83, 108, 132, 157, 180, 206, 228,
			15, 32, 55, 77, 101, 125, 151, 175, 201, 225,
			19, 42, 66, 89, 114, 137, 162, 184, 209, 230,
			12, 25, 50, 72, 97, 120, 147, 172, 200, 223,
			26, 44, 69, 90, 114, 135, 159, 180, 205, 225,
			13, 22, 53, 80, 106, 130, 156, 180, 205, 228,
			15, 25, 44, 64, 90, 115, 142, 168, 196, 222,
			19, 24, 62, 82, 100, 120, 145, 168, 190, 214,
			22, 31, 50, 79, 103, 120, 151, 170, 203, 227,
			21, 29, 45, 65, 106, 124, 150, 171, 196, 224,
			30, 49, 75, 97, 121, 142, 165, 186, 209, 229,
			19, 25, 52, 70, 93, 116, 143, 166, 192, 219,
			26, 34, 62, 75, 97, 118, 145, 167, 194, 217,
			25, 33, 56, 70, 91, 113, 143, 165, 196, 223,
			21, 34, 51, 72, 97, 117, 145, 171, 196, 222,
			20, 29, 50, 67, 90, 117, 144, 168, 197, 221,
			22, 31, 48, 66, 95, 117, 146, 168, 196, 222,
			24, 33, 51, 77, 116, 134, 158, 180, 200, 224,
			21, 28, 70, 87, 106, 124, 149, 170, 194, 217,
			26, 33, 53, 64, 83, 117, 152, 173, 204, 225,
			27, 34, 65, 95, 108, 129, 155, 174, 210, 225,
			20, 26, 72, 99, 113, 131, 154, 176, 200, 219,
			34, 43, 61, 78, 93, 114, 155, 177, 205, 229,
			23, 29, 54, 97, 124, 138, 163, 179, 209, 229,
			30, 38, 56, 89, 118, 129, 158, 178, 200, 231,
			21, 29, 49, 63, 85, 111, 142, 163, 193, 222,
			27, 48, 77, 103, 133, 158, 179, 196, 215, 232,
			29, 47, 74, 99, 124, 151, 176, 198, 220, 237,
			33, 42, 61, 76, 93, 121, 155, 174, 207, 225,
			29, 53, 87, 112, 136, 154, 170, 188, 208, 227,
			24, 30, 52, 84, 131, 150, 166, 186, 203, 229,
			37, 48, 64, 84, 104, 118, 156, 177, 201, 230
		};

		internal static readonly byte[] silk_NLSF_CB1_iCDF_NB_MB = new byte[64]
		{
			212, 178, 148, 129, 108, 96, 85, 82, 79, 77,
			61, 59, 57, 56, 51, 49, 48, 45, 42, 41,
			40, 38, 36, 34, 31, 30, 21, 12, 10, 3,
			1, 0, 255, 245, 244, 236, 233, 225, 217, 203,
			190, 176, 175, 161, 149, 136, 125, 114, 102, 91,
			81, 71, 60, 52, 43, 35, 28, 20, 19, 18,
			12, 11, 5, 0
		};

		internal static readonly byte[] silk_NLSF_CB2_SELECT_NB_MB = new byte[160]
		{
			16, 0, 0, 0, 0, 99, 66, 36, 36, 34,
			36, 34, 34, 34, 34, 83, 69, 36, 52, 34,
			116, 102, 70, 68, 68, 176, 102, 68, 68, 34,
			65, 85, 68, 84, 36, 116, 141, 152, 139, 170,
			132, 187, 184, 216, 137, 132, 249, 168, 185, 139,
			104, 102, 100, 68, 68, 178, 218, 185, 185, 170,
			244, 216, 187, 187, 170, 244, 187, 187, 219, 138,
			103, 155, 184, 185, 137, 116, 183, 155, 152, 136,
			132, 217, 184, 184, 170, 164, 217, 171, 155, 139,
			244, 169, 184, 185, 170, 164, 216, 223, 218, 138,
			214, 143, 188, 218, 168, 244, 141, 136, 155, 170,
			168, 138, 220, 219, 139, 164, 219, 202, 216, 137,
			168, 186, 246, 185, 139, 116, 185, 219, 185, 138,
			100, 100, 134, 100, 102, 34, 68, 68, 100, 68,
			168, 203, 221, 218, 168, 167, 154, 136, 104, 70,
			164, 246, 171, 137, 139, 137, 155, 218, 219, 139
		};

		internal static readonly byte[] silk_NLSF_CB2_iCDF_NB_MB = new byte[72]
		{
			255, 254, 253, 238, 14, 3, 2, 1, 0, 255,
			254, 252, 218, 35, 3, 2, 1, 0, 255, 254,
			250, 208, 59, 4, 2, 1, 0, 255, 254, 246,
			194, 71, 10, 2, 1, 0, 255, 252, 236, 183,
			82, 8, 2, 1, 0, 255, 252, 235, 180, 90,
			17, 2, 1, 0, 255, 248, 224, 171, 97, 30,
			4, 1, 0, 255, 254, 236, 173, 95, 37, 7,
			1, 0
		};

		internal static readonly byte[] silk_NLSF_CB2_BITS_NB_MB_Q5 = new byte[72]
		{
			255, 255, 255, 131, 6, 145, 255, 255, 255, 255,
			255, 236, 93, 15, 96, 255, 255, 255, 255, 255,
			194, 83, 25, 71, 221, 255, 255, 255, 255, 162,
			73, 34, 66, 162, 255, 255, 255, 210, 126, 73,
			43, 57, 173, 255, 255, 255, 201, 125, 71, 48,
			58, 130, 255, 255, 255, 166, 110, 73, 57, 62,
			104, 210, 255, 255, 251, 123, 65, 55, 68, 100,
			171, 255
		};

		internal static readonly byte[] silk_NLSF_PRED_NB_MB_Q8 = new byte[18]
		{
			179, 138, 140, 148, 151, 149, 153, 151, 163, 116,
			67, 82, 59, 92, 72, 100, 89, 92
		};

		internal static readonly short[] silk_NLSF_DELTA_MIN_NB_MB_Q15 = new short[11]
		{
			250, 3, 6, 3, 3, 3, 4, 3, 3, 3,
			461
		};

		internal static readonly NLSFCodebook silk_NLSF_CB_NB_MB = new NLSFCodebook
		{
			nVectors = 32,
			order = 10,
			quantStepSize_Q16 = 11796,
			invQuantStepSize_Q6 = 356,
			CB1_NLSF_Q8 = silk_NLSF_CB1_NB_MB_Q8,
			CB1_iCDF = silk_NLSF_CB1_iCDF_NB_MB,
			pred_Q8 = silk_NLSF_PRED_NB_MB_Q8,
			ec_sel = silk_NLSF_CB2_SELECT_NB_MB,
			ec_iCDF = silk_NLSF_CB2_iCDF_NB_MB,
			ec_Rates_Q5 = silk_NLSF_CB2_BITS_NB_MB_Q5,
			deltaMin_Q15 = silk_NLSF_DELTA_MIN_NB_MB_Q15
		};

		internal static readonly byte[] silk_NLSF_CB1_WB_Q8 = new byte[512]
		{
			7, 23, 38, 54, 69, 85, 100, 116, 131, 147,
			162, 178, 193, 208, 223, 239, 13, 25, 41, 55,
			69, 83, 98, 112, 127, 142, 157, 171, 187, 203,
			220, 236, 15, 21, 34, 51, 61, 78, 92, 106,
			126, 136, 152, 167, 185, 205, 225, 240, 10, 21,
			36, 50, 63, 79, 95, 110, 126, 141, 157, 173,
			189, 205, 221, 237, 17, 20, 37, 51, 59, 78,
			89, 107, 123, 134, 150, 164, 184, 205, 224, 240,
			10, 15, 32, 51, 67, 81, 96, 112, 129, 142,
			158, 173, 189, 204, 220, 236, 8, 21, 37, 51,
			65, 79, 98, 113, 126, 138, 155, 168, 179, 192,
			209, 218, 12, 15, 34, 55, 63, 78, 87, 108,
			118, 131, 148, 167, 185, 203, 219, 236, 16, 19,
			32, 36, 56, 79, 91, 108, 118, 136, 154, 171,
			186, 204, 220, 237, 11, 28, 43, 58, 74, 89,
			105, 120, 135, 150, 165, 180, 196, 211, 226, 241,
			6, 16, 33, 46, 60, 75, 92, 107, 123, 137,
			156, 169, 185, 199, 214, 225, 11, 19, 30, 44,
			57, 74, 89, 105, 121, 135, 152, 169, 186, 202,
			218, 234, 12, 19, 29, 46, 57, 71, 88, 100,
			120, 132, 148, 165, 182, 199, 216, 233, 17, 23,
			35, 46, 56, 77, 92, 106, 123, 134, 152, 167,
			185, 204, 222, 237, 14, 17, 45, 53, 63, 75,
			89, 107, 115, 132, 151, 171, 188, 206, 221, 240,
			9, 16, 29, 40, 56, 71, 88, 103, 119, 137,
			154, 171, 189, 205, 222, 237, 16, 19, 36, 48,
			57, 76, 87, 105, 118, 132, 150, 167, 185, 202,
			218, 236, 12, 17, 29, 54, 71, 81, 94, 104,
			126, 136, 149, 164, 182, 201, 221, 237, 15, 28,
			47, 62, 79, 97, 115, 129, 142, 155, 168, 180,
			194, 208, 223, 238, 8, 14, 30, 45, 62, 78,
			94, 111, 127, 143, 159, 175, 192, 207, 223, 239,
			17, 30, 49, 62, 79, 92, 107, 119, 132, 145,
			160, 174, 190, 204, 220, 235, 14, 19, 36, 45,
			61, 76, 91, 108, 121, 138, 154, 172, 189, 205,
			222, 238, 12, 18, 31, 45, 60, 76, 91, 107,
			123, 138, 154, 171, 187, 204, 221, 236, 13, 17,
			31, 43, 53, 70, 83, 103, 114, 131, 149, 167,
			185, 203, 220, 237, 17, 22, 35, 42, 58, 78,
			93, 110, 125, 139, 155, 170, 188, 206, 224, 240,
			8, 15, 34, 50, 67, 83, 99, 115, 131, 146,
			162, 178, 193, 209, 224, 239, 13, 16, 41, 66,
			73, 86, 95, 111, 128, 137, 150, 163, 183, 206,
			225, 241, 17, 25, 37, 52, 63, 75, 92, 102,
			119, 132, 144, 160, 175, 191, 212, 231, 19, 31,
			49, 65, 83, 100, 117, 133, 147, 161, 174, 187,
			200, 213, 227, 242, 18, 31, 52, 68, 88, 103,
			117, 126, 138, 149, 163, 177, 192, 207, 223, 239,
			16, 29, 47, 61, 76, 90, 106, 119, 133, 147,
			161, 176, 193, 209, 224, 240, 15, 21, 35, 50,
			61, 73, 86, 97, 110, 119, 129, 141, 175, 198,
			218, 237
		};

		internal static readonly byte[] silk_NLSF_CB1_iCDF_WB = new byte[64]
		{
			225, 204, 201, 184, 183, 175, 158, 154, 153, 135,
			119, 115, 113, 110, 109, 99, 98, 95, 79, 68,
			52, 50, 48, 45, 43, 32, 31, 27, 18, 10,
			3, 0, 255, 251, 235, 230, 212, 201, 196, 182,
			167, 166, 163, 151, 138, 124, 110, 104, 90, 78,
			76, 70, 69, 57, 45, 34, 24, 21, 11, 6,
			5, 4, 3, 0
		};

		internal static readonly byte[] silk_NLSF_CB2_SELECT_WB = new byte[256]
		{
			0, 0, 0, 0, 0, 0, 0, 1, 100, 102,
			102, 68, 68, 36, 34, 96, 164, 107, 158, 185,
			180, 185, 139, 102, 64, 66, 36, 34, 34, 0,
			1, 32, 208, 139, 141, 191, 152, 185, 155, 104,
			96, 171, 104, 166, 102, 102, 102, 132, 1, 0,
			0, 0, 0, 16, 16, 0, 80, 109, 78, 107,
			185, 139, 103, 101, 208, 212, 141, 139, 173, 153,
			123, 103, 36, 0, 0, 0, 0, 0, 0, 1,
			48, 0, 0, 0, 0, 0, 0, 32, 68, 135,
			123, 119, 119, 103, 69, 98, 68, 103, 120, 118,
			118, 102, 71, 98, 134, 136, 157, 184, 182, 153,
			139, 134, 208, 168, 248, 75, 189, 143, 121, 107,
			32, 49, 34, 34, 34, 0, 17, 2, 210, 235,
			139, 123, 185, 137, 105, 134, 98, 135, 104, 182,
			100, 183, 171, 134, 100, 70, 68, 70, 66, 66,
			34, 131, 64, 166, 102, 68, 36, 2, 1, 0,
			134, 166, 102, 68, 34, 34, 66, 132, 212, 246,
			158, 139, 107, 107, 87, 102, 100, 219, 125, 122,
			137, 118, 103, 132, 114, 135, 137, 105, 171, 106,
			50, 34, 164, 214, 141, 143, 185, 151, 121, 103,
			192, 34, 0, 0, 0, 0, 0, 1, 208, 109,
			74, 187, 134, 249, 159, 137, 102, 110, 154, 118,
			87, 101, 119, 101, 0, 2, 0, 36, 36, 66,
			68, 35, 96, 164, 102, 100, 36, 0, 2, 33,
			167, 138, 174, 102, 100, 84, 2, 2, 100, 107,
			120, 119, 36, 197, 24, 0
		};

		internal static readonly byte[] silk_NLSF_CB2_iCDF_WB = new byte[72]
		{
			255, 254, 253, 244, 12, 3, 2, 1, 0, 255,
			254, 252, 224, 38, 3, 2, 1, 0, 255, 254,
			251, 209, 57, 4, 2, 1, 0, 255, 254, 244,
			195, 69, 4, 2, 1, 0, 255, 251, 232, 184,
			84, 7, 2, 1, 0, 255, 254, 240, 186, 86,
			14, 2, 1, 0, 255, 254, 239, 178, 91, 30,
			5, 1, 0, 255, 248, 227, 177, 100, 19, 2,
			1, 0
		};

		internal static readonly byte[] silk_NLSF_CB2_BITS_WB_Q5 = new byte[72]
		{
			255, 255, 255, 156, 4, 154, 255, 255, 255, 255,
			255, 227, 102, 15, 92, 255, 255, 255, 255, 255,
			213, 83, 24, 72, 236, 255, 255, 255, 255, 150,
			76, 33, 63, 214, 255, 255, 255, 190, 121, 77,
			43, 55, 185, 255, 255, 255, 245, 137, 71, 43,
			59, 139, 255, 255, 255, 255, 131, 66, 50, 66,
			107, 194, 255, 255, 166, 116, 76, 55, 53, 125,
			255, 255
		};

		internal static readonly byte[] silk_NLSF_PRED_WB_Q8 = new byte[30]
		{
			175, 148, 160, 176, 178, 173, 174, 164, 177, 174,
			196, 182, 198, 192, 182, 68, 62, 66, 60, 72,
			117, 85, 90, 118, 136, 151, 142, 160, 142, 155
		};

		internal static readonly short[] silk_NLSF_DELTA_MIN_WB_Q15 = new short[17]
		{
			100, 3, 40, 3, 3, 3, 5, 14, 14, 10,
			11, 3, 8, 9, 7, 3, 347
		};

		internal static readonly NLSFCodebook silk_NLSF_CB_WB = new NLSFCodebook
		{
			nVectors = 32,
			order = 16,
			quantStepSize_Q16 = 9830,
			invQuantStepSize_Q6 = 427,
			CB1_NLSF_Q8 = silk_NLSF_CB1_WB_Q8,
			CB1_iCDF = silk_NLSF_CB1_iCDF_WB,
			pred_Q8 = silk_NLSF_PRED_WB_Q8,
			ec_sel = silk_NLSF_CB2_SELECT_WB,
			ec_iCDF = silk_NLSF_CB2_iCDF_WB,
			ec_Rates_Q5 = silk_NLSF_CB2_BITS_WB_Q5,
			deltaMin_Q15 = silk_NLSF_DELTA_MIN_WB_Q15
		};

		internal static readonly int[] silk_TargetRate_table_NB = new int[8] { 0, 8000, 9400, 11500, 13500, 17500, 25000, 80000 };

		internal static readonly int[] silk_TargetRate_table_MB = new int[8] { 0, 9000, 12000, 14500, 18500, 24500, 35500, 80000 };

		internal static readonly int[] silk_TargetRate_table_WB = new int[8] { 0, 10500, 14000, 17000, 21500, 28500, 42000, 80000 };

		internal static readonly short[] silk_SNR_table_Q1 = new short[8] { 18, 29, 38, 40, 46, 52, 62, 84 };

		internal static readonly short[] silk_stereo_pred_quant_Q13 = new short[16]
		{
			-13732, -10050, -8266, -7526, -6500, -5000, -2950, -820, 820, 2950,
			5000, 6500, 7526, 8266, 10050, 13732
		};

		internal static readonly byte[] silk_stereo_pred_joint_iCDF = new byte[25]
		{
			249, 247, 246, 245, 244, 234, 210, 202, 201, 200,
			197, 174, 82, 59, 56, 55, 54, 46, 22, 12,
			11, 10, 9, 7, 0
		};

		internal static readonly byte[] silk_stereo_only_code_mid_iCDF = new byte[2] { 64, 0 };

		internal static readonly byte[] silk_LBRR_flags_2_iCDF = new byte[3] { 203, 150, 0 };

		internal static readonly byte[] silk_LBRR_flags_3_iCDF = new byte[7] { 215, 195, 166, 125, 110, 82, 0 };

		internal static readonly byte[][] silk_LBRR_flags_iCDF_ptr = new byte[2][] { silk_LBRR_flags_2_iCDF, silk_LBRR_flags_3_iCDF };

		internal static readonly byte[] silk_lsb_iCDF = new byte[2] { 120, 0 };

		internal static readonly byte[] silk_LTPscale_iCDF = new byte[3] { 128, 64, 0 };

		internal static readonly byte[] silk_type_offset_VAD_iCDF = new byte[4] { 232, 158, 10, 0 };

		internal static readonly byte[] silk_type_offset_no_VAD_iCDF = new byte[2] { 230, 0 };

		internal static readonly byte[] silk_NLSF_interpolation_factor_iCDF = new byte[5] { 243, 221, 192, 181, 0 };

		internal static readonly short[][] silk_Quantization_Offsets_Q10 = new short[2][]
		{
			new short[2] { 100, 240 },
			new short[2] { 32, 100 }
		};

		internal static readonly short[] silk_LTPScales_table_Q14 = new short[3] { 15565, 12288, 8192 };

		internal static readonly byte[] silk_uniform3_iCDF = new byte[3] { 171, 85, 0 };

		internal static readonly byte[] silk_uniform4_iCDF = new byte[4] { 192, 128, 64, 0 };

		internal static readonly byte[] silk_uniform5_iCDF = new byte[5] { 205, 154, 102, 51, 0 };

		internal static readonly byte[] silk_uniform6_iCDF = new byte[6] { 213, 171, 128, 85, 43, 0 };

		internal static readonly byte[] silk_uniform8_iCDF = new byte[8] { 224, 192, 160, 128, 96, 64, 32, 0 };

		internal static readonly byte[] silk_NLSF_EXT_iCDF = new byte[7] { 100, 40, 16, 7, 3, 1, 0 };

		internal static readonly int[][] silk_Transition_LP_B_Q28 = new int[5][]
		{
			new int[3] { 250767114, 501534038, 250767114 },
			new int[3] { 209867381, 419732057, 209867381 },
			new int[3] { 170987846, 341967853, 170987846 },
			new int[3] { 131531482, 263046905, 131531482 },
			new int[3] { 89306658, 178584282, 89306658 }
		};

		internal static readonly int[][] silk_Transition_LP_A_Q28 = new int[5][]
		{
			new int[2] { 506393414, 239854379 },
			new int[2] { 411067935, 169683996 },
			new int[2] { 306733530, 116694253 },
			new int[2] { 185807084, 77959395 },
			new int[2] { 35497197, 57401098 }
		};

		internal static readonly byte[] silk_pitch_lag_iCDF = new byte[32]
		{
			253, 250, 244, 233, 212, 182, 150, 131, 120, 110,
			98, 85, 72, 60, 49, 40, 32, 25, 19, 15,
			13, 11, 9, 8, 7, 6, 5, 4, 3, 2,
			1, 0
		};

		internal static readonly byte[] silk_pitch_delta_iCDF = new byte[21]
		{
			210, 208, 206, 203, 199, 193, 183, 168, 142, 104,
			74, 52, 37, 27, 20, 14, 10, 6, 4, 2,
			0
		};

		internal static readonly byte[] silk_pitch_contour_iCDF = new byte[34]
		{
			223, 201, 183, 167, 152, 138, 124, 111, 98, 88,
			79, 70, 62, 56, 50, 44, 39, 35, 31, 27,
			24, 21, 18, 16, 14, 12, 10, 8, 6, 4,
			3, 2, 1, 0
		};

		internal static readonly byte[] silk_pitch_contour_NB_iCDF = new byte[11]
		{
			188, 176, 155, 138, 119, 97, 67, 43, 26, 10,
			0
		};

		internal static readonly byte[] silk_pitch_contour_10_ms_iCDF = new byte[12]
		{
			165, 119, 80, 61, 47, 35, 27, 20, 14, 9,
			4, 0
		};

		internal static readonly byte[] silk_pitch_contour_10_ms_NB_iCDF = new byte[3] { 113, 63, 0 };

		internal static readonly byte[] silk_max_pulses_table = new byte[4] { 8, 10, 12, 16 };

		internal static readonly byte[][] silk_pulses_per_block_iCDF = new byte[10][]
		{
			new byte[18]
			{
				125, 51, 26, 18, 15, 12, 11, 10, 9, 8,
				7, 6, 5, 4, 3, 2, 1, 0
			},
			new byte[18]
			{
				198, 105, 45, 22, 15, 12, 11, 10, 9, 8,
				7, 6, 5, 4, 3, 2, 1, 0
			},
			new byte[18]
			{
				213, 162, 116, 83, 59, 43, 32, 24, 18, 15,
				12, 9, 7, 6, 5, 3, 2, 0
			},
			new byte[18]
			{
				239, 187, 116, 59, 28, 16, 11, 10, 9, 8,
				7, 6, 5, 4, 3, 2, 1, 0
			},
			new byte[18]
			{
				250, 229, 188, 135, 86, 51, 30, 19, 13, 10,
				8, 6, 5, 4, 3, 2, 1, 0
			},
			new byte[18]
			{
				249, 235, 213, 185, 156, 128, 103, 83, 66, 53,
				42, 33, 26, 21, 17, 13, 10, 0
			},
			new byte[18]
			{
				254, 249, 235, 206, 164, 118, 77, 46, 27, 16,
				10, 7, 5, 4, 3, 2, 1, 0
			},
			new byte[18]
			{
				255, 253, 249, 239, 220, 191, 156, 119, 85, 57,
				37, 23, 15, 10, 6, 4, 2, 0
			},
			new byte[18]
			{
				255, 253, 251, 246, 237, 223, 203, 179, 152, 124,
				98, 75, 55, 40, 29, 21, 15, 0
			},
			new byte[18]
			{
				255, 254, 253, 247, 220, 162, 106, 67, 42, 28,
				18, 12, 9, 6, 4, 3, 2, 0
			}
		};

		internal static readonly byte[][] silk_pulses_per_block_BITS_Q5 = new byte[9][]
		{
			new byte[18]
			{
				31, 57, 107, 160, 205, 205, 255, 255, 255, 255,
				255, 255, 255, 255, 255, 255, 255, 255
			},
			new byte[18]
			{
				69, 47, 67, 111, 166, 205, 255, 255, 255, 255,
				255, 255, 255, 255, 255, 255, 255, 255
			},
			new byte[18]
			{
				82, 74, 79, 95, 109, 128, 145, 160, 173, 205,
				205, 205, 224, 255, 255, 224, 255, 224
			},
			new byte[18]
			{
				125, 74, 59, 69, 97, 141, 182, 255, 255, 255,
				255, 255, 255, 255, 255, 255, 255, 255
			},
			new byte[18]
			{
				173, 115, 85, 73, 76, 92, 115, 145, 173, 205,
				224, 224, 255, 255, 255, 255, 255, 255
			},
			new byte[18]
			{
				166, 134, 113, 102, 101, 102, 107, 118, 125, 138,
				145, 155, 166, 182, 192, 192, 205, 150
			},
			new byte[18]
			{
				224, 182, 134, 101, 83, 79, 85, 97, 120, 145,
				173, 205, 224, 255, 255, 255, 255, 255
			},
			new byte[18]
			{
				255, 224, 192, 150, 120, 101, 92, 89, 93, 102,
				118, 134, 160, 182, 192, 224, 224, 224
			},
			new byte[18]
			{
				255, 224, 224, 182, 155, 134, 118, 109, 104, 102,
				106, 111, 118, 131, 145, 160, 173, 131
			}
		};

		internal static readonly byte[][] silk_rate_levels_iCDF = new byte[2][]
		{
			new byte[9] { 241, 190, 178, 132, 87, 74, 41, 14, 0 },
			new byte[9] { 223, 193, 157, 140, 106, 57, 39, 18, 0 }
		};

		internal static readonly byte[][] silk_rate_levels_BITS_Q5 = new byte[2][]
		{
			new byte[9] { 131, 74, 141, 79, 80, 138, 95, 104, 134 },
			new byte[9] { 95, 99, 91, 125, 93, 76, 123, 115, 123 }
		};

		internal static readonly byte[] silk_shell_code_table0 = new byte[152]
		{
			128, 0, 214, 42, 0, 235, 128, 21, 0, 244,
			184, 72, 11, 0, 248, 214, 128, 42, 7, 0,
			248, 225, 170, 80, 25, 5, 0, 251, 236, 198,
			126, 54, 18, 3, 0, 250, 238, 211, 159, 82,
			35, 15, 5, 0, 250, 231, 203, 168, 128, 88,
			53, 25, 6, 0, 252, 238, 216, 185, 148, 108,
			71, 40, 18, 4, 0, 253, 243, 225, 199, 166,
			128, 90, 57, 31, 13, 3, 0, 254, 246, 233,
			212, 183, 147, 109, 73, 44, 23, 10, 2, 0,
			255, 250, 240, 223, 198, 166, 128, 90, 58, 33,
			16, 6, 1, 0, 255, 251, 244, 231, 210, 181,
			146, 110, 75, 46, 25, 12, 5, 1, 0, 255,
			253, 248, 238, 221, 196, 164, 128, 92, 60, 35,
			18, 8, 3, 1, 0, 255, 253, 249, 242, 229,
			208, 180, 146, 110, 76, 48, 27, 14, 7, 3,
			1, 0
		};

		internal static readonly byte[] silk_shell_code_table1 = new byte[152]
		{
			129, 0, 207, 50, 0, 236, 129, 20, 0, 245,
			185, 72, 10, 0, 249, 213, 129, 42, 6, 0,
			250, 226, 169, 87, 27, 4, 0, 251, 233, 194,
			130, 62, 20, 4, 0, 250, 236, 207, 160, 99,
			47, 17, 3, 0, 255, 240, 217, 182, 131, 81,
			41, 11, 1, 0, 255, 254, 233, 201, 159, 107,
			61, 20, 2, 1, 0, 255, 249, 233, 206, 170,
			128, 86, 50, 23, 7, 1, 0, 255, 250, 238,
			217, 186, 148, 108, 70, 39, 18, 6, 1, 0,
			255, 252, 243, 226, 200, 166, 128, 90, 56, 30,
			13, 4, 1, 0, 255, 252, 245, 231, 209, 180,
			146, 110, 76, 47, 25, 11, 4, 1, 0, 255,
			253, 248, 237, 219, 194, 163, 128, 93, 62, 37,
			19, 8, 3, 1, 0, 255, 254, 250, 241, 226,
			205, 177, 145, 111, 79, 51, 30, 15, 6, 2,
			1, 0
		};

		internal static readonly byte[] silk_shell_code_table2 = new byte[152]
		{
			129, 0, 203, 54, 0, 234, 129, 23, 0, 245,
			184, 73, 10, 0, 250, 215, 129, 41, 5, 0,
			252, 232, 173, 86, 24, 3, 0, 253, 240, 200,
			129, 56, 15, 2, 0, 253, 244, 217, 164, 94,
			38, 10, 1, 0, 253, 245, 226, 189, 132, 71,
			27, 7, 1, 0, 253, 246, 231, 203, 159, 105,
			56, 23, 6, 1, 0, 255, 248, 235, 213, 179,
			133, 85, 47, 19, 5, 1, 0, 255, 254, 243,
			221, 194, 159, 117, 70, 37, 12, 2, 1, 0,
			255, 254, 248, 234, 208, 171, 128, 85, 48, 22,
			8, 2, 1, 0, 255, 254, 250, 240, 220, 189,
			149, 107, 67, 36, 16, 6, 2, 1, 0, 255,
			254, 251, 243, 227, 201, 166, 128, 90, 55, 29,
			13, 5, 2, 1, 0, 255, 254, 252, 246, 234,
			213, 183, 147, 109, 73, 43, 22, 10, 4, 2,
			1, 0
		};

		internal static readonly byte[] silk_shell_code_table3 = new byte[152]
		{
			130, 0, 200, 58, 0, 231, 130, 26, 0, 244,
			184, 76, 12, 0, 249, 214, 130, 43, 6, 0,
			252, 232, 173, 87, 24, 3, 0, 253, 241, 203,
			131, 56, 14, 2, 0, 254, 246, 221, 167, 94,
			35, 8, 1, 0, 254, 249, 232, 193, 130, 65,
			23, 5, 1, 0, 255, 251, 239, 211, 162, 99,
			45, 15, 4, 1, 0, 255, 251, 243, 223, 186,
			131, 74, 33, 11, 3, 1, 0, 255, 252, 245,
			230, 202, 158, 105, 57, 24, 8, 2, 1, 0,
			255, 253, 247, 235, 214, 179, 132, 84, 44, 19,
			7, 2, 1, 0, 255, 254, 250, 240, 223, 196,
			159, 112, 69, 36, 15, 6, 2, 1, 0, 255,
			254, 253, 245, 231, 209, 176, 136, 93, 55, 27,
			11, 3, 2, 1, 0, 255, 254, 253, 252, 239,
			221, 194, 158, 117, 76, 42, 18, 4, 3, 2,
			1, 0
		};

		internal static readonly byte[] silk_shell_code_table_offsets = new byte[17]
		{
			0, 0, 2, 5, 9, 14, 20, 27, 35, 44,
			54, 65, 77, 90, 104, 119, 135
		};

		internal static readonly byte[] silk_sign_iCDF = new byte[42]
		{
			254, 49, 67, 77, 82, 93, 99, 198, 11, 18,
			24, 31, 36, 45, 255, 46, 66, 78, 87, 94,
			104, 208, 14, 21, 32, 42, 51, 66, 255, 94,
			104, 109, 112, 115, 118, 248, 53, 69, 80, 88,
			95, 102
		};

		internal static readonly sbyte[,] delay_matrix_enc = new sbyte[5, 3]
		{
			{ 6, 0, 3 },
			{ 0, 7, 3 },
			{ 0, 1, 10 },
			{ 0, 2, 6 },
			{ 18, 10, 12 }
		};

		internal static readonly sbyte[,] delay_matrix_dec = new sbyte[3, 5]
		{
			{ 4, 0, 2, 0, 0 },
			{ 0, 9, 4, 7, 4 },
			{ 0, 3, 12, 7, 7 }
		};

		internal static readonly short[] silk_Resampler_3_4_COEFS = new short[29]
		{
			-20694, -13867, -49, 64, 17, -157, 353, -496, 163, 11047,
			22205, -39, 6, 91, -170, 186, 23, -896, 6336, 19928,
			-19, -36, 102, -89, -24, 328, -951, 2568, 15909
		};

		internal static readonly short[] silk_Resampler_2_3_COEFS = new short[20]
		{
			-14457, -14019, 64, 128, -122, 36, 310, -768, 584, 9267,
			17733, 12, 128, 18, -142, 288, -117, -865, 4123, 14459
		};

		internal static readonly short[] silk_Resampler_1_2_COEFS = new short[14]
		{
			616, -14323, -10, 39, 58, -46, -84, 120, 184, -315,
			-541, 1284, 5380, 9024
		};

		internal static readonly short[] silk_Resampler_1_3_COEFS = new short[20]
		{
			16102, -15162, -13, 0, 20, 26, 5, -31, -43, -4,
			65, 90, 7, -157, -248, -44, 593, 1583, 2612, 3271
		};

		internal static readonly short[] silk_Resampler_1_4_COEFS = new short[20]
		{
			22500, -15099, 3, -14, -20, -15, 2, 25, 37, 25,
			-16, -71, -107, -79, 50, 292, 623, 982, 1288, 1464
		};

		internal static readonly short[] silk_Resampler_1_6_COEFS = new short[20]
		{
			27540, -15257, 17, 12, 8, 1, -10, -22, -30, -32,
			-22, 3, 44, 100, 168, 243, 317, 381, 429, 455
		};

		internal static readonly short[] silk_Resampler_2_3_COEFS_LQ = new short[6] { -2797, -6507, 4697, 10739, 1567, 8276 };

		internal static readonly short[,] silk_resampler_frac_FIR_12 = new short[12, 4]
		{
			{ 189, -600, 617, 30567 },
			{ 117, -159, -1070, 29704 },
			{ 52, 221, -2392, 28276 },
			{ -4, 529, -3350, 26341 },
			{ -48, 758, -3956, 23973 },
			{ -80, 905, -4235, 21254 },
			{ -99, 972, -4222, 18278 },
			{ -107, 967, -3957, 15143 },
			{ -103, 896, -3487, 11950 },
			{ -91, 773, -2865, 8798 },
			{ -71, 611, -2143, 5784 },
			{ -46, 425, -1375, 2996 }
		};

		public const short silk_resampler_down2_0 = 9872;

		public const short silk_resampler_down2_1 = -25727;

		internal static readonly short[] silk_resampler_up2_hq_0 = new short[3] { 1746, 14986, -26453 };

		internal static readonly short[] silk_resampler_up2_hq_1 = new short[3] { 6854, 25769, -9994 };

		internal static readonly sbyte[][] silk_CB_lags_stage2_10_ms = new sbyte[2][]
		{
			new sbyte[3] { 0, 1, 0 },
			new sbyte[3] { 0, 0, 1 }
		};

		internal static readonly sbyte[][] silk_CB_lags_stage3_10_ms = new sbyte[2][]
		{
			new sbyte[12]
			{
				0, 0, 1, -1, 1, -1, 2, -2, 2, -2,
				3, -3
			},
			new sbyte[12]
			{
				0, 1, 0, 1, -1, 2, -1, 2, -2, 3,
				-2, 3
			}
		};

		internal static readonly sbyte[][] silk_CB_lags_stage2 = new sbyte[4][]
		{
			new sbyte[11]
			{
				0, 2, -1, -1, -1, 0, 0, 1, 1, 0,
				1
			},
			new sbyte[11]
			{
				0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
				0
			},
			new sbyte[11]
			{
				0, 0, 1, 0, 0, 0, 1, 0, 0, 0,
				0
			},
			new sbyte[11]
			{
				0, -1, 2, 1, 0, 1, 1, 0, 0, -1,
				-1
			}
		};

		internal static readonly sbyte[][] silk_CB_lags_stage3 = new sbyte[4][]
		{
			new sbyte[34]
			{
				0, 0, 1, -1, 0, 1, -1, 0, -1, 1,
				-2, 2, -2, -2, 2, -3, 2, 3, -3, -4,
				3, -4, 4, 4, -5, 5, -6, -5, 6, -7,
				6, 5, 8, -9
			},
			new sbyte[34]
			{
				0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
				-1, 1, 0, 0, 1, -1, 0, 1, -1, -1,
				1, -1, 2, 1, -1, 2, -2, -2, 2, -2,
				2, 2, 3, -3
			},
			new sbyte[34]
			{
				0, 1, 0, 0, 0, 0, 0, 0, 1, 0,
				1, 0, 0, 1, -1, 1, 0, 0, 2, 1,
				-1, 2, -1, -1, 2, -1, 2, 2, -1, 3,
				-2, -2, -2, 3
			},
			new sbyte[34]
			{
				0, 1, 0, 0, 1, 0, 1, -1, 2, -1,
				2, -1, 2, 3, -2, 3, -2, -2, 4, 4,
				-3, 5, -3, -4, 6, -4, 6, 5, -5, 8,
				-6, -5, -7, 9
			}
		};

		internal static readonly sbyte[][] silk_Lag_range_stage3_10_ms = new sbyte[2][]
		{
			new sbyte[2] { -3, 7 },
			new sbyte[2] { -2, 7 }
		};

		internal static readonly sbyte[][][] silk_Lag_range_stage3 = new sbyte[3][][]
		{
			new sbyte[4][]
			{
				new sbyte[2] { -5, 8 },
				new sbyte[2] { -1, 6 },
				new sbyte[2] { -1, 6 },
				new sbyte[2] { -4, 10 }
			},
			new sbyte[4][]
			{
				new sbyte[2] { -6, 10 },
				new sbyte[2] { -2, 6 },
				new sbyte[2] { -1, 6 },
				new sbyte[2] { -5, 10 }
			},
			new sbyte[4][]
			{
				new sbyte[2] { -9, 12 },
				new sbyte[2] { -3, 7 },
				new sbyte[2] { -2, 7 },
				new sbyte[2] { -7, 13 }
			}
		};

		internal static readonly sbyte[] silk_nb_cbk_searchs_stage3 = new sbyte[3] { 16, 24, 34 };
	}
	internal class TuningParameters
	{
		internal const int BITRESERVOIR_DECAY_TIME_MS = 500;

		internal const float FIND_PITCH_WHITE_NOISE_FRACTION = 0.001f;

		internal const float FIND_PITCH_BANDWIDTH_EXPANSION = 0.99f;

		internal const float FIND_LPC_COND_FAC = 1E-05f;

		internal const float FIND_LTP_COND_FAC = 1E-05f;

		internal const float LTP_DAMPING = 0.05f;

		internal const float LTP_SMOOTHING = 0.1f;

		internal const float MU_LTP_QUANT_NB = 0.03f;

		internal const float MU_LTP_QUANT_MB = 0.025f;

		internal const float MU_LTP_QUANT_WB = 0.02f;

		internal const float MAX_SUM_LOG_GAIN_DB = 250f;

		internal const float VARIABLE_HP_SMTH_COEF1 = 0.1f;

		internal const float VARIABLE_HP_SMTH_COEF2 = 0.015f;

		internal const float VARIABLE_HP_MAX_DELTA_FREQ = 0.4f;

		internal const int VARIABLE_HP_MIN_CUTOFF_HZ = 60;

		internal const int VARIABLE_HP_MAX_CUTOFF_HZ = 100;

		internal const float SPEECH_ACTIVITY_DTX_THRES = 0.05f;

		internal const float LBRR_SPEECH_ACTIVITY_THRES = 0.3f;

		internal const float BG_SNR_DECR_dB = 2f;

		internal const float HARM_SNR_INCR_dB = 2f;

		internal const float SPARSE_SNR_INCR_dB = 2f;

		internal const float SPARSENESS_THRESHOLD_QNT_OFFSET = 0.75f;

		internal const float WARPING_MULTIPLIER = 0.015f;

		internal const float SHAPE_WHITE_NOISE_FRACTION = 5E-05f;

		internal const float BANDWIDTH_EXPANSION = 0.95f;

		internal const float LOW_RATE_BANDWIDTH_EXPANSION_DELTA = 0.01f;

		internal const float LOW_RATE_HARMONIC_BOOST = 0.1f;

		internal const float LOW_INPUT_QUALITY_HARMONIC_BOOST = 0.1f;

		internal const float HARMONIC_SHAPING = 0.3f;

		internal const float HIGH_RATE_OR_LOW_QUALITY_HARMONIC_SHAPING = 0.2f;

		internal const float HP_NOISE_COEF = 0.25f;

		internal const float HARM_HP_NOISE_COEF = 0.35f;

		internal const float INPUT_TILT = 0.05f;

		internal const float HIGH_RATE_INPUT_TILT = 0.1f;

		internal const float LOW_FREQ_SHAPING = 4f;

		internal const float LOW_QUALITY_LOW_FREQ_SHAPING_DECR = 0.5f;

		internal const float SUBFR_SMTH_COEF = 0.4f;

		internal const float LAMBDA_OFFSET = 1.2f;

		internal const float LAMBDA_SPEECH_ACT = -0.2f;

		internal const float LAMBDA_DELAYED_DECISIONS = -0.05f;

		internal const float LAMBDA_INPUT_QUALITY = -0.1f;

		internal const float LAMBDA_CODING_QUALITY = -0.2f;

		internal const float LAMBDA_QUANT_OFFSET = 0.8f;

		internal const int REDUCE_BITRATE_10_MS_BPS = 2200;

		internal const int MAX_BANDWIDTH_SWITCH_DELAY_MS = 5000;
	}
	internal static class VoiceActivityDetection
	{
		private static readonly int[] tiltWeights = new int[4] { 30000, 6000, -12000, -12000 };

		internal static int silk_VAD_Init(SilkVADState psSilk_VAD)
		{
			int result = 0;
			psSilk_VAD.Reset();
			for (int i = 0; i < 4; i++)
			{
				psSilk_VAD.NoiseLevelBias[i] = Inlines.silk_max_32(Inlines.silk_DIV32_16(50, (short)(i + 1)), 1);
			}
			for (int i = 0; i < 4; i++)
			{
				psSilk_VAD.NL[i] = Inlines.silk_MUL(100, psSilk_VAD.NoiseLevelBias[i]);
				psSilk_VAD.inv_NL[i] = Inlines.silk_DIV32(int.MaxValue, psSilk_VAD.NL[i]);
			}
			psSilk_VAD.counter = 15;
			for (int i = 0; i < 4; i++)
			{
				psSilk_VAD.NrgRatioSmth_Q8[i] = 25600;
			}
			return result;
		}

		internal static int silk_VAD_GetSA_Q8(SilkChannelEncoder psEncC, short[] pIn, int pIn_ptr)
		{
			int num = 0;
			int[] array = new int[4];
			int[] array2 = new int[4];
			int[] array3 = new int[4];
			int result = 0;
			SilkVADState sVAD = psEncC.sVAD;
			int num2 = Inlines.silk_RSHIFT(psEncC.frame_length, 1);
			int num3 = Inlines.silk_RSHIFT(psEncC.frame_length, 2);
			int num4 = Inlines.silk_RSHIFT(psEncC.frame_length, 3);
			array3[0] = 0;
			array3[1] = num4 + num3;
			array3[2] = array3[1] + num4;
			array3[3] = array3[2] + num3;
			short[] array4 = new short[array3[3] + num2];
			Filters.silk_ana_filt_bank_1(pIn, pIn_ptr, sVAD.AnaState, array4, array4, array3[3], psEncC.frame_length);
			Filters.silk_ana_filt_bank_1(array4, 0, sVAD.AnaState1, array4, array4, array3[2], num2);
			Filters.silk_ana_filt_bank_1(array4, 0, sVAD.AnaState2, array4, array4, array3[1], num3);
			array4[num4 - 1] = (short)Inlines.silk_RSHIFT(array4[num4 - 1], 1);
			short hPstate = array4[num4 - 1];
			for (int num5 = num4 - 1; num5 > 0; num5--)
			{
				array4[num5 - 1] = (short)Inlines.silk_RSHIFT(array4[num5 - 1], 1);
				array4[num5] -= array4[num5 - 1];
			}
			array4[0] -= sVAD.HPstate;
			sVAD.HPstate = hPstate;
			for (int i = 0; i < 4; i++)
			{
				num4 = Inlines.silk_RSHIFT(psEncC.frame_length, Inlines.silk_min_int(4 - i, 3));
				int num6 = Inlines.silk_RSHIFT(num4, 2);
				int num7 = 0;
				array[i] = sVAD.XnrgSubfr[i];
				for (int j = 0; j < 4; j++)
				{
					num = 0;
					for (int num5 = 0; num5 < num6; num5++)
					{
						int num8 = Inlines.silk_RSHIFT(array4[array3[i] + num5 + num7], 3);
						num = Inlines.silk_SMLABB(num, num8, num8);
					}
					if (j < 3)
					{
						array[i] = Inlines.silk_ADD_POS_SAT32(array[i], num);
					}
					else
					{
						array[i] = Inlines.silk_ADD_POS_SAT32(array[i], Inlines.silk_RSHIFT(num, 1));
					}
					num7 += num6;
				}
				sVAD.XnrgSubfr[i] = num;
			}
			silk_VAD_GetNoiseLevels(array, sVAD);
			num = 0;
			int num9 = 0;
			int num10;
			for (int i = 0; i < 4; i++)
			{
				num10 = array[i] - sVAD.NL[i];
				if (num10 > 0)
				{
					if ((array[i] & 0xFF800000u) == 0L)
					{
						array2[i] = Inlines.silk_DIV32(Inlines.silk_LSHIFT(array[i], 8), sVAD.NL[i] + 1);
					}
					else
					{
						array2[i] = Inlines.silk_DIV32(array[i], Inlines.silk_RSHIFT(sVAD.NL[i], 8) + 1);
					}
					int num11 = Inlines.silk_lin2log(array2[i]) - 1024;
					num = Inlines.silk_SMLABB(num, num11, num11);
					if (num10 < 1048576)
					{
						num11 = Inlines.silk_SMULWB(Inlines.silk_LSHIFT(Inlines.silk_SQRT_APPROX(num10), 6), num11);
					}
					num9 = Inlines.silk_SMLAWB(num9, tiltWeights[i], num11);
				}
				else
				{
					array2[i] = 256;
				}
			}
			num = Inlines.silk_DIV32_16(num, 4);
			int b = (short)(3 * Inlines.silk_SQRT_APPROX(num));
			int num12 = Sigmoid.silk_sigm_Q15(Inlines.silk_SMULWB(45000, b) - 128);
			psEncC.input_tilt_Q15 = Inlines.silk_LSHIFT(Sigmoid.silk_sigm_Q15(num9) - 16384, 1);
			num10 = 0;
			for (int i = 0; i < 4; i++)
			{
				num10 += (i + 1) * Inlines.silk_RSHIFT(array[i] - sVAD.NL[i], 4);
			}
			if (num10 <= 0)
			{
				num12 = Inlines.silk_RSHIFT(num12, 1);
			}
			else if (num10 < 32768)
			{
				num10 = ((psEncC.frame_length != 10 * psEncC.fs_kHz) ? Inlines.silk_LSHIFT_SAT32(num10, 15) : Inlines.silk_LSHIFT_SAT32(num10, 16));
				num10 = Inlines.silk_SQRT_APPROX(num10);
				num12 = Inlines.silk_SMULWB(32768 + num10, num12);
			}
			psEncC.speech_activity_Q8 = Inlines.silk_min_int(Inlines.silk_RSHIFT(num12, 7), 255);
			int num13 = Inlines.silk_SMULWB(4096, Inlines.silk_SMULWB(num12, num12));
			if (psEncC.frame_length == 10 * psEncC.fs_kHz)
			{
				num13 >>= 1;
			}
			for (int i = 0; i < 4; i++)
			{
				sVAD.NrgRatioSmth_Q8[i] = Inlines.silk_SMLAWB(sVAD.NrgRatioSmth_Q8[i], array2[i] - sVAD.NrgRatioSmth_Q8[i], num13);
				int num11 = 3 * (Inlines.silk_lin2log(sVAD.NrgRatioSmth_Q8[i]) - 1024);
				psEncC.input_quality_bands_Q15[i] = Sigmoid.silk_sigm_Q15(Inlines.silk_RSHIFT(num11 - 2048, 4));
			}
			return result;
		}

		internal static void silk_VAD_GetNoiseLevels(int[] pX, SilkVADState psSilk_VAD)
		{
			int b = ((psSilk_VAD.counter < 1000) ? Inlines.silk_DIV32_16(32767, (short)(Inlines.silk_RSHIFT(psSilk_VAD.counter, 4) + 1)) : 0);
			for (int i = 0; i < 4; i++)
			{
				int num = psSilk_VAD.NL[i];
				int num2 = Inlines.silk_ADD_POS_SAT32(pX[i], psSilk_VAD.NoiseLevelBias[i]);
				int num3 = Inlines.silk_DIV32(int.MaxValue, num2);
				int a = ((num2 <= Inlines.silk_LSHIFT(num, 3)) ? ((num2 >= num) ? Inlines.silk_SMULWB(Inlines.silk_SMULWW(num3, num), 2048) : 1024) : 128);
				a = Inlines.silk_max_int(a, b);
				psSilk_VAD.inv_NL[i] = Inlines.silk_SMLAWB(psSilk_VAD.inv_NL[i], num3 - psSilk_VAD.inv_NL[i], a);
				num = Inlines.silk_DIV32(int.MaxValue, psSilk_VAD.inv_NL[i]);
				num = Inlines.silk_min(num, 16777215);
				psSilk_VAD.NL[i] = num;
			}
			psSilk_VAD.counter++;
		}
	}
	internal static class VQ_WMat_EC
	{
		internal static void silk_VQ_WMat_EC(BoxedValueSbyte ind, BoxedValueInt rate_dist_Q14, BoxedValueInt gain_Q7, short[] in_Q14, int in_Q14_ptr, int[] W_Q18, int W_Q18_ptr, sbyte[][] cb_Q7, byte[] cb_gain_Q7, byte[] cl_Q5, int mu_Q9, int max_gain_Q7, int L)
		{
			int num = 0;
			short[] array = new short[5];
			rate_dist_Q14.Val = int.MaxValue;
			for (int i = 0; i < L; i++)
			{
				sbyte[] array2 = cb_Q7[num++];
				int num2 = cb_gain_Q7[i];
				array[0] = (short)(in_Q14[in_Q14_ptr] - Inlines.silk_LSHIFT(array2[0], 7));
				array[1] = (short)(in_Q14[in_Q14_ptr + 1] - Inlines.silk_LSHIFT(array2[1], 7));
				array[2] = (short)(in_Q14[in_Q14_ptr + 2] - Inlines.silk_LSHIFT(array2[2], 7));
				array[3] = (short)(in_Q14[in_Q14_ptr + 3] - Inlines.silk_LSHIFT(array2[3], 7));
				array[4] = (short)(in_Q14[in_Q14_ptr + 4] - Inlines.silk_LSHIFT(array2[4], 7));
				int a = Inlines.silk_SMULBB(mu_Q9, cl_Q5[i]);
				a = Inlines.silk_ADD_LSHIFT32(a, Inlines.silk_max(Inlines.silk_SUB32(num2, max_gain_Q7), 0), 10);
				int a2 = Inlines.silk_SMULWB(W_Q18[W_Q18_ptr + 1], array[1]);
				a2 = Inlines.silk_SMLAWB(a2, W_Q18[W_Q18_ptr + 2], array[2]);
				a2 = Inlines.silk_SMLAWB(a2, W_Q18[W_Q18_ptr + 3], array[3]);
				a2 = Inlines.silk_SMLAWB(a2, W_Q18[W_Q18_ptr + 4], array[4]);
				a2 = Inlines.silk_LSHIFT(a2, 1);
				a2 = Inlines.silk_SMLAWB(a2, W_Q18[W_Q18_ptr], array[0]);
				a = Inlines.silk_SMLAWB(a, a2, array[0]);
				a2 = Inlines.silk_SMULWB(W_Q18[W_Q18_ptr + 7], array[2]);
				a2 = Inlines.silk_SMLAWB(a2, W_Q18[W_Q18_ptr + 8], array[3]);
				a2 = Inlines.silk_SMLAWB(a2, W_Q18[W_Q18_ptr + 9], array[4]);
				a2 = Inlines.silk_LSHIFT(a2, 1);
				a2 = Inlines.silk_SMLAWB(a2, W_Q18[W_Q18_ptr + 6], array[1]);
				a = Inlines.silk_SMLAWB(a, a2, array[1]);
				a2 = Inlines.silk_SMULWB(W_Q18[W_Q18_ptr + 13], array[3]);
				a2 = Inlines.silk_SMLAWB(a2, W_Q18[W_Q18_ptr + 14], array[4]);
				a2 = Inlines.silk_LSHIFT(a2, 1);
				a2 = Inlines.silk_SMLAWB(a2, W_Q18[W_Q18_ptr + 12], array[2]);
				a = Inlines.silk_SMLAWB(a, a2, array[2]);
				a2 = Inlines.silk_SMULWB(W_Q18[W_Q18_ptr + 19], array[4]);
				a2 = Inlines.silk_LSHIFT(a2, 1);
				a2 = Inlines.silk_SMLAWB(a2, W_Q18[W_Q18_ptr + 18], array[3]);
				a = Inlines.silk_SMLAWB(a, a2, array[3]);
				a2 = Inlines.silk_SMULWB(W_Q18[W_Q18_ptr + 24], array[4]);
				a = Inlines.silk_SMLAWB(a, a2, array[4]);
				if (a < rate_dist_Q14.Val)
				{
					rate_dist_Q14.Val = a;
					ind.Val = (sbyte)i;
					gain_Q7.Val = num2;
				}
			}
		}
	}
}
namespace Concentus.Silk.Structs
{
	internal class CNGState
	{
		internal readonly int[] CNG_exc_buf_Q14 = new int[320];

		internal readonly short[] CNG_smth_NLSF_Q15 = new short[16];

		internal readonly int[] CNG_synth_state = new int[16];

		internal int CNG_smth_Gain_Q16;

		internal int rand_seed;

		internal int fs_kHz;

		internal void Reset()
		{
			Arrays.MemSetInt(CNG_exc_buf_Q14, 0, 320);
			Arrays.MemSetShort(CNG_smth_NLSF_Q15, 0, 16);
			Arrays.MemSetInt(CNG_synth_state, 0, 16);
			CNG_smth_Gain_Q16 = 0;
			rand_seed = 0;
			fs_kHz = 0;
		}
	}
	internal class DecControlState
	{
		internal int nChannelsAPI;

		internal int nChannelsInternal;

		internal int API_sampleRate;

		internal int internalSampleRate;

		internal int payloadSize_ms;

		internal int prevPitchLag;

		internal void Reset()
		{
			nChannelsAPI = 0;
			nChannelsInternal = 0;
			API_sampleRate = 0;
			internalSampleRate = 0;
			payloadSize_ms = 0;
			prevPitchLag = 0;
		}
	}
	internal class EncControlState
	{
		internal int nChannelsAPI;

		internal int nChannelsInternal;

		internal int API_sampleRate;

		internal int maxInternalSampleRate;

		internal int minInternalSampleRate;

		internal int desiredInternalSampleRate;

		internal int payloadSize_ms;

		internal int bitRate;

		internal int packetLossPercentage;

		internal int complexity;

		internal int useInBandFEC;

		internal int useDTX;

		internal int useCBR;

		internal int maxBits;

		internal int toMono;

		internal int opusCanSwitch;

		internal int reducedDependency;

		internal int internalSampleRate;

		internal int allowBandwidthSwitch;

		internal int inWBmodeWithoutVariableLP;

		internal int stereoWidth_Q14;

		internal int switchReady;

		internal void Reset()
		{
			nChannelsAPI = 0;
			nChannelsInternal = 0;
			API_sampleRate = 0;
			maxInternalSampleRate = 0;
			minInternalSampleRate = 0;
			desiredInternalSampleRate = 0;
			payloadSize_ms = 0;
			bitRate = 0;
			packetLossPercentage = 0;
			complexity = 0;
			useInBandFEC = 0;
			useDTX = 0;
			useCBR = 0;
			maxBits = 0;
			toMono = 0;
			opusCanSwitch = 0;
			reducedDependency = 0;
			internalSampleRate = 0;
			allowBandwidthSwitch = 0;
			inWBmodeWithoutVariableLP = 0;
			stereoWidth_Q14 = 0;
			switchReady = 0;
		}

		internal int check_control_input()
		{
			if ((API_sampleRate != 8000 && API_sampleRate != 12000 && API_sampleRate != 16000 && API_sampleRate != 24000 && API_sampleRate != 32000 && API_sampleRate != 44100 && API_sampleRate != 48000) || (desiredInternalSampleRate != 8000 && desiredInternalSampleRate != 12000 && desiredInternalSampleRate != 16000) || (maxInternalSampleRate != 8000 && maxInternalSampleRate != 12000 && maxInternalSampleRate != 16000) || (minInternalSampleRate != 8000 && minInternalSampleRate != 12000 && minInternalSampleRate != 16000) || minInternalSampleRate > desiredInternalSampleRate || maxInternalSampleRate < desiredInternalSampleRate || minInternalSampleRate > maxInternalSampleRate)
			{
				return SilkError.SILK_ENC_FS_NOT_SUPPORTED;
			}
			if (payloadSize_ms != 10 && payloadSize_ms != 20 && payloadSize_ms != 40 && payloadSize_ms != 60)
			{
				return SilkError.SILK_ENC_PACKET_SIZE_NOT_SUPPORTED;
			}
			if (packetLossPercentage < 0 || packetLossPercentage > 100)
			{
				return SilkError.SILK_ENC_INVALID_LOSS_RATE;
			}
			if (useDTX < 0 || useDTX > 1)
			{
				return SilkError.SILK_ENC_INVALID_DTX_SETTING;
			}
			if (useCBR < 0 || useCBR > 1)
			{
				return SilkError.SILK_ENC_INVALID_CBR_SETTING;
			}
			if (useInBandFEC < 0 || useInBandFEC > 1)
			{
				return SilkError.SILK_ENC_INVALID_INBAND_FEC_SETTING;
			}
			if (nChannelsAPI < 1 || nChannelsAPI > 2)
			{
				return SilkError.SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR;
			}
			if (nChannelsInternal < 1 || nChannelsInternal > 2)
			{
				return SilkError.SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR;
			}
			if (nChannelsInternal > nChannelsAPI)
			{
				return SilkError.SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR;
			}
			if (complexity < 0 || complexity > 10)
			{
				return SilkError.SILK_ENC_INVALID_COMPLEXITY_SETTING;
			}
			return SilkError.SILK_NO_ERROR;
		}
	}
	internal class NLSFCodebook
	{
		internal short nVectors;

		internal short order;

		internal short quantStepSize_Q16;

		internal short invQuantStepSize_Q6;

		internal byte[] CB1_NLSF_Q8;

		internal byte[] CB1_iCDF;

		internal byte[] pred_Q8;

		internal byte[] ec_sel;

		internal byte[] ec_iCDF;

		internal byte[] ec_Rates_Q5;

		internal short[] deltaMin_Q15;

		internal void Reset()
		{
			nVectors = 0;
			order = 0;
			quantStepSize_Q16 = 0;
			invQuantStepSize_Q6 = 0;
			CB1_NLSF_Q8 = null;
			CB1_iCDF = null;
			pred_Q8 = null;
			ec_sel = null;
			ec_iCDF = null;
			ec_Rates_Q5 = null;
			deltaMin_Q15 = null;
		}
	}
	internal class PLCStruct
	{
		internal int pitchL_Q8;

		internal readonly short[] LTPCoef_Q14 = new short[5];

		internal readonly short[] prevLPC_Q12 = new short[16];

		internal int last_frame_lost;

		internal int rand_seed;

		internal short randScale_Q14;

		internal int conc_energy;

		internal int conc_energy_shift;

		internal short prevLTP_scale_Q14;

		internal readonly int[] prevGain_Q16 = new int[2];

		internal int fs_kHz;

		internal int nb_subfr;

		internal int subfr_length;

		internal void Reset()
		{
			pitchL_Q8 = 0;
			Arrays.MemSetShort(LTPCoef_Q14, 0, 5);
			Arrays.MemSetShort(prevLPC_Q12, 0, 16);
			last_frame_lost = 0;
			rand_seed = 0;
			randScale_Q14 = 0;
			conc_energy = 0;
			conc_energy_shift = 0;
			prevLTP_scale_Q14 = 0;
			Arrays.MemSetInt(prevGain_Q16, 0, 2);
			fs_kHz = 0;
			nb_subfr = 0;
			subfr_length = 0;
		}
	}
	internal class SideInfoIndices
	{
		internal readonly sbyte[] GainsIndices = new sbyte[4];

		internal readonly sbyte[] LTPIndex = new sbyte[4];

		internal readonly sbyte[] NLSFIndices = new sbyte[17];

		internal short lagIndex;

		internal sbyte contourIndex;

		internal sbyte signalType;

		internal sbyte quantOffsetType;

		internal sbyte NLSFInterpCoef_Q2;

		internal sbyte PERIndex;

		internal sbyte LTP_scaleIndex;

		internal sbyte Seed;

		internal void Reset()
		{
			Arrays.MemSetSbyte(GainsIndices, 0, 4);
			Arrays.MemSetSbyte(LTPIndex, 0, 4);
			Arrays.MemSetSbyte(NLSFIndices, 0, 17);
			lagIndex = 0;
			contourIndex = 0;
			signalType = 0;
			quantOffsetType = 0;
			NLSFInterpCoef_Q2 = 0;
			PERIndex = 0;
			LTP_scaleIndex = 0;
			Seed = 0;
		}

		internal void Assign(SideInfoIndices other)
		{
			Array.Copy(other.GainsIndices, GainsIndices, 4);
			Array.Copy(other.LTPIndex, LTPIndex, 4);
			Array.Copy(other.NLSFIndices, NLSFIndices, 17);
			lagIndex = other.lagIndex;
			contourIndex = other.contourIndex;
			signalType = other.signalType;
			quantOffsetType = other.quantOffsetType;
			NLSFInterpCoef_Q2 = other.NLSFInterpCoef_Q2;
			PERIndex = other.PERIndex;
			LTP_scaleIndex = other.LTP_scaleIndex;
			Seed = other.Seed;
		}
	}
	internal class SilkChannelDecoder
	{
		internal int prev_gain_Q16;

		internal readonly int[] exc_Q14 = new int[320];

		internal readonly int[] sLPC_Q14_buf = new int[16];

		internal readonly short[] outBuf = new short[480];

		internal int lagPrev;

		internal sbyte LastGainIndex;

		internal int fs_kHz;

		internal int fs_API_hz;

		internal int nb_subfr;

		internal int frame_length;

		internal int subfr_length;

		internal int ltp_mem_length;

		internal int LPC_order;

		internal readonly short[] prevNLSF_Q15 = new short[16];

		internal int first_frame_after_reset;

		internal byte[] pitch_lag_low_bits_iCDF;

		internal byte[] pitch_contour_iCDF;

		internal int nFramesDecoded;

		internal int nFramesPerPacket;

		internal int ec_prevSignalType;

		internal short ec_prevLagIndex;

		internal readonly int[] VAD_flags = new int[3];

		internal int LBRR_flag;

		internal readonly int[] LBRR_flags = new int[3];

		internal readonly SilkResamplerState resampler_state = new SilkResamplerState();

		internal NLSFCodebook psNLSF_CB;

		internal readonly SideInfoIndices indices = new SideInfoIndices();

		internal readonly CNGState sCNG = new CNGState();

		internal int lossCnt;

		internal int prevSignalType;

		internal readonly PLCStruct sPLC = new PLCStruct();

		internal void Reset()
		{
			prev_gain_Q16 = 0;
			Arrays.MemSetInt(exc_Q14, 0, 320);
			Arrays.MemSetInt(sLPC_Q14_buf, 0, 16);
			Arrays.MemSetShort(outBuf, 0, 480);
			lagPrev = 0;
			LastGainIndex = 0;
			fs_kHz = 0;
			fs_API_hz = 0;
			nb_subfr = 0;
			frame_length = 0;
			subfr_length = 0;
			ltp_mem_length = 0;
			LPC_order = 0;
			Arrays.MemSetShort(prevNLSF_Q15, 0, 16);
			first_frame_after_reset = 0;
			pitch_lag_low_bits_iCDF = null;
			pitch_contour_iCDF = null;
			nFramesDecoded = 0;
			nFramesPerPacket = 0;
			ec_prevSignalType = 0;
			ec_prevLagIndex = 0;
			Arrays.MemSetInt(VAD_flags, 0, 3);
			LBRR_flag = 0;
			Arrays.MemSetInt(LBRR_flags, 0, 3);
			resampler_state.Reset();
			psNLSF_CB = null;
			indices.Reset();
			sCNG.Reset();
			lossCnt = 0;
			prevSignalType = 0;
			sPLC.Reset();
		}

		internal int silk_init_decoder()
		{
			Reset();
			first_frame_after_reset = 1;
			prev_gain_Q16 = 65536;
			silk_CNG_Reset();
			silk_PLC_Reset();
			return 0;
		}

		private void silk_CNG_Reset()
		{
			int num = Inlines.silk_DIV32_16(32767, LPC_order + 1);
			int num2 = 0;
			for (int i = 0; i < LPC_order; i++)
			{
				num2 += num;
				sCNG.CNG_smth_NLSF_Q15[i] = (short)num2;
			}
			sCNG.CNG_smth_Gain_Q16 = 0;
			sCNG.rand_seed = 3176576;
		}

		private void silk_PLC_Reset()
		{
			sPLC.pitchL_Q8 = Inlines.silk_LSHIFT(frame_length, 7);
			sPLC.prevGain_Q16[0] = 65536;
			sPLC.prevGain_Q16[1] = 65536;
			sPLC.subfr_length = 20;
			sPLC.nb_subfr = 2;
		}

		internal int silk_decoder_set_fs(int fs_kHz, int fs_API_Hz)
		{
			int num = 0;
			subfr_length = Inlines.silk_SMULBB(5, fs_kHz);
			int num2 = Inlines.silk_SMULBB(nb_subfr, subfr_length);
			if (this.fs_kHz != fs_kHz || fs_API_hz != fs_API_Hz)
			{
				num += Resampler.silk_resampler_init(resampler_state, Inlines.silk_SMULBB(fs_kHz, 1000), fs_API_Hz, 0);
				fs_API_hz = fs_API_Hz;
			}
			if (this.fs_kHz != fs_kHz || num2 != frame_length)
			{
				if (fs_kHz == 8)
				{
					if (nb_subfr == 4)
					{
						pitch_contour_iCDF = Tables.silk_pitch_contour_NB_iCDF;
					}
					else
					{
						pitch_contour_iCDF = Tables.silk_pitch_contour_10_ms_NB_iCDF;
					}
				}
				else if (nb_subfr == 4)
				{
					pitch_contour_iCDF = Tables.silk_pitch_contour_iCDF;
				}
				else
				{
					pitch_contour_iCDF = Tables.silk_pitch_contour_10_ms_iCDF;
				}
				if (this.fs_kHz != fs_kHz)
				{
					ltp_mem_length = Inlines.silk_SMULBB(20, fs_kHz);
					if (fs_kHz == 8 || fs_kHz == 12)
					{
						LPC_order = 10;
						psNLSF_CB = Tables.silk_NLSF_CB_NB_MB;
					}
					else
					{
						LPC_order = 16;
						psNLSF_CB = Tables.silk_NLSF_CB_WB;
					}
					switch (fs_kHz)
					{
					case 16:
						pitch_lag_low_bits_iCDF = Tables.silk_uniform8_iCDF;
						break;
					case 12:
						pitch_lag_low_bits_iCDF = Tables.silk_uniform6_iCDF;
						break;
					case 8:
						pitch_lag_low_bits_iCDF = Tables.silk_uniform4_iCDF;
						break;
					}
					first_frame_after_reset = 1;
					lagPrev = 100;
					LastGainIndex = 10;
					prevSignalType = 0;
					Arrays.MemSetShort(outBuf, 0, 480);
					Arrays.MemSetInt(sLPC_Q14_buf, 0, 16);
				}
				this.fs_kHz = fs_kHz;
				frame_length = num2;
			}
			return num;
		}

		internal int silk_decode_frame(EntropyCoder psRangeDec, short[] pOut, int pOut_ptr, BoxedValueInt pN, int lostFlag, int condCoding)
		{
			SilkDecoderControl silkDecoderControl = new SilkDecoderControl();
			int num = frame_length;
			silkDecoderControl.LTP_scale_Q14 = 0;
			if (lostFlag == 0 || (lostFlag == 2 && LBRR_flags[nFramesDecoded] == 1))
			{
				short[] pulses = new short[(num + 16 - 1) & -16];
				DecodeIndices.silk_decode_indices(this, psRangeDec, nFramesDecoded, lostFlag, condCoding);
				DecodePulses.silk_decode_pulses(psRangeDec, pulses, indices.signalType, indices.quantOffsetType, frame_length);
				DecodeParameters.silk_decode_parameters(this, silkDecoderControl, condCoding);
				DecodeCore.silk_decode_core(this, silkDecoderControl, pOut, pOut_ptr, pulses);
				PLC.silk_PLC(this, silkDecoderControl, pOut, pOut_ptr, 0);
				lossCnt = 0;
				prevSignalType = indices.signalType;
				first_frame_after_reset = 0;
			}
			else
			{
				PLC.silk_PLC(this, silkDecoderControl, pOut, pOut_ptr, 1);
			}
			int num2 = ltp_mem_length - frame_length;
			Arrays.MemMoveShort(outBuf, frame_length, 0, num2);
			Array.Copy(pOut, pOut_ptr, outBuf, num2, frame_length);
			CNG.silk_CNG(this, silkDecoderControl, pOut, pOut_ptr, num);
			PLC.silk_PLC_glue_frames(this, pOut, pOut_ptr, num);
			lagPrev = silkDecoderControl.pitchL[nb_subfr - 1];
			pN.Val = num;
			return 0;
		}
	}
	internal class SilkChannelEncoder
	{
		internal readonly int[] In_HP_State = new int[2];

		internal int variable_HP_smth1_Q15;

		internal int variable_HP_smth2_Q15;

		internal readonly SilkLPState sLP = new SilkLPState();

		internal readonly SilkVADState sVAD = new SilkVADState();

		internal readonly SilkNSQState sNSQ = new SilkNSQState();

		internal readonly short[] prev_NLSFq_Q15 = new short[16];

		internal int speech_activity_Q8;

		internal int allow_bandwidth_switch;

		internal sbyte LBRRprevLastGainIndex;

		internal sbyte prevSignalType;

		internal int prevLag;

		internal int pitch_LPC_win_length;

		internal int max_pitch_lag;

		internal int API_fs_Hz;

		internal int prev_API_fs_Hz;

		internal int maxInternal_fs_Hz;

		internal int minInternal_fs_Hz;

		internal int desiredInternal_fs_Hz;

		internal int fs_kHz;

		internal int nb_subfr;

		internal int frame_length;

		internal int subfr_length;

		internal int ltp_mem_length;

		internal int la_pitch;

		internal int la_shape;

		internal int shapeWinLength;

		internal int TargetRate_bps;

		internal int PacketSize_ms;

		internal int PacketLoss_perc;

		internal int frameCounter;

		internal int Complexity;

		internal int nStatesDelayedDecision;

		internal int useInterpolatedNLSFs;

		internal int shapingLPCOrder;

		internal int predictLPCOrder;

		internal int pitchEstimationComplexity;

		internal int pitchEstimationLPCOrder;

		internal int pitchEstimationThreshold_Q16;

		internal int LTPQuantLowComplexity;

		internal int mu_LTP_Q9;

		internal int sum_log_gain_Q7;

		internal int NLSF_MSVQ_Survivors;

		internal int first_frame_after_reset;

		internal int controlled_since_last_payload;

		internal int warping_Q16;

		internal int useCBR;

		internal int prefillFlag;

		internal byte[] pitch_lag_low_bits_iCDF;

		internal byte[] pitch_contour_iCDF;

		internal NLSFCodebook psNLSF_CB;

		internal readonly int[] input_quality_bands_Q15 = new int[4];

		internal int input_tilt_Q15;

		internal int SNR_dB_Q7;

		internal readonly sbyte[] VAD_flags = new sbyte[3];

		internal sbyte LBRR_flag;

		internal readonly int[] LBRR_flags = new int[3];

		internal readonly SideInfoIndices indices = new SideInfoIndices();

		internal readonly sbyte[] pulses = new sbyte[320];

		internal readonly short[] inputBuf = new short[322];

		internal int inputBufIx;

		internal int nFramesPerPacket;

		internal int nFramesEncoded;

		internal int nChannelsAPI;

		internal int nChannelsInternal;

		internal int channelNb;

		internal int frames_since_onset;

		internal int ec_prevSignalType;

		internal short ec_prevLagIndex;

		internal readonly SilkResamplerState resampler_state = new SilkResamplerState();

		internal int useDTX;

		internal int inDTX;

		internal int noSpeechCounter;

		internal int useInBandFEC;

		internal int LBRR_enabled;

		internal int LBRR_GainIncreases;

		internal readonly SideInfoIndices[] indices_LBRR = new SideInfoIndices[3];

		internal readonly sbyte[][] pulses_LBRR = Arrays.InitTwoDimensionalArray<sbyte>(3, 320);

		internal readonly SilkShapeState sShape = new SilkShapeState();

		internal readonly SilkPrefilterState sPrefilt = new SilkPrefilterState();

		internal readonly short[] x_buf = new short[720];

		internal int LTPCorr_Q15;

		internal SilkChannelEncoder()
		{
			for (int i = 0; i < 3; i++)
			{
				indices_LBRR[i] = new SideInfoIndices();
			}
		}

		internal void Reset()
		{
			Arrays.MemSetInt(In_HP_State, 0, 2);
			variable_HP_smth1_Q15 = 0;
			variable_HP_smth2_Q15 = 0;
			sLP.Reset();
			sVAD.Reset();
			sNSQ.Reset();
			Arrays.MemSetShort(prev_NLSFq_Q15, 0, 16);
			speech_activity_Q8 = 0;
			allow_bandwidth_switch = 0;
			LBRRprevLastGainIndex = 0;
			prevSignalType = 0;
			prevLag = 0;
			pitch_LPC_win_length = 0;
			max_pitch_lag = 0;
			API_fs_Hz = 0;
			prev_API_fs_Hz = 0;
			maxInternal_fs_Hz = 0;
			minInternal_fs_Hz = 0;
			desiredInternal_fs_Hz = 0;
			fs_kHz = 0;
			nb_subfr = 0;
			frame_length = 0;
			subfr_length = 0;
			ltp_mem_length = 0;
			la_pitch = 0;
			la_shape = 0;
			shapeWinLength = 0;
			TargetRate_bps = 0;
			PacketSize_ms = 0;
			PacketLoss_perc = 0;
			frameCounter = 0;
			Complexity = 0;
			nStatesDelayedDecision = 0;
			useInterpolatedNLSFs = 0;
			shapingLPCOrder = 0;
			predictLPCOrder = 0;
			pitchEstimationComplexity = 0;
			pitchEstimationLPCOrder = 0;
			pitchEstimationThreshold_Q16 = 0;
			LTPQuantLowComplexity = 0;
			mu_LTP_Q9 = 0;
			sum_log_gain_Q7 = 0;
			NLSF_MSVQ_Survivors = 0;
			first_frame_after_reset = 0;
			controlled_since_last_payload = 0;
			warping_Q16 = 0;
			useCBR = 0;
			prefillFlag = 0;
			pitch_lag_low_bits_iCDF = null;
			pitch_contour_iCDF = null;
			psNLSF_CB = null;
			Arrays.MemSetInt(input_quality_bands_Q15, 0, 4);
			input_tilt_Q15 = 0;
			SNR_dB_Q7 = 0;
			Arrays.MemSetSbyte(VAD_flags, 0, 3);
			LBRR_flag = 0;
			Arrays.MemSetInt(LBRR_flags, 0, 3);
			indices.Reset();
			Arrays.MemSetSbyte(pulses, 0, 320);
			Arrays.MemSetShort(inputBuf, 0, 322);
			inputBufIx = 0;
			nFramesPerPacket = 0;
			nFramesEncoded = 0;
			nChannelsAPI = 0;
			nChannelsInternal = 0;
			channelNb = 0;
			frames_since_onset = 0;
			ec_prevSignalType = 0;
			ec_prevLagIndex = 0;
			resampler_state.Reset();
			useDTX = 0;
			inDTX = 0;
			noSpeechCounter = 0;
			useInBandFEC = 0;
			LBRR_enabled = 0;
			LBRR_GainIncreases = 0;
			for (int i = 0; i < 3; i++)
			{
				indices_LBRR[i].Reset();
				Arrays.MemSetSbyte(pulses_LBRR[i], 0, 320);
			}
			sShape.Reset();
			sPrefilt.Reset();
			Arrays.MemSetShort(x_buf, 0, 720);
			LTPCorr_Q15 = 0;
		}

		internal int silk_control_encoder(EncControlState encControl, int TargetRate_bps, int allow_bw_switch, int channelNb, int force_fs_kHz)
		{
			int result = SilkError.SILK_NO_ERROR;
			useDTX = encControl.useDTX;
			useCBR = encControl.useCBR;
			API_fs_Hz = encControl.API_sampleRate;
			maxInternal_fs_Hz = encControl.maxInternalSampleRate;
			minInternal_fs_Hz = encControl.minInternalSampleRate;
			desiredInternal_fs_Hz = encControl.desiredInternalSampleRate;
			useInBandFEC = encControl.useInBandFEC;
			nChannelsAPI = encControl.nChannelsAPI;
			nChannelsInternal = encControl.nChannelsInternal;
			allow_bandwidth_switch = allow_bw_switch;
			this.channelNb = channelNb;
			if (controlled_since_last_payload != 0 && prefillFlag == 0)
			{
				if (API_fs_Hz != prev_API_fs_Hz && fs_kHz > 0)
				{
					result = silk_setup_resamplers(fs_kHz);
				}
				return result;
			}
			int num = silk_control_audio_bandwidth(encControl);
			if (force_fs_kHz != 0)
			{
				num = force_fs_kHz;
			}
			result = silk_setup_resamplers(num);
			result = silk_setup_fs(num, encControl.payloadSize_ms);
			result = silk_setup_complexity(encControl.complexity);
			PacketLoss_perc = encControl.packetLossPercentage;
			result = silk_setup_LBRR(TargetRate_bps);
			controlled_since_last_payload = 1;
			return result;
		}

		private int silk_setup_resamplers(int fs_kHz)
		{
			int num = 0;
			if (this.fs_kHz != fs_kHz || prev_API_fs_Hz != API_fs_Hz)
			{
				if (this.fs_kHz == 0)
				{
					num += Resampler.silk_resampler_init(resampler_state, API_fs_Hz, fs_kHz * 1000, 1);
				}
				else
				{
					SilkResamplerState silkResamplerState = null;
					int num2 = Inlines.silk_LSHIFT(nb_subfr * 5, 1) + 5;
					int inLen = num2 * this.fs_kHz;
					silkResamplerState = new SilkResamplerState();
					num += Resampler.silk_resampler_init(silkResamplerState, Inlines.silk_SMULBB(this.fs_kHz, 1000), API_fs_Hz, 0);
					int num3 = num2 * Inlines.silk_DIV32_16(API_fs_Hz, 1000);
					short[] array = new short[num3];
					num += Resampler.silk_resampler(silkResamplerState, array, 0, x_buf, 0, inLen);
					num += Resampler.silk_resampler_init(resampler_state, API_fs_Hz, Inlines.silk_SMULBB(fs_kHz, 1000), 1);
					num += Resampler.silk_resampler(resampler_state, x_buf, 0, array, 0, num3);
				}
			}
			prev_API_fs_Hz = API_fs_Hz;
			return num;
		}

		private int silk_setup_fs(int fs_kHz, int PacketSize_ms)
		{
			int result = SilkError.SILK_NO_ERROR;
			if (PacketSize_ms != this.PacketSize_ms)
			{
				if (PacketSize_ms != 10 && PacketSize_ms != 20 && PacketSize_ms != 40 && PacketSize_ms != 60)
				{
					result = SilkError.SILK_ENC_PACKET_SIZE_NOT_SUPPORTED;
				}
				if (PacketSize_ms <= 10)
				{
					nFramesPerPacket = 1;
					nb_subfr = ((PacketSize_ms != 10) ? 1 : 2);
					frame_length = Inlines.silk_SMULBB(PacketSize_ms, fs_kHz);
					pitch_LPC_win_length = Inlines.silk_SMULBB(14, fs_kHz);
					if (this.fs_kHz == 8)
					{
						pitch_contour_iCDF = Tables.silk_pitch_contour_10_ms_NB_iCDF;
					}
					else
					{
						pitch_contour_iCDF = Tables.silk_pitch_contour_10_ms_iCDF;
					}
				}
				else
				{
					nFramesPerPacket = Inlines.silk_DIV32_16(PacketSize_ms, 20);
					nb_subfr = 4;
					frame_length = Inlines.silk_SMULBB(20, fs_kHz);
					pitch_LPC_win_length = Inlines.silk_SMULBB(24, fs_kHz);
					if (this.fs_kHz == 8)
					{
						pitch_contour_iCDF = Tables.silk_pitch_contour_NB_iCDF;
					}
					else
					{
						pitch_contour_iCDF = Tables.silk_pitch_contour_iCDF;
					}
				}
				this.PacketSize_ms = PacketSize_ms;
				TargetRate_bps = 0;
			}
			if (this.fs_kHz != fs_kHz)
			{
				sShape.Reset();
				sPrefilt.Reset();
				sNSQ.Reset();
				Arrays.MemSetShort(prev_NLSFq_Q15, 0, 16);
				Arrays.MemSetInt(sLP.In_LP_State, 0, 2);
				inputBufIx = 0;
				nFramesEncoded = 0;
				TargetRate_bps = 0;
				prevLag = 100;
				first_frame_after_reset = 1;
				sPrefilt.lagPrev = 100;
				sShape.LastGainIndex = 10;
				sNSQ.lagPrev = 100;
				sNSQ.prev_gain_Q16 = 65536;
				prevSignalType = 0;
				this.fs_kHz = fs_kHz;
				if (this.fs_kHz == 8)
				{
					if (nb_subfr == 4)
					{
						pitch_contour_iCDF = Tables.silk_pitch_contour_NB_iCDF;
					}
					else
					{
						pitch_contour_iCDF = Tables.silk_pitch_contour_10_ms_NB_iCDF;
					}
				}
				else if (nb_subfr == 4)
				{
					pitch_contour_iCDF = Tables.silk_pitch_contour_iCDF;
				}
				else
				{
					pitch_contour_iCDF = Tables.silk_pitch_contour_10_ms_iCDF;
				}
				if (this.fs_kHz == 8 || this.fs_kHz == 12)
				{
					predictLPCOrder = 10;
					psNLSF_CB = Tables.silk_NLSF_CB_NB_MB;
				}
				else
				{
					predictLPCOrder = 16;
					psNLSF_CB = Tables.silk_NLSF_CB_WB;
				}
				subfr_length = 5 * fs_kHz;
				frame_length = Inlines.silk_SMULBB(subfr_length, nb_subfr);
				ltp_mem_length = Inlines.silk_SMULBB(20, fs_kHz);
				la_pitch = Inlines.silk_SMULBB(2, fs_kHz);
				max_pitch_lag = Inlines.silk_SMULBB(18, fs_kHz);
				if (nb_subfr == 4)
				{
					pitch_LPC_win_length = Inlines.silk_SMULBB(24, fs_kHz);
				}
				else
				{
					pitch_LPC_win_length = Inlines.silk_SMULBB(14, fs_kHz);
				}
				if (this.fs_kHz == 16)
				{
					mu_LTP_Q9 = 10;
					pitch_lag_low_bits_iCDF = Tables.silk_uniform8_iCDF;
				}
				else if (this.fs_kHz == 12)
				{
					mu_LTP_Q9 = 13;
					pitch_lag_low_bits_iCDF = Tables.silk_uniform6_iCDF;
				}
				else
				{
					mu_LTP_Q9 = 15;
					pitch_lag_low_bits_iCDF = Tables.silk_uniform4_iCDF;
				}
			}
			return result;
		}

		private int silk_setup_complexity(int Complexity)
		{
			if (Complexity < 2)
			{
				pitchEstimationComplexity = 0;
				pitchEstimationThreshold_Q16 = 52429;
				pitchEstimationLPCOrder = 6;
				shapingLPCOrder = 8;
				la_shape = 3 * fs_kHz;
				nStatesDelayedDecision = 1;
				useInterpolatedNLSFs = 0;
				LTPQuantLowComplexity = 1;
				NLSF_MSVQ_Survivors = 2;
				warping_Q16 = 0;
			}
			else if (Complexity < 4)
			{
				pitchEstimationComplexity = 1;
				pitchEstimationThreshold_Q16 = 49807;
				pitchEstimationLPCOrder = 8;
				shapingLPCOrder = 10;
				la_shape = 5 * fs_kHz;
				nStatesDelayedDecision = 1;
				useInterpolatedNLSFs = 0;
				LTPQuantLowComplexity = 0;
				NLSF_MSVQ_Survivors = 4;
				warping_Q16 = 0;
			}
			else if (Complexity < 6)
			{
				pitchEstimationComplexity = 1;
				pitchEstimationThreshold_Q16 = 48497;
				pitchEstimationLPCOrder = 10;
				shapingLPCOrder = 12;
				la_shape = 5 * fs_kHz;
				nStatesDelayedDecision = 2;
				useInterpolatedNLSFs = 1;
				LTPQuantLowComplexity = 0;
				NLSF_MSVQ_Survivors = 8;
				warping_Q16 = fs_kHz * 983;
			}
			else if (Complexity < 8)
			{
				pitchEstimationComplexity = 1;
				pitchEstimationThreshold_Q16 = 47186;
				pitchEstimationLPCOrder = 12;
				shapingLPCOrder = 14;
				la_shape = 5 * fs_kHz;
				nStatesDelayedDecision = 3;
				useInterpolatedNLSFs = 1;
				LTPQuantLowComplexity = 0;
				NLSF_MSVQ_Survivors = 16;
				warping_Q16 = fs_kHz * 983;
			}
			else
			{
				pitchEstimationComplexity = 2;
				pitchEstimationThreshold_Q16 = 45875;
				pitchEstimationLPCOrder = 16;
				shapingLPCOrder = 16;
				la_shape = 5 * fs_kHz;
				nStatesDelayedDecision = 4;
				useInterpolatedNLSFs = 1;
				LTPQuantLowComplexity = 0;
				NLSF_MSVQ_Survivors = 32;
				warping_Q16 = fs_kHz * 983;
			}
			pitchEstimationLPCOrder = Inlines.silk_min_int(pitchEstimationLPCOrder, predictLPCOrder);
			shapeWinLength = 5 * fs_kHz + 2 * la_shape;
			this.Complexity = Complexity;
			return 0;
		}

		private int silk_setup_LBRR(int TargetRate_bps)
		{
			int sILK_NO_ERROR = SilkError.SILK_NO_ERROR;
			int lBRR_enabled = LBRR_enabled;
			LBRR_enabled = 0;
			if (useInBandFEC != 0 && PacketLoss_perc > 0)
			{
				int a = ((fs_kHz == 8) ? 12000 : ((fs_kHz != 12) ? 16000 : 14000));
				a = Inlines.silk_SMULWB(Inlines.silk_MUL(a, 125 - Inlines.silk_min(PacketLoss_perc, 25)), 655);
				if (TargetRate_bps > a)
				{
					if (lBRR_enabled == 0)
					{
						LBRR_GainIncreases = 7;
					}
					else
					{
						LBRR_GainIncreases = Inlines.silk_max_int(7 - Inlines.silk_SMULWB(PacketLoss_perc, 26214), 2);
					}
					LBRR_enabled = 1;
				}
			}
			return sILK_NO_ERROR;
		}

		internal int silk_control_audio_bandwidth(EncControlState encControl)
		{
			int num = fs_kHz;
			int num2 = Inlines.silk_SMULBB(num, 1000);
			if (num2 == 0)
			{
				num2 = Inlines.silk_min(desiredInternal_fs_Hz, API_fs_Hz);
				num = Inlines.silk_DIV32_16(num2, 1000);
			}
			else if (num2 > API_fs_Hz || num2 > maxInternal_fs_Hz || num2 < minInternal_fs_Hz)
			{
				num2 = API_fs_Hz;
				num2 = Inlines.silk_min(num2, maxInternal_fs_Hz);
				num2 = Inlines.silk_max(num2, minInternal_fs_Hz);
				num = Inlines.silk_DIV32_16(num2, 1000);
			}
			else
			{
				if (sLP.transition_frame_no >= 256)
				{
					sLP.mode = 0;
				}
				if (allow_bandwidth_switch != 0 || encControl.opusCanSwitch != 0)
				{
					if (Inlines.silk_SMULBB(fs_kHz, 1000) > desiredInternal_fs_Hz)
					{
						if (sLP.mode == 0)
						{
							sLP.transition_frame_no = 256;
							Arrays.MemSetInt(sLP.In_LP_State, 0, 2);
						}
						if (encControl.opusCanSwitch != 0)
						{
							sLP.mode = 0;
							num = ((fs_kHz == 16) ? 12 : 8);
						}
						else if (sLP.transition_frame_no <= 0)
						{
							encControl.switchReady = 1;
							encControl.maxBits -= encControl.maxBits * 5 / (encControl.payloadSize_ms + 5);
						}
						else
						{
							sLP.mode = -2;
						}
					}
					else if (Inlines.silk_SMULBB(fs_kHz, 1000) < desiredInternal_fs_Hz)
					{
						if (encControl.opusCanSwitch != 0)
						{
							num = ((fs_kHz == 8) ? 12 : 16);
							sLP.transition_frame_no = 0;
							Arrays.MemSetInt(sLP.In_LP_State, 0, 2);
							sLP.mode = 1;
						}
						else if (sLP.mode == 0)
						{
							encControl.switchReady = 1;
							encControl.maxBits -= encControl.maxBits * 5 / (encControl.payloadSize_ms + 5);
						}
						else
						{
							sLP.mode = 1;
						}
					}
					else if (sLP.mode < 0)
					{
						sLP.mode = 1;
					}
				}
			}
			return num;
		}

		internal int silk_control_SNR(int TargetRate_bps)
		{
			int sILK_NO_ERROR = SilkError.SILK_NO_ERROR;
			TargetRate_bps = Inlines.silk_LIMIT(TargetRate_bps, 5000, 80000);
			if (TargetRate_bps != this.TargetRate_bps)
			{
				this.TargetRate_bps = TargetRate_bps;
				int[] array = ((fs_kHz == 8) ? Tables.silk_TargetRate_table_NB : ((fs_kHz != 12) ? Tables.silk_TargetRate_table_WB : Tables.silk_TargetRate_table_MB));
				if (nb_subfr == 2)
				{
					TargetRate_bps -= 2200;
				}
				for (int i = 1; i < 8; i++)
				{
					if (TargetRate_bps <= array[i])
					{
						int a = Inlines.silk_DIV32(Inlines.silk_LSHIFT(TargetRate_bps - array[i - 1], 6), array[i] - array[i - 1]);
						SNR_dB_Q7 = Inlines.silk_LSHIFT(Tables.silk_SNR_table_Q1[i - 1], 6) + Inlines.silk_MUL(a, Tables.silk_SNR_table_Q1[i] - Tables.silk_SNR_table_Q1[i - 1]);
						break;
					}
				}
			}
			return sILK_NO_ERROR;
		}

		internal void silk_encode_do_VAD()
		{
			VoiceActivityDetection.silk_VAD_GetSA_Q8(this, inputBuf, 1);
			if (speech_activity_Q8 < 13)
			{
				indices.signalType = 0;
				noSpeechCounter++;
				if (noSpeechCounter < 10)
				{
					inDTX = 0;
				}
				else if (noSpeechCounter > 30)
				{
					noSpeechCounter = 10;
					inDTX = 0;
				}
				VAD_flags[nFramesEncoded] = 0;
			}
			else
			{
				noSpeechCounter = 0;
				inDTX = 0;
				indices.signalType = 1;
				VAD_flags[nFramesEncoded] = 1;
			}
		}

		internal int silk_encode_frame(BoxedValueInt pnBytesOut, EntropyCoder psRangeEnc, int condCoding, int maxBits, int useCBR)
		{
			SilkEncoderControl silkEncoderControl = new SilkEncoderControl();
			int result = 0;
			EntropyCoder entropyCoder = new EntropyCoder();
			EntropyCoder entropyCoder2 = new EntropyCoder();
			SilkNSQState silkNSQState = new SilkNSQState();
			SilkNSQState silkNSQState2 = new SilkNSQState();
			sbyte lastGainIndex = 0;
			int num2;
			int num3;
			int num4;
			int num = (num2 = (num3 = (num4 = 0)));
			indices.Seed = (sbyte)(frameCounter++ & 3);
			int num5 = ltp_mem_length;
			sLP.silk_LP_variable_cutoff(inputBuf, 1, frame_length);
			Array.Copy(inputBuf, 1, x_buf, num5 + 5 * fs_kHz, frame_length);
			if (prefillFlag == 0)
			{
				short[] array = new short[la_pitch + frame_length + ltp_mem_length];
				int pitch_res_ptr = ltp_mem_length;
				FindPitchLags.silk_find_pitch_lags(this, silkEncoderControl, array, x_buf, num5);
				NoiseShapeAnalysis.silk_noise_shape_analysis(this, silkEncoderControl, array, pitch_res_ptr, x_buf, num5);
				FindPredCoefs.silk_find_pred_coefs(this, silkEncoderControl, array, x_buf, num5, condCoding);
				ProcessGains.silk_process_gains(this, silkEncoderControl, condCoding);
				int[] array2 = new int[frame_length];
				Filters.silk_prefilter(this, silkEncoderControl, array2, x_buf, num5);
				silk_LBRR_encode(silkEncoderControl, array2, condCoding);
				int num6 = 6;
				short num7 = 256;
				int num8 = 0;
				int num9 = 0;
				int num10 = GainQuantization.silk_gains_ID(indices.GainsIndices, nb_subfr);
				int num11 = -1;
				int num12 = -1;
				entropyCoder.Assign(psRangeEnc);
				silkNSQState.Assign(sNSQ);
				sbyte seed = indices.Seed;
				short num13 = ec_prevLagIndex;
				int num14 = ec_prevSignalType;
				byte[] array3 = new byte[1275];
				int num15 = 0;
				while (true)
				{
					int num16;
					if (num10 == num11)
					{
						num16 = num;
					}
					else if (num10 == num12)
					{
						num16 = num2;
					}
					else
					{
						if (num15 > 0)
						{
							psRangeEnc.Assign(entropyCoder);
							sNSQ.Assign(silkNSQState);
							indices.Seed = seed;
							ec_prevLagIndex = num13;
							ec_prevSignalType = num14;
						}
						if (nStatesDelayedDecision > 1 || warping_Q16 > 0)
						{
							sNSQ.silk_NSQ_del_dec(this, indices, array2, pulses, silkEncoderControl.PredCoef_Q12, silkEncoderControl.LTPCoef_Q14, silkEncoderControl.AR2_Q13, silkEncoderControl.HarmShapeGain_Q14, silkEncoderControl.Tilt_Q14, silkEncoderControl.LF_shp_Q14, silkEncoderControl.Gains_Q16, silkEncoderControl.pitchL, silkEncoderControl.Lambda_Q10, silkEncoderControl.LTP_scale_Q14);
						}
						else
						{
							sNSQ.silk_NSQ(this, indices, array2, pulses, silkEncoderControl.PredCoef_Q12, silkEncoderControl.LTPCoef_Q14, silkEncoderControl.AR2_Q13, silkEncoderControl.HarmShapeGain_Q14, silkEncoderControl.Tilt_Q14, silkEncoderControl.LF_shp_Q14, silkEncoderControl.Gains_Q16, silkEncoderControl.pitchL, silkEncoderControl.Lambda_Q10, silkEncoderControl.LTP_scale_Q14);
						}
						EncodeIndices.silk_encode_indices(this, psRangeEnc, nFramesEncoded, 0, condCoding);
						EncodePulses.silk_encode_pulses(psRangeEnc, indices.signalType, indices.quantOffsetType, pulses, frame_length);
						num16 = psRangeEnc.tell();
						if (useCBR == 0 && num15 == 0 && num16 <= maxBits)
						{
							break;
						}
					}
					if (num15 == num6)
					{
						if (num8 != 0 && (num10 == num11 || num16 > maxBits))
						{
							psRangeEnc.Assign(entropyCoder2);
							Array.Copy(array3, 0, psRangeEnc.buf, psRangeEnc.buf_ptr, (int)entropyCoder2.offs);
							sNSQ.Assign(silkNSQState2);
							sShape.LastGainIndex = lastGainIndex;
						}
						break;
					}
					if (num16 > maxBits)
					{
						if (num8 == 0 && num15 >= 2)
						{
							silkEncoderControl.Lambda_Q10 = Inlines.silk_ADD_RSHIFT32(silkEncoderControl.Lambda_Q10, silkEncoderControl.Lambda_Q10, 1);
							num9 = 0;
							num12 = -1;
						}
						else
						{
							num9 = 1;
							num2 = num16;
							num4 = num7;
							num12 = num10;
						}
					}
					else
					{
						if (num16 >= maxBits - 5)
						{
							break;
						}
						num8 = 1;
						num = num16;
						num3 = num7;
						if (num10 != num11)
						{
							num11 = num10;
							entropyCoder2.Assign(psRangeEnc);
							Array.Copy(psRangeEnc.buf, psRangeEnc.buf_ptr, array3, 0, (int)psRangeEnc.offs);
							silkNSQState2.Assign(sNSQ);
							lastGainIndex = sShape.LastGainIndex;
						}
					}
					if ((num8 & num9) == 0)
					{
						int a = Inlines.silk_log2lin(Inlines.silk_LSHIFT(num16 - maxBits, 7) / frame_length + 2048);
						a = Inlines.silk_min_32(a, 131072);
						if (num16 > maxBits)
						{
							a = Inlines.silk_max_32(a, 85197);
						}
						num7 = (short)Inlines.silk_SMULWB(a, num7);
					}
					else
					{
						num7 = (short)(num3 + Inlines.silk_DIV32_16(Inlines.silk_MUL(num4 - num3, maxBits - num), num2 - num));
						if (num7 > Inlines.silk_ADD_RSHIFT32(num3, num4 - num3, 2))
						{
							num7 = (short)Inlines.silk_ADD_RSHIFT32(num3, num4 - num3, 2);
						}
						else if (num7 < Inlines.silk_SUB_RSHIFT32(num4, num4 - num3, 2))
						{
							num7 = (short)Inlines.silk_SUB_RSHIFT32(num4, num4 - num3, 2);
						}
					}
					for (int i = 0; i < nb_subfr; i++)
					{
						silkEncoderControl.Gains_Q16[i] = Inlines.silk_LSHIFT_SAT32(Inlines.silk_SMULWB(silkEncoderControl.GainsUnq_Q16[i], num7), 8);
					}
					sShape.LastGainIndex = silkEncoderControl.lastGainIndexPrev;
					BoxedValueSbyte boxedValueSbyte = new BoxedValueSbyte(sShape.LastGainIndex);
					GainQuantization.silk_gains_quant(indices.GainsIndices, silkEncoderControl.Gains_Q16, boxedValueSbyte, (condCoding == 2) ? 1 : 0, nb_subfr);
					sShape.LastGainIndex = boxedValueSbyte.Val;
					num10 = GainQuantization.silk_gains_ID(indices.GainsIndices, nb_subfr);
					num15++;
				}
			}
			Arrays.MemMove(x_buf, frame_length, 0, ltp_mem_length + 5 * fs_kHz);
			if (prefillFlag != 0)
			{
				pnBytesOut.Val = 0;
				return result;
			}
			prevLag = silkEncoderControl.pitchL[nb_subfr - 1];
			prevSignalType = indices.signalType;
			first_frame_after_reset = 0;
			pnBytesOut.Val = Inlines.silk_RSHIFT(psRangeEnc.tell() + 7, 3);
			return result;
		}

		internal void silk_LBRR_encode(SilkEncoderControl thisCtrl, int[] xfw_Q3, int condCoding)
		{
			int[] array = new int[nb_subfr];
			SideInfoIndices sideInfoIndices = indices_LBRR[nFramesEncoded];
			SilkNSQState silkNSQState = new SilkNSQState();
			if (LBRR_enabled != 0 && speech_activity_Q8 > 77)
			{
				LBRR_flags[nFramesEncoded] = 1;
				silkNSQState.Assign(sNSQ);
				sideInfoIndices.Assign(indices);
				Array.Copy(thisCtrl.Gains_Q16, array, nb_subfr);
				if (nFramesEncoded == 0 || LBRR_flags[nFramesEncoded - 1] == 0)
				{
					LBRRprevLastGainIndex = sShape.LastGainIndex;
					sideInfoIndices.GainsIndices[0] = (sbyte)(sideInfoIndices.GainsIndices[0] + LBRR_GainIncreases);
					sideInfoIndices.GainsIndices[0] = (sbyte)Inlines.silk_min_int(sideInfoIndices.GainsIndices[0], 63);
				}
				BoxedValueSbyte boxedValueSbyte = new BoxedValueSbyte(LBRRprevLastGainIndex);
				GainQuantization.silk_gains_dequant(thisCtrl.Gains_Q16, sideInfoIndices.GainsIndices, boxedValueSbyte, (condCoding == 2) ? 1 : 0, nb_subfr);
				LBRRprevLastGainIndex = boxedValueSbyte.Val;
				if (nStatesDelayedDecision > 1 || warping_Q16 > 0)
				{
					silkNSQState.silk_NSQ_del_dec(this, sideInfoIndices, xfw_Q3, pulses_LBRR[nFramesEncoded], thisCtrl.PredCoef_Q12, thisCtrl.LTPCoef_Q14, thisCtrl.AR2_Q13, thisCtrl.HarmShapeGain_Q14, thisCtrl.Tilt_Q14, thisCtrl.LF_shp_Q14, thisCtrl.Gains_Q16, thisCtrl.pitchL, thisCtrl.Lambda_Q10, thisCtrl.LTP_scale_Q14);
				}
				else
				{
					silkNSQState.silk_NSQ(this, sideInfoIndices, xfw_Q3, pulses_LBRR[nFramesEncoded], thisCtrl.PredCoef_Q12, thisCtrl.LTPCoef_Q14, thisCtrl.AR2_Q13, thisCtrl.HarmShapeGain_Q14, thisCtrl.Tilt_Q14, thisCtrl.LF_shp_Q14, thisCtrl.Gains_Q16, thisCtrl.pitchL, thisCtrl.Lambda_Q10, thisCtrl.LTP_scale_Q14);
				}
				Array.Copy(array, thisCtrl.Gains_Q16, nb_subfr);
			}
		}
	}
	internal class SilkDecoder
	{
		internal readonly SilkChannelDecoder[] channel_state = new SilkChannelDecoder[2];

		internal readonly StereoDecodeState sStereo = new StereoDecodeState();

		internal int nChannelsAPI;

		internal int nChannelsInternal;

		internal int prev_decode_only_middle;

		internal SilkDecoder()
		{
			for (int i = 0; i < 2; i++)
			{
				channel_state[i] = new SilkChannelDecoder();
			}
		}

		internal void Reset()
		{
			for (int i = 0; i < 2; i++)
			{
				channel_state[i].Reset();
			}
			sStereo.Reset();
			nChannelsAPI = 0;
			nChannelsInternal = 0;
			prev_decode_only_middle = 0;
		}
	}
	internal class SilkDecoderControl
	{
		internal readonly int[] pitchL = new int[4];

		internal readonly int[] Gains_Q16 = new int[4];

		internal readonly short[][] PredCoef_Q12 = Arrays.InitTwoDimensionalArray<short>(2, 16);

		internal readonly short[] LTPCoef_Q14 = new short[20];

		internal int LTP_scale_Q14;

		internal void Reset()
		{
			Arrays.MemSetInt(pitchL, 0, 4);
			Arrays.MemSetInt(Gains_Q16, 0, 4);
			Arrays.MemSetShort(PredCoef_Q12[0], 0, 16);
			Arrays.MemSetShort(PredCoef_Q12[1], 0, 16);
			Arrays.MemSetShort(LTPCoef_Q14, 0, 20);
			LTP_scale_Q14 = 0;
		}
	}
	internal class SilkEncoder
	{
		internal readonly SilkChannelEncoder[] state_Fxx = new SilkChannelEncoder[2];

		internal readonly StereoEncodeState sStereo = new StereoEncodeState();

		internal int nBitsUsedLBRR;

		internal int nBitsExceeded;

		internal int nChannelsAPI;

		internal int nChannelsInternal;

		internal int nPrevChannelsInternal;

		internal int timeSinceSwitchAllowed_ms;

		internal int allowBandwidthSwitch;

		internal int prev_decode_only_middle;

		internal SilkEncoder()
		{
			for (int i = 0; i < 2; i++)
			{
				state_Fxx[i] = new SilkChannelEncoder();
			}
		}

		internal void Reset()
		{
			for (int i = 0; i < 2; i++)
			{
				state_Fxx[i].Reset();
			}
			sStereo.Reset();
			nBitsUsedLBRR = 0;
			nBitsExceeded = 0;
			nChannelsAPI = 0;
			nChannelsInternal = 0;
			nPrevChannelsInternal = 0;
			timeSinceSwitchAllowed_ms = 0;
			allowBandwidthSwitch = 0;
			prev_decode_only_middle = 0;
		}

		internal static int silk_init_encoder(SilkChannelEncoder psEnc)
		{
			psEnc.Reset();
			psEnc.variable_HP_smth1_Q15 = Inlines.silk_LSHIFT(Inlines.silk_lin2log(3932160) - 2048, 8);
			psEnc.variable_HP_smth2_Q15 = psEnc.variable_HP_smth1_Q15;
			psEnc.first_frame_after_reset = 1;
			return 0 + VoiceActivityDetection.silk_VAD_Init(psEnc.sVAD);
		}
	}
	internal class SilkEncoderControl
	{
		internal readonly int[] Gains_Q16 = new int[4];

		internal readonly short[][] PredCoef_Q12 = Arrays.InitTwoDimensionalArray<short>(2, 16);

		internal readonly short[] LTPCoef_Q14 = new short[20];

		internal int LTP_scale_Q14;

		internal readonly int[] pitchL = new int[4];

		internal readonly short[] AR1_Q13 = new short[64];

		internal readonly short[] AR2_Q13 = new short[64];

		internal readonly int[] LF_shp_Q14 = new int[4];

		internal readonly int[] GainsPre_Q14 = new int[4];

		internal readonly int[] HarmBoost_Q14 = new int[4];

		internal readonly int[] Tilt_Q14 = new int[4];

		internal readonly int[] HarmShapeGain_Q14 = new int[4];

		internal int Lambda_Q10;

		internal int input_quality_Q14;

		internal int coding_quality_Q14;

		internal int sparseness_Q8;

		internal int predGain_Q16;

		internal int LTPredCodGain_Q7;

		internal readonly int[] ResNrg = new int[4];

		internal readonly int[] ResNrgQ = new int[4];

		internal readonly int[] GainsUnq_Q16 = new int[4];

		internal sbyte lastGainIndexPrev;

		internal void Reset()
		{
			Arrays.MemSetInt(Gains_Q16, 0, 4);
			Arrays.MemSetShort(PredCoef_Q12[0], 0, 16);
			Arrays.MemSetShort(PredCoef_Q12[1], 0, 16);
			Arrays.MemSetShort(LTPCoef_Q14, 0, 20);
			LTP_scale_Q14 = 0;
			Arrays.MemSetInt(pitchL, 0, 4);
			Arrays.MemSetShort(AR1_Q13, 0, 64);
			Arrays.MemSetShort(AR2_Q13, 0, 64);
			Arrays.MemSetInt(LF_shp_Q14, 0, 4);
			Arrays.MemSetInt(GainsPre_Q14, 0, 4);
			Arrays.MemSetInt(HarmBoost_Q14, 0, 4);
			Arrays.MemSetInt(Tilt_Q14, 0, 4);
			Arrays.MemSetInt(HarmShapeGain_Q14, 0, 4);
			Lambda_Q10 = 0;
			input_quality_Q14 = 0;
			coding_quality_Q14 = 0;
			sparseness_Q8 = 0;
			predGain_Q16 = 0;
			LTPredCodGain_Q7 = 0;
			Arrays.MemSetInt(ResNrg, 0, 4);
			Arrays.MemSetInt(ResNrgQ, 0, 4);
			Arrays.MemSetInt(GainsUnq_Q16, 0, 4);
			lastGainIndexPrev = 0;
		}
	}
	internal class SilkLPState
	{
		internal readonly int[] In_LP_State = new int[2];

		internal int transition_frame_no;

		internal int mode;

		internal void Reset()
		{
			In_LP_State[0] = 0;
			In_LP_State[1] = 0;
			transition_frame_no = 0;
			mode = 0;
		}

		internal void silk_LP_variable_cutoff(short[] frame, int frame_ptr, int frame_length)
		{
			int[] b_Q = new int[3];
			int[] a_Q = new int[2];
			int num = 0;
			int num2 = 0;
			if (mode != 0)
			{
				num = Inlines.silk_LSHIFT(256 - transition_frame_no, 10);
				num2 = Inlines.silk_RSHIFT(num, 16);
				num -= Inlines.silk_LSHIFT(num2, 16);
				Filters.silk_LP_interpolate_filter_taps(b_Q, a_Q, num2, num);
				transition_frame_no = Inlines.silk_LIMIT(transition_frame_no + mode, 0, 256);
				Filters.silk_biquad_alt(frame, frame_ptr, b_Q, a_Q, In_LP_State, frame, frame_ptr, frame_length, 1);
			}
		}
	}
	internal class SilkNSQState
	{
		private class NSQ_del_dec_struct
		{
			internal readonly int[] sLPC_Q14 = new int[80 + SilkConstants.NSQ_LPC_BUF_LENGTH];

			internal readonly int[] RandState = new int[32];

			internal readonly int[] Q_Q10 = new int[32];

			internal readonly int[] Xq_Q14 = new int[32];

			internal readonly int[] Pred_Q15 = new int[32];

			internal readonly int[] Shape_Q14 = new int[32];

			internal int[] sAR2_Q14;

			internal int LF_AR_Q14;

			internal int Seed;

			internal int SeedInit;

			internal int RD_Q10;

			internal NSQ_del_dec_struct(int shapingOrder)
			{
				sAR2_Q14 = new int[shapingOrder];
			}

			internal void PartialCopyFrom(NSQ_del_dec_struct other, int q14Offset)
			{
				Buffer.BlockCopy(other.sLPC_Q14, q14Offset * 4, sLPC_Q14, q14Offset * 4, (80 + SilkConstants.NSQ_LPC_BUF_LENGTH - q14Offset) * 4);
				Buffer.BlockCopy(other.RandState, 0, RandState, 0, 128);
				Buffer.BlockCopy(other.Q_Q10, 0, Q_Q10, 0, 128);
				Buffer.BlockCopy(other.Xq_Q14, 0, Xq_Q14, 0, 128);
				Buffer.BlockCopy(other.Pred_Q15, 0, Pred_Q15, 0, 128);
				Buffer.BlockCopy(other.Shape_Q14, 0, Shape_Q14, 0, 128);
				Buffer.BlockCopy(other.sAR2_Q14, 0, sAR2_Q14, 0, sAR2_Q14.Length * 4);
				LF_AR_Q14 = other.LF_AR_Q14;
				Seed = other.Seed;
				SeedInit = other.SeedInit;
				RD_Q10 = other.RD_Q10;
			}

			internal void Assign(NSQ_del_dec_struct other)
			{
				PartialCopyFrom(other, 0);
			}
		}

		private struct NSQ_sample_struct
		{
			internal int Q_Q10;

			internal int RD_Q10;

			internal int xq_Q14;

			internal int LF_AR_Q14;

			internal int sLTP_shp_Q14;

			internal int LPC_exc_Q14;
		}

		internal readonly short[] xq = new short[640];

		internal readonly int[] sLTP_shp_Q14 = new int[640];

		internal readonly int[] sLPC_Q14 = new int[80 + SilkConstants.NSQ_LPC_BUF_LENGTH];

		internal readonly int[] sAR2_Q14 = new int[16];

		internal int sLF_AR_shp_Q14;

		internal int lagPrev;

		internal int sLTP_buf_idx;

		internal int sLTP_shp_buf_idx;

		internal int rand_seed;

		internal int prev_gain_Q16;

		internal int rewhite_flag;

		internal void Reset()
		{
			Arrays.MemSetShort(xq, 0, 640);
			Arrays.MemSetInt(sLTP_shp_Q14, 0, 640);
			Arrays.MemSetInt(sLPC_Q14, 0, 80 + SilkConstants.NSQ_LPC_BUF_LENGTH);
			Arrays.MemSetInt(sAR2_Q14, 0, 16);
			sLF_AR_shp_Q14 = 0;
			lagPrev = 0;
			sLTP_buf_idx = 0;
			sLTP_shp_buf_idx = 0;
			rand_seed = 0;
			prev_gain_Q16 = 0;
			rewhite_flag = 0;
		}

		internal void Assign(SilkNSQState other)
		{
			sLF_AR_shp_Q14 = other.sLF_AR_shp_Q14;
			lagPrev = other.lagPrev;
			sLTP_buf_idx = other.sLTP_buf_idx;
			sLTP_shp_buf_idx = other.sLTP_shp_buf_idx;
			rand_seed = other.rand_seed;
			prev_gain_Q16 = other.prev_gain_Q16;
			rewhite_flag = other.rewhite_flag;
			Array.Copy(other.xq, xq, 640);
			Array.Copy(other.sLTP_shp_Q14, sLTP_shp_Q14, 640);
			Array.Copy(other.sLPC_Q14, sLPC_Q14, 80 + SilkConstants.NSQ_LPC_BUF_LENGTH);
			Array.Copy(other.sAR2_Q14, sAR2_Q14, 16);
		}

		internal void silk_NSQ(SilkChannelEncoder psEncC, SideInfoIndices psIndices, int[] x_Q3, sbyte[] pulses, short[][] PredCoef_Q12, short[] LTPCoef_Q14, short[] AR2_Q13, int[] HarmShapeGain_Q14, int[] Tilt_Q14, int[] LF_shp_Q14, int[] Gains_Q16, int[] pitchL, int Lambda_Q10, int LTP_scale_Q14)
		{
			int num = 0;
			int num2 = 0;
			rand_seed = psIndices.Seed;
			int num3 = lagPrev;
			int offset_Q = Tables.silk_Quantization_Offsets_Q10[psIndices.signalType >> 1][psIndices.quantOffsetType];
			int num4 = ((psIndices.NLSFInterpCoef_Q2 != 4) ? 1 : 0);
			int[] sLTP_Q = new int[psEncC.ltp_mem_length + psEncC.frame_length];
			short[] array = new short[psEncC.ltp_mem_length + psEncC.frame_length];
			int[] x_sc_Q = new int[psEncC.subfr_length];
			sLTP_shp_buf_idx = psEncC.ltp_mem_length;
			sLTP_buf_idx = psEncC.ltp_mem_length;
			int num5 = psEncC.ltp_mem_length;
			for (int i = 0; i < psEncC.nb_subfr; i++)
			{
				int num6 = (i >> 1) | (1 - num4);
				int b_Q14_ptr = i * 5;
				int aR_shp_Q13_ptr = i * 16;
				int num7 = Inlines.silk_RSHIFT(HarmShapeGain_Q14[i], 2);
				num7 |= Inlines.silk_LSHIFT(Inlines.silk_RSHIFT(HarmShapeGain_Q14[i], 1), 16);
				rewhite_flag = 0;
				if (psIndices.signalType == 2)
				{
					num3 = pitchL[i];
					if ((i & (3 - Inlines.silk_LSHIFT(num4, 1))) == 0)
					{
						int num8 = psEncC.ltp_mem_length - num3 - psEncC.predictLPCOrder - 2;
						Filters.silk_LPC_analysis_filter(array, num8, xq, num8 + i * psEncC.subfr_length, PredCoef_Q12[num6], 0, psEncC.ltp_mem_length - num8, psEncC.predictLPCOrder);
						rewhite_flag = 1;
						sLTP_buf_idx = psEncC.ltp_mem_length;
					}
				}
				silk_nsq_scale_states(psEncC, x_Q3, num2, x_sc_Q, array, sLTP_Q, i, LTP_scale_Q14, Gains_Q16, pitchL, psIndices.signalType);
				silk_noise_shape_quantizer(psIndices.signalType, x_sc_Q, pulses, num, xq, num5, sLTP_Q, PredCoef_Q12[num6], LTPCoef_Q14, b_Q14_ptr, AR2_Q13, aR_shp_Q13_ptr, num3, num7, Tilt_Q14[i], LF_shp_Q14[i], Gains_Q16[i], Lambda_Q10, offset_Q, psEncC.subfr_length, psEncC.shapingLPCOrder, psEncC.predictLPCOrder);
				num2 += psEncC.subfr_length;
				num += psEncC.subfr_length;
				num5 += psEncC.subfr_length;
			}
			lagPrev = pitchL[psEncC.nb_subfr - 1];
			Arrays.MemMoveShort(xq, psEncC.frame_length, 0, psEncC.ltp_mem_length);
			Arrays.MemMoveInt(sLTP_shp_Q14, psEncC.frame_length, 0, psEncC.ltp_mem_length);
		}

		private void silk_noise_shape_quantizer(int signalType, int[] x_sc_Q10, sbyte[] pulses, int pulses_ptr, short[] xq, int xq_ptr, int[] sLTP_Q15, short[] a_Q12, short[] b_Q14, int b_Q14_ptr, short[] AR_shp_Q13, int AR_shp_Q13_ptr, int lag, int HarmShapeFIRPacked_Q14, int Tilt_Q14, int LF_shp_Q14, int Gain_Q16, int Lambda_Q10, int offset_Q10, int length, int shapingLPCOrder, int predictLPCOrder)
		{
			int num = sLTP_shp_buf_idx - lag + 1;
			int num2 = sLTP_buf_idx - lag + 2;
			int b = Inlines.silk_RSHIFT(Gain_Q16, 6);
			int num3 = SilkConstants.NSQ_LPC_BUF_LENGTH - 1;
			for (int i = 0; i < length; i++)
			{
				rand_seed = Inlines.silk_RAND(rand_seed);
				int a = Inlines.silk_RSHIFT(predictLPCOrder, 1);
				a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3], a_Q12[0]);
				a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 1], a_Q12[1]);
				a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 2], a_Q12[2]);
				a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 3], a_Q12[3]);
				a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 4], a_Q12[4]);
				a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 5], a_Q12[5]);
				a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 6], a_Q12[6]);
				a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 7], a_Q12[7]);
				a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 8], a_Q12[8]);
				a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 9], a_Q12[9]);
				if (predictLPCOrder == 16)
				{
					a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 10], a_Q12[10]);
					a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 11], a_Q12[11]);
					a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 12], a_Q12[12]);
					a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 13], a_Q12[13]);
					a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 14], a_Q12[14]);
					a = Inlines.silk_SMLAWB(a, sLPC_Q14[num3 - 15], a_Q12[15]);
				}
				int a2;
				if (signalType == 2)
				{
					a2 = 2;
					a2 = Inlines.silk_SMLAWB(a2, sLTP_Q15[num2], b_Q14[b_Q14_ptr]);
					a2 = Inlines.silk_SMLAWB(a2, sLTP_Q15[num2 - 1], b_Q14[b_Q14_ptr + 1]);
					a2 = Inlines.silk_SMLAWB(a2, sLTP_Q15[num2 - 2], b_Q14[b_Q14_ptr + 2]);
					a2 = Inlines.silk_SMLAWB(a2, sLTP_Q15[num2 - 3], b_Q14[b_Q14_ptr + 3]);
					a2 = Inlines.silk_SMLAWB(a2, sLTP_Q15[num2 - 4], b_Q14[b_Q14_ptr + 4]);
					num2++;
				}
				else
				{
					a2 = 0;
				}
				int num4 = sLPC_Q14[num3];
				int num5 = sAR2_Q14[0];
				sAR2_Q14[0] = num4;
				int a3 = Inlines.silk_RSHIFT(shapingLPCOrder, 1);
				a3 = Inlines.silk_SMLAWB(a3, num4, AR_shp_Q13[AR_shp_Q13_ptr]);
				for (int j = 2; j < shapingLPCOrder; j += 2)
				{
					num4 = sAR2_Q14[j - 1];
					sAR2_Q14[j - 1] = num5;
					a3 = Inlines.silk_SMLAWB(a3, num5, AR_shp_Q13[AR_shp_Q13_ptr + j - 1]);
					num5 = sAR2_Q14[j];
					sAR2_Q14[j] = num4;
					a3 = Inlines.silk_SMLAWB(a3, num4, AR_shp_Q13[AR_shp_Q13_ptr + j]);
				}
				sAR2_Q14[shapingLPCOrder - 1] = num5;
				a3 = Inlines.silk_SMLAWB(a3, num5, AR_shp_Q13[AR_shp_Q13_ptr + shapingLPCOrder - 1]);
				a3 = Inlines.silk_LSHIFT32(a3, 1);
				a3 = Inlines.silk_SMLAWB(a3, sLF_AR_shp_Q14, Tilt_Q14);
				int a4 = Inlines.silk_SMULWB(sLTP_shp_Q14[sLTP_shp_buf_idx - 1], LF_shp_Q14);
				a4 = Inlines.silk_SMLAWT(a4, sLF_AR_shp_Q14, LF_shp_Q14);
				num5 = Inlines.silk_SUB32(Inlines.silk_LSHIFT32(a, 2), a3);
				num5 = Inlines.silk_SUB32(num5, a4);
				if (lag > 0)
				{
					int a5 = Inlines.silk_SMULWB(Inlines.silk_ADD32(sLTP_shp_Q14[num], sLTP_shp_Q14[num - 2]), HarmShapeFIRPacked_Q14);
					a5 = Inlines.silk_SMLAWT(a5, sLTP_shp_Q14[num - 1], HarmShapeFIRPacked_Q14);
					a5 = Inlines.silk_LSHIFT(a5, 1);
					num++;
					num4 = Inlines.silk_SUB32(a2, a5);
					num5 = Inlines.silk_ADD_LSHIFT32(num4, num5, 1);
					num5 = Inlines.silk_RSHIFT_ROUND(num5, 3);
				}
				else
				{
					num5 = Inlines.silk_RSHIFT_ROUND(num5, 2);
				}
				int num6 = Inlines.silk_SUB32(x_sc_Q10[i], num5);
				if (rand_seed < 0)
				{
					num6 = -num6;
				}
				num6 = Inlines.silk_LIMIT_32(num6, -31744, 30720);
				int a6 = Inlines.silk_SUB32(num6, offset_Q10);
				int num7 = Inlines.silk_RSHIFT(a6, 10);
				int num8;
				int a7;
				int a8;
				if (num7 > 0)
				{
					a6 = Inlines.silk_SUB32(Inlines.silk_LSHIFT(num7, 10), 80);
					a6 = Inlines.silk_ADD32(a6, offset_Q10);
					num8 = Inlines.silk_ADD32(a6, 1024);
					a7 = Inlines.silk_SMULBB(a6, Lambda_Q10);
					a8 = Inlines.silk_SMULBB(num8, Lambda_Q10);
				}
				else
				{
					switch (num7)
					{
					case 0:
						a6 = offset_Q10;
						num8 = Inlines.silk_ADD32(a6, 944);
						a7 = Inlines.silk_SMULBB(a6, Lambda_Q10);
						a8 = Inlines.silk_SMULBB(num8, Lambda_Q10);
						break;
					case -1:
						num8 = offset_Q10;
						a6 = Inlines.silk_SUB32(num8, 944);
						a7 = Inlines.silk_SMULBB(-a6, Lambda_Q10);
						a8 = Inlines.silk_SMULBB(num8, Lambda_Q10);
						break;
					default:
						a6 = Inlines.silk_ADD32(Inlines.silk_LSHIFT(num7, 10), 80);
						a6 = Inlines.silk_ADD32(a6, offset_Q10);
						num8 = Inlines.silk_ADD32(a6, 1024);
						a7 = Inlines.silk_SMULBB(-a6, Lambda_Q10);
						a8 = Inlines.silk_SMULBB(-num8, Lambda_Q10);
						break;
					}
				}
				int num9 = Inlines.silk_SUB32(num6, a6);
				a7 = Inlines.silk_SMLABB(a7, num9, num9);
				num9 = Inlines.silk_SUB32(num6, num8);
				a8 = Inlines.silk_SMLABB(a8, num9, num9);
				if (a8 < a7)
				{
					a6 = num8;
				}
				pulses[pulses_ptr + i] = (sbyte)Inlines.silk_RSHIFT_ROUND(a6, 10);
				int num10 = Inlines.silk_LSHIFT(a6, 4);
				if (rand_seed < 0)
				{
					num10 = -num10;
				}
				int a9 = Inlines.silk_ADD_LSHIFT32(num10, a2, 1);
				int num11 = Inlines.silk_ADD_LSHIFT32(a9, a, 4);
				xq[xq_ptr + i] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULWW(num11, b), 8));
				num3++;
				sLPC_Q14[num3] = num11;
				int a10 = (sLF_AR_shp_Q14 = Inlines.silk_SUB_LSHIFT32(num11, a3, 2));
				sLTP_shp_Q14[sLTP_shp_buf_idx] = Inlines.silk_SUB_LSHIFT32(a10, a4, 2);
				sLTP_Q15[sLTP_buf_idx] = Inlines.silk_LSHIFT(a9, 1);
				sLTP_shp_buf_idx++;
				sLTP_buf_idx++;
				rand_seed = Inlines.silk_ADD32_ovflw(rand_seed, pulses[pulses_ptr + i]);
			}
			Array.Copy(sLPC_Q14, length, sLPC_Q14, 0, SilkConstants.NSQ_LPC_BUF_LENGTH);
		}

		private void silk_nsq_scale_states(SilkChannelEncoder psEncC, int[] x_Q3, int x_Q3_ptr, int[] x_sc_Q10, short[] sLTP, int[] sLTP_Q15, int subfr, int LTP_scale_Q14, int[] Gains_Q16, int[] pitchL, int signal_type)
		{
			int num = pitchL[subfr];
			int num2 = Inlines.silk_INVERSE32_varQ(Inlines.silk_max(Gains_Q16[subfr], 1), 47);
			int num3 = ((Gains_Q16[subfr] == prev_gain_Q16) ? 65536 : Inlines.silk_DIV32_varQ(prev_gain_Q16, Gains_Q16[subfr], 16));
			int b = Inlines.silk_RSHIFT_ROUND(num2, 8);
			for (int i = 0; i < psEncC.subfr_length; i++)
			{
				x_sc_Q10[i] = Inlines.silk_SMULWW(x_Q3[x_Q3_ptr + i], b);
			}
			prev_gain_Q16 = Gains_Q16[subfr];
			if (rewhite_flag != 0)
			{
				if (subfr == 0)
				{
					num2 = Inlines.silk_LSHIFT(Inlines.silk_SMULWB(num2, LTP_scale_Q14), 2);
				}
				for (int i = sLTP_buf_idx - num - 2; i < sLTP_buf_idx; i++)
				{
					sLTP_Q15[i] = Inlines.silk_SMULWB(num2, sLTP[i]);
				}
			}
			if (num3 == 65536)
			{
				return;
			}
			for (int i = sLTP_shp_buf_idx - psEncC.ltp_mem_length; i < sLTP_shp_buf_idx; i++)
			{
				sLTP_shp_Q14[i] = Inlines.silk_SMULWW(num3, sLTP_shp_Q14[i]);
			}
			if (signal_type == 2 && rewhite_flag == 0)
			{
				for (int i = sLTP_buf_idx - num - 2; i < sLTP_buf_idx; i++)
				{
					sLTP_Q15[i] = Inlines.silk_SMULWW(num3, sLTP_Q15[i]);
				}
			}
			sLF_AR_shp_Q14 = Inlines.silk_SMULWW(num3, sLF_AR_shp_Q14);
			for (int i = 0; i < SilkConstants.NSQ_LPC_BUF_LENGTH; i++)
			{
				sLPC_Q14[i] = Inlines.silk_SMULWW(num3, sLPC_Q14[i]);
			}
			for (int i = 0; i < 16; i++)
			{
				sAR2_Q14[i] = Inlines.silk_SMULWW(num3, sAR2_Q14[i]);
			}
		}

		internal void silk_NSQ_del_dec(SilkChannelEncoder psEncC, SideInfoIndices psIndices, int[] x_Q3, sbyte[] pulses, short[][] PredCoef_Q12, short[] LTPCoef_Q14, short[] AR2_Q13, int[] HarmShapeGain_Q14, int[] Tilt_Q14, int[] LF_shp_Q14, int[] Gains_Q16, int[] pitchL, int Lambda_Q10, int LTP_scale_Q14)
		{
			int num = 0;
			int num2 = 0;
			int num3 = lagPrev;
			NSQ_del_dec_struct[] array = new NSQ_del_dec_struct[psEncC.nStatesDelayedDecision];
			for (int i = 0; i < psEncC.nStatesDelayedDecision; i++)
			{
				array[i] = new NSQ_del_dec_struct(psEncC.shapingLPCOrder);
			}
			NSQ_del_dec_struct nSQ_del_dec_struct;
			for (int j = 0; j < psEncC.nStatesDelayedDecision; j++)
			{
				nSQ_del_dec_struct = array[j];
				nSQ_del_dec_struct.Seed = (j + psIndices.Seed) & 3;
				nSQ_del_dec_struct.SeedInit = nSQ_del_dec_struct.Seed;
				nSQ_del_dec_struct.RD_Q10 = 0;
				nSQ_del_dec_struct.LF_AR_Q14 = sLF_AR_shp_Q14;
				nSQ_del_dec_struct.Shape_Q14[0] = sLTP_shp_Q14[psEncC.ltp_mem_length - 1];
				Array.Copy(sLPC_Q14, nSQ_del_dec_struct.sLPC_Q14, SilkConstants.NSQ_LPC_BUF_LENGTH);
				Array.Copy(sAR2_Q14, nSQ_del_dec_struct.sAR2_Q14, psEncC.shapingLPCOrder);
			}
			int offset_Q = Tables.silk_Quantization_Offsets_Q10[psIndices.signalType >> 1][psIndices.quantOffsetType];
			int num4 = 0;
			int num5 = Inlines.silk_min_int(32, psEncC.subfr_length);
			if (psIndices.signalType == 2)
			{
				for (int j = 0; j < psEncC.nb_subfr; j++)
				{
					num5 = Inlines.silk_min_int(num5, pitchL[j] - 2 - 1);
				}
			}
			else if (num3 > 0)
			{
				num5 = Inlines.silk_min_int(num5, num3 - 2 - 1);
			}
			int num6 = ((psIndices.NLSFInterpCoef_Q2 != 4) ? 1 : 0);
			int[] sLTP_Q = new int[psEncC.ltp_mem_length + psEncC.frame_length];
			short[] array2 = new short[psEncC.ltp_mem_length + psEncC.frame_length];
			int[] array3 = new int[psEncC.subfr_length];
			int[] delayedGain_Q = new int[32];
			int num7 = psEncC.ltp_mem_length;
			sLTP_shp_buf_idx = psEncC.ltp_mem_length;
			sLTP_buf_idx = psEncC.ltp_mem_length;
			int num8 = 0;
			int rD_Q;
			int num11;
			int num12;
			for (int j = 0; j < psEncC.nb_subfr; j++)
			{
				int num9 = (j >> 1) | (1 - num6);
				int num10 = Inlines.silk_RSHIFT(HarmShapeGain_Q14[j], 2);
				num10 |= Inlines.silk_LSHIFT(Inlines.silk_RSHIFT(HarmShapeGain_Q14[j], 1), 16);
				rewhite_flag = 0;
				if (psIndices.signalType == 2)
				{
					num3 = pitchL[j];
					if ((j & (3 - Inlines.silk_LSHIFT(num6, 1))) == 0)
					{
						if (j == 2)
						{
							rD_Q = array[0].RD_Q10;
							num11 = 0;
							for (int k = 1; k < psEncC.nStatesDelayedDecision; k++)
							{
								if (array[k].RD_Q10 < rD_Q)
								{
									rD_Q = array[k].RD_Q10;
									num11 = k;
								}
							}
							for (int k = 0; k < psEncC.nStatesDelayedDecision; k++)
							{
								if (k != num11)
								{
									array[k].RD_Q10 += 134217727;
								}
							}
							nSQ_del_dec_struct = array[num11];
							num12 = num4 + num5;
							for (int k = 0; k < num5; k++)
							{
								num12 = (num12 - 1) & 0x1F;
								pulses[num + k - num5] = (sbyte)Inlines.silk_RSHIFT_ROUND(nSQ_del_dec_struct.Q_Q10[num12], 10);
								xq[num7 + k - num5] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULWW(nSQ_del_dec_struct.Xq_Q14[num12], Gains_Q16[1]), 14));
								sLTP_shp_Q14[sLTP_shp_buf_idx - num5 + k] = nSQ_del_dec_struct.Shape_Q14[num12];
							}
							num8 = 0;
						}
						int num13 = psEncC.ltp_mem_length - num3 - psEncC.predictLPCOrder - 2;
						Filters.silk_LPC_analysis_filter(array2, num13, xq, num13 + j * psEncC.subfr_length, PredCoef_Q12[num9], 0, psEncC.ltp_mem_length - num13, psEncC.predictLPCOrder);
						sLTP_buf_idx = psEncC.ltp_mem_length;
						rewhite_flag = 1;
					}
				}
				silk_nsq_del_dec_scale_states(psEncC, array, x_Q3, num2, array3, array2, sLTP_Q, j, psEncC.nStatesDelayedDecision, LTP_scale_Q14, Gains_Q16, pitchL, psIndices.signalType, num5);
				BoxedValueInt boxedValueInt = new BoxedValueInt(num4);
				silk_noise_shape_quantizer_del_dec(array, psIndices.signalType, array3, pulses, num, xq, num7, sLTP_Q, delayedGain_Q, PredCoef_Q12[num9], LTPCoef_Q14, j * 5, AR2_Q13, j * 16, num3, num10, Tilt_Q14[j], LF_shp_Q14[j], Gains_Q16[j], Lambda_Q10, offset_Q, psEncC.subfr_length, num8++, psEncC.shapingLPCOrder, psEncC.predictLPCOrder, psEncC.warping_Q16, psEncC.nStatesDelayedDecision, boxedValueInt, num5);
				num4 = boxedValueInt.Val;
				num2 += psEncC.subfr_length;
				num += psEncC.subfr_length;
				num7 += psEncC.subfr_length;
			}
			rD_Q = array[0].RD_Q10;
			num11 = 0;
			for (int j = 1; j < psEncC.nStatesDelayedDecision; j++)
			{
				if (array[j].RD_Q10 < rD_Q)
				{
					rD_Q = array[j].RD_Q10;
					num11 = j;
				}
			}
			nSQ_del_dec_struct = array[num11];
			psIndices.Seed = (sbyte)nSQ_del_dec_struct.SeedInit;
			num12 = num4 + num5;
			int b = Inlines.silk_RSHIFT32(Gains_Q16[psEncC.nb_subfr - 1], 6);
			for (int k = 0; k < num5; k++)
			{
				num12 = (num12 - 1) & 0x1F;
				pulses[num + k - num5] = (sbyte)Inlines.silk_RSHIFT_ROUND(nSQ_del_dec_struct.Q_Q10[num12], 10);
				xq[num7 + k - num5] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULWW(nSQ_del_dec_struct.Xq_Q14[num12], b), 8));
				sLTP_shp_Q14[sLTP_shp_buf_idx - num5 + k] = nSQ_del_dec_struct.Shape_Q14[num12];
			}
			Array.Copy(nSQ_del_dec_struct.sLPC_Q14, psEncC.subfr_length, sLPC_Q14, 0, SilkConstants.NSQ_LPC_BUF_LENGTH);
			Array.Copy(nSQ_del_dec_struct.sAR2_Q14, 0, sAR2_Q14, 0, psEncC.shapingLPCOrder);
			sLF_AR_shp_Q14 = nSQ_del_dec_struct.LF_AR_Q14;
			lagPrev = pitchL[psEncC.nb_subfr - 1];
			Arrays.MemMoveShort(xq, psEncC.frame_length, 0, psEncC.ltp_mem_length);
			Arrays.MemMoveInt(sLTP_shp_Q14, psEncC.frame_length, 0, psEncC.ltp_mem_length);
		}

		private void silk_noise_shape_quantizer_del_dec(NSQ_del_dec_struct[] psDelDec, int signalType, int[] x_Q10, sbyte[] pulses, int pulses_ptr, short[] xq, int xq_ptr, int[] sLTP_Q15, int[] delayedGain_Q10, short[] a_Q12, short[] b_Q14, int b_Q14_ptr, short[] AR_shp_Q13, int AR_shp_Q13_ptr, int lag, int HarmShapeFIRPacked_Q14, int Tilt_Q14, int LF_shp_Q14, int Gain_Q16, int Lambda_Q10, int offset_Q10, int length, int subfr, int shapingLPCOrder, int predictLPCOrder, int warping_Q16, int nStatesDelayedDecision, BoxedValueInt smpl_buf_idx, int decisionDelay)
		{
			NSQ_sample_struct[] array = new NSQ_sample_struct[2 * nStatesDelayedDecision];
			for (int i = 0; i < 2 * nStatesDelayedDecision; i++)
			{
				array[i] = default(NSQ_sample_struct);
			}
			int num = sLTP_shp_buf_idx - lag + 1;
			int num2 = sLTP_buf_idx - lag + 2;
			int num3 = Inlines.silk_RSHIFT(Gain_Q16, 6);
			for (int j = 0; j < length; j++)
			{
				int a;
				if (signalType == 2)
				{
					a = 2;
					a = Inlines.silk_SMLAWB(a, sLTP_Q15[num2], b_Q14[b_Q14_ptr]);
					a = Inlines.silk_SMLAWB(a, sLTP_Q15[num2 - 1], b_Q14[b_Q14_ptr + 1]);
					a = Inlines.silk_SMLAWB(a, sLTP_Q15[num2 - 2], b_Q14[b_Q14_ptr + 2]);
					a = Inlines.silk_SMLAWB(a, sLTP_Q15[num2 - 3], b_Q14[b_Q14_ptr + 3]);
					a = Inlines.silk_SMLAWB(a, sLTP_Q15[num2 - 4], b_Q14[b_Q14_ptr + 4]);
					a = Inlines.silk_LSHIFT(a, 1);
					num2++;
				}
				else
				{
					a = 0;
				}
				int a2;
				if (lag > 0)
				{
					a2 = Inlines.silk_SMULWB(Inlines.silk_ADD32(sLTP_shp_Q14[num], sLTP_shp_Q14[num - 2]), HarmShapeFIRPacked_Q14);
					a2 = Inlines.silk_SMLAWT(a2, sLTP_shp_Q14[num - 1], HarmShapeFIRPacked_Q14);
					a2 = Inlines.silk_SUB_LSHIFT32(a, a2, 2);
					num++;
				}
				else
				{
					a2 = 0;
				}
				NSQ_del_dec_struct nSQ_del_dec_struct;
				for (int k = 0; k < nStatesDelayedDecision; k++)
				{
					nSQ_del_dec_struct = psDelDec[k];
					int[] array2 = nSQ_del_dec_struct.sAR2_Q14;
					int num4 = 2 * k;
					int num5 = num4 + 1;
					nSQ_del_dec_struct.Seed = Inlines.silk_RAND(nSQ_del_dec_struct.Seed);
					int num6 = SilkConstants.NSQ_LPC_BUF_LENGTH - 1 + j;
					int a3 = Inlines.silk_RSHIFT(predictLPCOrder, 1);
					a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6], a_Q12[0]);
					a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 1], a_Q12[1]);
					a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 2], a_Q12[2]);
					a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 3], a_Q12[3]);
					a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 4], a_Q12[4]);
					a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 5], a_Q12[5]);
					a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 6], a_Q12[6]);
					a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 7], a_Q12[7]);
					a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 8], a_Q12[8]);
					a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 9], a_Q12[9]);
					if (predictLPCOrder == 16)
					{
						a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 10], a_Q12[10]);
						a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 11], a_Q12[11]);
						a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 12], a_Q12[12]);
						a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 13], a_Q12[13]);
						a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 14], a_Q12[14]);
						a3 = Inlines.silk_SMLAWB(a3, nSQ_del_dec_struct.sLPC_Q14[num6 - 15], a_Q12[15]);
					}
					a3 = Inlines.silk_LSHIFT(a3, 4);
					int num7 = Inlines.silk_SMLAWB(nSQ_del_dec_struct.sLPC_Q14[num6], array2[0], warping_Q16);
					int num8 = Inlines.silk_SMLAWB(array2[0], array2[1] - num7, warping_Q16);
					array2[0] = num7;
					int a4 = Inlines.silk_RSHIFT(shapingLPCOrder, 1);
					a4 = Inlines.silk_SMLAWB(a4, num7, AR_shp_Q13[AR_shp_Q13_ptr]);
					for (int l = 2; l < shapingLPCOrder; l += 2)
					{
						num7 = Inlines.silk_SMLAWB(array2[l - 1], array2[l] - num8, warping_Q16);
						array2[l - 1] = num8;
						a4 = Inlines.silk_SMLAWB(a4, num8, AR_shp_Q13[AR_shp_Q13_ptr + l - 1]);
						num8 = Inlines.silk_SMLAWB(array2[l], array2[l + 1] - num7, warping_Q16);
						array2[l] = num7;
						a4 = Inlines.silk_SMLAWB(a4, num7, AR_shp_Q13[AR_shp_Q13_ptr + l]);
					}
					array2[shapingLPCOrder - 1] = num8;
					a4 = Inlines.silk_SMLAWB(a4, num8, AR_shp_Q13[AR_shp_Q13_ptr + shapingLPCOrder - 1]);
					a4 = Inlines.silk_LSHIFT(a4, 1);
					a4 = Inlines.silk_SMLAWB(a4, nSQ_del_dec_struct.LF_AR_Q14, Tilt_Q14);
					a4 = Inlines.silk_LSHIFT(a4, 2);
					int a5 = Inlines.silk_SMULWB(nSQ_del_dec_struct.Shape_Q14[smpl_buf_idx.Val], LF_shp_Q14);
					a5 = Inlines.silk_SMLAWT(a5, nSQ_del_dec_struct.LF_AR_Q14, LF_shp_Q14);
					a5 = Inlines.silk_LSHIFT(a5, 2);
					num8 = Inlines.silk_ADD32(a4, a5);
					num7 = Inlines.silk_ADD32(a2, a3);
					num8 = Inlines.silk_SUB32(num7, num8);
					num8 = Inlines.silk_RSHIFT_ROUND(num8, 4);
					int num9 = Inlines.silk_SUB32(x_Q10[j], num8);
					if (nSQ_del_dec_struct.Seed < 0)
					{
						num9 = -num9;
					}
					num9 = Inlines.silk_LIMIT_32(num9, -31744, 30720);
					int a6 = Inlines.silk_SUB32(num9, offset_Q10);
					int num10 = Inlines.silk_RSHIFT(a6, 10);
					int num11;
					int a7;
					int a8;
					if (num10 > 0)
					{
						a6 = Inlines.silk_SUB32(Inlines.silk_LSHIFT(num10, 10), 80);
						a6 = Inlines.silk_ADD32(a6, offset_Q10);
						num11 = Inlines.silk_ADD32(a6, 1024);
						a7 = Inlines.silk_SMULBB(a6, Lambda_Q10);
						a8 = Inlines.silk_SMULBB(num11, Lambda_Q10);
					}
					else
					{
						switch (num10)
						{
						case 0:
							a6 = offset_Q10;
							num11 = Inlines.silk_ADD32(a6, 944);
							a7 = Inlines.silk_SMULBB(a6, Lambda_Q10);
							a8 = Inlines.silk_SMULBB(num11, Lambda_Q10);
							break;
						case -1:
							num11 = offset_Q10;
							a6 = Inlines.silk_SUB32(num11, 944);
							a7 = Inlines.silk_SMULBB(-a6, Lambda_Q10);
							a8 = Inlines.silk_SMULBB(num11, Lambda_Q10);
							break;
						default:
							a6 = Inlines.silk_ADD32(Inlines.silk_LSHIFT(num10, 10), 80);
							a6 = Inlines.silk_ADD32(a6, offset_Q10);
							num11 = Inlines.silk_ADD32(a6, 1024);
							a7 = Inlines.silk_SMULBB(-a6, Lambda_Q10);
							a8 = Inlines.silk_SMULBB(-num11, Lambda_Q10);
							break;
						}
					}
					int num12 = Inlines.silk_SUB32(num9, a6);
					a7 = Inlines.silk_RSHIFT(Inlines.silk_SMLABB(a7, num12, num12), 10);
					num12 = Inlines.silk_SUB32(num9, num11);
					a8 = Inlines.silk_RSHIFT(Inlines.silk_SMLABB(a8, num12, num12), 10);
					if (a7 < a8)
					{
						array[num4].RD_Q10 = Inlines.silk_ADD32(nSQ_del_dec_struct.RD_Q10, a7);
						array[num5].RD_Q10 = Inlines.silk_ADD32(nSQ_del_dec_struct.RD_Q10, a8);
						array[num4].Q_Q10 = a6;
						array[num5].Q_Q10 = num11;
					}
					else
					{
						array[num4].RD_Q10 = Inlines.silk_ADD32(nSQ_del_dec_struct.RD_Q10, a8);
						array[num5].RD_Q10 = Inlines.silk_ADD32(nSQ_del_dec_struct.RD_Q10, a7);
						array[num4].Q_Q10 = num11;
						array[num5].Q_Q10 = a6;
					}
					int num13 = Inlines.silk_LSHIFT32(array[num4].Q_Q10, 4);
					if (nSQ_del_dec_struct.Seed < 0)
					{
						num13 = -num13;
					}
					int num14 = Inlines.silk_ADD32(num13, a);
					int num15 = Inlines.silk_ADD32(num14, a3);
					int num16 = Inlines.silk_SUB32(num15, a4);
					array[num4].sLTP_shp_Q14 = Inlines.silk_SUB32(num16, a5);
					array[num4].LF_AR_Q14 = num16;
					array[num4].LPC_exc_Q14 = num14;
					array[num4].xq_Q14 = num15;
					num13 = Inlines.silk_LSHIFT32(array[num5].Q_Q10, 4);
					if (nSQ_del_dec_struct.Seed < 0)
					{
						num13 = -num13;
					}
					num14 = Inlines.silk_ADD32(num13, a);
					num15 = Inlines.silk_ADD32(num14, a3);
					num16 = Inlines.silk_SUB32(num15, a4);
					array[num5].sLTP_shp_Q14 = Inlines.silk_SUB32(num16, a5);
					array[num5].LF_AR_Q14 = num16;
					array[num5].LPC_exc_Q14 = num14;
					array[num5].xq_Q14 = num15;
				}
				smpl_buf_idx.Val = (smpl_buf_idx.Val - 1) & 0x1F;
				int num17 = (smpl_buf_idx.Val + decisionDelay) & 0x1F;
				int rD_Q = array[0].RD_Q10;
				int num18 = 0;
				for (int k = 1; k < nStatesDelayedDecision; k++)
				{
					if (array[k * 2].RD_Q10 < rD_Q)
					{
						rD_Q = array[k * 2].RD_Q10;
						num18 = k;
					}
				}
				int num19 = psDelDec[num18].RandState[num17];
				for (int k = 0; k < nStatesDelayedDecision; k++)
				{
					if (psDelDec[k].RandState[num17] != num19)
					{
						int num20 = k * 2;
						array[num20].RD_Q10 = Inlines.silk_ADD32(array[num20].RD_Q10, 134217727);
						array[num20 + 1].RD_Q10 = Inlines.silk_ADD32(array[num20 + 1].RD_Q10, 134217727);
					}
				}
				int rD_Q2 = array[0].RD_Q10;
				rD_Q = array[1].RD_Q10;
				int num21 = 0;
				int num22 = 0;
				for (int k = 1; k < nStatesDelayedDecision; k++)
				{
					int num23 = k * 2;
					if (array[num23].RD_Q10 > rD_Q2)
					{
						rD_Q2 = array[num23].RD_Q10;
						num21 = k;
					}
					if (array[num23 + 1].RD_Q10 < rD_Q)
					{
						rD_Q = array[num23 + 1].RD_Q10;
						num22 = k;
					}
				}
				if (rD_Q < rD_Q2)
				{
					psDelDec[num21].PartialCopyFrom(psDelDec[num22], j);
					array[num21 * 2] = array[num22 * 2 + 1];
				}
				nSQ_del_dec_struct = psDelDec[num18];
				if (subfr > 0 || j >= decisionDelay)
				{
					pulses[pulses_ptr + j - decisionDelay] = (sbyte)Inlines.silk_RSHIFT_ROUND(nSQ_del_dec_struct.Q_Q10[num17], 10);
					xq[xq_ptr + j - decisionDelay] = (short)Inlines.silk_SAT16(Inlines.silk_RSHIFT_ROUND(Inlines.silk_SMULWW(nSQ_del_dec_struct.Xq_Q14[num17], delayedGain_Q10[num17]), 8));
					sLTP_shp_Q14[sLTP_shp_buf_idx - decisionDelay] = nSQ_del_dec_struct.Shape_Q14[num17];
					sLTP_Q15[sLTP_buf_idx - decisionDelay] = nSQ_del_dec_struct.Pred_Q15[num17];
				}
				sLTP_shp_buf_idx++;
				sLTP_buf_idx++;
				for (int k = 0; k < nStatesDelayedDecision; k++)
				{
					nSQ_del_dec_struct = psDelDec[k];
					int num4 = k * 2;
					nSQ_del_dec_struct.LF_AR_Q14 = array[num4].LF_AR_Q14;
					nSQ_del_dec_struct.sLPC_Q14[SilkConstants.NSQ_LPC_BUF_LENGTH + j] = array[num4].xq_Q14;
					nSQ_del_dec_struct.Xq_Q14[smpl_buf_idx.Val] = array[num4].xq_Q14;
					nSQ_del_dec_struct.Q_Q10[smpl_buf_idx.Val] = array[num4].Q_Q10;
					nSQ_del_dec_struct.Pred_Q15[smpl_buf_idx.Val] = Inlines.silk_LSHIFT32(array[num4].LPC_exc_Q14, 1);
					nSQ_del_dec_struct.Shape_Q14[smpl_buf_idx.Val] = array[num4].sLTP_shp_Q14;
					nSQ_del_dec_struct.Seed = Inlines.silk_ADD32_ovflw(nSQ_del_dec_struct.Seed, Inlines.silk_RSHIFT_ROUND(array[num4].Q_Q10, 10));
					nSQ_del_dec_struct.RandState[smpl_buf_idx.Val] = nSQ_del_dec_struct.Seed;
					nSQ_del_dec_struct.RD_Q10 = array[num4].RD_Q10;
				}
				delayedGain_Q10[smpl_buf_idx.Val] = num3;
			}
			for (int k = 0; k < nStatesDelayedDecision; k++)
			{
				NSQ_del_dec_struct nSQ_del_dec_struct = psDelDec[k];
				Buffer.BlockCopy(nSQ_del_dec_struct.sLPC_Q14, length * 4, nSQ_del_dec_struct.sLPC_Q14, 0, SilkConstants.NSQ_LPC_BUF_LENGTH * 4);
			}
		}

		private void silk_nsq_del_dec_scale_states(SilkChannelEncoder psEncC, NSQ_del_dec_struct[] psDelDec, int[] x_Q3, int x_Q3_ptr, int[] x_sc_Q10, short[] sLTP, int[] sLTP_Q15, int subfr, int nStatesDelayedDecision, int LTP_scale_Q14, int[] Gains_Q16, int[] pitchL, int signal_type, int decisionDelay)
		{
			int num = pitchL[subfr];
			int num2 = Inlines.silk_INVERSE32_varQ(Inlines.silk_max(Gains_Q16[subfr], 1), 47);
			int num3 = ((Gains_Q16[subfr] == prev_gain_Q16) ? 65536 : Inlines.silk_DIV32_varQ(prev_gain_Q16, Gains_Q16[subfr], 16));
			int b = Inlines.silk_RSHIFT_ROUND(num2, 8);
			for (int i = 0; i < psEncC.subfr_length; i++)
			{
				x_sc_Q10[i] = Inlines.silk_SMULWW(x_Q3[x_Q3_ptr + i], b);
			}
			prev_gain_Q16 = Gains_Q16[subfr];
			if (rewhite_flag != 0)
			{
				if (subfr == 0)
				{
					num2 = Inlines.silk_LSHIFT(Inlines.silk_SMULWB(num2, LTP_scale_Q14), 2);
				}
				for (int i = sLTP_buf_idx - num - 2; i < sLTP_buf_idx; i++)
				{
					sLTP_Q15[i] = Inlines.silk_SMULWB(num2, sLTP[i]);
				}
			}
			if (num3 == 65536)
			{
				return;
			}
			for (int i = sLTP_shp_buf_idx - psEncC.ltp_mem_length; i < sLTP_shp_buf_idx; i++)
			{
				sLTP_shp_Q14[i] = Inlines.silk_SMULWW(num3, sLTP_shp_Q14[i]);
			}
			if (signal_type == 2 && rewhite_flag == 0)
			{
				for (int i = sLTP_buf_idx - num - 2; i < sLTP_buf_idx - decisionDelay; i++)
				{
					sLTP_Q15[i] = Inlines.silk_SMULWW(num3, sLTP_Q15[i]);
				}
			}
			for (int j = 0; j < nStatesDelayedDecision; j++)
			{
				NSQ_del_dec_struct nSQ_del_dec_struct = psDelDec[j];
				nSQ_del_dec_struct.LF_AR_Q14 = Inlines.silk_SMULWW(num3, nSQ_del_dec_struct.LF_AR_Q14);
				for (int i = 0; i < SilkConstants.NSQ_LPC_BUF_LENGTH; i++)
				{
					nSQ_del_dec_struct.sLPC_Q14[i] = Inlines.silk_SMULWW(num3, nSQ_del_dec_struct.sLPC_Q14[i]);
				}
				for (int i = 0; i < psEncC.shapingLPCOrder; i++)
				{
					nSQ_del_dec_struct.sAR2_Q14[i] = Inlines.silk_SMULWW(num3, nSQ_del_dec_struct.sAR2_Q14[i]);
				}
				for (int i = 0; i < 32; i++)
				{
					nSQ_del_dec_struct.Pred_Q15[i] = Inlines.silk_SMULWW(num3, nSQ_del_dec_struct.Pred_Q15[i]);
					nSQ_del_dec_struct.Shape_Q14[i] = Inlines.silk_SMULWW(num3, nSQ_del_dec_struct.Shape_Q14[i]);
				}
			}
		}
	}
	internal class SilkPrefilterState
	{
		internal readonly short[] sLTP_shp = new short[512];

		internal readonly int[] sAR_shp = new int[17];

		internal int sLTP_shp_buf_idx;

		internal int sLF_AR_shp_Q12;

		internal int sLF_MA_shp_Q12;

		internal int sHarmHP_Q2;

		internal int rand_seed;

		internal int lagPrev;

		internal SilkPrefilterState()
		{
		}

		internal void Reset()
		{
			Arrays.MemSetShort(sLTP_shp, 0, 512);
			Arrays.MemSetInt(sAR_shp, 0, 17);
			sLTP_shp_buf_idx = 0;
			sLF_AR_shp_Q12 = 0;
			sLF_MA_shp_Q12 = 0;
			sHarmHP_Q2 = 0;
			rand_seed = 0;
			lagPrev = 0;
		}
	}
	internal class SilkResamplerState
	{
		internal readonly int[] sIIR = new int[6];

		internal readonly int[] sFIR_i32 = new int[36];

		internal readonly short[] sFIR_i16 = new short[36];

		internal readonly short[] delayBuf = new short[48];

		internal int resampler_function;

		internal int batchSize;

		internal int invRatio_Q16;

		internal int FIR_Order;

		internal int FIR_Fracs;

		internal int Fs_in_kHz;

		internal int Fs_out_kHz;

		internal int inputDelay;

		internal short[] Coefs;

		internal void Reset()
		{
			Arrays.MemSetInt(sIIR, 0, 6);
			Arrays.MemSetInt(sFIR_i32, 0, 36);
			Arrays.MemSetShort(sFIR_i16, 0, 36);
			Arrays.MemSetShort(delayBuf, 0, 48);
			resampler_function = 0;
			batchSize = 0;
			invRatio_Q16 = 0;
			FIR_Order = 0;
			FIR_Fracs = 0;
			Fs_in_kHz = 0;
			Fs_out_kHz = 0;
			inputDelay = 0;
			Coefs = null;
		}

		internal void Assign(SilkResamplerState other)
		{
			resampler_function = other.resampler_function;
			batchSize = other.batchSize;
			invRatio_Q16 = other.invRatio_Q16;
			FIR_Order = other.FIR_Order;
			FIR_Fracs = other.FIR_Fracs;
			Fs_in_kHz = other.Fs_in_kHz;
			Fs_out_kHz = other.Fs_out_kHz;
			inputDelay = other.inputDelay;
			Coefs = other.Coefs;
			Array.Copy(other.sIIR, sIIR, 6);
			Array.Copy(other.sFIR_i32, sFIR_i32, 36);
			Array.Copy(other.sFIR_i16, sFIR_i16, 36);
			Array.Copy(other.delayBuf, delayBuf, 48);
		}
	}
	internal class SilkShapeState
	{
		internal sbyte LastGainIndex;

		internal int HarmBoost_smth_Q16;

		internal int HarmShapeGain_smth_Q16;

		internal int Tilt_smth_Q16;

		internal void Reset()
		{
			LastGainIndex = 0;
			HarmBoost_smth_Q16 = 0;
			HarmShapeGain_smth_Q16 = 0;
			Tilt_smth_Q16 = 0;
		}
	}
	internal class SilkVADState
	{
		internal readonly int[] AnaState = new int[2];

		internal readonly int[] AnaState1 = new int[2];

		internal readonly int[] AnaState2 = new int[2];

		internal readonly int[] XnrgSubfr = new int[4];

		internal readonly int[] NrgRatioSmth_Q8 = new int[4];

		internal short HPstate;

		internal readonly int[] NL = new int[4];

		internal readonly int[] inv_NL = new int[4];

		internal readonly int[] NoiseLevelBias = new int[4];

		internal int counter;

		internal void Reset()
		{
			Arrays.MemSetInt(AnaState, 0, 2);
			Arrays.MemSetInt(AnaState1, 0, 2);
			Arrays.MemSetInt(AnaState2, 0, 2);
			Arrays.MemSetInt(XnrgSubfr, 0, 4);
			Arrays.MemSetInt(NrgRatioSmth_Q8, 0, 4);
			HPstate = 0;
			Arrays.MemSetInt(NL, 0, 4);
			Arrays.MemSetInt(inv_NL, 0, 4);
			Arrays.MemSetInt(NoiseLevelBias, 0, 4);
			counter = 0;
		}
	}
	internal class StereoDecodeState
	{
		internal readonly short[] pred_prev_Q13 = new short[2];

		internal readonly short[] sMid = new short[2];

		internal readonly short[] sSide = new short[2];

		internal void Reset()
		{
			Arrays.MemSetShort(pred_prev_Q13, 0, 2);
			Arrays.MemSetShort(sMid, 0, 2);
			Arrays.MemSetShort(sSide, 0, 2);
		}
	}
	internal class StereoEncodeState
	{
		internal readonly short[] pred_prev_Q13 = new short[2];

		internal readonly short[] sMid = new short[2];

		internal readonly short[] sSide = new short[2];

		internal readonly int[] mid_side_amp_Q0 = new int[4];

		internal short smth_width_Q14;

		internal short width_prev_Q14;

		internal short silent_side_len;

		internal readonly sbyte[][][] predIx = Arrays.InitThreeDimensionalArray<sbyte>(3, 2, 3);

		internal readonly sbyte[] mid_only_flags = new sbyte[3];

		internal void Reset()
		{
			Arrays.MemSetShort(pred_prev_Q13, 0, 2);
			Arrays.MemSetShort(sMid, 0, 2);
			Arrays.MemSetShort(sSide, 0, 2);
			Arrays.MemSetInt(mid_side_amp_Q0, 0, 4);
			smth_width_Q14 = 0;
			width_prev_Q14 = 0;
			silent_side_len = 0;
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 2; j++)
				{
					Arrays.MemSetSbyte(predIx[i][j], 0, 3);
				}
			}
			Arrays.MemSetSbyte(mid_only_flags, 0, 3);
		}
	}
	internal class TOCStruct
	{
		internal int VADFlag;

		internal readonly int[] VADFlags = new int[3];

		internal int inbandFECFlag;

		internal void Reset()
		{
			VADFlag = 0;
			Arrays.MemSetInt(VADFlags, 0, 3);
			inbandFECFlag = 0;
		}
	}
}
namespace Concentus.Silk.Enums
{
	internal static class DecoderAPIFlag
	{
		public const int FLAG_DECODE_NORMAL = 0;

		public const int FLAG_PACKET_LOST = 1;

		public const int FLAG_DECODE_LBRR = 2;
	}
	internal static class SilkError
	{
		internal static int SILK_NO_ERROR = 0;

		internal static int SILK_ENC_INPUT_INVALID_NO_OF_SAMPLES = -101;

		internal static int SILK_ENC_FS_NOT_SUPPORTED = -102;

		internal static int SILK_ENC_PACKET_SIZE_NOT_SUPPORTED = -103;

		internal static int SILK_ENC_PAYLOAD_BUF_TOO_SHORT = -104;

		internal static int SILK_ENC_INVALID_LOSS_RATE = -105;

		internal static int SILK_ENC_INVALID_COMPLEXITY_SETTING = -106;

		internal static int SILK_ENC_INVALID_INBAND_FEC_SETTING = -107;

		internal static int SILK_ENC_INVALID_DTX_SETTING = -108;

		internal static int SILK_ENC_INVALID_CBR_SETTING = -109;

		internal static int SILK_ENC_INTERNAL_ERROR = -110;

		internal static int SILK_ENC_INVALID_NUMBER_OF_CHANNELS_ERROR = -111;

		internal static int SILK_DEC_INVALID_SAMPLING_FREQUENCY = -200;

		internal static int SILK_DEC_PAYLOAD_TOO_LARGE = -201;

		internal static int SILK_DEC_PAYLOAD_ERROR = -202;

		internal static int SILK_DEC_INVALID_FRAME_SIZE = -203;
	}
}
namespace Concentus.Structs
{
	internal class ChannelLayout
	{
		internal int nb_channels;

		internal int nb_streams;

		internal int nb_coupled_streams;

		internal readonly byte[] mapping = new byte[256];

		internal void Reset()
		{
			nb_channels = 0;
			nb_streams = 0;
			nb_coupled_streams = 0;
			Arrays.MemSetByte(mapping, 0);
		}
	}
	internal class MLP
	{
		internal int layers;

		internal int[] topo;

		internal float[] weights;
	}
	internal class OpusDecoder
	{
		internal int channels;

		internal int Fs;

		internal readonly DecControlState DecControl = new DecControlState();

		internal int decode_gain;

		internal int stream_channels;

		internal OpusBandwidth bandwidth;

		internal OpusMode mode;

		internal OpusMode prev_mode;

		internal int frame_size;

		internal int prev_redundancy;

		internal int last_packet_duration;

		internal uint rangeFinal;

		internal SilkDecoder SilkDecoder = new SilkDecoder();

		internal CeltDecoder Celt_Decoder = new CeltDecoder();

		private static readonly byte[] SILENCE = new byte[2] { 255, 255 };

		public OpusBandwidth Bandwidth => bandwidth;

		public uint FinalRange => rangeFinal;

		public int SampleRate => Fs;

		public int NumChannels => channels;

		public int Pitch
		{
			get
			{
				if (prev_mode == OpusMode.MODE_CELT_ONLY)
				{
					return Celt_Decoder.GetPitch();
				}
				return DecControl.prevPitchLag;
			}
		}

		public int Gain
		{
			get
			{
				return decode_gain;
			}
			set
			{
				if (value < -32768 || value > 32767)
				{
					throw new ArgumentException("Gain must be within the range of a signed int16");
				}
				decode_gain = value;
			}
		}

		public int LastPacketDuration => last_packet_duration;

		internal OpusDecoder()
		{
		}

		internal void Reset()
		{
			channels = 0;
			Fs = 0;
			DecControl.Reset();
			decode_gain = 0;
			PartialReset();
		}

		internal void PartialReset()
		{
			stream_channels = 0;
			bandwidth = (OpusBandwidth)0;
			mode = (OpusMode)0;
			prev_mode = (OpusMode)0;
			frame_size = 0;
			prev_redundancy = 0;
			last_packet_duration = 0;
			rangeFinal = 0u;
		}

		public static OpusDecoder Create(int Fs, int channels)
		{
			return new OpusDecoder(Fs, channels);
		}

		public OpusDecoder(int Fs, int channels)
		{
			if (Fs != 48000 && Fs != 24000 && Fs != 16000 && Fs != 12000 && Fs != 8000)
			{
				throw new ArgumentException("Sample rate is invalid (must be 8/12/16/24/48 Khz)");
			}
			if (channels != 1 && channels != 2)
			{
				throw new ArgumentException("Number of channels must be 1 or 2");
			}
			int num = opus_decoder_init(Fs, channels);
			switch (num)
			{
			case -1:
				throw new ArgumentException("OPUS_BAD_ARG when creating decoder");
			default:
				throw new OpusException("Error while initializing decoder", num);
			case 0:
				break;
			}
		}

		internal int opus_decoder_init(int Fs, int channels)
		{
			if ((Fs != 48000 && Fs != 24000 && Fs != 16000 && Fs != 12000 && Fs != 8000) || (channels != 1 && channels != 2))
			{
				return -1;
			}
			Reset();
			SilkDecoder silkDecoder = SilkDecoder;
			CeltDecoder celt_Decoder = Celt_Decoder;
			stream_channels = (this.channels = channels);
			this.Fs = Fs;
			DecControl.API_sampleRate = this.Fs;
			DecControl.nChannelsAPI = this.channels;
			if (DecodeAPI.silk_InitDecoder(silkDecoder) != 0)
			{
				return -3;
			}
			if (celt_Decoder.celt_decoder_init(Fs, channels) != 0)
			{
				return -3;
			}
			celt_Decoder.SetSignalling(0);
			prev_mode = (OpusMode)0;
			frame_size = Fs / 400;
			return 0;
		}

		internal int opus_decode_frame(byte[] data, int data_ptr, int len, short[] pcm, int pcm_ptr, int frame_size, int decode_fec)
		{
			int num = 0;
			EntropyCoder entropyCoder = new EntropyCoder();
			short[] array = null;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			uint num6 = 0u;
			SilkDecoder silkDecoder = SilkDecoder;
			CeltDecoder celt_Decoder = Celt_Decoder;
			int num7 = Fs / 50;
			int num8 = num7 >> 1;
			int num9 = num8 >> 1;
			int num10 = num9 >> 1;
			if (frame_size < num10)
			{
				return -2;
			}
			frame_size = Inlines.IMIN(frame_size, Fs / 25 * 3);
			if (len <= 1)
			{
				data = null;
				frame_size = Inlines.IMIN(frame_size, this.frame_size);
			}
			int num11;
			OpusMode opusMode;
			if (data != null)
			{
				num11 = this.frame_size;
				opusMode = mode;
				entropyCoder.dec_init(data, data_ptr, (uint)len);
			}
			else
			{
				num11 = frame_size;
				opusMode = prev_mode;
				if (opusMode == (OpusMode)0)
				{
					for (int i = pcm_ptr; i < pcm_ptr + num11 * channels; i++)
					{
						pcm[i] = 0;
					}
					return num11;
				}
				if (num11 > num7)
				{
					do
					{
						int num12 = opus_decode_frame(null, 0, 0, pcm, pcm_ptr, Inlines.IMIN(num11, num7), 0);
						if (num12 < 0)
						{
							return num12;
						}
						pcm_ptr += num12 * channels;
						num11 -= num12;
					}
					while (num11 > 0);
					return frame_size;
				}
				if (num11 < num7)
				{
					if (num11 > num8)
					{
						num11 = num8;
					}
					else if (opusMode != OpusMode.MODE_SILK_ONLY && num11 > num9 && num11 < num8)
					{
						num11 = num9;
					}
				}
			}
			int num13 = ((opusMode != OpusMode.MODE_CELT_ONLY && frame_size >= num8) ? 1 : 0);
			int num14 = 0;
			int num15 = 0;
			if (data != null && prev_mode > (OpusMode)0 && ((opusMode == OpusMode.MODE_CELT_ONLY && prev_mode != OpusMode.MODE_CELT_ONLY && prev_redundancy == 0) || (opusMode != OpusMode.MODE_CELT_ONLY && prev_mode == OpusMode.MODE_CELT_ONLY)))
			{
				num2 = 1;
				if (opusMode == OpusMode.MODE_CELT_ONLY)
				{
					num15 = num9 * channels;
				}
				else
				{
					num14 = num9 * channels;
				}
			}
			short[] array2 = new short[num15];
			if (num2 != 0 && opusMode == OpusMode.MODE_CELT_ONLY)
			{
				array = array2;
				opus_decode_frame(null, 0, 0, array, 0, Inlines.IMIN(num9, num11), 0);
			}
			if (num11 > frame_size)
			{
				return -1;
			}
			frame_size = num11;
			short[] array3 = new short[(opusMode != OpusMode.MODE_CELT_ONLY && num13 == 0) ? (Inlines.IMAX(num8, frame_size) * channels) : 0];
			if (opusMode != OpusMode.MODE_CELT_ONLY)
			{
				int num16 = 0;
				short[] array4;
				if (num13 != 0)
				{
					array4 = pcm;
					num16 = pcm_ptr;
				}
				else
				{
					array4 = array3;
					num16 = 0;
				}
				if (prev_mode == OpusMode.MODE_CELT_ONLY)
				{
					DecodeAPI.silk_InitDecoder(silkDecoder);
				}
				DecControl.payloadSize_ms = Inlines.IMAX(10, 1000 * num11 / Fs);
				if (data != null)
				{
					DecControl.nChannelsInternal = stream_channels;
					if (opusMode == OpusMode.MODE_SILK_ONLY)
					{
						if (bandwidth == OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND)
						{
							DecControl.internalSampleRate = 8000;
						}
						else if (bandwidth == OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND)
						{
							DecControl.internalSampleRate = 12000;
						}
						else if (bandwidth == OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND)
						{
							DecControl.internalSampleRate = 16000;
						}
						else
						{
							DecControl.internalSampleRate = 16000;
						}
					}
					else
					{
						DecControl.internalSampleRate = 16000;
					}
				}
				int num17 = ((data == null) ? 1 : (2 * decode_fec));
				int num18 = 0;
				do
				{
					int newPacketFlag = ((num18 == 0) ? 1 : 0);
					if (DecodeAPI.silk_Decode(silkDecoder, DecControl, num17, newPacketFlag, entropyCoder, array4, num16, out var nSamplesOut) != 0)
					{
						if (num17 == 0)
						{
							return -3;
						}
						nSamplesOut = frame_size;
						Arrays.MemSetWithOffset(array4, (short)0, num16, frame_size * channels);
					}
					num16 += nSamplesOut * channels;
					num18 += nSamplesOut;
				}
				while (num18 < frame_size);
			}
			int startBand = 0;
			if (decode_fec == 0 && opusMode != OpusMode.MODE_CELT_ONLY && data != null && entropyCoder.tell() + 17 + 20 * ((mode == OpusMode.MODE_HYBRID) ? 1 : 0) <= 8 * len)
			{
				num3 = ((opusMode != OpusMode.MODE_HYBRID) ? 1 : entropyCoder.dec_bit_logp(12u));
				if (num3 != 0)
				{
					num5 = entropyCoder.dec_bit_logp(1u);
					num4 = ((opusMode == OpusMode.MODE_HYBRID) ? ((int)(entropyCoder.dec_uint(256u) + 2)) : (len - (entropyCoder.tell() + 7 >> 3)));
					len -= num4;
					if (len * 8 < entropyCoder.tell())
					{
						len = 0;
						num4 = 0;
						num3 = 0;
					}
					entropyCoder.storage = (uint)(entropyCoder.storage - num4);
				}
			}
			if (opusMode != OpusMode.MODE_CELT_ONLY)
			{
				startBand = 17;
			}
			int endBand = 21;
			switch (bandwidth)
			{
			case OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND:
				endBand = 13;
				break;
			case OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND:
			case OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND:
				endBand = 17;
				break;
			case OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND:
				endBand = 19;
				break;
			case OpusBandwidth.OPUS_BANDWIDTH_FULLBAND:
				endBand = 21;
				break;
			}
			celt_Decoder.SetEndBand(endBand);
			celt_Decoder.SetChannels(stream_channels);
			if (num3 != 0)
			{
				num2 = 0;
				num14 = 0;
			}
			short[] array5 = new short[num14];
			if (num2 != 0 && opusMode != OpusMode.MODE_CELT_ONLY)
			{
				array = array5;
				opus_decode_frame(null, 0, 0, array, 0, Inlines.IMIN(num9, num11), 0);
			}
			short[] array6 = new short[(num3 != 0) ? (num9 * channels) : 0];
			if (num3 != 0 && num5 != 0)
			{
				celt_Decoder.SetStartBand(0);
				celt_Decoder.celt_decode_with_ec(data, data_ptr + len, num4, array6, 0, num9, null, 0);
				num6 = celt_Decoder.GetFinalRange();
			}
			celt_Decoder.SetStartBand(startBand);
			if (opusMode != OpusMode.MODE_SILK_ONLY)
			{
				int num19 = Inlines.IMIN(num7, frame_size);
				if (opusMode != prev_mode && prev_mode > (OpusMode)0 && prev_redundancy == 0)
				{
					celt_Decoder.ResetState();
				}
				num = celt_Decoder.celt_decode_with_ec((decode_fec != 0) ? null : data, data_ptr, len, pcm, pcm_ptr, num19, entropyCoder, num13);
			}
			else
			{
				if (num13 == 0)
				{
					for (int i = pcm_ptr; i < frame_size * channels + pcm_ptr; i++)
					{
						pcm[i] = 0;
					}
				}
				if (prev_mode == OpusMode.MODE_HYBRID && (num3 == 0 || num5 == 0 || prev_redundancy == 0))
				{
					celt_Decoder.SetStartBand(0);
					celt_Decoder.celt_decode_with_ec(SILENCE, 0, 2, pcm, pcm_ptr, num10, null, num13);
				}
			}
			if (opusMode != OpusMode.MODE_CELT_ONLY && num13 == 0)
			{
				for (int i = 0; i < frame_size * channels; i++)
				{
					pcm[pcm_ptr + i] = Inlines.SAT16(Inlines.ADD32(pcm[pcm_ptr + i], array3[i]));
				}
			}
			int[] window = celt_Decoder.GetMode().window;
			if (num3 != 0 && num5 == 0)
			{
				celt_Decoder.ResetState();
				celt_Decoder.SetStartBand(0);
				celt_Decoder.celt_decode_with_ec(data, data_ptr + len, num4, array6, 0, num9, null, 0);
				num6 = celt_Decoder.GetFinalRange();
				CodecHelpers.smooth_fade(pcm, pcm_ptr + channels * (frame_size - num10), array6, channels * num10, pcm, pcm_ptr + channels * (frame_size - num10), num10, channels, window, Fs);
			}
			if (num3 != 0 && num5 != 0)
			{
				for (int j = 0; j < channels; j++)
				{
					for (int i = 0; i < num10; i++)
					{
						pcm[channels * i + j + pcm_ptr] = array6[channels * i + j];
					}
				}
				CodecHelpers.smooth_fade(array6, channels * num10, pcm, pcm_ptr + channels * num10, pcm, pcm_ptr + channels * num10, num10, channels, window, Fs);
			}
			if (num2 != 0)
			{
				if (num11 >= num9)
				{
					for (int i = 0; i < channels * num10; i++)
					{
						pcm[i] = array[i];
					}
					CodecHelpers.smooth_fade(array, channels * num10, pcm, pcm_ptr + channels * num10, pcm, pcm_ptr + channels * num10, num10, channels, window, Fs);
				}
				else
				{
					CodecHelpers.smooth_fade(array, 0, pcm, pcm_ptr, pcm, pcm_ptr, num10, channels, window, Fs);
				}
			}
			if (decode_gain != 0)
			{
				int b = Inlines.celt_exp2(Inlines.MULT16_16_P15(21771, decode_gain));
				for (int i = pcm_ptr; i < pcm_ptr + frame_size * channels; i++)
				{
					int x = Inlines.MULT16_32_P16(pcm[i], b);
					pcm[i] = (short)Inlines.SATURATE(x, 32767);
				}
			}
			if (len <= 1)
			{
				rangeFinal = 0u;
			}
			else
			{
				rangeFinal = entropyCoder.rng ^ num6;
			}
			prev_mode = opusMode;
			prev_redundancy = ((num3 != 0 && num5 == 0) ? 1 : 0);
			if (num >= 0)
			{
				return num11;
			}
			return num;
		}

		internal int opus_decode_native(byte[] data, int data_ptr, int len, short[] pcm_out, int pcm_out_ptr, int frame_size, int decode_fec, int self_delimited, out int packet_offset, int soft_clip)
		{
			packet_offset = 0;
			short[] array = new short[48];
			if (decode_fec < 0 || decode_fec > 1)
			{
				return -1;
			}
			if ((decode_fec != 0 || len == 0 || data == null) && frame_size % (Fs / 400) != 0)
			{
				return -1;
			}
			if (len == 0 || data == null)
			{
				int num = 0;
				do
				{
					int num2 = opus_decode_frame(null, 0, 0, pcm_out, pcm_out_ptr + num * channels, frame_size - num, 0);
					if (num2 < 0)
					{
						return num2;
					}
					num += num2;
				}
				while (num < frame_size);
				last_packet_duration = num;
				return num;
			}
			if (len < 0)
			{
				return -1;
			}
			OpusMode encoderMode = OpusPacketInfo.GetEncoderMode(data, data_ptr);
			OpusBandwidth opusBandwidth = OpusPacketInfo.GetBandwidth(data, data_ptr);
			int numSamplesPerFrame = OpusPacketInfo.GetNumSamplesPerFrame(data, data_ptr, Fs);
			int numEncodedChannels = OpusPacketInfo.GetNumEncodedChannels(data, data_ptr);
			byte out_toc;
			int payload_offset;
			int num3 = OpusPacketInfo.opus_packet_parse_impl(data, data_ptr, len, self_delimited, out out_toc, null, null, 0, array, 0, out payload_offset, out packet_offset);
			if (num3 < 0)
			{
				return num3;
			}
			data_ptr += payload_offset;
			if (decode_fec != 0)
			{
				int packet_offset2;
				if (frame_size < numSamplesPerFrame || encoderMode == OpusMode.MODE_CELT_ONLY || mode == OpusMode.MODE_CELT_ONLY)
				{
					return opus_decode_native(null, 0, 0, pcm_out, pcm_out_ptr, frame_size, 0, 0, out packet_offset2, soft_clip);
				}
				int num4 = last_packet_duration;
				int num5;
				if (frame_size - numSamplesPerFrame != 0)
				{
					num5 = opus_decode_native(null, 0, 0, pcm_out, pcm_out_ptr, frame_size - numSamplesPerFrame, 0, 0, out packet_offset2, soft_clip);
					if (num5 < 0)
					{
						last_packet_duration = num4;
						return num5;
					}
				}
				mode = encoderMode;
				bandwidth = opusBandwidth;
				this.frame_size = numSamplesPerFrame;
				stream_channels = numEncodedChannels;
				num5 = opus_decode_frame(data, data_ptr, array[0], pcm_out, pcm_out_ptr + channels * (frame_size - numSamplesPerFrame), numSamplesPerFrame, 1);
				if (num5 < 0)
				{
					return num5;
				}
				last_packet_duration = frame_size;
				return frame_size;
			}
			if (num3 * numSamplesPerFrame > frame_size)
			{
				return -2;
			}
			mode = encoderMode;
			bandwidth = opusBandwidth;
			this.frame_size = numSamplesPerFrame;
			stream_channels = numEncodedChannels;
			int num6 = 0;
			for (int i = 0; i < num3; i++)
			{
				int num7 = opus_decode_frame(data, data_ptr, array[i], pcm_out, pcm_out_ptr + num6 * channels, frame_size - num6, 0);
				if (num7 < 0)
				{
					return num7;
				}
				data_ptr += array[i];
				num6 += num7;
			}
			last_packet_duration = num6;
			return num6;
		}

		public int Decode(byte[] in_data, int in_data_offset, int len, short[] out_pcm, int out_pcm_offset, int frame_size, bool decode_fec = false)
		{
			if (frame_size <= 0)
			{
				throw new ArgumentException("Frame size must be > 0");
			}
			try
			{
				int packet_offset;
				int num = opus_decode_native(in_data, in_data_offset, len, out_pcm, out_pcm_offset, frame_size, decode_fec ? 1 : 0, 0, out packet_offset, 0);
				if (num < 0)
				{
					if (num == -1)
					{
						throw new ArgumentException("OPUS_BAD_ARG while decoding");
					}
					throw new OpusException("An error occurred during decoding", num);
				}
				return num;
			}
			catch (ArgumentException ex)
			{
				throw new OpusException("Internal error during decoding: " + ex.Message);
			}
		}

		public int Decode(byte[] in_data, int in_data_offset, int len, float[] out_pcm, int out_pcm_offset, int frame_size, bool decode_fec = false)
		{
			if (frame_size <= 0)
			{
				throw new ArgumentException("Frame size must be > 0");
			}
			if (in_data != null && len > 0 && !decode_fec)
			{
				int numSamples = OpusPacketInfo.GetNumSamples(this, in_data, in_data_offset, len);
				if (numSamples <= 0)
				{
					throw new OpusException("An invalid packet was provided (unable to parse # of samples)");
				}
				frame_size = Inlines.IMIN(frame_size, numSamples);
			}
			short[] array = new short[frame_size * channels];
			try
			{
				int packet_offset;
				int num = opus_decode_native(in_data, in_data_offset, len, array, 0, frame_size, decode_fec ? 1 : 0, 0, out packet_offset, 0);
				if (num < 0)
				{
					if (num == -1)
					{
						throw new ArgumentException("OPUS_BAD_ARG when decoding");
					}
					throw new OpusException("An error occurred during decoding", num);
				}
				if (num > 0)
				{
					for (int i = 0; i < num * channels; i++)
					{
						out_pcm[out_pcm_offset + i] = 3.0517578E-05f * (float)array[i];
					}
				}
				return num;
			}
			catch (ArgumentException ex)
			{
				throw new OpusException("Internal error during decoding: " + ex.Message);
			}
		}

		public void ResetState()
		{
			PartialReset();
			Celt_Decoder.ResetState();
			DecodeAPI.silk_InitDecoder(SilkDecoder);
			stream_channels = channels;
			frame_size = Fs / 400;
		}
	}
	internal class OpusEncoder
	{
		internal readonly EncControlState silk_mode = new EncControlState();

		internal OpusApplication application;

		internal int channels;

		internal int delay_compensation;

		internal int force_channels;

		internal OpusSignal signal_type;

		internal OpusBandwidth user_bandwidth;

		internal OpusBandwidth max_bandwidth;

		internal OpusMode user_forced_mode;

		internal int voice_ratio;

		internal int Fs;

		internal int use_vbr;

		internal int vbr_constraint;

		internal OpusFramesize variable_duration;

		internal int bitrate_bps;

		internal int user_bitrate_bps;

		internal int lsb_depth;

		internal int encoder_buffer;

		internal int lfe;

		internal readonly TonalityAnalysisState analysis = new TonalityAnalysisState();

		internal int stream_channels;

		internal short hybrid_stereo_width_Q14;

		internal int variable_HP_smth2_Q15;

		internal int prev_HB_gain;

		internal readonly int[] hp_mem = new int[4];

		internal OpusMode mode;

		internal OpusMode prev_mode;

		internal int prev_channels;

		internal int prev_framesize;

		internal OpusBandwidth bandwidth;

		internal int silk_bw_switch;

		internal int first;

		internal int[] energy_masking;

		internal readonly StereoWidthState width_mem = new StereoWidthState();

		internal readonly short[] delay_buffer = new short[960];

		internal OpusBandwidth detected_bandwidth;

		internal uint rangeFinal;

		private int? _vqLevel;

		internal readonly SilkEncoder SilkEncoder = new SilkEncoder();

		internal readonly CeltEncoder Celt_Encoder = new CeltEncoder();

		private static readonly int[][] vqTable = new int[11][]
		{
			new int[2] { 7000, 16000 },
			new int[2] { 10000, 24000 },
			new int[2] { 13000, 32000 },
			new int[2] { 17000, 48000 },
			new int[2] { 20000, 64000 },
			new int[2] { 24000, 80000 },
			new int[2] { 28000, 96000 },
			new int[2] { 32000, 112000 },
			new int[2] { 38000, 128000 },
			new int[2] { 48000, 192000 },
			new int[2] { 64000, 256000 }
		};

		public OpusApplication Application
		{
			get
			{
				return application;
			}
			set
			{
				if (first == 0 && application != value)
				{
					throw new ArgumentException("Application cannot be changed after encoding has started");
				}
				application = value;
			}
		}

		public int Bitrate
		{
			get
			{
				return user_bitrate_to_bitrate(user_bitrate_bps, prev_framesize, 1276);
			}
			set
			{
				if (ConstantQuality.HasValue)
				{
					throw new ArgumentException("Bitrate is read-only while the ConstantQuality parameter is set");
				}
				if (value != -1000 && value != -1)
				{
					if (value <= 0)
					{
						throw new ArgumentException("Bitrate must be positive");
					}
					if (value <= 500)
					{
						value = 500;
					}
					else if (value > 300000 * channels)
					{
						value = 300000 * channels;
					}
				}
				user_bitrate_bps = value;
			}
		}

		public int ForceChannels
		{
			get
			{
				return force_channels;
			}
			set
			{
				if ((value < 1 || value > channels) && value != -1000)
				{
					throw new ArgumentException("Force channels must be <= num. of channels");
				}
				force_channels = value;
			}
		}

		public OpusBandwidth MaxBandwidth
		{
			get
			{
				return max_bandwidth;
			}
			set
			{
				max_bandwidth = value;
				if (max_bandwidth == OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND)
				{
					silk_mode.maxInternalSampleRate = 8000;
				}
				else if (max_bandwidth == OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND)
				{
					silk_mode.maxInternalSampleRate = 12000;
				}
				else
				{
					silk_mode.maxInternalSampleRate = 16000;
				}
			}
		}

		public OpusBandwidth Bandwidth
		{
			get
			{
				return bandwidth;
			}
			set
			{
				user_bandwidth = value;
				if (user_bandwidth == OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND)
				{
					silk_mode.maxInternalSampleRate = 8000;
				}
				else if (user_bandwidth == OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND)
				{
					silk_mode.maxInternalSampleRate = 12000;
				}
				else
				{
					silk_mode.maxInternalSampleRate = 16000;
				}
			}
		}

		public bool UseDTX
		{
			get
			{
				return silk_mode.useDTX != 0;
			}
			set
			{
				silk_mode.useDTX = (value ? 1 : 0);
			}
		}

		public int Complexity
		{
			get
			{
				return silk_mode.complexity;
			}
			set
			{
				if (value < 0 || value > 10)
				{
					throw new ArgumentException("Complexity must be between 0 and 10");
				}
				silk_mode.complexity = value;
				Celt_Encoder.SetComplexity(value);
			}
		}

		public bool UseInbandFEC
		{
			get
			{
				return silk_mode.useInBandFEC != 0;
			}
			set
			{
				silk_mode.useInBandFEC = (value ? 1 : 0);
			}
		}

		public int PacketLossPercent
		{
			get
			{
				return silk_mode.packetLossPercentage;
			}
			set
			{
				if (value < 0 || value > 100)
				{
					throw new ArgumentException("Packet loss must be between 0 and 100");
				}
				silk_mode.packetLossPercentage = value;
				Celt_Encoder.SetPacketLossPercent(value);
			}
		}

		public bool UseVBR
		{
			get
			{
				return use_vbr != 0;
			}
			set
			{
				use_vbr = (value ? 1 : 0);
				silk_mode.useCBR = ((!value) ? 1 : 0);
			}
		}

		public bool UseConstrainedVBR
		{
			get
			{
				return vbr_constraint != 0;
			}
			set
			{
				vbr_constraint = (value ? 1 : 0);
			}
		}

		public OpusSignal SignalType
		{
			get
			{
				return signal_type;
			}
			set
			{
				signal_type = value;
			}
		}

		public int Lookahead
		{
			get
			{
				int num = Fs / 400;
				if (application != OpusApplication.OPUS_APPLICATION_RESTRICTED_LOWDELAY)
				{
					num += delay_compensation;
				}
				return num;
			}
		}

		public int SampleRate => Fs;

		public int NumChannels => channels;

		public uint FinalRange => rangeFinal;

		public int LSBDepth
		{
			get
			{
				return lsb_depth;
			}
			set
			{
				if (value < 8 || value > 24)
				{
					throw new ArgumentException("LSB depth must be between 8 and 24");
				}
				lsb_depth = value;
			}
		}

		public OpusFramesize ExpertFrameDuration
		{
			get
			{
				return variable_duration;
			}
			set
			{
				variable_duration = value;
				Celt_Encoder.SetExpertFrameDuration(value);
			}
		}

		public OpusMode ForceMode
		{
			get
			{
				return user_forced_mode;
			}
			set
			{
				user_forced_mode = value;
			}
		}

		public bool IsLFE
		{
			get
			{
				return lfe != 0;
			}
			set
			{
				lfe = (value ? 1 : 0);
				Celt_Encoder.SetLFE(value ? 1 : 0);
			}
		}

		public bool PredictionDisabled
		{
			get
			{
				return silk_mode.reducedDependency != 0;
			}
			set
			{
				silk_mode.reducedDependency = (value ? 1 : 0);
			}
		}

		public bool EnableAnalysis
		{
			get
			{
				return analysis.enabled;
			}
			set
			{
				if (!value && _vqLevel.HasValue)
				{
					throw new ArgumentException("You cannot disable analysis while also specifying a ConstantQuality parameter");
				}
				if (value && Fs != 48000)
				{
					throw new ArgumentException("EnableAnalysis only works if the encoder is in 48000Khz mode");
				}
				analysis.enabled = value;
			}
		}

		public int? ConstantQuality
		{
			get
			{
				return _vqLevel;
			}
			set
			{
				if (value.HasValue && (value.Value < 0 || value.Value > 10))
				{
					throw new ArgumentException("Constant quality VBR level must be either null (disabled) or between 0 and 10, inclusive.");
				}
				if (value.HasValue && Fs != 48000)
				{
					throw new ArgumentException("ConstantQuality only works if the encoder is in 48000Khz mode");
				}
				EnableAnalysis = true;
				_vqLevel = value;
			}
		}

		public float MusicProbability => analysis.music_prob;

		internal OpusEncoder()
		{
		}

		internal void Reset()
		{
			silk_mode.Reset();
			application = OpusApplication.OPUS_APPLICATION_UNIMPLEMENTED;
			channels = 0;
			delay_compensation = 0;
			force_channels = 0;
			signal_type = (OpusSignal)0;
			user_bandwidth = (OpusBandwidth)0;
			max_bandwidth = (OpusBandwidth)0;
			user_forced_mode = (OpusMode)0;
			voice_ratio = 0;
			Fs = 0;
			use_vbr = 0;
			vbr_constraint = 0;
			variable_duration = (OpusFramesize)0;
			bitrate_bps = 0;
			user_bitrate_bps = 0;
			lsb_depth = 0;
			encoder_buffer = 0;
			lfe = 0;
			analysis.Reset();
			PartialReset();
		}

		internal void PartialReset()
		{
			stream_channels = 0;
			hybrid_stereo_width_Q14 = 0;
			variable_HP_smth2_Q15 = 0;
			prev_HB_gain = 0;
			Arrays.MemSetInt(hp_mem, 0, 4);
			mode = (OpusMode)0;
			prev_mode = (OpusMode)0;
			prev_channels = 0;
			prev_framesize = 0;
			bandwidth = (OpusBandwidth)0;
			silk_bw_switch = 0;
			first = 0;
			energy_masking = null;
			width_mem.Reset();
			Arrays.MemSetShort(delay_buffer, 0, 960);
			detected_bandwidth = (OpusBandwidth)0;
			rangeFinal = 0u;
		}

		public void ResetState()
		{
			EncControlState encStatus = new EncControlState();
			analysis.Reset();
			PartialReset();
			Celt_Encoder.ResetState();
			EncodeAPI.silk_InitEncoder(SilkEncoder, encStatus);
			stream_channels = channels;
			hybrid_stereo_width_Q14 = 16384;
			prev_HB_gain = 32767;
			first = 1;
			mode = OpusMode.MODE_HYBRID;
			bandwidth = OpusBandwidth.OPUS_BANDWIDTH_FULLBAND;
			variable_HP_smth2_Q15 = Inlines.silk_LSHIFT(Inlines.silk_lin2log(60), 8);
		}

		public static OpusEncoder Create(int Fs, int channels, OpusApplication application)
		{
			return new OpusEncoder(Fs, channels, application);
		}

		public OpusEncoder(int Fs, int channels, OpusApplication application)
		{
			if (Fs != 48000 && Fs != 24000 && Fs != 16000 && Fs != 12000 && Fs != 8000)
			{
				throw new ArgumentException("Sample rate is invalid (must be 8/12/16/24/48 Khz)");
			}
			if (channels != 1 && channels != 2)
			{
				throw new ArgumentException("Number of channels must be 1 or 2");
			}
			int num = opus_init_encoder(Fs, channels, application);
			switch (num)
			{
			case -1:
				throw new ArgumentException("OPUS_BAD_ARG when creating encoder");
			default:
				throw new OpusException("Error while initializing encoder", num);
			case 0:
				break;
			}
		}

		internal int opus_init_encoder(int Fs, int channels, OpusApplication application)
		{
			if ((Fs != 48000 && Fs != 24000 && Fs != 16000 && Fs != 12000 && Fs != 8000) || (channels != 1 && channels != 2) || application == OpusApplication.OPUS_APPLICATION_UNIMPLEMENTED)
			{
				return -1;
			}
			Reset();
			SilkEncoder silkEncoder = SilkEncoder;
			CeltEncoder celt_Encoder = Celt_Encoder;
			stream_channels = (this.channels = channels);
			this.Fs = Fs;
			if (EncodeAPI.silk_InitEncoder(silkEncoder, silk_mode) != 0)
			{
				return -3;
			}
			silk_mode.nChannelsAPI = channels;
			silk_mode.nChannelsInternal = channels;
			silk_mode.API_sampleRate = this.Fs;
			silk_mode.maxInternalSampleRate = 16000;
			silk_mode.minInternalSampleRate = 8000;
			silk_mode.desiredInternalSampleRate = 16000;
			silk_mode.payloadSize_ms = 20;
			silk_mode.bitRate = 25000;
			silk_mode.packetLossPercentage = 0;
			silk_mode.complexity = 9;
			silk_mode.useInBandFEC = 0;
			silk_mode.useDTX = 0;
			silk_mode.useCBR = 0;
			silk_mode.reducedDependency = 0;
			if (celt_Encoder.celt_encoder_init(Fs, channels) != 0)
			{
				return -3;
			}
			celt_Encoder.SetSignalling(0);
			celt_Encoder.SetComplexity(silk_mode.complexity);
			use_vbr = 1;
			vbr_constraint = 1;
			user_bitrate_bps = -1000;
			bitrate_bps = 3000 + Fs * channels;
			this.application = application;
			signal_type = OpusSignal.OPUS_SIGNAL_AUTO;
			user_bandwidth = OpusBandwidth.OPUS_BANDWIDTH_AUTO;
			max_bandwidth = OpusBandwidth.OPUS_BANDWIDTH_FULLBAND;
			force_channels = -1000;
			user_forced_mode = OpusMode.MODE_AUTO;
			voice_ratio = -1;
			encoder_buffer = this.Fs / 100;
			lsb_depth = 24;
			variable_duration = OpusFramesize.OPUS_FRAMESIZE_ARG;
			delay_compensation = this.Fs / 250;
			hybrid_stereo_width_Q14 = 16384;
			prev_HB_gain = 32767;
			variable_HP_smth2_Q15 = Inlines.silk_LSHIFT(Inlines.silk_lin2log(60), 8);
			first = 1;
			mode = OpusMode.MODE_HYBRID;
			bandwidth = OpusBandwidth.OPUS_BANDWIDTH_FULLBAND;
			Analysis.tonality_analysis_init(analysis);
			return 0;
		}

		internal int user_bitrate_to_bitrate(int user_bitrate, int frame_size, int max_data_bytes)
		{
			if (frame_size == 0)
			{
				frame_size = Fs / 400;
			}
			return user_bitrate switch
			{
				-1000 => 60 * Fs / frame_size + Fs * channels, 
				-1 => max_data_bytes * 8 * Fs / frame_size, 
				_ => user_bitrate, 
			};
		}

		internal int opus_encode_native<T>(short[] pcm, int pcm_ptr, int frame_size, byte[] data, int data_ptr, int out_data_bytes, int lsb_depth, T[] analysis_pcm, int analysis_pcm_ptr, int analysis_size, int c1, int c2, int analysis_channels, Downmix.downmix_func<T> downmix, int float_api)
		{
			int num = 0;
			EntropyCoder entropyCoder = new EntropyCoder();
			int num2 = 0;
			int startBand = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			uint num7 = 0u;
			AnalysisInfo analysisInfo = new AnalysisInfo();
			int num8 = -1;
			int read_subframe = -1;
			int num9 = Inlines.IMIN(1276, out_data_bytes);
			rangeFinal = 0u;
			if ((variable_duration == (OpusFramesize)0 && 400 * frame_size != Fs && 200 * frame_size != Fs && 100 * frame_size != Fs && 50 * frame_size != Fs && 25 * frame_size != Fs && 50 * frame_size != 3 * Fs) || 400 * frame_size < Fs || num9 <= 0)
			{
				return -1;
			}
			SilkEncoder silkEncoder = SilkEncoder;
			CeltEncoder celt_Encoder = Celt_Encoder;
			int num10 = ((application != OpusApplication.OPUS_APPLICATION_RESTRICTED_LOWDELAY) ? delay_compensation : 0);
			lsb_depth = Inlines.IMIN(lsb_depth, this.lsb_depth);
			CeltMode celtMode = celt_Encoder.GetMode();
			voice_ratio = -1;
			if (analysis.enabled)
			{
				analysisInfo.valid = 0;
				if ((_vqLevel.HasValue || silk_mode.complexity >= 7) && Fs == 48000)
				{
					num8 = analysis.read_pos;
					read_subframe = analysis.read_subframe;
					Analysis.run_analysis(analysis, celtMode, (analysis_pcm != null) ? analysis_pcm : null, analysis_pcm_ptr, analysis_size, frame_size, c1, c2, analysis_channels, Fs, lsb_depth, downmix, analysisInfo);
				}
				detected_bandwidth = (OpusBandwidth)0;
				if (analysisInfo.valid != 0)
				{
					if (signal_type == OpusSignal.OPUS_SIGNAL_AUTO)
					{
						voice_ratio = (int)Math.Floor(0.5f + 100f * (1f - analysisInfo.music_prob));
					}
					int num11 = analysisInfo.bandwidth;
					if (num11 <= 12)
					{
						detected_bandwidth = OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND;
					}
					else if (num11 <= 14)
					{
						detected_bandwidth = OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND;
					}
					else if (num11 <= 16)
					{
						detected_bandwidth = OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND;
					}
					else if (num11 <= 18)
					{
						detected_bandwidth = OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND;
					}
					else
					{
						detected_bandwidth = OpusBandwidth.OPUS_BANDWIDTH_FULLBAND;
					}
					if (_vqLevel.HasValue)
					{
						user_bitrate_bps = GetVariableQualityBitrate(_vqLevel.Value, analysis.music_prob);
					}
				}
			}
			int num12 = ((channels == 2 && force_channels != 1) ? CodecHelpers.compute_stereo_width(pcm, pcm_ptr, frame_size, Fs, width_mem) : 0);
			int num13 = num10;
			bitrate_bps = user_bitrate_to_bitrate(user_bitrate_bps, frame_size, num9);
			int num14 = Fs / frame_size;
			if (use_vbr == 0)
			{
				int num15 = 3 * Fs / frame_size;
				int num16 = Inlines.IMIN((3 * bitrate_bps / 8 + num15 / 2) / num15, num9);
				bitrate_bps = num16 * num15 * 8 / 3;
				num9 = num16;
			}
			if (num9 < 3 || bitrate_bps < 3 * num14 * 8 || (num14 < 50 && (num9 * num14 < 300 || bitrate_bps < 2400)))
			{
				OpusMode opusMode = mode;
				OpusBandwidth opusBandwidth = ((bandwidth == (OpusBandwidth)0) ? OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND : bandwidth);
				if (opusMode == (OpusMode)0)
				{
					opusMode = OpusMode.MODE_SILK_ONLY;
				}
				if (num14 > 100)
				{
					opusMode = OpusMode.MODE_CELT_ONLY;
				}
				if (num14 < 50)
				{
					opusMode = OpusMode.MODE_SILK_ONLY;
				}
				if (opusMode == OpusMode.MODE_SILK_ONLY && opusBandwidth > OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND)
				{
					opusBandwidth = OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND;
				}
				else if (opusMode == OpusMode.MODE_CELT_ONLY && opusBandwidth == OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND)
				{
					opusBandwidth = OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND;
				}
				else if (opusMode == OpusMode.MODE_HYBRID && opusBandwidth <= OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND)
				{
					opusBandwidth = OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND;
				}
				data[data_ptr] = CodecHelpers.gen_toc(opusMode, num14, opusBandwidth, stream_channels);
				num = 1;
				if (use_vbr == 0)
				{
					num = OpusRepacketizer.PadPacket(data, data_ptr, num, num9);
					if (num == 0)
					{
						num = num9;
					}
				}
				return num;
			}
			int num17 = num14 * num9 * 8;
			int num18 = bitrate_bps - (40 * channels + 20) * (Fs / frame_size - 50);
			int num19;
			if (signal_type == OpusSignal.OPUS_SIGNAL_VOICE)
			{
				num19 = 127;
			}
			else if (signal_type == OpusSignal.OPUS_SIGNAL_MUSIC)
			{
				num19 = 0;
			}
			else if (voice_ratio < 0)
			{
				num19 = ((application != OpusApplication.OPUS_APPLICATION_VOIP) ? 48 : 115);
			}
			else
			{
				num19 = voice_ratio * 327 >> 8;
				if (application == OpusApplication.OPUS_APPLICATION_AUDIO)
				{
					num19 = Inlines.IMIN(num19, 115);
				}
			}
			if (force_channels != -1000 && channels == 2)
			{
				stream_channels = force_channels;
			}
			else if (channels == 2)
			{
				int num20 = 30000 + (0 >> 14);
				num20 = ((stream_channels != 2) ? (num20 + 1000) : (num20 - 1000));
				stream_channels = ((num18 <= num20) ? 1 : 2);
			}
			else
			{
				stream_channels = channels;
			}
			num18 = bitrate_bps - (40 * stream_channels + 20) * (Fs / frame_size - 50);
			if (application == OpusApplication.OPUS_APPLICATION_RESTRICTED_LOWDELAY)
			{
				mode = OpusMode.MODE_CELT_ONLY;
			}
			else if (user_forced_mode == OpusMode.MODE_AUTO)
			{
				int num21 = Inlines.MULT16_32_Q15(32767 - num12, Tables.mode_thresholds[0][0]) + Inlines.MULT16_32_Q15(num12, Tables.mode_thresholds[1][0]);
				int num22 = Inlines.MULT16_32_Q15(32767 - num12, Tables.mode_thresholds[1][1]) + Inlines.MULT16_32_Q15(num12, Tables.mode_thresholds[1][1]);
				int num23 = num22 + (num19 * num19 * (num21 - num22) >> 14);
				if (application == OpusApplication.OPUS_APPLICATION_VOIP)
				{
					num23 += 8000;
				}
				if (prev_mode == OpusMode.MODE_CELT_ONLY)
				{
					num23 -= 4000;
				}
				else if (prev_mode > (OpusMode)0)
				{
					num23 += 4000;
				}
				mode = ((num18 >= num23) ? OpusMode.MODE_CELT_ONLY : OpusMode.MODE_SILK_ONLY);
				if (silk_mode.useInBandFEC != 0 && silk_mode.packetLossPercentage > 128 - num19 >> 4)
				{
					mode = OpusMode.MODE_SILK_ONLY;
				}
				if (silk_mode.useDTX != 0 && num19 > 100)
				{
					mode = OpusMode.MODE_SILK_ONLY;
				}
			}
			else
			{
				mode = user_forced_mode;
			}
			if (mode != OpusMode.MODE_CELT_ONLY && frame_size < Fs / 100)
			{
				mode = OpusMode.MODE_CELT_ONLY;
			}
			if (lfe != 0)
			{
				mode = OpusMode.MODE_CELT_ONLY;
			}
			if (num9 < ((num14 > 50) ? 12000 : 8000) * frame_size / (Fs * 8))
			{
				mode = OpusMode.MODE_CELT_ONLY;
			}
			if (stream_channels == 1 && prev_channels == 2 && silk_mode.toMono == 0 && mode != OpusMode.MODE_CELT_ONLY && prev_mode != OpusMode.MODE_CELT_ONLY)
			{
				silk_mode.toMono = 1;
				stream_channels = 2;
			}
			else
			{
				silk_mode.toMono = 0;
			}
			if (prev_mode > (OpusMode)0 && ((mode != OpusMode.MODE_CELT_ONLY && prev_mode == OpusMode.MODE_CELT_ONLY) || (mode == OpusMode.MODE_CELT_ONLY && prev_mode != OpusMode.MODE_CELT_ONLY)))
			{
				num3 = 1;
				num5 = ((mode != OpusMode.MODE_CELT_ONLY) ? 1 : 0);
				if (num5 == 0)
				{
					if (frame_size >= Fs / 100)
					{
						mode = prev_mode;
						num6 = 1;
					}
					else
					{
						num3 = 0;
					}
				}
			}
			if (silk_bw_switch != 0)
			{
				num3 = 1;
				num5 = 1;
				silk_bw_switch = 0;
				num2 = 1;
			}
			if (num3 != 0)
			{
				num4 = Inlines.IMIN(257, num9 * (Fs / 200) / (frame_size + Fs / 200));
				if (use_vbr != 0)
				{
					num4 = Inlines.IMIN(num4, bitrate_bps / 1600);
				}
			}
			if (mode != OpusMode.MODE_CELT_ONLY && prev_mode == OpusMode.MODE_CELT_ONLY)
			{
				EncControlState encStatus = new EncControlState();
				EncodeAPI.silk_InitEncoder(silkEncoder, encStatus);
				num2 = 1;
			}
			if (mode == OpusMode.MODE_CELT_ONLY || first != 0 || silk_mode.allowBandwidthSwitch != 0)
			{
				int[] array = new int[8];
				OpusBandwidth opusBandwidth2 = OpusBandwidth.OPUS_BANDWIDTH_FULLBAND;
				int num24 = num18;
				if (mode != OpusMode.MODE_CELT_ONLY)
				{
					num24 = num24 * (45 + silk_mode.complexity) / 50;
					if (use_vbr == 0)
					{
						num24 -= 1000;
					}
				}
				int[] array2;
				int[] array3;
				if (channels == 2 && force_channels != 1)
				{
					array2 = Tables.stereo_voice_bandwidth_thresholds;
					array3 = Tables.stereo_music_bandwidth_thresholds;
				}
				else
				{
					array2 = Tables.mono_voice_bandwidth_thresholds;
					array3 = Tables.mono_music_bandwidth_thresholds;
				}
				for (int i = 0; i < 8; i++)
				{
					array[i] = array3[i] + (num19 * num19 * (array2[i] - array3[i]) >> 14);
				}
				int num25;
				do
				{
					num25 = array[2 * (int)(opusBandwidth2 - 1102)];
					int num26 = array[2 * (int)(opusBandwidth2 - 1102) + 1];
					if (first == 0)
					{
						num25 = ((bandwidth < opusBandwidth2) ? (num25 + num26) : (num25 - num26));
					}
				}
				while (num24 < num25 && --opusBandwidth2 > OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND);
				bandwidth = opusBandwidth2;
				if (first == 0 && mode != OpusMode.MODE_CELT_ONLY && silk_mode.inWBmodeWithoutVariableLP == 0 && bandwidth > OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND)
				{
					bandwidth = OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND;
				}
			}
			if (bandwidth > max_bandwidth)
			{
				bandwidth = max_bandwidth;
			}
			if (user_bandwidth != OpusBandwidth.OPUS_BANDWIDTH_AUTO)
			{
				bandwidth = user_bandwidth;
			}
			if (mode != OpusMode.MODE_CELT_ONLY && num17 < 15000)
			{
				bandwidth = OpusBandwidthHelpers.MIN(bandwidth, OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND);
			}
			if (Fs <= 24000 && bandwidth > OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND)
			{
				bandwidth = OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND;
			}
			if (Fs <= 16000 && bandwidth > OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND)
			{
				bandwidth = OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND;
			}
			if (Fs <= 12000 && bandwidth > OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND)
			{
				bandwidth = OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND;
			}
			if (Fs <= 8000 && bandwidth > OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND)
			{
				bandwidth = OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND;
			}
			if (detected_bandwidth != 0 && user_bandwidth == OpusBandwidth.OPUS_BANDWIDTH_AUTO)
			{
				detected_bandwidth = OpusBandwidthHelpers.MAX(b: (num18 <= 18000 * stream_channels && mode == OpusMode.MODE_CELT_ONLY) ? OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND : ((num18 <= 24000 * stream_channels && mode == OpusMode.MODE_CELT_ONLY) ? OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND : ((num18 <= 30000 * stream_channels) ? OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND : ((num18 > 44000 * stream_channels) ? OpusBandwidth.OPUS_BANDWIDTH_FULLBAND : OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND))), a: detected_bandwidth);
				bandwidth = OpusBandwidthHelpers.MIN(bandwidth, detected_bandwidth);
			}
			celt_Encoder.SetLSBDepth(lsb_depth);
			if (mode == OpusMode.MODE_CELT_ONLY && bandwidth == OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND)
			{
				bandwidth = OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND;
			}
			if (lfe != 0)
			{
				bandwidth = OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND;
			}
			if (frame_size > Fs / 50 && (mode == OpusMode.MODE_CELT_ONLY || bandwidth > OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND))
			{
				if (analysis.enabled && num8 != -1)
				{
					analysis.read_pos = num8;
					analysis.read_subframe = read_subframe;
				}
				int num27 = ((frame_size > Fs / 25) ? 3 : 2);
				int num28 = Inlines.IMIN(1276, (out_data_bytes - 3) / num27);
				byte[] data2 = new byte[num27 * num28];
				OpusRepacketizer opusRepacketizer = new OpusRepacketizer();
				OpusMode opusMode2 = user_forced_mode;
				OpusBandwidth opusBandwidth3 = user_bandwidth;
				int num29 = force_channels;
				user_forced_mode = mode;
				user_bandwidth = bandwidth;
				force_channels = stream_channels;
				int toMono = silk_mode.toMono;
				if (toMono != 0)
				{
					force_channels = 1;
				}
				else
				{
					prev_channels = stream_channels;
				}
				for (int i = 0; i < num27; i++)
				{
					silk_mode.toMono = 0;
					if (num6 != 0 && i == num27 - 1)
					{
						user_forced_mode = OpusMode.MODE_CELT_ONLY;
					}
					int num30 = opus_encode_native(pcm, pcm_ptr + i * (channels * Fs / 50), Fs / 50, data2, i * num28, num28, lsb_depth, null, 0, 0, c1, c2, analysis_channels, downmix, float_api);
					if (num30 < 0)
					{
						return -3;
					}
					num = opusRepacketizer.AddPacket(data2, i * num28, num30);
					if (num < 0)
					{
						return -3;
					}
				}
				int maxlen = ((use_vbr == 0) ? Inlines.IMIN(3 * bitrate_bps / (1200 / num27), out_data_bytes) : out_data_bytes);
				num = opusRepacketizer.opus_repacketizer_out_range_impl(0, num27, data, data_ptr, maxlen, 0, (use_vbr == 0) ? 1 : 0);
				if (num < 0)
				{
					return -3;
				}
				user_forced_mode = opusMode2;
				user_bandwidth = opusBandwidth3;
				force_channels = num29;
				silk_mode.toMono = toMono;
				return num;
			}
			OpusBandwidth opusBandwidth4 = bandwidth;
			if (mode == OpusMode.MODE_SILK_ONLY && opusBandwidth4 > OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND)
			{
				mode = OpusMode.MODE_HYBRID;
			}
			if (mode == OpusMode.MODE_HYBRID && opusBandwidth4 <= OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND)
			{
				mode = OpusMode.MODE_SILK_ONLY;
			}
			int num31 = Inlines.IMIN(num9 - num4, bitrate_bps * frame_size / (Fs * 8)) - 1;
			data_ptr++;
			entropyCoder.enc_init(data, data_ptr, (uint)(num9 - 1));
			short[] array4 = new short[(num13 + frame_size) * channels];
			Array.Copy(delay_buffer, (encoder_buffer - num13) * channels, array4, 0, num13 * channels);
			variable_HP_smth2_Q15 = Inlines.silk_SMLAWB(b32: ((mode != OpusMode.MODE_CELT_ONLY) ? silkEncoder.state_Fxx[0].variable_HP_smth1_Q15 : Inlines.silk_LSHIFT(Inlines.silk_lin2log(60), 8)) - variable_HP_smth2_Q15, a32: variable_HP_smth2_Q15, c32: 983);
			int cutoff_Hz = Inlines.silk_log2lin(Inlines.silk_RSHIFT(variable_HP_smth2_Q15, 8));
			if (application == OpusApplication.OPUS_APPLICATION_VOIP)
			{
				CodecHelpers.hp_cutoff(pcm, pcm_ptr, cutoff_Hz, array4, num13 * channels, hp_mem, frame_size, channels, Fs);
			}
			else
			{
				CodecHelpers.dc_reject(pcm, pcm_ptr, 3, array4, num13 * channels, hp_mem, frame_size, channels, Fs);
			}
			int num32 = 32767;
			if (mode != OpusMode.MODE_CELT_ONLY)
			{
				short[] array5 = new short[channels * frame_size];
				int num33 = 8 * num31 * num14;
				if (mode == OpusMode.MODE_HYBRID)
				{
					silk_mode.bitRate = stream_channels * (5000 + ((Fs == 100 * frame_size) ? 1000 : 0));
					if (opusBandwidth4 == OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND)
					{
						silk_mode.bitRate += (num33 - silk_mode.bitRate) * 2 / 3;
					}
					else
					{
						silk_mode.bitRate += (num33 - silk_mode.bitRate) * 3 / 5;
					}
					if (silk_mode.bitRate > num33 * 4 / 5)
					{
						silk_mode.bitRate = num33 * 4 / 5;
					}
					if (energy_masking == null)
					{
						int num34 = num33 - silk_mode.bitRate;
						int num35 = ((opusBandwidth4 == OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND) ? 3000 : 3600);
						num32 = Inlines.SHL32(num34, 9) / Inlines.SHR32(num34 + stream_channels * num35, 6);
						num32 = ((num32 < 28086) ? (num32 + 4681) : 32767);
					}
				}
				else
				{
					silk_mode.bitRate = num33;
				}
				if (energy_masking != null && use_vbr != 0 && lfe == 0)
				{
					int num36 = 0;
					int num37 = 17;
					short a = 16000;
					if (bandwidth == OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND)
					{
						num37 = 13;
						a = 8000;
					}
					else if (bandwidth == OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND)
					{
						num37 = 15;
						a = 12000;
					}
					for (int j = 0; j < channels; j++)
					{
						for (int i = 0; i < num37; i++)
						{
							int num38 = Inlines.MAX16(Inlines.MIN16(energy_masking[21 * j + i], 512), -2048);
							if (num38 > 0)
							{
								num38 = Inlines.HALF16(num38);
							}
							num36 += num38;
						}
					}
					int num39 = num36 / num37 * channels;
					num39 += 205;
					int a2 = Inlines.PSHR32(Inlines.MULT16_16(a, num39), 10);
					a2 = Inlines.MAX32(a2, -2 * silk_mode.bitRate / 3);
					if (bandwidth == OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND || bandwidth == OpusBandwidth.OPUS_BANDWIDTH_FULLBAND)
					{
						silk_mode.bitRate += 3 * a2 / 5;
					}
					else
					{
						silk_mode.bitRate += a2;
					}
					num31 += a2 * frame_size / (8 * Fs);
				}
				silk_mode.payloadSize_ms = 1000 * frame_size / Fs;
				silk_mode.nChannelsAPI = channels;
				silk_mode.nChannelsInternal = stream_channels;
				switch (opusBandwidth4)
				{
				case OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND:
					silk_mode.desiredInternalSampleRate = 8000;
					break;
				case OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND:
					silk_mode.desiredInternalSampleRate = 12000;
					break;
				default:
					silk_mode.desiredInternalSampleRate = 16000;
					break;
				}
				if (mode == OpusMode.MODE_HYBRID)
				{
					silk_mode.minInternalSampleRate = 16000;
				}
				else
				{
					silk_mode.minInternalSampleRate = 8000;
				}
				if (mode == OpusMode.MODE_SILK_ONLY)
				{
					int num40 = num17;
					silk_mode.maxInternalSampleRate = 16000;
					if (num14 > 50)
					{
						num40 = num40 * 2 / 3;
					}
					if (num40 < 13000)
					{
						silk_mode.maxInternalSampleRate = 12000;
						silk_mode.desiredInternalSampleRate = Inlines.IMIN(12000, silk_mode.desiredInternalSampleRate);
					}
					if (num40 < 9600)
					{
						silk_mode.maxInternalSampleRate = 8000;
						silk_mode.desiredInternalSampleRate = Inlines.IMIN(8000, silk_mode.desiredInternalSampleRate);
					}
				}
				else
				{
					silk_mode.maxInternalSampleRate = 16000;
				}
				silk_mode.useCBR = ((use_vbr == 0) ? 1 : 0);
				int num41 = Inlines.IMIN(1275, num9 - 1 - num4);
				silk_mode.maxBits = num41 * 8;
				if (mode == OpusMode.MODE_HYBRID)
				{
					silk_mode.maxBits = silk_mode.maxBits * 9 / 10;
				}
				if (silk_mode.useCBR != 0)
				{
					silk_mode.maxBits = silk_mode.bitRate * frame_size / (Fs * 8) * 8;
					silk_mode.bitRate = Inlines.IMAX(1, silk_mode.bitRate - 2000);
				}
				if (num2 != 0)
				{
					BoxedValueInt nBytesOut = new BoxedValueInt();
					int num42 = channels * (encoder_buffer - delay_compensation - Fs / 400);
					CodecHelpers.gain_fade(delay_buffer, num42, 0, 32767, celtMode.overlap, Fs / 400, channels, celtMode.window, Fs);
					Arrays.MemSetShort(delay_buffer, 0, num42);
					Array.Copy(delay_buffer, 0, array5, 0, encoder_buffer * channels);
					EncodeAPI.silk_Encode(silkEncoder, silk_mode, array5, encoder_buffer, null, nBytesOut, 1);
				}
				Array.Copy(array4, num13 * channels, array5, 0, frame_size * channels);
				BoxedValueInt boxedValueInt = new BoxedValueInt(num41);
				num = EncodeAPI.silk_Encode(silkEncoder, silk_mode, array5, frame_size, entropyCoder, boxedValueInt, 0);
				num41 = boxedValueInt.Val;
				if (num != 0)
				{
					return -3;
				}
				if (num41 == 0)
				{
					rangeFinal = 0u;
					data[data_ptr - 1] = CodecHelpers.gen_toc(mode, Fs / frame_size, opusBandwidth4, stream_channels);
					return 1;
				}
				if (mode == OpusMode.MODE_SILK_ONLY)
				{
					if (silk_mode.internalSampleRate == 8000)
					{
						opusBandwidth4 = OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND;
					}
					else if (silk_mode.internalSampleRate == 12000)
					{
						opusBandwidth4 = OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND;
					}
					else if (silk_mode.internalSampleRate == 16000)
					{
						opusBandwidth4 = OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND;
					}
				}
				silk_mode.opusCanSwitch = silk_mode.switchReady;
				if (silk_mode.opusCanSwitch != 0)
				{
					num3 = 1;
					num5 = 0;
					silk_bw_switch = 1;
				}
			}
			int endBand = 21;
			switch (opusBandwidth4)
			{
			case OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND:
				endBand = 13;
				break;
			case OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND:
			case OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND:
				endBand = 17;
				break;
			case OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND:
				endBand = 19;
				break;
			case OpusBandwidth.OPUS_BANDWIDTH_FULLBAND:
				endBand = 21;
				break;
			}
			celt_Encoder.SetEndBand(endBand);
			celt_Encoder.SetChannels(stream_channels);
			celt_Encoder.SetBitrate(-1);
			int num44;
			if (mode != OpusMode.MODE_SILK_ONLY)
			{
				int prediction = 2;
				celt_Encoder.SetVBR(value: false);
				if (silk_mode.reducedDependency != 0)
				{
					prediction = 0;
				}
				celt_Encoder.SetPrediction(prediction);
				if (mode == OpusMode.MODE_HYBRID)
				{
					int num43 = entropyCoder.tell() + 7 >> 3;
					if (num3 != 0)
					{
						num43 += ((mode != OpusMode.MODE_HYBRID) ? 1 : 3);
					}
					num44 = ((use_vbr == 0) ? ((num43 > num31) ? num43 : num31) : (num43 + num31 - silk_mode.bitRate * frame_size / (8 * Fs)));
				}
				else if (use_vbr != 0)
				{
					int num45 = 0;
					if (analysis.enabled && variable_duration == OpusFramesize.OPUS_FRAMESIZE_VARIABLE && frame_size != Fs / 50)
					{
						num45 = (60 * stream_channels + 40) * (Fs / frame_size - 50);
						if (analysisInfo.valid != 0)
						{
							num45 = (int)((float)num45 * (1f + 0.5f * analysisInfo.tonality));
						}
					}
					celt_Encoder.SetVBR(value: true);
					celt_Encoder.SetVBRConstraint(vbr_constraint != 0);
					celt_Encoder.SetBitrate(bitrate_bps + num45);
					num44 = num9 - 1 - num4;
				}
				else
				{
					num44 = num31;
				}
			}
			else
			{
				num44 = 0;
			}
			short[] array6 = new short[channels * Fs / 400];
			if (mode != OpusMode.MODE_SILK_ONLY && mode != prev_mode && prev_mode > (OpusMode)0)
			{
				Array.Copy(delay_buffer, (encoder_buffer - num13 - Fs / 400) * channels, array6, 0, channels * Fs / 400);
			}
			if (channels * (encoder_buffer - (frame_size + num13)) > 0)
			{
				Arrays.MemMoveShort(delay_buffer, channels * frame_size, 0, channels * (encoder_buffer - frame_size - num13));
				Array.Copy(array4, 0, delay_buffer, channels * (encoder_buffer - frame_size - num13), (frame_size + num13) * channels);
			}
			else
			{
				Array.Copy(array4, (frame_size + num13 - encoder_buffer) * channels, delay_buffer, 0, encoder_buffer * channels);
			}
			if (prev_HB_gain < 32767 || num32 < 32767)
			{
				CodecHelpers.gain_fade(array4, 0, prev_HB_gain, num32, celtMode.overlap, frame_size, channels, celtMode.window, Fs);
			}
			prev_HB_gain = num32;
			if (mode != OpusMode.MODE_HYBRID || stream_channels == 1)
			{
				silk_mode.stereoWidth_Q14 = Inlines.IMIN(16384, 2 * Inlines.IMAX(0, num18 - 30000));
			}
			if (energy_masking == null && channels == 2 && (hybrid_stereo_width_Q14 < 16384 || silk_mode.stereoWidth_Q14 < 16384))
			{
				int num46 = hybrid_stereo_width_Q14;
				int stereoWidth_Q = silk_mode.stereoWidth_Q14;
				num46 = ((num46 == 16384) ? 32767 : Inlines.SHL16(num46, 1));
				stereoWidth_Q = ((stereoWidth_Q == 16384) ? 32767 : Inlines.SHL16(stereoWidth_Q, 1));
				CodecHelpers.stereo_fade(array4, num46, stereoWidth_Q, celtMode.overlap, frame_size, channels, celtMode.window, Fs);
				hybrid_stereo_width_Q14 = (short)silk_mode.stereoWidth_Q14;
			}
			if (mode != OpusMode.MODE_CELT_ONLY && entropyCoder.tell() + 17 + 20 * ((mode == OpusMode.MODE_HYBRID) ? 1 : 0) <= 8 * (num9 - 1))
			{
				if (mode == OpusMode.MODE_HYBRID && (num3 != 0 || entropyCoder.tell() + 37 <= 8 * num44))
				{
					entropyCoder.enc_bit_logp(num3, 12u);
				}
				if (num3 != 0)
				{
					entropyCoder.enc_bit_logp(num5, 1u);
					int a3 = ((mode != OpusMode.MODE_HYBRID) ? (num9 - 1 - (entropyCoder.tell() + 7 >> 3)) : (num9 - 1 - num44));
					num4 = Inlines.IMIN(a3, bitrate_bps / 1600);
					num4 = Inlines.IMIN(257, Inlines.IMAX(2, num4));
					if (mode == OpusMode.MODE_HYBRID)
					{
						entropyCoder.enc_uint((uint)(num4 - 2), 256u);
					}
				}
			}
			else
			{
				num3 = 0;
			}
			if (num3 == 0)
			{
				silk_bw_switch = 0;
				num4 = 0;
			}
			if (mode != OpusMode.MODE_CELT_ONLY)
			{
				startBand = 17;
			}
			if (mode == OpusMode.MODE_SILK_ONLY)
			{
				num = entropyCoder.tell() + 7 >> 3;
				entropyCoder.enc_done();
				num44 = num;
			}
			else
			{
				num44 = Inlines.IMIN(num9 - 1 - num4, num44);
				entropyCoder.enc_shrink((uint)num44);
			}
			if ((analysis.enabled && num3 != 0) || mode != OpusMode.MODE_SILK_ONLY)
			{
				celt_Encoder.SetAnalysis(analysisInfo);
			}
			if (num3 != 0 && num5 != 0)
			{
				celt_Encoder.SetStartBand(0);
				celt_Encoder.SetVBR(value: false);
				if (celt_Encoder.celt_encode_with_ec(array4, 0, Fs / 200, data, data_ptr + num44, num4, null) < 0)
				{
					return -3;
				}
				num7 = celt_Encoder.GetFinalRange();
				celt_Encoder.ResetState();
			}
			celt_Encoder.SetStartBand(startBand);
			if (mode != OpusMode.MODE_SILK_ONLY)
			{
				if (mode != prev_mode && prev_mode > (OpusMode)0)
				{
					byte[] compressed = new byte[2];
					celt_Encoder.ResetState();
					celt_Encoder.celt_encode_with_ec(array6, 0, Fs / 400, compressed, 0, 2, null);
					celt_Encoder.SetPrediction(0);
				}
				if (entropyCoder.tell() <= 8 * num44)
				{
					num = celt_Encoder.celt_encode_with_ec(array4, 0, frame_size, null, 0, num44, entropyCoder);
					if (num < 0)
					{
						return -3;
					}
				}
			}
			if (num3 != 0 && num5 == 0)
			{
				byte[] compressed2 = new byte[2];
				int num47 = Fs / 200;
				int num48 = Fs / 400;
				celt_Encoder.ResetState();
				celt_Encoder.SetStartBand(0);
				celt_Encoder.SetPrediction(0);
				celt_Encoder.celt_encode_with_ec(array4, channels * (frame_size - num47 - num48), num48, compressed2, 0, 2, null);
				if (celt_Encoder.celt_encode_with_ec(array4, channels * (frame_size - num47), num47, data, data_ptr + num44, num4, null) < 0)
				{
					return -3;
				}
				num7 = celt_Encoder.GetFinalRange();
			}
			data_ptr--;
			data[data_ptr] = CodecHelpers.gen_toc(mode, Fs / frame_size, opusBandwidth4, stream_channels);
			rangeFinal = entropyCoder.rng ^ num7;
			if (num6 != 0)
			{
				prev_mode = OpusMode.MODE_CELT_ONLY;
			}
			else
			{
				prev_mode = mode;
			}
			prev_channels = stream_channels;
			prev_framesize = frame_size;
			first = 0;
			if (entropyCoder.tell() > (num9 - 1) * 8)
			{
				if (num9 < 2)
				{
					return -2;
				}
				data[data_ptr + 1] = 0;
				num = 1;
				rangeFinal = 0u;
			}
			else if (mode == OpusMode.MODE_SILK_ONLY && num3 == 0)
			{
				while (num > 2 && data[data_ptr + num] == 0)
				{
					num--;
				}
			}
			num += 1 + num4;
			if (use_vbr == 0)
			{
				if (OpusRepacketizer.PadPacket(data, data_ptr, num, num9) != 0)
				{
					return -3;
				}
				num = num9;
			}
			return num;
		}

		private static int GetVariableQualityBitrate(int vqLevel, float music_prob)
		{
			float num = vqTable[vqLevel][0];
			float num2 = vqTable[vqLevel][1];
			float num3 = (float)Math.Sqrt(music_prob);
			return (int)(num2 * num3 + num * (1f - num3));
		}

		public int Encode(short[] in_pcm, int pcm_offset, int frame_size, byte[] out_data, int out_data_offset, int max_data_bytes)
		{
			if (out_data_offset + max_data_bytes > out_data.Length)
			{
				throw new ArgumentException(string.Format("Output buffer is too small: Stated size is {0} bytes, actual size is {1} bytes", new object[2]
				{
					max_data_bytes,
					out_data.Length - out_data_offset
				}));
			}
			int num = CodecHelpers.compute_frame_size(delay_compensation: (application != OpusApplication.OPUS_APPLICATION_RESTRICTED_LOWDELAY) ? delay_compensation : 0, analysis_pcm: in_pcm, analysis_pcm_ptr: pcm_offset, frame_size: frame_size, variable_duration: variable_duration, C: channels, Fs: Fs, bitrate_bps: bitrate_bps, downmix: Downmix.downmix_int, subframe_mem: analysis.subframe_mem, analysis_enabled: analysis.enabled);
			if (pcm_offset + num > in_pcm.Length)
			{
				throw new ArgumentException(string.Format("Not enough samples provided in input signal: Expected {0} samples, found {1}", new object[2]
				{
					num,
					in_pcm.Length - pcm_offset
				}));
			}
			try
			{
				int num2 = opus_encode_native(in_pcm, pcm_offset, num, out_data, out_data_offset, max_data_bytes, 16, in_pcm, pcm_offset, frame_size, 0, -2, channels, Downmix.downmix_int, 0);
				if (num2 < 0)
				{
					if (num2 == -1)
					{
						throw new ArgumentException("OPUS_BAD_ARG while encoding");
					}
					throw new OpusException("An error occurred during encoding", num2);
				}
				return num2;
			}
			catch (OutOfMemoryException ex)
			{
				throw new OpusException("Internal error during encoding: " + ex.Message);
			}
		}

		public int Encode(float[] in_pcm, int pcm_offset, int frame_size, byte[] out_data, int out_data_offset, int max_data_bytes)
		{
			if (out_data_offset + max_data_bytes > out_data.Length)
			{
				throw new ArgumentException(string.Format("Output buffer is too small: Stated size is {0} bytes, actual size is {1} bytes", new object[2]
				{
					max_data_bytes,
					out_data.Length - out_data_offset
				}));
			}
			int num = CodecHelpers.compute_frame_size(delay_compensation: (application != OpusApplication.OPUS_APPLICATION_RESTRICTED_LOWDELAY) ? delay_compensation : 0, analysis_pcm: in_pcm, analysis_pcm_ptr: pcm_offset, frame_size: frame_size, variable_duration: variable_duration, C: channels, Fs: Fs, bitrate_bps: bitrate_bps, downmix: Downmix.downmix_float, subframe_mem: analysis.subframe_mem, analysis_enabled: analysis.enabled);
			if (pcm_offset + num > in_pcm.Length)
			{
				throw new ArgumentException(string.Format("Not enough samples provided in input signal: Expected {0} samples, found {1}", new object[2]
				{
					num,
					in_pcm.Length - pcm_offset
				}));
			}
			short[] array = new short[num * channels];
			for (int i = 0; i < num * channels; i++)
			{
				array[i] = Inlines.FLOAT2INT16(in_pcm[pcm_offset + i]);
			}
			try
			{
				int num2 = opus_encode_native(array, 0, num, out_data, out_data_offset, max_data_bytes, 16, in_pcm, pcm_offset, frame_size, 0, -2, channels, Downmix.downmix_float, 1);
				if (num2 < 0)
				{
					if (num2 == -1)
					{
						throw new ArgumentException("OPUS_BAD_ARG while decoding");
					}
					throw new OpusException("An error occurred during encoding", num2);
				}
				return num2;
			}
			catch (OutOfMemoryException ex)
			{
				throw new OpusException("Internal error during encoding: " + ex.Message);
			}
		}

		internal void SetEnergyMask(int[] value)
		{
			energy_masking = value;
			Celt_Encoder.SetEnergyMask(value);
		}

		internal CeltMode GetCeltMode()
		{
			return Celt_Encoder.GetMode();
		}
	}
	internal class OpusMSDecoder
	{
		internal delegate void opus_copy_channel_out_func<T>(T[] dst, int dst_ptr, int dst_stride, int dst_channel, short[] src, int src_ptr, int src_stride, int frame_size);

		internal ChannelLayout layout = new ChannelLayout();

		internal OpusDecoder[] decoders;

		public OpusBandwidth Bandwidth
		{
			get
			{
				if (decoders == null || decoders.Length == 0)
				{
					throw new InvalidOperationException("Decoder not initialized");
				}
				return decoders[0].Bandwidth;
			}
		}

		public int SampleRate
		{
			get
			{
				if (decoders == null || decoders.Length == 0)
				{
					throw new InvalidOperationException("Decoder not initialized");
				}
				return decoders[0].SampleRate;
			}
		}

		public int Gain
		{
			get
			{
				if (decoders == null || decoders.Length == 0)
				{
					return -6;
				}
				return decoders[0].Gain;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					decoders[i].Gain = value;
				}
			}
		}

		public int LastPacketDuration
		{
			get
			{
				if (decoders == null || decoders.Length == 0)
				{
					return -6;
				}
				return decoders[0].LastPacketDuration;
			}
		}

		public uint FinalRange
		{
			get
			{
				uint num = 0u;
				for (int i = 0; i < layout.nb_streams; i++)
				{
					num ^= decoders[i].FinalRange;
				}
				return num;
			}
		}

		private OpusMSDecoder(int nb_streams, int nb_coupled_streams)
		{
			decoders = new OpusDecoder[nb_streams];
			for (int i = 0; i < nb_streams; i++)
			{
				decoders[i] = new OpusDecoder();
			}
		}

		internal int opus_multistream_decoder_init(int Fs, int channels, int streams, int coupled_streams, byte[] mapping)
		{
			int num = 0;
			if (channels > 255 || channels < 1 || coupled_streams > streams || streams < 1 || coupled_streams < 0 || streams > 255 - coupled_streams)
			{
				throw new ArgumentException("Invalid channel or coupled stream count");
			}
			layout.nb_channels = channels;
			layout.nb_streams = streams;
			layout.nb_coupled_streams = coupled_streams;
			int i;
			for (i = 0; i < layout.nb_channels; i++)
			{
				layout.mapping[i] = mapping[i];
			}
			if (OpusMultistream.validate_layout(layout) == 0)
			{
				throw new ArgumentException("Invalid surround channel layout");
			}
			for (i = 0; i < layout.nb_coupled_streams; i++)
			{
				int num2 = decoders[num].opus_decoder_init(Fs, 2);
				if (num2 != 0)
				{
					return num2;
				}
				num++;
			}
			for (; i < layout.nb_streams; i++)
			{
				int num2 = decoders[num].opus_decoder_init(Fs, 1);
				if (num2 != 0)
				{
					return num2;
				}
				num++;
			}
			return 0;
		}

		public OpusMSDecoder(int Fs, int channels, int streams, int coupled_streams, byte[] mapping)
			: this(streams, coupled_streams)
		{
			if (channels > 255 || channels < 1 || coupled_streams > streams || streams < 1 || coupled_streams < 0 || streams > 255 - coupled_streams)
			{
				throw new ArgumentException("Invalid channel / stream configuration");
			}
			int num = opus_multistream_decoder_init(Fs, channels, streams, coupled_streams, mapping);
			switch (num)
			{
			case -1:
				throw new ArgumentException("Bad argument while creating MS decoder");
			default:
				throw new OpusException("Could not create MS decoder", num);
			case 0:
				break;
			}
		}

		internal static int opus_multistream_packet_validate(byte[] data, int data_ptr, int len, int nb_streams, int Fs)
		{
			short[] sizes = new short[48];
			int num = 0;
			for (int i = 0; i < nb_streams; i++)
			{
				if (len <= 0)
				{
					return -4;
				}
				byte out_toc;
				int payload_offset;
				int packet_offset;
				int num2 = OpusPacketInfo.opus_packet_parse_impl(data, data_ptr, len, (i != nb_streams - 1) ? 1 : 0, out out_toc, null, null, 0, sizes, 0, out payload_offset, out packet_offset);
				if (num2 < 0)
				{
					return num2;
				}
				int numSamples = OpusPacketInfo.GetNumSamples(data, data_ptr, packet_offset, Fs);
				if (i != 0 && num != numSamples)
				{
					return -4;
				}
				num = numSamples;
				data_ptr += packet_offset;
				len -= packet_offset;
			}
			return num;
		}

		internal int opus_multistream_decode_native<T>(byte[] data, int data_ptr, int len, T[] pcm, int pcm_ptr, opus_copy_channel_out_func<T> copy_channel_out, int frame_size, int decode_fec, int soft_clip)
		{
			int num = 0;
			int sampleRate = SampleRate;
			frame_size = Inlines.IMIN(frame_size, sampleRate / 25 * 3);
			short[] array = new short[2 * frame_size];
			int num2 = 0;
			if (len == 0)
			{
				num = 1;
			}
			if (len < 0)
			{
				return -1;
			}
			if (num == 0 && len < 2 * layout.nb_streams - 1)
			{
				return -4;
			}
			if (num == 0)
			{
				int num3 = opus_multistream_packet_validate(data, data_ptr, len, layout.nb_streams, sampleRate);
				if (num3 < 0)
				{
					return num3;
				}
				if (num3 > frame_size)
				{
					return -2;
				}
			}
			for (int i = 0; i < layout.nb_streams; i++)
			{
				OpusDecoder opusDecoder = decoders[num2++];
				if (num == 0 && len <= 0)
				{
					return -3;
				}
				int packet_offset;
				int num4 = opusDecoder.opus_decode_native(data, data_ptr, len, array, 0, frame_size, decode_fec, (i != layout.nb_streams - 1) ? 1 : 0, out packet_offset, soft_clip);
				data_ptr += packet_offset;
				len -= packet_offset;
				if (num4 <= 0)
				{
					return num4;
				}
				frame_size = num4;
				if (i < layout.nb_coupled_streams)
				{
					int prev = -1;
					int num5;
					while ((num5 = OpusMultistream.get_left_channel(layout, i, prev)) != -1)
					{
						copy_channel_out(pcm, pcm_ptr, layout.nb_channels, num5, array, 0, 2, frame_size);
						prev = num5;
					}
					prev = -1;
					while ((num5 = OpusMultistream.get_right_channel(layout, i, prev)) != -1)
					{
						copy_channel_out(pcm, pcm_ptr, layout.nb_channels, num5, array, 1, 2, frame_size);
						prev = num5;
					}
				}
				else
				{
					int prev2 = -1;
					int num6;
					while ((num6 = OpusMultistream.get_mono_channel(layout, i, prev2)) != -1)
					{
						copy_channel_out(pcm, pcm_ptr, layout.nb_channels, num6, array, 0, 1, frame_size);
						prev2 = num6;
					}
				}
			}
			for (int j = 0; j < layout.nb_channels; j++)
			{
				if (layout.mapping[j] == byte.MaxValue)
				{
					copy_channel_out(pcm, pcm_ptr, layout.nb_channels, j, null, 0, 0, frame_size);
				}
			}
			return frame_size;
		}

		internal static void opus_copy_channel_out_float(float[] dst, int dst_ptr, int dst_stride, int dst_channel, short[] src, int src_ptr, int src_stride, int frame_size)
		{
			if (src != null)
			{
				for (int i = 0; i < frame_size; i++)
				{
					dst[i * dst_stride + dst_channel + dst_ptr] = 3.0517578E-05f * (float)src[i * src_stride + src_ptr];
				}
			}
			else
			{
				for (int i = 0; i < frame_size; i++)
				{
					dst[i * dst_stride + dst_channel + dst_ptr] = 0f;
				}
			}
		}

		internal static void opus_copy_channel_out_short(short[] dst, int dst_ptr, int dst_stride, int dst_channel, short[] src, int src_ptr, int src_stride, int frame_size)
		{
			if (src != null)
			{
				for (int i = 0; i < frame_size; i++)
				{
					dst[i * dst_stride + dst_channel + dst_ptr] = src[i * src_stride + src_ptr];
				}
			}
			else
			{
				for (int i = 0; i < frame_size; i++)
				{
					dst[i * dst_stride + dst_channel + dst_ptr] = 0;
				}
			}
		}

		public int DecodeMultistream(byte[] data, int data_offset, int len, short[] out_pcm, int out_pcm_offset, int frame_size, int decode_fec)
		{
			return opus_multistream_decode_native(data, data_offset, len, out_pcm, out_pcm_offset, opus_copy_channel_out_short, frame_size, decode_fec, 0);
		}

		public int DecodeMultistream(byte[] data, int data_offset, int len, float[] out_pcm, int out_pcm_offset, int frame_size, int decode_fec)
		{
			return opus_multistream_decode_native(data, data_offset, len, out_pcm, out_pcm_offset, opus_copy_channel_out_float, frame_size, decode_fec, 0);
		}

		public void ResetState()
		{
			for (int i = 0; i < layout.nb_streams; i++)
			{
				decoders[i].ResetState();
			}
		}

		public OpusDecoder GetMultistreamDecoderState(int streamId)
		{
			return decoders[streamId];
		}
	}
	internal class OpusMSEncoder
	{
		internal delegate void opus_copy_channel_in_func<T>(short[] dst, int dst_ptr, int dst_stride, T[] src, int src_ptr, int src_stride, int src_channel, int frame_size);

		internal readonly ChannelLayout layout = new ChannelLayout();

		internal int lfe_stream;

		internal OpusApplication application = OpusApplication.OPUS_APPLICATION_AUDIO;

		internal OpusFramesize variable_duration;

		internal int surround;

		internal int bitrate_bps;

		internal readonly float[] subframe_mem = new float[3];

		internal readonly OpusEncoder[] encoders;

		internal readonly int[] window_mem;

		internal readonly int[] preemph_mem;

		private static readonly int[] diff_table = new int[9] { 512, 300, 165, 87, 45, 23, 11, 6, 3 };

		private const int MS_FRAME_TMP = 3832;

		public int Bitrate
		{
			get
			{
				int num = 0;
				int num2 = 0;
				for (int i = 0; i < layout.nb_streams; i++)
				{
					OpusEncoder opusEncoder = encoders[num2++];
					num += opusEncoder.Bitrate;
				}
				return num;
			}
			set
			{
				if (value < 0 && value != -1000 && value != -1)
				{
					throw new ArgumentException("Invalid bitrate");
				}
				bitrate_bps = value;
			}
		}

		public OpusApplication Application
		{
			get
			{
				return encoders[0].Application;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].Application = value;
				}
			}
		}

		public int ForceChannels
		{
			get
			{
				return encoders[0].ForceChannels;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].ForceChannels = value;
				}
			}
		}

		public OpusBandwidth MaxBandwidth
		{
			get
			{
				return encoders[0].MaxBandwidth;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].MaxBandwidth = value;
				}
			}
		}

		public OpusBandwidth Bandwidth
		{
			get
			{
				return encoders[0].Bandwidth;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].Bandwidth = value;
				}
			}
		}

		public bool UseDTX
		{
			get
			{
				return encoders[0].UseDTX;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].UseDTX = value;
				}
			}
		}

		public int Complexity
		{
			get
			{
				return encoders[0].Complexity;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].Complexity = value;
				}
			}
		}

		public OpusMode ForceMode
		{
			get
			{
				return encoders[0].ForceMode;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].ForceMode = value;
				}
			}
		}

		public bool UseInbandFEC
		{
			get
			{
				return encoders[0].UseInbandFEC;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].UseInbandFEC = value;
				}
			}
		}

		public int PacketLossPercent
		{
			get
			{
				return encoders[0].PacketLossPercent;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].PacketLossPercent = value;
				}
			}
		}

		public bool UseVBR
		{
			get
			{
				return encoders[0].UseVBR;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].UseVBR = value;
				}
			}
		}

		public bool UseConstrainedVBR
		{
			get
			{
				return encoders[0].UseConstrainedVBR;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].UseConstrainedVBR = value;
				}
			}
		}

		public OpusSignal SignalType
		{
			get
			{
				return encoders[0].SignalType;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].SignalType = value;
				}
			}
		}

		public int Lookahead => encoders[0].Lookahead;

		public int SampleRate => encoders[0].SampleRate;

		public uint FinalRange
		{
			get
			{
				uint num = 0u;
				int num2 = 0;
				for (int i = 0; i < layout.nb_streams; i++)
				{
					num ^= encoders[num2++].FinalRange;
				}
				return num;
			}
		}

		public int LSBDepth
		{
			get
			{
				return encoders[0].LSBDepth;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].LSBDepth = value;
				}
			}
		}

		public bool PredictionDisabled
		{
			get
			{
				return encoders[0].PredictionDisabled;
			}
			set
			{
				for (int i = 0; i < layout.nb_streams; i++)
				{
					encoders[i].PredictionDisabled = value;
				}
			}
		}

		public OpusFramesize ExpertFrameDuration
		{
			get
			{
				return variable_duration;
			}
			set
			{
				variable_duration = value;
			}
		}

		private OpusMSEncoder(int nb_streams, int nb_coupled_streams)
		{
			if (nb_streams < 1 || nb_coupled_streams > nb_streams || nb_coupled_streams < 0)
			{
				throw new ArgumentException("Invalid channel count in MS encoder");
			}
			encoders = new OpusEncoder[nb_streams];
			for (int i = 0; i < nb_streams; i++)
			{
				encoders[i] = new OpusEncoder();
			}
			window_mem = new int[nb_streams * 120];
			preemph_mem = new int[nb_streams];
		}

		public void ResetState()
		{
			subframe_mem[0] = (subframe_mem[1] = (subframe_mem[2] = 0f));
			if (surround != 0)
			{
				Arrays.MemSetInt(preemph_mem, 0, layout.nb_channels);
				Arrays.MemSetInt(window_mem, 0, layout.nb_channels * 120);
			}
			int num = 0;
			for (int i = 0; i < layout.nb_streams; i++)
			{
				encoders[num++].ResetState();
			}
		}

		internal static int validate_encoder_layout(ChannelLayout layout)
		{
			for (int i = 0; i < layout.nb_streams; i++)
			{
				if (i < layout.nb_coupled_streams)
				{
					if (OpusMultistream.get_left_channel(layout, i, -1) == -1)
					{
						return 0;
					}
					if (OpusMultistream.get_right_channel(layout, i, -1) == -1)
					{
						return 0;
					}
				}
				else if (OpusMultistream.get_mono_channel(layout, i, -1) == -1)
				{
					return 0;
				}
			}
			return 1;
		}

		internal static void channel_pos(int channels, int[] pos)
		{
			switch (channels)
			{
			case 4:
				pos[0] = 1;
				pos[1] = 3;
				pos[2] = 1;
				pos[3] = 3;
				break;
			case 3:
			case 5:
			case 6:
				pos[0] = 1;
				pos[1] = 2;
				pos[2] = 3;
				pos[3] = 1;
				pos[4] = 3;
				pos[5] = 0;
				break;
			case 7:
				pos[0] = 1;
				pos[1] = 2;
				pos[2] = 3;
				pos[3] = 1;
				pos[4] = 3;
				pos[5] = 2;
				pos[6] = 0;
				break;
			case 8:
				pos[0] = 1;
				pos[1] = 2;
				pos[2] = 3;
				pos[3] = 1;
				pos[4] = 3;
				pos[5] = 1;
				pos[6] = 3;
				pos[7] = 0;
				break;
			}
		}

		internal static int logSum(int a, int b)
		{
			int num;
			int num2;
			if (a > b)
			{
				num = a;
				num2 = Inlines.SUB32(Inlines.EXTEND32(a), Inlines.EXTEND32(b));
			}
			else
			{
				num = b;
				num2 = Inlines.SUB32(Inlines.EXTEND32(b), Inlines.EXTEND32(a));
			}
			if (num2 >= 8192)
			{
				return num;
			}
			int num3 = Inlines.SHR32(num2, 9);
			int a2 = Inlines.SHL16(num2 - Inlines.SHL16(num3, 9), 6);
			return num + diff_table[num3] + Inlines.MULT16_16_Q15(a2, Inlines.SUB16(diff_table[num3 + 1], diff_table[num3]));
		}

		internal static void surround_analysis<T>(CeltMode celt_mode, T[] pcm, int pcm_ptr, int[] bandLogE, int[] mem, int[] preemph_mem, int len, int overlap, int channels, int rate, opus_copy_channel_in_func<T> copy_channel_in)
		{
			int[] array = new int[8];
			int[][] array2 = Arrays.InitTwoDimensionalArray<int>(1, 21);
			int[][] array3 = Arrays.InitTwoDimensionalArray<int>(3, 21);
			int num = CeltCommon.resampling_factor(rate);
			int num2 = len * num;
			int i;
			for (i = 0; i < celt_mode.maxLM && celt_mode.shortMdctSize << i != num2; i++)
			{
			}
			int[] array4 = new int[num2 + overlap];
			short[] array5 = new short[len];
			int[][] array6 = Arrays.InitTwoDimensionalArray<int>(1, num2);
			channel_pos(channels, array);
			for (int j = 0; j < 3; j++)
			{
				for (int k = 0; k < 21; k++)
				{
					array3[j][k] = -28672;
				}
			}
			for (int j = 0; j < channels; j++)
			{
				Array.Copy(mem, j * overlap, array4, 0, overlap);
				copy_channel_in(array5, 0, 1, pcm, pcm_ptr, channels, j, len);
				BoxedValueInt boxedValueInt = new BoxedValueInt(preemph_mem[j]);
				CeltCommon.celt_preemphasis(array5, array4, overlap, num2, 1, num, celt_mode.preemph, boxedValueInt, 0);
				preemph_mem[j] = boxedValueInt.Val;
				MDCT.clt_mdct_forward(celt_mode.mdct, array4, 0, array6[0], 0, celt_mode.window, overlap, celt_mode.maxLM - i, 1);
				if (num != 1)
				{
					int k;
					for (k = 0; k < len; k++)
					{
						array6[0][k] *= num;
					}
					for (; k < num2; k++)
					{
						array6[0][k] = 0;
					}
				}
				Bands.compute_band_energies(celt_mode, array6, array2, 21, 1, i);
				QuantizeBands.amp2Log2(celt_mode, 21, 21, array2[0], bandLogE, 21 * j, 1);
				for (int k = 1; k < 21; k++)
				{
					bandLogE[21 * j + k] = Inlines.MAX16(bandLogE[21 * j + k], bandLogE[21 * j + k - 1] - 1024);
				}
				for (int k = 19; k >= 0; k--)
				{
					bandLogE[21 * j + k] = Inlines.MAX16(bandLogE[21 * j + k], bandLogE[21 * j + k + 1] - 2048);
				}
				if (array[j] == 1)
				{
					for (int k = 0; k < 21; k++)
					{
						array3[0][k] = logSum(array3[0][k], bandLogE[21 * j + k]);
					}
				}
				else if (array[j] == 3)
				{
					for (int k = 0; k < 21; k++)
					{
						array3[2][k] = logSum(array3[2][k], bandLogE[21 * j + k]);
					}
				}
				else if (array[j] == 2)
				{
					for (int k = 0; k < 21; k++)
					{
						array3[0][k] = logSum(array3[0][k], bandLogE[21 * j + k] - 512);
						array3[2][k] = logSum(array3[2][k], bandLogE[21 * j + k] - 512);
					}
				}
				Array.Copy(array4, num2, mem, j * overlap, overlap);
			}
			for (int k = 0; k < 21; k++)
			{
				array3[1][k] = Inlines.MIN32(array3[0][k], array3[2][k]);
			}
			int num3 = Inlines.HALF16(Inlines.celt_log2(32768 / (channels - 1)));
			for (int j = 0; j < 3; j++)
			{
				for (int k = 0; k < 21; k++)
				{
					array3[j][k] += num3;
				}
			}
			for (int j = 0; j < channels; j++)
			{
				if (array[j] != 0)
				{
					int[] array7 = array3[array[j] - 1];
					for (int k = 0; k < 21; k++)
					{
						bandLogE[21 * j + k] -= array7[k];
					}
				}
				else
				{
					for (int k = 0; k < 21; k++)
					{
						bandLogE[21 * j + k] = 0;
					}
				}
			}
		}

		internal int opus_multistream_encoder_init(int Fs, int channels, int streams, int coupled_streams, byte[] mapping, OpusApplication application, int surround)
		{
			if (channels > 255 || channels < 1 || coupled_streams > streams || streams < 1 || coupled_streams < 0 || streams > 255 - coupled_streams)
			{
				return -1;
			}
			layout.nb_channels = channels;
			layout.nb_streams = streams;
			layout.nb_coupled_streams = coupled_streams;
			subframe_mem[0] = (subframe_mem[1] = (subframe_mem[2] = 0f));
			if (surround == 0)
			{
				lfe_stream = -1;
			}
			bitrate_bps = -1000;
			this.application = application;
			variable_duration = OpusFramesize.OPUS_FRAMESIZE_ARG;
			int i;
			for (i = 0; i < layout.nb_channels; i++)
			{
				layout.mapping[i] = mapping[i];
			}
			if (OpusMultistream.validate_layout(layout) == 0 || validate_encoder_layout(layout) == 0)
			{
				return -1;
			}
			int num = 0;
			for (i = 0; i < layout.nb_coupled_streams; i++)
			{
				int num2 = encoders[num].opus_init_encoder(Fs, 2, application);
				if (num2 != 0)
				{
					return num2;
				}
				if (i == lfe_stream)
				{
					encoders[num].IsLFE = true;
				}
				num++;
			}
			for (; i < layout.nb_streams; i++)
			{
				int num2 = encoders[num].opus_init_encoder(Fs, 1, application);
				if (i == lfe_stream)
				{
					encoders[num].IsLFE = true;
				}
				if (num2 != 0)
				{
					return num2;
				}
				num++;
			}
			if (surround != 0)
			{
				Arrays.MemSetInt(preemph_mem, 0, channels);
				Arrays.MemSetInt(window_mem, 0, channels * 120);
			}
			this.surround = surround;
			return 0;
		}

		internal int opus_multistream_surround_encoder_init(int Fs, int channels, int mapping_family, out int streams, out int coupled_streams, byte[] mapping, OpusApplication application)
		{
			streams = 0;
			coupled_streams = 0;
			if (channels > 255 || channels < 1)
			{
				return -1;
			}
			lfe_stream = -1;
			if (mapping_family == 0)
			{
				switch (channels)
				{
				case 1:
					streams = 1;
					coupled_streams = 0;
					mapping[0] = 0;
					break;
				case 2:
					streams = 1;
					coupled_streams = 1;
					mapping[0] = 0;
					mapping[1] = 1;
					break;
				default:
					return -5;
				}
			}
			else if (mapping_family == 1 && channels <= 8 && channels >= 1)
			{
				streams = VorbisLayout.vorbis_mappings[channels - 1].nb_streams;
				coupled_streams = VorbisLayout.vorbis_mappings[channels - 1].nb_coupled_streams;
				for (int i = 0; i < channels; i++)
				{
					mapping[i] = VorbisLayout.vorbis_mappings[channels - 1].mapping[i];
				}
				if (channels >= 6)
				{
					lfe_stream = streams - 1;
				}
			}
			else
			{
				if (mapping_family != 255)
				{
					return -5;
				}
				streams = channels;
				coupled_streams = 0;
				for (byte b = 0; b < channels; b++)
				{
					mapping[b] = b;
				}
			}
			return opus_multistream_encoder_init(Fs, channels, streams, coupled_streams, mapping, application, (channels > 2 && mapping_family == 1) ? 1 : 0);
		}

		public static OpusMSEncoder Create(int Fs, int channels, int streams, int coupled_streams, byte[] mapping, OpusApplication application)
		{
			if (channels > 255 || channels < 1 || coupled_streams > streams || streams < 1 || coupled_streams < 0 || streams > 255 - coupled_streams)
			{
				throw new ArgumentException("Invalid channel / stream configuration");
			}
			OpusMSEncoder opusMSEncoder = new OpusMSEncoder(streams, coupled_streams);
			int num = opusMSEncoder.opus_multistream_encoder_init(Fs, channels, streams, coupled_streams, mapping, application, 0);
			return num switch
			{
				-1 => throw new ArgumentException("OPUS_BAD_ARG when creating MS encoder"), 
				0 => opusMSEncoder, 
				_ => throw new OpusException("Could not create MS encoder", num), 
			};
		}

		internal static void GetStreamCount(int channels, int mapping_family, BoxedValueInt nb_streams, BoxedValueInt nb_coupled_streams)
		{
			switch (mapping_family)
			{
			case 0:
				switch (channels)
				{
				case 1:
					nb_streams.Val = 1;
					nb_coupled_streams.Val = 0;
					break;
				case 2:
					nb_streams.Val = 1;
					nb_coupled_streams.Val = 1;
					break;
				default:
					throw new ArgumentException("More than 2 channels requires custom mappings");
				}
				return;
			case 1:
				if (channels <= 8 && channels >= 1)
				{
					nb_streams.Val = VorbisLayout.vorbis_mappings[channels - 1].nb_streams;
					nb_coupled_streams.Val = VorbisLayout.vorbis_mappings[channels - 1].nb_coupled_streams;
					return;
				}
				break;
			}
			if (mapping_family == 255)
			{
				nb_streams.Val = channels;
				nb_coupled_streams.Val = 0;
				return;
			}
			throw new ArgumentException("Invalid mapping family");
		}

		public static OpusMSEncoder CreateSurround(int Fs, int channels, int mapping_family, out int streams, out int coupled_streams, byte[] mapping, OpusApplication application)
		{
			if (channels > 255 || channels < 1 || application == OpusApplication.OPUS_APPLICATION_UNIMPLEMENTED)
			{
				throw new ArgumentException("Invalid channel count or application");
			}
			BoxedValueInt boxedValueInt = new BoxedValueInt();
			BoxedValueInt boxedValueInt2 = new BoxedValueInt();
			GetStreamCount(channels, mapping_family, boxedValueInt, boxedValueInt2);
			OpusMSEncoder opusMSEncoder = new OpusMSEncoder(boxedValueInt.Val, boxedValueInt2.Val);
			int num = opusMSEncoder.opus_multistream_surround_encoder_init(Fs, channels, mapping_family, out streams, out coupled_streams, mapping, application);
			return num switch
			{
				-1 => throw new ArgumentException("Bad argument passed to CreateSurround"), 
				0 => opusMSEncoder, 
				_ => throw new OpusException("Could not create multistream encoder", num), 
			};
		}

		internal int surround_rate_allocation(int[] out_rates, int frame_size)
		{
			int num = 0;
			int sampleRate = encoders[0].SampleRate;
			int num2 = ((bitrate_bps <= layout.nb_channels * 40000) ? (bitrate_bps / layout.nb_channels / 2) : 20000);
			num2 += 60 * (sampleRate / frame_size - 50);
			int num3 = 3500 + 60 * (sampleRate / frame_size - 50);
			int num4 = 512;
			int num5 = 32;
			int num6;
			if (bitrate_bps == -1000)
			{
				num6 = sampleRate + 60 * sampleRate / frame_size;
			}
			else if (bitrate_bps == -1)
			{
				num6 = 300000;
			}
			else
			{
				int num7 = ((lfe_stream != -1) ? 1 : 0);
				int nb_coupled_streams = layout.nb_coupled_streams;
				int num8 = layout.nb_streams - nb_coupled_streams - num7;
				int num9 = (num8 << 8) + num4 * nb_coupled_streams + num7 * num5;
				num6 = 256 * (bitrate_bps - num3 * num7 - num2 * (nb_coupled_streams + num8)) / num9;
			}
			for (int i = 0; i < layout.nb_streams; i++)
			{
				if (i < layout.nb_coupled_streams)
				{
					out_rates[i] = num2 + (num6 * num4 >> 8);
				}
				else if (i != lfe_stream)
				{
					out_rates[i] = num2 + num6;
				}
				else
				{
					out_rates[i] = num3 + (num6 * num5 >> 8);
				}
				out_rates[i] = Inlines.IMAX(out_rates[i], 500);
				num += out_rates[i];
			}
			return num;
		}

		internal int opus_multistream_encode_native<T>(opus_copy_channel_in_func<T> copy_channel_in, T[] pcm, int pcm_ptr, int analysis_frame_size, byte[] data, int data_ptr, int max_data_bytes, int lsb_depth, Downmix.downmix_func<T> downmix, int float_api)
		{
			byte[] data2 = new byte[3832];
			OpusRepacketizer opusRepacketizer = new OpusRepacketizer();
			int[] array = new int[256];
			int[] array2 = new int[42];
			int[] mem = null;
			int[] array3 = null;
			if (surround != 0)
			{
				array3 = preemph_mem;
				mem = window_mem;
			}
			int num = 0;
			int sampleRate = encoders[num].SampleRate;
			int num2 = (encoders[num].UseVBR ? 1 : 0);
			CeltMode celtMode = encoders[num].GetCeltMode();
			int c = layout.nb_streams + layout.nb_coupled_streams;
			int lookahead = encoders[num].Lookahead;
			lookahead -= sampleRate / 400;
			int num3 = CodecHelpers.compute_frame_size(pcm, pcm_ptr, analysis_frame_size, variable_duration, c, sampleRate, bitrate_bps, lookahead, downmix, subframe_mem, encoders[num].analysis.enabled);
			if (400 * num3 < sampleRate)
			{
				return -1;
			}
			if (400 * num3 != sampleRate && 200 * num3 != sampleRate && 100 * num3 != sampleRate && 50 * num3 != sampleRate && 25 * num3 != sampleRate && 50 * num3 != 3 * sampleRate)
			{
				return -1;
			}
			int num4 = layout.nb_streams * 2 - 1;
			if (max_data_bytes < num4)
			{
				return -2;
			}
			short[] array4 = new short[2 * num3];
			int[] array5 = new int[21 * layout.nb_channels];
			if (surround != 0)
			{
				surround_analysis(celtMode, pcm, pcm_ptr, array5, mem, array3, num3, 120, layout.nb_channels, sampleRate, copy_channel_in);
			}
			int num5 = surround_rate_allocation(array, num3);
			if (num2 == 0)
			{
				if (bitrate_bps == -1000)
				{
					max_data_bytes = Inlines.IMIN(max_data_bytes, 3 * num5 / (24 * sampleRate / num3));
				}
				else if (bitrate_bps != -1)
				{
					max_data_bytes = Inlines.IMIN(max_data_bytes, Inlines.IMAX(num4, 3 * bitrate_bps / (24 * sampleRate / num3)));
				}
			}
			for (int i = 0; i < layout.nb_streams; i++)
			{
				OpusEncoder opusEncoder = encoders[num];
				num++;
				opusEncoder.Bitrate = array[i];
				if (surround != 0)
				{
					int num6 = bitrate_bps;
					if (num3 * 50 < sampleRate)
					{
						num6 -= 60 * (sampleRate / num3 - 50) * layout.nb_channels;
					}
					if (num6 > 10000 * layout.nb_channels)
					{
						opusEncoder.Bandwidth = OpusBandwidth.OPUS_BANDWIDTH_FULLBAND;
					}
					else if (num6 > 7000 * layout.nb_channels)
					{
						opusEncoder.Bandwidth = OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND;
					}
					else if (num6 > 5000 * layout.nb_channels)
					{
						opusEncoder.Bandwidth = OpusBandwidth.OPUS_BANDWIDTH_WIDEBAND;
					}
					else
					{
						opusEncoder.Bandwidth = OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND;
					}
					if (i < layout.nb_coupled_streams)
					{
						opusEncoder.ForceMode = OpusMode.MODE_CELT_ONLY;
						opusEncoder.ForceChannels = 2;
					}
				}
			}
			num = 0;
			int num7 = 0;
			for (int i = 0; i < layout.nb_streams; i++)
			{
				opusRepacketizer.Reset();
				OpusEncoder opusEncoder2 = encoders[num];
				int c2;
				int c3;
				if (i < layout.nb_coupled_streams)
				{
					int num8 = OpusMultistream.get_left_channel(layout, i, -1);
					int num9 = OpusMultistream.get_right_channel(layout, i, -1);
					copy_channel_in(array4, 0, 2, pcm, pcm_ptr, layout.nb_channels, num8, num3);
					copy_channel_in(array4, 1, 2, pcm, pcm_ptr, layout.nb_channels, num9, num3);
					num++;
					if (surround != 0)
					{
						for (int j = 0; j < 21; j++)
						{
							array2[j] = array5[21 * num8 + j];
							array2[21 + j] = array5[21 * num9 + j];
						}
					}
					c2 = num8;
					c3 = num9;
				}
				else
				{
					int num10 = OpusMultistream.get_mono_channel(layout, i, -1);
					copy_channel_in(array4, 0, 1, pcm, pcm_ptr, layout.nb_channels, num10, num3);
					num++;
					if (surround != 0)
					{
						for (int k = 0; k < 21; k++)
						{
							array2[k] = array5[21 * num10 + k];
						}
					}
					c2 = num10;
					c3 = -1;
				}
				if (surround != 0)
				{
					opusEncoder2.SetEnergyMask(array2);
				}
				int num11 = max_data_bytes - num7;
				num11 -= Inlines.IMAX(0, 2 * (layout.nb_streams - i - 1) - 1);
				num11 = Inlines.IMIN(num11, 3832);
				if (i != layout.nb_streams - 1)
				{
					num11 -= ((num11 <= 253) ? 1 : 2);
				}
				if (num2 == 0 && i == layout.nb_streams - 1)
				{
					opusEncoder2.Bitrate = num11 * (8 * sampleRate / num3);
				}
				int num12 = opusEncoder2.opus_encode_native(array4, 0, num3, data2, 0, num11, lsb_depth, pcm, pcm_ptr, analysis_frame_size, c2, c3, layout.nb_channels, downmix, float_api);
				if (num12 < 0)
				{
					return num12;
				}
				opusRepacketizer.AddPacket(data2, 0, num12);
				num12 = opusRepacketizer.opus_repacketizer_out_range_impl(0, opusRepacketizer.GetNumFrames(), data, data_ptr, max_data_bytes - num7, (i != layout.nb_streams - 1) ? 1 : 0, (num2 == 0 && i == layout.nb_streams - 1) ? 1 : 0);
				data_ptr += num12;
				num7 += num12;
			}
			return num7;
		}

		internal static void opus_copy_channel_in_float(short[] dst, int dst_ptr, int dst_stride, float[] src, int src_ptr, int src_stride, int src_channel, int frame_size)
		{
			for (int i = 0; i < frame_size; i++)
			{
				dst[dst_ptr + i * dst_stride] = Inlines.FLOAT2INT16(src[i * src_stride + src_channel + src_ptr]);
			}
		}

		internal static void opus_copy_channel_in_short(short[] dst, int dst_ptr, int dst_stride, short[] src, int src_ptr, int src_stride, int src_channel, int frame_size)
		{
			for (int i = 0; i < frame_size; i++)
			{
				dst[dst_ptr + i * dst_stride] = src[i * src_stride + src_channel + src_ptr];
			}
		}

		public int EncodeMultistream(short[] pcm, int pcm_offset, int frame_size, byte[] outputBuffer, int outputBuffer_offset, int max_data_bytes)
		{
			return opus_multistream_encode_native(opus_copy_channel_in_short, pcm, pcm_offset, frame_size, outputBuffer, outputBuffer_offset, max_data_bytes, 16, Downmix.downmix_int, 0);
		}

		public int EncodeMultistream(float[] pcm, int pcm_offset, int frame_size, byte[] outputBuffer, int outputBuffer_offset, int max_data_bytes)
		{
			return opus_multistream_encode_native(opus_copy_channel_in_float, pcm, pcm_offset, frame_size, outputBuffer, outputBuffer_offset, max_data_bytes, 16, Downmix.downmix_float, 1);
		}

		public OpusEncoder GetMultistreamEncoderState(int streamId)
		{
			if (streamId >= layout.nb_streams)
			{
				throw new ArgumentException("Requested stream doesn't exist");
			}
			return encoders[streamId];
		}
	}
	internal class OpusPacketInfo
	{
		public readonly byte TOCByte;

		public readonly IList<byte[]> Frames;

		public readonly int PayloadOffset;

		private OpusPacketInfo(byte toc, IList<byte[]> frames, int payloadOffset)
		{
			TOCByte = toc;
			Frames = frames;
			PayloadOffset = payloadOffset;
		}

		public static OpusPacketInfo ParseOpusPacket(byte[] packet, int packet_offset, int len)
		{
			int numFrames = GetNumFrames(packet, packet_offset, len);
			byte[][] array = new byte[numFrames][];
			int[] array2 = new int[numFrames];
			short[] array3 = new short[numFrames];
			byte out_toc;
			int payload_offset;
			int packet_offset2;
			int num = opus_packet_parse_impl(packet, packet_offset, len, 0, out out_toc, array, array2, 0, array3, 0, out payload_offset, out packet_offset2);
			if (num < 0)
			{
				throw new OpusException("An error occurred while parsing the packet", num);
			}
			IList<byte[]> list = new List<byte[]>();
			for (int i = 0; i < numFrames; i++)
			{
				byte[] array4 = new byte[array3[i]];
				Array.Copy(array[i], array2[i], array4, 0, array4.Length);
				list.Add(array4);
			}
			return new OpusPacketInfo(out_toc, list, payload_offset);
		}

		public static int GetNumSamplesPerFrame(byte[] packet, int packet_offset, int Fs)
		{
			int num;
			if ((packet[packet_offset] & 0x80) != 0)
			{
				num = (packet[packet_offset] >> 3) & 3;
				return (Fs << num) / 400;
			}
			if ((packet[packet_offset] & 0x60) == 96)
			{
				return ((packet[packet_offset] & 8) != 0) ? (Fs / 50) : (Fs / 100);
			}
			num = (packet[packet_offset] >> 3) & 3;
			if (num == 3)
			{
				return Fs * 60 / 1000;
			}
			return (Fs << num) / 100;
		}

		public static OpusBandwidth GetBandwidth(byte[] packet, int packet_offset)
		{
			OpusBandwidth opusBandwidth;
			if ((packet[packet_offset] & 0x80) == 0)
			{
				opusBandwidth = (((packet[packet_offset] & 0x60) != 96) ? ((OpusBandwidth)(1101 + ((packet[packet_offset] >> 5) & 3))) : (((packet[packet_offset] & 0x10) != 0) ? OpusBandwidth.OPUS_BANDWIDTH_FULLBAND : OpusBandwidth.OPUS_BANDWIDTH_SUPERWIDEBAND));
			}
			else
			{
				opusBandwidth = (OpusBandwidth)(1102 + ((packet[packet_offset] >> 5) & 3));
				if (opusBandwidth == OpusBandwidth.OPUS_BANDWIDTH_MEDIUMBAND)
				{
					opusBandwidth = OpusBandwidth.OPUS_BANDWIDTH_NARROWBAND;
				}
			}
			return opusBandwidth;
		}

		public static int GetNumEncodedChannels(byte[] packet, int packet_offset)
		{
			if ((packet[packet_offset] & 4) == 0)
			{
				return 1;
			}
			return 2;
		}

		public static int GetNumFrames(byte[] packet, int packet_offset, int len)
		{
			if (len < 1)
			{
				return -1;
			}
			switch (packet[packet_offset] & 3)
			{
			case 0:
				return 1;
			default:
				return 2;
			case 3:
				if (len < 2)
				{
					return -4;
				}
				return packet[packet_offset + 1] & 0x3F;
			}
		}

		public static int GetNumSamples(byte[] packet, int packet_offset, int len, int Fs)
		{
			int numFrames = GetNumFrames(packet, packet_offset, len);
			if (numFrames < 0)
			{
				return numFrames;
			}
			int num = numFrames * GetNumSamplesPerFrame(packet, packet_offset, Fs);
			if (num * 25 > Fs * 3)
			{
				return -4;
			}
			return num;
		}

		public static int GetNumSamples(OpusDecoder dec, byte[] packet, int packet_offset, int len)
		{
			return GetNumSamples(packet, packet_offset, len, dec.Fs);
		}

		public static OpusMode GetEncoderMode(byte[] packet, int packet_offset)
		{
			if ((packet[packet_offset] & 0x80) != 0)
			{
				return OpusMode.MODE_CELT_ONLY;
			}
			if ((packet[packet_offset] & 0x60) == 96)
			{
				return OpusMode.MODE_HYBRID;
			}
			return OpusMode.MODE_SILK_ONLY;
		}

		internal static int encode_size(int size, byte[] data, int data_ptr)
		{
			if (size < 252)
			{
				data[data_ptr] = (byte)size;
				return 1;
			}
			data[data_ptr] = (byte)(252 + (size & 3));
			data[data_ptr + 1] = (byte)(size - data[data_ptr] >> 2);
			return 2;
		}

		internal static int parse_size(byte[] data, int data_ptr, int len, BoxedValueShort size)
		{
			if (len < 1)
			{
				size.Val = -1;
				return -1;
			}
			if (data[data_ptr] < 252)
			{
				size.Val = data[data_ptr];
				return 1;
			}
			if (len < 2)
			{
				size.Val = -1;
				return -1;
			}
			size.Val = (short)(4 * data[data_ptr + 1] + data[data_ptr]);
			return 2;
		}

		internal static int opus_packet_parse_impl(byte[] data, int data_ptr, int len, int self_delimited, out byte out_toc, byte[][] frames, int[] frames_ptrs, int frames_ptr, short[] sizes, int sizes_ptr, out int payload_offset, out int packet_offset)
		{
			int num = 0;
			int num2 = data_ptr;
			out_toc = 0;
			payload_offset = 0;
			packet_offset = 0;
			if (sizes == null || len < 0)
			{
				return -1;
			}
			if (len == 0)
			{
				return -4;
			}
			int numSamplesPerFrame = GetNumSamplesPerFrame(data, data_ptr, 48000);
			int num3 = 0;
			byte b = data[data_ptr++];
			len--;
			int num4 = len;
			int num5;
			switch (b & 3)
			{
			case 0:
				num5 = 1;
				break;
			case 1:
				num5 = 2;
				num3 = 1;
				if (self_delimited == 0)
				{
					if ((len & 1) != 0)
					{
						return -4;
					}
					num4 = len / 2;
					sizes[sizes_ptr] = (short)num4;
				}
				break;
			case 2:
			{
				num5 = 2;
				BoxedValueShort boxedValueShort = new BoxedValueShort(sizes[sizes_ptr]);
				int num8 = parse_size(data, data_ptr, len, boxedValueShort);
				sizes[sizes_ptr] = boxedValueShort.Val;
				len -= num8;
				if (sizes[sizes_ptr] < 0 || sizes[sizes_ptr] > len)
				{
					return -4;
				}
				data_ptr += num8;
				num4 = len - sizes[sizes_ptr];
				break;
			}
			default:
			{
				if (len < 1)
				{
					return -4;
				}
				byte b2 = data[data_ptr++];
				num5 = b2 & 0x3F;
				if (num5 <= 0 || numSamplesPerFrame * num5 > 5760)
				{
					return -4;
				}
				len--;
				if ((b2 & 0x40) != 0)
				{
					int num6;
					do
					{
						if (len <= 0)
						{
							return -4;
						}
						num6 = data[data_ptr++];
						len--;
						int num7 = ((num6 == 255) ? 254 : num6);
						len -= num7;
						num += num7;
					}
					while (num6 == 255);
				}
				if (len < 0)
				{
					return -4;
				}
				num3 = (((b2 & 0x80) == 0) ? 1 : 0);
				if (num3 == 0)
				{
					num4 = len;
					for (int i = 0; i < num5 - 1; i++)
					{
						BoxedValueShort boxedValueShort = new BoxedValueShort(sizes[sizes_ptr + i]);
						int num8 = parse_size(data, data_ptr, len, boxedValueShort);
						sizes[sizes_ptr + i] = boxedValueShort.Val;
						len -= num8;
						if (sizes[sizes_ptr + i] < 0 || sizes[sizes_ptr + i] > len)
						{
							return -4;
						}
						data_ptr += num8;
						num4 -= num8 + sizes[sizes_ptr + i];
					}
					if (num4 < 0)
					{
						return -4;
					}
				}
				else if (self_delimited == 0)
				{
					num4 = len / num5;
					if (num4 * num5 != len)
					{
						return -4;
					}
					for (int i = 0; i < num5 - 1; i++)
					{
						sizes[sizes_ptr + i] = (short)num4;
					}
				}
				break;
			}
			}
			if (self_delimited != 0)
			{
				BoxedValueShort boxedValueShort2 = new BoxedValueShort(sizes[sizes_ptr + num5 - 1]);
				int num8 = parse_size(data, data_ptr, len, boxedValueShort2);
				sizes[sizes_ptr + num5 - 1] = boxedValueShort2.Val;
				len -= num8;
				if (sizes[sizes_ptr + num5 - 1] < 0 || sizes[sizes_ptr + num5 - 1] > len)
				{
					return -4;
				}
				data_ptr += num8;
				if (num3 != 0)
				{
					if (sizes[sizes_ptr + num5 - 1] * num5 > len)
					{
						return -4;
					}
					for (int i = 0; i < num5 - 1; i++)
					{
						sizes[sizes_ptr + i] = sizes[sizes_ptr + num5 - 1];
					}
				}
				else if (num8 + sizes[sizes_ptr + num5 - 1] > num4)
				{
					return -4;
				}
			}
			else
			{
				if (num4 > 1275)
				{
					return -4;
				}
				sizes[sizes_ptr + num5 - 1] = (short)num4;
			}
			payload_offset = data_ptr - num2;
			for (int i = 0; i < num5; i++)
			{
				if (frames != null)
				{
					frames[frames_ptr + i] = data;
				}
				if (frames_ptrs != null)
				{
					frames_ptrs[frames_ptr + i] = data_ptr;
				}
				data_ptr += sizes[sizes_ptr + i];
			}
			packet_offset = num + (data_ptr - num2);
			out_toc = b;
			return num5;
		}
	}
	internal class OpusRepacketizer
	{
		internal byte toc;

		internal int nb_frames;

		internal readonly byte[][] frames = new byte[48][];

		internal readonly int[] frames_ptrs = new int[48];

		internal readonly short[] len = new short[48];

		internal int framesize;

		public void Reset()
		{
			nb_frames = 0;
		}

		public OpusRepacketizer()
		{
			Reset();
		}

		internal int opus_repacketizer_cat_impl(byte[] data, int data_ptr, int len, int self_delimited)
		{
			if (len < 1)
			{
				return -4;
			}
			if (nb_frames == 0)
			{
				toc = data[data_ptr];
				framesize = OpusPacketInfo.GetNumSamplesPerFrame(data, data_ptr, 8000);
			}
			else if ((toc & 0xFC) != (data[data_ptr] & 0xFC))
			{
				return -4;
			}
			int numFrames = OpusPacketInfo.GetNumFrames(data, data_ptr, len);
			if (numFrames < 1)
			{
				return -4;
			}
			if ((numFrames + nb_frames) * framesize > 960)
			{
				return -4;
			}
			byte out_toc;
			int payload_offset;
			int num = OpusPacketInfo.opus_packet_parse_impl(data, data_ptr, len, self_delimited, out out_toc, frames, frames_ptrs, nb_frames, this.len, nb_frames, out payload_offset, out payload_offset);
			if (num < 1)
			{
				return num;
			}
			nb_frames += numFrames;
			return 0;
		}

		public int AddPacket(byte[] data, int data_offset, int len)
		{
			return opus_repacketizer_cat_impl(data, data_offset, len, 0);
		}

		public int GetNumFrames()
		{
			return nb_frames;
		}

		internal int opus_repacketizer_out_range_impl(int begin, int end, byte[] data, int data_ptr, int maxlen, int self_delimited, int pad)
		{
			if (begin < 0 || begin >= end || end > nb_frames)
			{
				return -1;
			}
			int num = end - begin;
			int num2 = ((self_delimited != 0) ? (1 + ((len[num - 1] >= 252) ? 1 : 0)) : 0);
			int num3 = data_ptr;
			switch (num)
			{
			case 1:
				num2 += len[0] + 1;
				if (num2 > maxlen)
				{
					return -2;
				}
				data[num3++] = (byte)(toc & 0xFC);
				break;
			case 2:
				if (len[1] == len[0])
				{
					num2 += 2 * len[0] + 1;
					if (num2 > maxlen)
					{
						return -2;
					}
					data[num3++] = (byte)((toc & 0xFC) | 1);
					break;
				}
				num2 += len[0] + len[1] + 2 + ((len[0] >= 252) ? 1 : 0);
				if (num2 > maxlen)
				{
					return -2;
				}
				data[num3++] = (byte)((toc & 0xFC) | 2);
				num3 += OpusPacketInfo.encode_size(len[0], data, num3);
				break;
			}
			if (num > 2 || (pad != 0 && num2 < maxlen))
			{
				int num4 = 0;
				num3 = data_ptr;
				num2 = ((self_delimited != 0) ? (1 + ((len[num - 1] >= 252) ? 1 : 0)) : 0);
				int num5 = 0;
				for (int i = 1; i < num; i++)
				{
					if (len[i] != len[0])
					{
						num5 = 1;
						break;
					}
				}
				if (num5 != 0)
				{
					num2 += 2;
					for (int i = 0; i < num - 1; i++)
					{
						num2 += 1 + ((len[i] >= 252) ? 1 : 0) + len[i];
					}
					num2 += len[num - 1];
					if (num2 > maxlen)
					{
						return -2;
					}
					data[num3++] = (byte)((toc & 0xFC) | 3);
					data[num3++] = (byte)(num | 0x80);
				}
				else
				{
					num2 += num * len[0] + 2;
					if (num2 > maxlen)
					{
						return -2;
					}
					data[num3++] = (byte)((toc & 0xFC) | 3);
					data[num3++] = (byte)num;
				}
				num4 = ((pad != 0) ? (maxlen - num2) : 0);
				if (num4 != 0)
				{
					data[data_ptr + 1] |= 64;
					int num6 = (num4 - 1) / 255;
					for (int i = 0; i < num6; i++)
					{
						data[num3++] = byte.MaxValue;
					}
					data[num3++] = (byte)(num4 - 255 * num6 - 1);
					num2 += num4;
				}
				if (num5 != 0)
				{
					for (int i = 0; i < num - 1; i++)
					{
						num3 += OpusPacketInfo.encode_size(len[i], data, num3);
					}
				}
			}
			if (self_delimited != 0)
			{
				int num7 = OpusPacketInfo.encode_size(len[num - 1], data, num3);
				num3 += num7;
			}
			for (int i = begin; i < num + begin; i++)
			{
				if (frames[i] == data)
				{
					Arrays.MemMove(data, frames_ptrs[i], num3, len[i]);
				}
				else
				{
					Array.Copy(frames[i], frames_ptrs[i], data, num3, len[i]);
				}
				num3 += len[i];
			}
			if (pad != 0)
			{
				while (num3 < data_ptr + maxlen)
				{
					data[num3++] = 0;
				}
			}
			return num2;
		}

		public int CreatePacket(int begin, int end, byte[] data, int data_offset, int maxlen)
		{
			return opus_repacketizer_out_range_impl(begin, end, data, data_offset, maxlen, 0, 0);
		}

		public int CreatePacket(byte[] data, int data_offset, int maxlen)
		{
			return opus_repacketizer_out_range_impl(0, nb_frames, data, data_offset, maxlen, 0, 0);
		}

		public static int PadPacket(byte[] data, int data_offset, int len, int new_len)
		{
			OpusRepacketizer opusRepacketizer = new OpusRepacketizer();
			if (len < 1)
			{
				return -1;
			}
			if (len == new_len)
			{
				return 0;
			}
			if (len > new_len)
			{
				return -1;
			}
			opusRepacketizer.Reset();
			Arrays.MemMove(data, data_offset, data_offset + new_len - len, len);
			opusRepacketizer.AddPacket(data, data_offset + new_len - len, len);
			int num = opusRepacketizer.opus_repacketizer_out_range_impl(0, opusRepacketizer.nb_frames, data, data_offset, new_len, 0, 1);
			if (num > 0)
			{
				return 0;
			}
			return num;
		}

		public static int UnpadPacket(byte[] data, int data_offset, int len)
		{
			if (len < 1)
			{
				return -1;
			}
			OpusRepacketizer opusRepacketizer = new OpusRepacketizer();
			opusRepacketizer.Reset();
			int num = opusRepacketizer.AddPacket(data, data_offset, len);
			if (num < 0)
			{
				return num;
			}
			return opusRepacketizer.opus_repacketizer_out_range_impl(0, opusRepacketizer.nb_frames, data, data_offset, len, 0, 0);
		}

		public static int PadMultistreamPacket(byte[] data, int data_offset, int len, int new_len, int nb_streams)
		{
			short[] sizes = new short[48];
			if (len < 1)
			{
				return -1;
			}
			if (len == new_len)
			{
				return 0;
			}
			if (len > new_len)
			{
				return -1;
			}
			int num = new_len - len;
			for (int i = 0; i < nb_streams - 1; i++)
			{
				if (len <= 0)
				{
					return -4;
				}
				byte out_toc;
				int payload_offset;
				int packet_offset;
				int num2 = OpusPacketInfo.opus_packet_parse_impl(data, data_offset, len, 1, out out_toc, null, null, 0, sizes, 0, out payload_offset, out packet_offset);
				if (num2 < 0)
				{
					return num2;
				}
				data_offset += packet_offset;
				len -= packet_offset;
			}
			return PadPacket(data, data_offset, len, len + num);
		}

		public static int UnpadMultistreamPacket(byte[] data, int data_offset, int len, int nb_streams)
		{
			short[] sizes = new short[48];
			OpusRepacketizer opusRepacketizer = new OpusRepacketizer();
			if (len < 1)
			{
				return -1;
			}
			int num = data_offset;
			int num2 = 0;
			for (int i = 0; i < nb_streams; i++)
			{
				int self_delimited = ((i != nb_streams) ? 1 : 0) - 1;
				if (len <= 0)
				{
					return -4;
				}
				opusRepacketizer.Reset();
				int num3 = OpusPacketInfo.opus_packet_parse_impl(data, data_offset, len, self_delimited, out var _, null, null, 0, sizes, 0, out var _, out var packet_offset);
				if (num3 < 0)
				{
					return num3;
				}
				num3 = opusRepacketizer.opus_repacketizer_cat_impl(data, data_offset, packet_offset, self_delimited);
				if (num3 < 0)
				{
					return num3;
				}
				num3 = opusRepacketizer.opus_repacketizer_out_range_impl(0, opusRepacketizer.nb_frames, data, num, len, self_delimited, 0);
				if (num3 < 0)
				{
					return num3;
				}
				num2 += num3;
				num += num3;
				data_offset += packet_offset;
				len -= packet_offset;
			}
			return num2;
		}
	}
	internal class StereoWidthState
	{
		internal int XX;

		internal int XY;

		internal int YY;

		internal int smoothed_width;

		internal int max_follower;

		internal void Reset()
		{
			XX = 0;
			XY = 0;
			YY = 0;
			smoothed_width = 0;
			max_follower = 0;
		}
	}
	internal class TonalityAnalysisState
	{
		internal bool enabled;

		internal readonly float[] angle = new float[240];

		internal readonly float[] d_angle = new float[240];

		internal readonly float[] d2_angle = new float[240];

		internal readonly int[] inmem = new int[720];

		internal int mem_fill;

		internal readonly float[] prev_band_tonality = new float[18];

		internal float prev_tonality;

		internal readonly float[][] E = Arrays.InitTwoDimensionalArray<float>(8, 18);

		internal readonly float[] lowE = new float[18];

		internal readonly float[] highE = new float[18];

		internal readonly float[] meanE = new float[21];

		internal readonly float[] mem = new float[32];

		internal readonly float[] cmean = new float[8];

		internal readonly float[] std = new float[9];

		internal float music_prob;

		internal float Etracker;

		internal float lowECount;

		internal int E_count;

		internal int last_music;

		internal int last_transition;

		internal int count;

		internal readonly float[] subframe_mem = new float[3];

		internal int analysis_offset;

		internal readonly float[] pspeech = new float[200];

		internal readonly float[] pmusic = new float[200];

		internal float speech_confidence;

		internal float music_confidence;

		internal int speech_confidence_count;

		internal int music_confidence_count;

		internal int write_pos;

		internal int read_pos;

		internal int read_subframe;

		internal readonly AnalysisInfo[] info = new AnalysisInfo[200];

		internal TonalityAnalysisState()
		{
			for (int i = 0; i < 200; i++)
			{
				info[i] = new AnalysisInfo();
			}
		}

		internal void Reset()
		{
			Arrays.MemSetFloat(angle, 0f, 240);
			Arrays.MemSetFloat(d_angle, 0f, 240);
			Arrays.MemSetFloat(d2_angle, 0f, 240);
			Arrays.MemSetInt(inmem, 0, 720);
			mem_fill = 0;
			Arrays.MemSetFloat(prev_band_tonality, 0f, 18);
			prev_tonality = 0f;
			for (int i = 0; i < 8; i++)
			{
				Arrays.MemSetFloat(E[i], 0f, 18);
			}
			Arrays.MemSetFloat(lowE, 0f, 18);
			Arrays.MemSetFloat(highE, 0f, 18);
			Arrays.MemSetFloat(meanE, 0f, 21);
			Arrays.MemSetFloat(mem, 0f, 32);
			Arrays.MemSetFloat(cmean, 0f, 8);
			Arrays.MemSetFloat(std, 0f, 9);
			music_prob = 0f;
			Etracker = 0f;
			lowECount = 0f;
			E_count = 0;
			last_music = 0;
			last_transition = 0;
			count = 0;
			Arrays.MemSetFloat(subframe_mem, 0f, 3);
			analysis_offset = 0;
			Arrays.MemSetFloat(pspeech, 0f, 200);
			Arrays.MemSetFloat(pmusic, 0f, 200);
			speech_confidence = 0f;
			music_confidence = 0f;
			speech_confidence_count = 0;
			music_confidence_count = 0;
			write_pos = 0;
			read_pos = 0;
			read_subframe = 0;
			for (int j = 0; j < 200; j++)
			{
				info[j].Reset();
			}
		}
	}
	internal class VorbisLayout
	{
		internal int nb_streams;

		internal int nb_coupled_streams;

		internal byte[] mapping;

		internal static readonly VorbisLayout[] vorbis_mappings = new VorbisLayout[8]
		{
			new VorbisLayout(1, 0, new byte[1]),
			new VorbisLayout(1, 1, new byte[2] { 0, 1 }),
			new VorbisLayout(2, 1, new byte[3] { 0, 2, 1 }),
			new VorbisLayout(2, 2, new byte[4] { 0, 1, 2, 3 }),
			new VorbisLayout(3, 2, new byte[5] { 0, 4, 1, 2, 3 }),
			new VorbisLayout(4, 2, new byte[6] { 0, 4, 1, 2, 3, 5 }),
			new VorbisLayout(4, 3, new byte[7] { 0, 4, 1, 2, 3, 5, 6 }),
			new VorbisLayout(5, 3, new byte[8] { 0, 6, 1, 2, 3, 4, 5, 7 })
		};

		internal VorbisLayout(int streams, int coupled_streams, byte[] map)
		{
			nb_streams = streams;
			nb_coupled_streams = coupled_streams;
			mapping = map;
		}
	}
}
namespace Concentus.Enums
{
	internal enum OpusApplication
	{
		OPUS_APPLICATION_UNIMPLEMENTED = 0,
		OPUS_APPLICATION_VOIP = 2048,
		OPUS_APPLICATION_AUDIO = 2049,
		OPUS_APPLICATION_RESTRICTED_LOWDELAY = 2051
	}
	internal enum OpusBandwidth
	{
		OPUS_BANDWIDTH_AUTO = -1000,
		OPUS_BANDWIDTH_NARROWBAND = 1101,
		OPUS_BANDWIDTH_MEDIUMBAND = 1102,
		OPUS_BANDWIDTH_WIDEBAND = 1103,
		OPUS_BANDWIDTH_SUPERWIDEBAND = 1104,
		OPUS_BANDWIDTH_FULLBAND = 1105
	}
	internal static class OpusBandwidthHelpers
	{
		internal static int GetOrdinal(OpusBandwidth bw)
		{
			return (int)(bw - 1101);
		}

		internal static OpusBandwidth MIN(OpusBandwidth a, OpusBandwidth b)
		{
			if (a < b)
			{
				return a;
			}
			return b;
		}

		internal static OpusBandwidth MAX(OpusBandwidth a, OpusBandwidth b)
		{
			if (a > b)
			{
				return a;
			}
			return b;
		}
	}
	internal static class OpusControl
	{
		public const int OPUS_SET_APPLICATION_REQUEST = 4000;

		public const int OPUS_GET_APPLICATION_REQUEST = 4001;

		public const int OPUS_SET_BITRATE_REQUEST = 4002;

		public const int OPUS_GET_BITRATE_REQUEST = 4003;

		public const int OPUS_SET_MAX_BANDWIDTH_REQUEST = 4004;

		public const int OPUS_GET_MAX_BANDWIDTH_REQUEST = 4005;

		public const int OPUS_SET_VBR_REQUEST = 4006;

		public const int OPUS_GET_VBR_REQUEST = 4007;

		public const int OPUS_SET_BANDWIDTH_REQUEST = 4008;

		public const int OPUS_GET_BANDWIDTH_REQUEST = 4009;

		public const int OPUS_SET_COMPLEXITY_REQUEST = 4010;

		public const int OPUS_GET_COMPLEXITY_REQUEST = 4011;

		public const int OPUS_SET_INBAND_FEC_REQUEST = 4012;

		public const int OPUS_GET_INBAND_FEC_REQUEST = 4013;

		public const int OPUS_SET_PACKET_LOSS_PERC_REQUEST = 4014;

		public const int OPUS_GET_PACKET_LOSS_PERC_REQUEST = 4015;

		public const int OPUS_SET_DTX_REQUEST = 4016;

		public const int OPUS_GET_DTX_REQUEST = 4017;

		public const int OPUS_SET_VBR_CONSTRAINT_REQUEST = 4020;

		public const int OPUS_GET_VBR_CONSTRAINT_REQUEST = 4021;

		public const int OPUS_SET_FORCE_CHANNELS_REQUEST = 4022;

		public const int OPUS_GET_FORCE_CHANNELS_REQUEST = 4023;

		public const int OPUS_SET_SIGNAL_REQUEST = 4024;

		public const int OPUS_GET_SIGNAL_REQUEST = 4025;

		public const int OPUS_GET_LOOKAHEAD_REQUEST = 4027;

		public const int OPUS_GET_SAMPLE_RATE_REQUEST = 4029;

		public const int OPUS_GET_FINAL_RANGE_REQUEST = 4031;

		public const int OPUS_GET_PITCH_REQUEST = 4033;

		public const int OPUS_SET_GAIN_REQUEST = 4034;

		public const int OPUS_GET_GAIN_REQUEST = 4045;

		public const int OPUS_SET_LSB_DEPTH_REQUEST = 4036;

		public const int OPUS_GET_LSB_DEPTH_REQUEST = 4037;

		public const int OPUS_GET_LAST_PACKET_DURATION_REQUEST = 4039;

		public const int OPUS_SET_EXPERT_FRAME_DURATION_REQUEST = 4040;

		public const int OPUS_GET_EXPERT_FRAME_DURATION_REQUEST = 4041;

		public const int OPUS_SET_PREDICTION_DISABLED_REQUEST = 4042;

		public const int OPUS_GET_PREDICTION_DISABLED_REQUEST = 4043;

		public const int OPUS_RESET_STATE = 4028;

		public const int OPUS_SET_VOICE_RATIO_REQUEST = 11018;

		public const int OPUS_GET_VOICE_RATIO_REQUEST = 11019;

		public const int OPUS_SET_FORCE_MODE_REQUEST = 11002;
	}
	internal static class OpusError
	{
		public const int OPUS_OK = 0;

		public const int OPUS_BAD_ARG = -1;

		public const int OPUS_BUFFER_TOO_SMALL = -2;

		public const int OPUS_INTERNAL_ERROR = -3;

		public const int OPUS_INVALID_PACKET = -4;

		public const int OPUS_UNIMPLEMENTED = -5;

		public const int OPUS_INVALID_STATE = -6;

		public const int OPUS_ALLOC_FAIL = -7;
	}
	internal enum OpusFramesize
	{
		OPUS_FRAMESIZE_ARG = 5000,
		OPUS_FRAMESIZE_2_5_MS = 5001,
		OPUS_FRAMESIZE_5_MS = 5002,
		OPUS_FRAMESIZE_10_MS = 5003,
		OPUS_FRAMESIZE_20_MS = 5004,
		OPUS_FRAMESIZE_40_MS = 5005,
		OPUS_FRAMESIZE_60_MS = 5006,
		OPUS_FRAMESIZE_VARIABLE = 5010
	}
	internal enum OpusMode
	{
		MODE_AUTO = -1000,
		MODE_SILK_ONLY = 1000,
		MODE_HYBRID = 1001,
		MODE_CELT_ONLY = 1002
	}
	internal enum OpusSignal
	{
		OPUS_SIGNAL_AUTO = -1000,
		OPUS_SIGNAL_VOICE = 3001,
		OPUS_SIGNAL_MUSIC = 3002
	}
}
namespace Concentus.Common
{
	internal static class Autocorrelation
	{
		private const int QC = 10;

		private const int QS = 14;

		internal static void silk_autocorr(int[] results, BoxedValueInt scale, short[] inputData, int inputDataSize, int correlationCount)
		{
			int num = Inlines.silk_min_int(inputDataSize, correlationCount);
			scale.Val = _celt_autocorr(inputData, results, num - 1, inputDataSize);
		}

		internal static int _celt_autocorr(short[] x, int[] ac, int lag, int n)
		{
			int num = n - lag;
			short[] array = new short[n];
			short[] array2 = x;
			int num2 = 0;
			int num3 = 1 + (n << 7);
			if ((n & 1) != 0)
			{
				num3 += Inlines.SHR32(Inlines.MULT16_16(array2[0], array2[0]), 9);
			}
			for (int i = n & 1; i < n; i += 2)
			{
				num3 += Inlines.SHR32(Inlines.MULT16_16(array2[i], array2[i]), 9);
				num3 += Inlines.SHR32(Inlines.MULT16_16(array2[i + 1], array2[i + 1]), 9);
			}
			num2 = Inlines.celt_ilog2(num3) - 30 + 10;
			num2 /= 2;
			if (num2 > 0)
			{
				for (int i = 0; i < n; i++)
				{
					array[i] = (short)Inlines.PSHR32(array2[i], num2);
				}
				array2 = array;
			}
			else
			{
				num2 = 0;
			}
			CeltPitchXCorr.pitch_xcorr(array2, array2, ac, num, lag + 1);
			for (int j = 0; j <= lag; j++)
			{
				int i = j + num;
				int num4 = 0;
				for (; i < n; i++)
				{
					num4 = Inlines.MAC16_16(num4, array2[i], array2[i - j]);
				}
				ac[j] += num4;
			}
			num2 = 2 * num2;
			if (num2 <= 0)
			{
				ac[0] += Inlines.SHL32(1, -num2);
			}
			if (ac[0] < 268435456)
			{
				int num5 = 29 - Inlines.EC_ILOG((uint)ac[0]);
				for (int i = 0; i <= lag; i++)
				{
					ac[i] = Inlines.SHL32(ac[i], num5);
				}
				num2 -= num5;
			}
			else if (ac[0] >= 536870912)
			{
				int num6 = 1;
				if (ac[0] >= 1073741824)
				{
					num6++;
				}
				for (int i = 0; i <= lag; i++)
				{
					ac[i] = Inlines.SHR32(ac[i], num6);
				}
				num2 += num6;
			}
			return num2;
		}

		internal static int _celt_autocorr(int[] x, int[] ac, int[] window, int overlap, int lag, int n)
		{
			int num = n - lag;
			int[] array = new int[n];
			int[] array2;
			if (overlap == 0)
			{
				array2 = x;
			}
			else
			{
				for (int i = 0; i < n; i++)
				{
					array[i] = x[i];
				}
				for (int i = 0; i < overlap; i++)
				{
					array[i] = Inlines.MULT16_16_Q15(x[i], window[i]);
					array[n - i - 1] = Inlines.MULT16_16_Q15(x[n - i - 1], window[i]);
				}
				array2 = array;
			}
			int num2 = 0;
			int num3 = 1 + (n << 7);
			if ((n & 1) != 0)
			{
				num3 += Inlines.SHR32(Inlines.MULT16_16(array2[0], array2[0]), 9);
			}
			for (int i = n & 1; i < n; i += 2)
			{
				num3 += Inlines.SHR32(Inlines.MULT16_16(array2[i], array2[i]), 9);
				num3 += Inlines.SHR32(Inlines.MULT16_16(array2[i + 1], array2[i + 1]), 9);
			}
			num2 = Inlines.celt_ilog2(num3) - 30 + 10;
			num2 /= 2;
			if (num2 > 0)
			{
				for (int i = 0; i < n; i++)
				{
					array[i] = Inlines.PSHR32(array2[i], num2);
				}
				array2 = array;
			}
			else
			{
				num2 = 0;
			}
			CeltPitchXCorr.pitch_xcorr(array2, array2, ac, num, lag + 1);
			for (int j = 0; j <= lag; j++)
			{
				int i = j + num;
				int num4 = 0;
				for (; i < n; i++)
				{
					num4 = Inlines.MAC16_16(num4, array2[i], array2[i - j]);
				}
				ac[j] += num4;
			}
			num2 = 2 * num2;
			if (num2 <= 0)
			{
				ac[0] += Inlines.SHL32(1, -num2);
			}
			if (ac[0] < 268435456)
			{
				int num5 = 29 - Inlines.EC_ILOG((uint)ac[0]);
				for (int i = 0; i <= lag; i++)
				{
					ac[i] = Inlines.SHL32(ac[i], num5);
				}
				num2 -= num5;
			}
			else if (ac[0] >= 536870912)
			{
				int num6 = 1;
				if (ac[0] >= 1073741824)
				{
					num6++;
				}
				for (int i = 0; i <= lag; i++)
				{
					ac[i] = Inlines.SHR32(ac[i], num6);
				}
				num2 += num6;
			}
			return num2;
		}

		internal static void silk_warped_autocorrelation(int[] corr, BoxedValueInt scale, short[] input, int warping_Q16, int length, int order)
		{
			int[] array = new int[17];
			long[] array2 = new long[17];
			for (int i = 0; i < length; i++)
			{
				int num = Inlines.silk_LSHIFT32(input[i], 14);
				for (int j = 0; j < order; j += 2)
				{
					int num2 = Inlines.silk_SMLAWB(array[j], array[j + 1] - num, warping_Q16);
					array[j] = num;
					array2[j] += Inlines.silk_RSHIFT64(Inlines.silk_SMULL(num, array[0]), 18);
					num = Inlines.silk_SMLAWB(array[j + 1], array[j + 2] - num2, warping_Q16);
					array[j + 1] = num2;
					array2[j + 1] += Inlines.silk_RSHIFT64(Inlines.silk_SMULL(num2, array[0]), 18);
				}
				array[order] = num;
				array2[order] += Inlines.silk_RSHIFT64(Inlines.silk_SMULL(num, array[0]), 18);
			}
			int a = Inlines.silk_CLZ64(array2[0]) - 35;
			a = Inlines.silk_LIMIT(a, -22, 20);
			scale.Val = -(10 + a);
			if (a >= 0)
			{
				for (int j = 0; j < order + 1; j++)
				{
					corr[j] = (int)Inlines.silk_LSHIFT64(array2[j], a);
				}
			}
			else
			{
				for (int j = 0; j < order + 1; j++)
				{
					corr[j] = (int)Inlines.silk_RSHIFT64(array2[j], -a);
				}
			}
		}
	}
	internal class EntropyCoder
	{
		private const int EC_WINDOW_SIZE = 32;

		private const int EC_UINT_BITS = 8;

		public const int BITRES = 3;

		private const int EC_SYM_BITS = 8;

		private const int EC_CODE_BITS = 32;

		private const uint EC_SYM_MAX = 255u;

		private const uint EC_CODE_SHIFT = 23u;

		private const uint EC_CODE_TOP = 2147483648u;

		private const uint EC_CODE_BOT = 8388608u;

		private const int EC_CODE_EXTRA = 7;

		public byte[] buf;

		public int buf_ptr;

		public uint storage;

		public uint end_offs;

		public uint end_window;

		public int nend_bits;

		public int nbits_total;

		public uint offs;

		public uint rng;

		public uint val;

		public uint ext;

		public int rem;

		public int error;

		private static readonly uint[] correction = new uint[8] { 35733u, 38967u, 42495u, 46340u, 50535u, 55109u, 60097u, 65535u };

		public EntropyCoder()
		{
			Reset();
		}

		public void Reset()
		{
			buf = null;
			buf_ptr = 0;
			storage = 0u;
			end_offs = 0u;
			end_window = 0u;
			nend_bits = 0;
			offs = 0u;
			rng = 0u;
			val = 0u;
			ext = 0u;
			rem = 0;
			error = 0;
		}

		public void Assign(EntropyCoder other)
		{
			buf = other.buf;
			buf_ptr = other.buf_ptr;
			storage = other.storage;
			end_offs = other.end_offs;
			end_window = other.end_window;
			nend_bits = other.nend_bits;
			nbits_total = other.nbits_total;
			offs = other.offs;
			rng = other.rng;
			val = other.val;
			ext = other.ext;
			rem = other.rem;
			error = other.error;
		}

		internal int read_byte()
		{
			if (offs >= storage)
			{
				return 0;
			}
			return buf[buf_ptr + offs++];
		}

		internal int read_byte_from_end()
		{
			if (end_offs >= storage)
			{
				return 0;
			}
			return buf[buf_ptr + (storage - ++end_offs)];
		}

		internal int write_byte(uint _value)
		{
			if (offs + end_offs >= storage)
			{
				return -1;
			}
			buf[buf_ptr + offs++] = (byte)_value;
			return 0;
		}

		internal int write_byte_at_end(uint _value)
		{
			if (offs + end_offs >= storage)
			{
				return -1;
			}
			buf[buf_ptr + (storage - ++end_offs)] = (byte)_value;
			return 0;
		}

		internal void dec_normalize()
		{
			while (rng <= 8388608)
			{
				nbits_total += 8;
				rng <<= 8;
				int num = rem;
				rem = read_byte();
				num = ((num << 8) | rem) >> 1;
				val = (uint)((int)((val << 8) + (0xFFuL & (ulong)(~num))) & 0x7FFFFFFF);
			}
		}

		internal void dec_init(byte[] _buf, int _buf_ptr, uint _storage)
		{
			buf = _buf;
			buf_ptr = _buf_ptr;
			storage = _storage;
			end_offs = 0u;
			end_window = 0u;
			nend_bits = 0;
			nbits_total = 9;
			offs = 0u;
			rng = 128u;
			rem = read_byte();
			val = rng - 1 - (uint)(rem >> 1);
			error = 0;
			dec_normalize();
		}

		internal uint decode(uint _ft)
		{
			ext = rng / _ft;
			uint num = val / ext;
			return _ft - Inlines.EC_MINI(num + 1, _ft);
		}

		internal uint decode_bin(uint _bits)
		{
			ext = rng >> (int)_bits;
			uint num = val / ext;
			return (uint)(1 << (int)_bits) - Inlines.EC_MINI(num + 1, (uint)(1 << (int)_bits));
		}

		internal void dec_update(uint _fl, uint _fh, uint _ft)
		{
			uint num = ext * (_ft - _fh);
			val -= num;
			rng = ((_fl != 0) ? (ext * (_fh - _fl)) : (rng - num));
			dec_normalize();
		}

		internal int dec_bit_logp(uint _logp)
		{
			uint num = rng;
			uint num2 = val;
			uint num3 = num >> (int)_logp;
			int num4 = ((num2 < num3) ? 1 : 0);
			if (num4 == 0)
			{
				val = num2 - num3;
			}
			rng = ((num4 != 0) ? num3 : (num - num3));
			dec_normalize();
			return num4;
		}

		internal int dec_icdf(byte[] _icdf, uint _ftb)
		{
			uint num = rng;
			uint num2 = val;
			uint num3 = num >> (int)_ftb;
			int num4 = -1;
			uint num5;
			do
			{
				num5 = num;
				num = num3 * _icdf[++num4];
			}
			while (num2 < num);
			val = num2 - num;
			rng = num5 - num;
			dec_normalize();
			return num4;
		}

		internal int dec_icdf(byte[] _icdf, int _icdf_offset, uint _ftb)
		{
			uint num = rng;
			uint num2 = val;
			uint num3 = num >> (int)_ftb;
			int num4 = _icdf_offset - 1;
			uint num5;
			do
			{
				num5 = num;
				num = num3 * _icdf[++num4];
			}
			while (num2 < num);
			val = num2 - num;
			rng = num5 - num;
			dec_normalize();
			return num4 - _icdf_offset;
		}

		internal uint dec_uint(uint _ft)
		{
			_ft--;
			int num = Inlines.EC_ILOG(_ft);
			uint num2;
			if (num > 8)
			{
				num -= 8;
				uint ft = (_ft >> num) + 1;
				num2 = decode(ft);
				dec_update(num2, num2 + 1, ft);
				uint num3 = (num2 << num) | dec_bits((uint)num);
				if (num3 <= _ft)
				{
					return num3;
				}
				error = 1;
				return _ft;
			}
			_ft++;
			num2 = decode(_ft);
			dec_update(num2, num2 + 1, _ft);
			return num2;
		}

		internal uint dec_bits(uint _bits)
		{
			uint num = end_window;
			int num2 = nend_bits;
			if ((uint)num2 < _bits)
			{
				do
				{
					num |= (uint)(read_byte_from_end() << num2);
					num2 += 8;
				}
				while (num2 <= 24);
			}
			int result = (int)num & ((1 << (int)_bits) - 1);
			num >>= (int)_bits;
			num2 -= (int)_bits;
			end_window = num;
			nend_bits = num2;
			nbits_total += (int)_bits;
			return (uint)result;
		}

		internal void enc_carry_out(int _c)
		{
			if ((long)_c != 255)
			{
				int num = _c >> 8;
				if (rem >= 0)
				{
					error |= write_byte((uint)(rem + num));
				}
				if (ext != 0)
				{
					uint value = (uint)((255 + num) & 0xFF);
					do
					{
						error |= write_byte(value);
					}
					while (--ext != 0);
				}
				rem = _c & 0xFF;
			}
			else
			{
				ext++;
			}
		}

		internal void enc_normalize()
		{
			while (rng <= 8388608)
			{
				enc_carry_out((int)(val >> 23));
				val = (val << 8) & 0x7FFFFFFF;
				rng <<= 8;
				nbits_total += 8;
			}
		}

		internal void enc_init(byte[] _buf, int buf_ptr, uint _size)
		{
			buf = _buf;
			this.buf_ptr = buf_ptr;
			end_offs = 0u;
			end_window = 0u;
			nend_bits = 0;
			nbits_total = 33;
			offs = 0u;
			rng = 2147483648u;
			rem = -1;
			val = 0u;
			ext = 0u;
			storage = _size;
			error = 0;
		}

		internal void encode(uint _fl, uint _fh, uint _ft)
		{
			uint num = rng / _ft;
			if (_fl != 0)
			{
				val += rng - num * (_ft - _fl);
				rng = num * (_fh - _fl);
			}
			else
			{
				rng -= num * (_ft - _fh);
			}
			enc_normalize();
		}

		internal void encode_bin(uint _fl, uint _fh, uint _bits)
		{
			uint num = rng >> (int)_bits;
			if (_fl != 0)
			{
				val += (uint)((int)rng - (int)num * ((1 << (int)_bits) - (int)_fl));
				rng = num * (_fh - _fl);
			}
			else
			{
				rng -= (uint)((int)num * ((1 << (int)_bits) - (int)_fh));
			}
			enc_normalize();
		}

		internal void enc_bit_logp(int _val, uint _logp)
		{
			uint num = rng;
			uint num2 = val;
			uint num3 = num >> (int)_logp;
			num -= num3;
			if (_val != 0)
			{
				val = num2 + num;
			}
			rng = ((_val != 0) ? num3 : num);
			enc_normalize();
		}

		internal void enc_icdf(int _s, byte[] _icdf, uint _ftb)
		{
			uint num = rng >> (int)_ftb;
			if (_s > 0)
			{
				val += rng - num * _icdf[_s - 1];
				rng = num * (uint)(_icdf[_s - 1] - _icdf[_s]);
			}
			else
			{
				rng -= num * _icdf[_s];
			}
			enc_normalize();
		}

		internal void enc_icdf(int _s, byte[] _icdf, int icdf_ptr, uint _ftb)
		{
			uint num = rng >> (int)_ftb;
			if (_s > 0)
			{
				val += rng - num * _icdf[icdf_ptr + _s - 1];
				rng = num * (uint)(_icdf[icdf_ptr + _s - 1] - _icdf[icdf_ptr + _s]);
			}
			else
			{
				rng -= num * _icdf[icdf_ptr + _s];
			}
			enc_normalize();
		}

		internal void enc_uint(uint _fl, uint _ft)
		{
			_ft--;
			int num = Inlines.EC_ILOG(_ft);
			if (num > 8)
			{
				num -= 8;
				uint ft = (_ft >> num) + 1;
				uint num2 = _fl >> num;
				encode(num2, num2 + 1, ft);
				enc_bits(_fl & (uint)((1 << num) - 1), (uint)num);
			}
			else
			{
				encode(_fl, _fl + 1, _ft + 1);
			}
		}

		internal void enc_bits(uint _fl, uint _bits)
		{
			uint num = end_window;
			int num2 = nend_bits;
			if (num2 + _bits > 32)
			{
				do
				{
					error |= write_byte_at_end(num & 0xFF);
					num >>= 8;
					num2 -= 8;
				}
				while (num2 >= 8);
			}
			num |= _fl << num2;
			num2 += (int)_bits;
			end_window = num;
			nend_bits = num2;
			nbits_total += (int)_bits;
		}

		internal void enc_patch_initial_bits(uint _val, uint _nbits)
		{
			int num = (int)(8 - _nbits);
			uint num2 = (uint)((1 << (int)_nbits) - 1 << num);
			if (offs != 0)
			{
				buf[buf_ptr] = (byte)((buf[buf_ptr] & ~num2) | (_val << num));
			}
			else if (rem >= 0)
			{
				rem = (int)((((uint)rem & ~num2) | _val) << num);
			}
			else if (rng <= (uint)(int.MinValue >>> (int)_nbits))
			{
				val = (val & ~(num2 << 23)) | (_val << (int)(23L + (long)num));
			}
			else
			{
				error = -1;
			}
		}

		internal void enc_shrink(uint _size)
		{
			Arrays.MemMove(buf, buf_ptr + (int)_size - (int)end_offs, buf_ptr + (int)storage - (int)end_offs, (int)end_offs);
			storage = _size;
		}

		internal uint range_bytes()
		{
			return offs;
		}

		internal int get_error()
		{
			return error;
		}

		internal int tell()
		{
			return nbits_total - Inlines.EC_ILOG(rng);
		}

		internal uint tell_frac()
		{
			int num = nbits_total << 3;
			int num2 = Inlines.EC_ILOG(rng);
			int num3 = (int)(rng >> num2 - 16);
			uint num4 = (uint)((num3 >> 12) - 8);
			num4 += (uint)((num3 > correction[num4]) ? 1 : 0);
			num2 = (int)((num2 << 3) + num4);
			return (uint)(num - num2);
		}

		internal void enc_done()
		{
			int num = 32 - Inlines.EC_ILOG(rng);
			uint num2 = 2147483647u >> num;
			uint num3 = (val + num2) & ~num2;
			if ((num3 | num2) >= val + rng)
			{
				num++;
				num2 >>= 1;
				num3 = (val + num2) & ~num2;
			}
			while (num > 0)
			{
				enc_carry_out((int)(num3 >> 23));
				num3 = (num3 << 8) & 0x7FFFFFFF;
				num -= 8;
			}
			if (rem >= 0 || ext != 0)
			{
				enc_carry_out(0);
			}
			uint num4 = end_window;
			int num5;
			for (num5 = nend_bits; num5 >= 8; num5 -= 8)
			{
				error |= write_byte_at_end(num4 & 0xFF);
				num4 >>= 8;
			}
			if (error != 0)
			{
				return;
			}
			Arrays.MemSetWithOffset(buf, (byte)0, buf_ptr + (int)offs, (int)(storage - offs - end_offs));
			if (num5 <= 0)
			{
				return;
			}
			if (end_offs >= storage)
			{
				error = -1;
				return;
			}
			num = -num;
			if (offs + end_offs >= storage && num < num5)
			{
				num4 &= (uint)((1 << num) - 1);
				error = -1;
			}
			buf[buf_ptr + storage - end_offs - 1] |= (byte)num4;
		}
	}
	internal static class Inlines
	{
		private const MethodImplOptions INLINE_ATTR = MethodImplOptions.AggressiveInlining;

		private static readonly short[] sqrt_C = new short[5] { 23175, 11561, -3011, 1699, -664 };

		private const short log2_C0 = -6793;

		[Conditional("DEBUG")]
		public static void OpusAssert(bool condition, string message = "Unknown error")
		{
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16SU(int a, int b)
		{
			return (short)a * (ushort)b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16SU(short a, ushort b)
		{
			return a * b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16SU(int a, uint b)
		{
			return a * (int)b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_32_Q16(short a, int b)
		{
			return ADD32(MULT16_16(a, SHR(b, 16)), SHR(MULT16_16SU(a, b & 0xFFFF), 16));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_32_Q16(int a, int b)
		{
			return ADD32(MULT16_16(a, SHR(b, 16)), SHR(MULT16_16SU(a, b & 0xFFFF), 16));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_32_P16(short a, int b)
		{
			return ADD32(MULT16_16(a, SHR(b, 16)), PSHR(MULT16_16SU(a, b & 0xFFFF), 16));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_32_P16(int a, int b)
		{
			return ADD32(MULT16_16(a, SHR(b, 16)), PSHR(MULT16_16SU(a, b & 0xFFFF), 16));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_32_Q15(short a, int b)
		{
			return (a * (b >> 16) << 1) + (a * (b & 0xFFFF) >> 15);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_32_Q15(int a, int b)
		{
			return (a * (b >> 16) << 1) + (a * (b & 0xFFFF) >> 15);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT32_32_Q31(int a, int b)
		{
			return ADD32(ADD32(SHL(MULT16_16(SHR(a, 16), SHR(b, 16)), 1), SHR(MULT16_16SU(SHR(a, 16), b & 0xFFFF), 15)), SHR(MULT16_16SU(SHR(b, 16), a & 0xFFFF), 15));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short QCONST16(float x, int bits)
		{
			return (short)(0.5 + (double)(x * (float)(1 << bits)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int QCONST32(float x, int bits)
		{
			return (int)(0.5 + (double)(x * (float)(1 << bits)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short NEG16(short x)
		{
			return (short)(-x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int NEG16(int x)
		{
			return -x;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int NEG32(int x)
		{
			return -x;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short EXTRACT16(int x)
		{
			return (short)x;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int EXTEND32(short x)
		{
			return x;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int EXTEND32(int x)
		{
			return x;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short SHR16(short a, int shift)
		{
			return (short)(a >> shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int SHR16(int a, int shift)
		{
			return a >> shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short SHL16(short a, int shift)
		{
			return (short)((ushort)a << shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int SHL16(int a, int shift)
		{
			return a << shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int SHR32(int a, int shift)
		{
			return a >> shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int SHL32(int a, int shift)
		{
			return a << shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int PSHR32(int a, int shift)
		{
			return SHR32(a + (EXTEND32(1) << shift >> 1), shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short PSHR16(short a, int shift)
		{
			return SHR16((short)(a + (1 << shift >> 1)), shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int PSHR16(int a, int shift)
		{
			return SHR32(a + (1 << shift >> 1), shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int VSHR32(int a, int shift)
		{
			if (shift <= 0)
			{
				return SHL32(a, -shift);
			}
			return SHR32(a, shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int SHR(int a, int shift)
		{
			return a >> shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int SHL(int a, int shift)
		{
			return SHL32(a, shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int SHR(short a, int shift)
		{
			return a >> shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int SHL(short a, int shift)
		{
			return SHL32(a, shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int PSHR(int a, int shift)
		{
			return SHR(a + (EXTEND32(1) << shift >> 1), shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int SATURATE(int x, int a)
		{
			if (x <= a)
			{
				if (x >= -a)
				{
					return x;
				}
				return -a;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short SATURATE16(int x)
		{
			return EXTRACT16((x > 32767) ? 32767 : ((x < -32768) ? (-32768) : x));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short ROUND16(short x, short a)
		{
			return EXTRACT16(PSHR32(x, a));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ROUND16(int x, int a)
		{
			return PSHR32(x, a);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int PDIV32(int a, int b)
		{
			return a / b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short HALF16(short x)
		{
			return SHR16(x, 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int HALF16(int x)
		{
			return SHR32(x, 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int HALF32(int x)
		{
			return SHR32(x, 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short ADD16(short a, short b)
		{
			return (short)(a + b);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ADD16(int a, int b)
		{
			return a + b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short SUB16(short a, short b)
		{
			return (short)(a - b);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int SUB16(int a, int b)
		{
			return a - b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ADD32(int a, int b)
		{
			return a + b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int SUB32(int a, int b)
		{
			return a - b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short MULT16_16_16(short a, short b)
		{
			return (short)(a * b);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16_16(int a, int b)
		{
			return a * b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16(int a, int b)
		{
			return a * b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16(short a, short b)
		{
			return a * b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MAC16_16(short c, short a, short b)
		{
			return c + a * b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MAC16_16(int c, short a, short b)
		{
			return c + a * b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MAC16_16(int c, int a, int b)
		{
			return c + a * b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MAC16_32_Q15(int c, short a, short b)
		{
			return ADD32(c, ADD32(MULT16_16(a, SHR(b, 15)), SHR(MULT16_16(a, b & 0x7FFF), 15)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MAC16_32_Q15(int c, int a, int b)
		{
			return ADD32(c, ADD32(MULT16_16(a, SHR(b, 15)), SHR(MULT16_16(a, b & 0x7FFF), 15)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MAC16_32_Q16(int c, short a, short b)
		{
			return ADD32(c, ADD32(MULT16_16(a, SHR(b, 16)), SHR(MULT16_16SU(a, b & 0xFFFF), 16)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MAC16_32_Q16(int c, int a, int b)
		{
			return ADD32(c, ADD32(MULT16_16(a, SHR(b, 16)), SHR(MULT16_16SU(a, b & 0xFFFF), 16)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16_Q11_32(short a, short b)
		{
			return SHR(MULT16_16(a, b), 11);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16_Q11_32(int a, int b)
		{
			return SHR(MULT16_16(a, b), 11);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short MULT16_16_Q11(short a, short b)
		{
			return (short)SHR(MULT16_16(a, b), 11);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16_Q11(int a, int b)
		{
			return SHR(MULT16_16(a, b), 11);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short MULT16_16_Q13(short a, short b)
		{
			return (short)SHR(MULT16_16(a, b), 13);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16_Q13(int a, int b)
		{
			return SHR(MULT16_16(a, b), 13);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short MULT16_16_Q14(short a, short b)
		{
			return (short)SHR(MULT16_16(a, b), 14);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16_Q14(int a, int b)
		{
			return SHR(MULT16_16(a, b), 14);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short MULT16_16_Q15(short a, short b)
		{
			return (short)SHR(MULT16_16(a, b), 15);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16_Q15(int a, int b)
		{
			return SHR(MULT16_16(a, b), 15);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short MULT16_16_P13(short a, short b)
		{
			return (short)SHR(ADD32(4096, MULT16_16(a, b)), 13);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16_P13(int a, int b)
		{
			return SHR(ADD32(4096, MULT16_16(a, b)), 13);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short MULT16_16_P14(short a, short b)
		{
			return (short)SHR(ADD32(8192, MULT16_16(a, b)), 14);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16_P14(int a, int b)
		{
			return SHR(ADD32(8192, MULT16_16(a, b)), 14);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short MULT16_16_P15(short a, short b)
		{
			return (short)SHR(ADD32(16384, MULT16_16(a, b)), 15);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MULT16_16_P15(int a, int b)
		{
			return SHR(ADD32(16384, MULT16_16(a, b)), 15);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short DIV32_16(int a, short b)
		{
			return (short)(a / b);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int DIV32_16(int a, int b)
		{
			return a / b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int DIV32(int a, int b)
		{
			return a / b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short SAT16(int x)
		{
			return (x > 32767) ? short.MaxValue : ((x < -32768) ? short.MinValue : ((short)x));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short SIG2WORD16(int x)
		{
			x = PSHR32(x, 12);
			x = MAX32(x, -32768);
			x = MIN32(x, 32767);
			return EXTRACT16(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short MIN(short a, short b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short MAX(short a, short b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short MIN16(short a, short b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short MAX16(short a, short b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MIN16(int a, int b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MAX16(int a, int b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float MIN16(float a, float b)
		{
			if (!(a < b))
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float MAX16(float a, float b)
		{
			if (!(a > b))
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MIN(int a, int b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MAX(int a, int b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IMIN(int a, int b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint IMIN(uint a, uint b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IMAX(int a, int b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MIN32(int a, int b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MAX32(int a, int b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float MIN32(float a, float b)
		{
			if (!(a < b))
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float MAX32(float a, float b)
		{
			if (!(a > b))
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ABS16(int x)
		{
			if (x >= 0)
			{
				return x;
			}
			return -x;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float ABS16(float x)
		{
			if (!(x < 0f))
			{
				return x;
			}
			return 0f - x;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short ABS16(short x)
		{
			return (short)((x < 0) ? (-x) : x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ABS32(int x)
		{
			if (x >= 0)
			{
				return x;
			}
			return -x;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint celt_udiv(uint n, uint d)
		{
			return n / d;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_udiv(int n, int d)
		{
			return n / d;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_sudiv(int n, int d)
		{
			return n / d;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_div(int a, int b)
		{
			return MULT32_32_Q31(a, celt_rcp(b));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_ilog2(int x)
		{
			return EC_ILOG((uint)x) - 1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_zlog2(int x)
		{
			if (x > 0)
			{
				return celt_ilog2(x);
			}
			return 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_maxabs16(int[] x, int x_ptr, int len)
		{
			int num = 0;
			int num2 = 0;
			for (int i = x_ptr; i < len + x_ptr; i++)
			{
				num = MAX32(num, x[i]);
				num2 = MIN32(num2, x[i]);
			}
			return MAX32(EXTEND32(num), -EXTEND32(num2));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_maxabs32(int[] x, int x_ptr, int len)
		{
			int a = 0;
			int num = 0;
			for (int i = x_ptr; i < x_ptr + len; i++)
			{
				a = MAX32(a, x[i]);
				num = MIN32(num, x[i]);
			}
			return MAX32(a, -num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short celt_maxabs32(short[] x, int x_ptr, int len)
		{
			short a = 0;
			short num = 0;
			for (int i = x_ptr; i < x_ptr + len; i++)
			{
				a = MAX16(a, x[i]);
				num = MIN16(num, x[i]);
			}
			return MAX(a, (short)(-num));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int FRAC_MUL16(int a, int b)
		{
			return 16384 + (short)a * (short)b >> 15;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint isqrt32(uint _val)
		{
			uint num = 0u;
			int num2 = EC_ILOG(_val) - 1 >> 1;
			uint num3 = (uint)(1 << num2);
			do
			{
				uint num4 = (num << 1) + num3 << num2;
				if (num4 <= _val)
				{
					num += num3;
					_val -= num4;
				}
				num3 >>= 1;
				num2--;
			}
			while (num2 >= 0);
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_sqrt(int x)
		{
			if (x == 0)
			{
				return 0;
			}
			if (x >= 1073741824)
			{
				return 32767;
			}
			int num = (celt_ilog2(x) >> 1) - 7;
			x = VSHR32(x, 2 * num);
			short a = (short)(x - 32768);
			return VSHR32(ADD16(sqrt_C[0], MULT16_16_Q15(a, ADD16(sqrt_C[1], MULT16_16_Q15(a, ADD16(sqrt_C[2], MULT16_16_Q15(a, ADD16(sqrt_C[3], MULT16_16_Q15(a, sqrt_C[4])))))))), 7 - num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_rcp(int x)
		{
			int num = celt_ilog2(x);
			int b = VSHR32(x, num - 15) - 32768;
			int a = ADD16(30840, MULT16_16_Q15(-15420, b));
			a = SUB16(a, MULT16_16_Q15(a, ADD16(MULT16_16_Q15(a, b), ADD16(a, -32768))));
			a = SUB16(a, ADD16(1, MULT16_16_Q15(a, ADD16(MULT16_16_Q15(a, b), ADD16(a, -32768)))));
			return VSHR32(EXTEND32(a), num - 16);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_rsqrt_norm(int x)
		{
			int num = x - 32768;
			int num2 = ADD16(23557, MULT16_16_Q15(num, ADD16(-13490, MULT16_16_Q15(num, 6713))));
			int num3 = MULT16_16_Q15(num2, num2);
			int a = SHL16(SUB16(ADD16(MULT16_16_Q15(num3, num), num3), 16384), 1);
			return ADD16(num2, MULT16_16_Q15(num2, MULT16_16_Q15(a, SUB16(MULT16_16_Q15(a, 12288), 16384))));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int frac_div32(int a, int b)
		{
			int shift = celt_ilog2(b) - 29;
			a = VSHR32(a, shift);
			b = VSHR32(b, shift);
			int a2 = ROUND16(celt_rcp(ROUND16(b, 16)), 3);
			int a3 = MULT16_32_Q15(a2, a);
			int b2 = PSHR32(a, 2) - MULT32_32_Q31(a3, b);
			a3 = ADD32(a3, SHL32(MULT16_32_Q15(a2, b2), 2));
			if (a3 >= 536870912)
			{
				return int.MaxValue;
			}
			if (a3 <= -536870912)
			{
				return -2147483647;
			}
			return SHL32(a3, 2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_log2(int x)
		{
			if (x == 0)
			{
				return -32767;
			}
			int num = celt_ilog2(x);
			int a = VSHR32(x, num - 15) - 32768 - 16384;
			int a2 = ADD16(-6793, MULT16_16_Q15(a, ADD16(15746, MULT16_16_Q15(a, ADD16(-5217, MULT16_16_Q15(a, ADD16(2545, MULT16_16_Q15(a, -1401))))))));
			return SHL16((short)(num - 13), 10) + SHR16(a2, 4);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_exp2_frac(int x)
		{
			int num = SHL16(x, 4);
			return ADD16(16383, MULT16_16_Q15(num, ADD16(22804, MULT16_16_Q15(num, ADD16(14819, MULT16_16_Q15(10204, num))))));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_exp2(int x)
		{
			int num = SHR16(x, 10);
			if (num > 14)
			{
				return 2130706432;
			}
			if (num < -15)
			{
				return 0;
			}
			return VSHR32(EXTEND32((int)(short)celt_exp2_frac((short)(x - SHL16((short)num, 10)))), -num - 2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_atan01(int x)
		{
			return MULT16_16_P15(x, ADD32(32767, MULT16_16_P15(x, ADD32(-21, MULT16_16_P15(x, ADD32(-11943, MULT16_16_P15(4936, x)))))));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_atan2p(int y, int x)
		{
			if (y < x)
			{
				int num = celt_div(SHL32(EXTEND32(y), 15), x);
				if (num >= 32767)
				{
					num = 32767;
				}
				return SHR32(celt_atan01(EXTRACT16(num)), 1);
			}
			int num2 = celt_div(SHL32(EXTEND32(x), 15), y);
			if (num2 >= 32767)
			{
				num2 = 32767;
			}
			return 25736 - SHR16(celt_atan01(EXTRACT16(num2)), 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int celt_cos_norm(int x)
		{
			x &= 0x1FFFF;
			if (x > SHL32(EXTEND32(1), 16))
			{
				x = SUB32(SHL32(EXTEND32(1), 17), x);
			}
			if ((x & 0x7FFF) != 0)
			{
				if (x < SHL32(EXTEND32(1), 15))
				{
					return _celt_cos_pi_2(EXTRACT16(x));
				}
				return NEG32(_celt_cos_pi_2(EXTRACT16(65536 - x)));
			}
			if ((x & 0xFFFF) != 0)
			{
				return 0;
			}
			if ((x & 0x1FFFF) != 0)
			{
				return -32767;
			}
			return 32767;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int _celt_cos_pi_2(int x)
		{
			int num = MULT16_16_P15(x, x);
			return ADD32(1, MIN32(32766, ADD32(SUB16(32767, num), MULT16_16_P15(num, ADD32(-7651, MULT16_16_P15(num, ADD32(8277, MULT16_16_P15(-626, num))))))));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short FLOAT2INT16(float x)
		{
			x *= 32768f;
			if (x < -32768f)
			{
				x = -32768f;
			}
			if (x > 32767f)
			{
				x = 32767f;
			}
			return (short)x;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_ROR32(int a32, int rot)
		{
			return (int)silk_ROR32((uint)a32, rot);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint silk_ROR32(uint a32, int rot)
		{
			int num = -rot;
			if (rot == 0)
			{
				return a32;
			}
			if (rot < 0)
			{
				return (a32 << num) | (a32 >> 32 - num);
			}
			return (a32 << 32 - rot) | (a32 >> rot);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_MUL(int a32, int b32)
		{
			return a32 * b32;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint silk_MUL_uint(uint a32, uint b32)
		{
			return a32 * b32;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_MLA(int a32, int b32, int c32)
		{
			return silk_ADD32(a32, b32 * c32);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_MLA_uint(uint a32, uint b32, uint c32)
		{
			return (int)silk_ADD32(a32, b32 * c32);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMULTT(int a32, int b32)
		{
			return (a32 >> 16) * (b32 >> 16);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMLATT(int a32, int b32, int c32)
		{
			return silk_ADD32(a32, (b32 >> 16) * (c32 >> 16));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_SMLALBB(long a64, short b16, short c16)
		{
			return silk_ADD64(a64, b16 * c16);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_SMULL(int a32, int b32)
		{
			return (long)a32 * (long)b32;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_ADD32_ovflw(int a, int b)
		{
			return a + b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_ADD32_ovflw(uint a, uint b)
		{
			return (int)(a + b);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SUB32_ovflw(int a, int b)
		{
			return a - b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_MLA_ovflw(int a32, int b32, int c32)
		{
			return silk_ADD32_ovflw((uint)a32, (uint)(b32 * c32));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMLABB_ovflw(int a32, int b32, int c32)
		{
			return silk_ADD32_ovflw(a32, (short)b32 * (short)c32);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMULBB(int a32, int b32)
		{
			return (short)a32 * (short)b32;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMULWB(int a32, int b32)
		{
			return (int)((long)a32 * (long)(short)b32 >> 16);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMLABB(int a32, int b32, int c32)
		{
			return a32 + (short)b32 * (short)c32;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_DIV32_16(int a32, int b32)
		{
			return a32 / b32;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_DIV32(int a32, int b32)
		{
			return a32 / b32;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short silk_ADD16(short a, short b)
		{
			return (short)(a + b);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_ADD32(int a, int b)
		{
			return a + b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint silk_ADD32(uint a, uint b)
		{
			return a + b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_ADD64(long a, long b)
		{
			return a + b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short silk_SUB16(short a, short b)
		{
			return (short)(a - b);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SUB32(int a, int b)
		{
			return a - b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_SUB64(long a, long b)
		{
			return a - b;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SAT8(int a)
		{
			if (a <= 255)
			{
				if (a >= 0)
				{
					return a;
				}
				return 0;
			}
			return 255;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SAT16(int a)
		{
			if (a <= 32767)
			{
				if (a >= -32768)
				{
					return a;
				}
				return -32768;
			}
			return 32767;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SAT32(long a)
		{
			if (a <= int.MaxValue)
			{
				if (a >= int.MinValue)
				{
					return (int)a;
				}
				return int.MinValue;
			}
			return int.MaxValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short silk_ADD_SAT16(short a16, short b16)
		{
			return (short)silk_SAT16(silk_ADD32(a16, b16));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_ADD_SAT32(int a32, int b32)
		{
			if (((a32 + b32) & int.MinValue) != 0)
			{
				if (((a32 | b32) & 0x80000000u) != 0L)
				{
					return a32 + b32;
				}
				return int.MaxValue;
			}
			if ((a32 & b32 & 0x80000000u) == 0L)
			{
				return a32 + b32;
			}
			return int.MinValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_ADD_SAT64(long a64, long b64)
		{
			if (((a64 + b64) & long.MinValue) != 0L)
			{
				if (((a64 | b64) & long.MinValue) != 0L)
				{
					return a64 + b64;
				}
				return long.MaxValue;
			}
			if ((a64 & b64 & long.MinValue) == 0L)
			{
				return a64 + b64;
			}
			return long.MinValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short silk_SUB_SAT16(short a16, short b16)
		{
			return (short)silk_SAT16(silk_SUB32(a16, b16));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SUB_SAT32(int a32, int b32)
		{
			if (((a32 - b32) & int.MinValue) != 0)
			{
				if (((a32 ^ 0x80000000u) & b32 & 0x80000000u) == 0L)
				{
					return a32 - b32;
				}
				return int.MaxValue;
			}
			if ((a32 & (b32 ^ 0x80000000u) & 0x80000000u) == 0L)
			{
				return a32 - b32;
			}
			return int.MinValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_SUB_SAT64(long a64, long b64)
		{
			if (((a64 - b64) & long.MinValue) != 0L)
			{
				if (((a64 ^ long.MinValue) & b64 & long.MinValue) == 0L)
				{
					return a64 - b64;
				}
				return long.MaxValue;
			}
			if ((a64 & (b64 ^ long.MinValue) & long.MinValue) == 0L)
			{
				return a64 - b64;
			}
			return long.MinValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static sbyte silk_ADD_POS_SAT8(sbyte a, sbyte b)
		{
			return (sbyte)((((a + b) & 0x80) != 0) ? 127 : (a + b));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short silk_ADD_POS_SAT16(short a, short b)
		{
			return (short)((((a + b) & 0x8000) != 0) ? 32767 : (a + b));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_ADD_POS_SAT32(int a, int b)
		{
			if (((a + b) & 0x80000000u) == 0L)
			{
				return a + b;
			}
			return int.MaxValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_ADD_POS_SAT64(long a, long b)
		{
			if (((a + b) & long.MinValue) == 0L)
			{
				return a + b;
			}
			return long.MaxValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static sbyte silk_LSHIFT8(sbyte a, int shift)
		{
			return (sbyte)(a << shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short silk_LSHIFT16(short a, int shift)
		{
			return (short)(a << shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_LSHIFT32(int a, int shift)
		{
			return a << shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_LSHIFT64(long a, int shift)
		{
			return a << shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_LSHIFT(int a, int shift)
		{
			return a << shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_LSHIFT_ovflw(int a, int shift)
		{
			return a << shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint silk_LSHIFT_uint(uint a, int shift)
		{
			return a << shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_LSHIFT_SAT32(int a, int shift)
		{
			return silk_LSHIFT32(silk_LIMIT(a, silk_RSHIFT32(int.MinValue, shift), silk_RSHIFT32(int.MaxValue, shift)), shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static sbyte silk_RSHIFT8(sbyte a, int shift)
		{
			return (sbyte)(a >> shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short silk_RSHIFT16(short a, int shift)
		{
			return (short)(a >> shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_RSHIFT32(int a, int shift)
		{
			return a >> shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_RSHIFT(int a, int shift)
		{
			return a >> shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_RSHIFT64(long a, int shift)
		{
			return a >> shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint silk_RSHIFT_uint(uint a, int shift)
		{
			return a >> shift;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_ADD_LSHIFT(int a, int b, int shift)
		{
			return a + (b << shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_ADD_LSHIFT32(int a, int b, int shift)
		{
			return a + (b << shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint silk_ADD_LSHIFT_uint(uint a, uint b, int shift)
		{
			return a + (b << shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_ADD_RSHIFT(int a, int b, int shift)
		{
			return a + (b >> shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_ADD_RSHIFT32(int a, int b, int shift)
		{
			return a + (b >> shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint silk_ADD_RSHIFT_uint(uint a, uint b, int shift)
		{
			return a + (b >> shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SUB_LSHIFT32(int a, int b, int shift)
		{
			return a - (b << shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SUB_RSHIFT32(int a, int b, int shift)
		{
			return a - (b >> shift);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_RSHIFT_ROUND(int a, int shift)
		{
			if (shift != 1)
			{
				return (a >> shift - 1) + 1 >> 1;
			}
			return (a >> 1) + (a & 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_RSHIFT_ROUND64(long a, int shift)
		{
			if (shift != 1)
			{
				return (a >> shift - 1) + 1 >> 1;
			}
			return (a >> 1) + (a & 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_min(int a, int b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_max(int a, int b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float silk_min(float a, float b)
		{
			if (!(a < b))
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float silk_max(float a, float b)
		{
			if (!(a > b))
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int SILK_CONST(float number, int scale)
		{
			return (int)((double)(number * (float)(1L << scale)) + 0.5);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_min_int(int a, int b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short silk_min_16(short a, short b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_min_32(int a, int b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_min_64(long a, long b)
		{
			if (a >= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_max_int(int a, int b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short silk_max_16(short a, short b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_max_32(int a, int b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_max_64(long a, long b)
		{
			if (a <= b)
			{
				return b;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float silk_LIMIT(float a, float limit1, float limit2)
		{
			if (!(limit1 > limit2))
			{
				if (!(a > limit2))
				{
					if (!(a < limit1))
					{
						return a;
					}
					return limit1;
				}
				return limit2;
			}
			if (!(a > limit1))
			{
				if (!(a < limit2))
				{
					return a;
				}
				return limit2;
			}
			return limit1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_LIMIT(int a, int limit1, int limit2)
		{
			return silk_LIMIT_32(a, limit1, limit2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_LIMIT_int(int a, int limit1, int limit2)
		{
			return silk_LIMIT_32(a, limit1, limit2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short silk_LIMIT_16(short a, short limit1, short limit2)
		{
			if (limit1 <= limit2)
			{
				if (a <= limit2)
				{
					if (a >= limit1)
					{
						return a;
					}
					return limit1;
				}
				return limit2;
			}
			if (a <= limit1)
			{
				if (a >= limit2)
				{
					return a;
				}
				return limit2;
			}
			return limit1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_LIMIT_32(int a, int limit1, int limit2)
		{
			if (limit1 <= limit2)
			{
				if (a <= limit2)
				{
					if (a >= limit1)
					{
						return a;
					}
					return limit1;
				}
				return limit2;
			}
			if (a <= limit1)
			{
				if (a >= limit2)
				{
					return a;
				}
				return limit2;
			}
			return limit1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_abs(int a)
		{
			if (a <= 0)
			{
				return -a;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_abs_int16(int a)
		{
			return (a ^ (a >> 15)) - (a >> 15);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_abs_int32(int a)
		{
			return (a ^ (a >> 31)) - (a >> 31);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_abs_int64(long a)
		{
			if (a <= 0)
			{
				return -a;
			}
			return a;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_sign(int a)
		{
			return (a > 0) ? 1 : ((a < 0) ? (-1) : 0);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_RAND(int seed)
		{
			return silk_MLA_ovflw(907633515, seed, 196314165);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMMUL(int a32, int b32)
		{
			return (int)silk_RSHIFT64(silk_SMULL(a32, b32), 32);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMLAWT(int a32, int b32, int c32)
		{
			return a32 + (b32 >> 16) * (c32 >> 16) + ((b32 & 0xFFFF) * (c32 >> 16) >> 16);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_DIV32_varQ(int a32, int b32, int Qres)
		{
			int num = silk_CLZ32(silk_abs(a32)) - 1;
			int num2 = silk_LSHIFT(a32, num);
			int num3 = silk_CLZ32(silk_abs(b32)) - 1;
			int num4 = silk_LSHIFT(b32, num3);
			int num5 = silk_DIV32_16(536870911, silk_RSHIFT(num4, 16));
			int num6 = silk_SMULWB(num2, num5);
			num2 = silk_SUB32_ovflw(num2, silk_LSHIFT_ovflw(silk_SMMUL(num4, num6), 3));
			num6 = silk_SMLAWB(num6, num2, num5);
			int num7 = 29 + num - num3 - Qres;
			if (num7 < 0)
			{
				return silk_LSHIFT_SAT32(num6, -num7);
			}
			if (num7 < 32)
			{
				return silk_RSHIFT(num6, num7);
			}
			return 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_INVERSE32_varQ(int b32, int Qres)
		{
			int num = silk_CLZ32(silk_abs(b32)) - 1;
			int num2 = silk_LSHIFT(b32, num);
			int num3 = silk_DIV32_16(536870911, (short)silk_RSHIFT(num2, 16));
			int a = silk_LSHIFT(num3, 16);
			int b33 = silk_LSHIFT(536870912 - silk_SMULWB(num2, num3), 3);
			a = silk_SMLAWW(a, b33, num3);
			int num4 = 61 - num - Qres;
			if (num4 <= 0)
			{
				return silk_LSHIFT_SAT32(a, -num4);
			}
			if (num4 < 32)
			{
				return silk_RSHIFT(a, num4);
			}
			return 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMLAWB(int a32, int b32, int c32)
		{
			return a32 + silk_SMULWB(b32, c32);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMULWT(int a32, int b32)
		{
			return (a32 >> 16) * (b32 >> 16) + ((a32 & 0xFFFF) * (b32 >> 16) >> 16);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMULBT(int a32, int b32)
		{
			return (short)a32 * (b32 >> 16);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMLABT(int a32, int b32, int c32)
		{
			return a32 + (short)b32 * (c32 >> 16);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_SMLAL(long a64, int b32, int c32)
		{
			return silk_ADD64(a64, (long)b32 * (long)c32);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void MatrixSet<T>(T[] Matrix_base_adr, int Matrix_ptr, int row, int column, int N, T value)
		{
			Matrix_base_adr[Matrix_ptr + row * N + column] = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MatrixGetPointer(int row, int column, int N)
		{
			return row * N + column;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T MatrixGet<T>(T[] Matrix_base_adr, int row, int column, int N)
		{
			return Matrix_base_adr[row * N + column];
		}

		public static T MatrixGet<T>(T[] Matrix_base_adr, int matrix_ptr, int row, int column, int N)
		{
			return Matrix_base_adr[matrix_ptr + row * N + column];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void MatrixSet<T>(T[] Matrix_base_adr, int row, int column, int N, T value)
		{
			Matrix_base_adr[row * N + column] = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMULWW(int a32, int b32)
		{
			return silk_MLA(silk_SMULWB(a32, b32), a32, silk_RSHIFT_ROUND(b32, 16));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SMLAWW(int a32, int b32, int c32)
		{
			return silk_MLA(silk_SMLAWB(a32, b32, c32), b32, silk_RSHIFT_ROUND(c32, 16));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_CLZ64(long input)
		{
			int num = (int)silk_RSHIFT64(input, 32);
			if (num == 0)
			{
				return 32 + silk_CLZ32((int)input);
			}
			return silk_CLZ32(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_CLZ32(int in32)
		{
			if (in32 != 0)
			{
				return 32 - EC_ILOG((uint)in32);
			}
			return 32;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void silk_CLZ_FRAC(int input, out int lz, out int frac_Q7)
		{
			frac_Q7 = silk_ROR32(input, 24 - (lz = silk_CLZ32(input))) & 0x7F;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_SQRT_APPROX(int x)
		{
			if (x <= 0)
			{
				return 0;
			}
			silk_CLZ_FRAC(x, out var lz, out var frac_Q);
			int num = (((lz & 1) == 0) ? 46214 : 32768);
			num >>= silk_RSHIFT(lz, 1);
			return silk_SMLAWB(num, num, silk_SMULBB(213, frac_Q));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MUL32_FRAC_Q(int a32, int b32, int Q)
		{
			return (int)silk_RSHIFT_ROUND64(silk_SMULL(a32, b32), Q);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_lin2log(int inLin)
		{
			silk_CLZ_FRAC(inLin, out var lz, out var frac_Q);
			return silk_LSHIFT(31 - lz, 7) + silk_SMLAWB(frac_Q, silk_MUL(frac_Q, 128 - frac_Q), 179);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_log2lin(int inLog_Q7)
		{
			if (inLog_Q7 < 0)
			{
				return 0;
			}
			if (inLog_Q7 >= 3967)
			{
				return int.MaxValue;
			}
			int num = silk_LSHIFT(1, silk_RSHIFT(inLog_Q7, 7));
			int num2 = inLog_Q7 & 0x7F;
			if (inLog_Q7 < 2048)
			{
				return silk_ADD_RSHIFT32(num, silk_MUL(num, silk_SMLAWB(num2, silk_SMULBB(num2, 128 - num2), -174)), 7);
			}
			return silk_MLA(num, silk_RSHIFT(num, 7), silk_SMLAWB(num2, silk_SMULBB(num2, 128 - num2), -174));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void silk_interpolate(short[] xi, short[] x0, short[] x1, int ifact_Q2, int d)
		{
			for (int i = 0; i < d; i++)
			{
				xi[i] = (short)silk_ADD_RSHIFT(x0[i], silk_SMULBB(x1[i] - x0[i], ifact_Q2), 2);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_inner_prod_aligned_scale(short[] inVec1, short[] inVec2, int scale, int len)
		{
			int num = 0;
			for (int i = 0; i < len; i++)
			{
				num = silk_ADD_RSHIFT32(num, silk_SMULBB(inVec1[i], inVec2[i]), scale);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void silk_scale_copy_vector16(short[] data_out, int data_out_ptr, short[] data_in, int data_in_ptr, int gain_Q16, int dataSize)
		{
			for (int i = 0; i < dataSize; i++)
			{
				data_out[data_out_ptr + i] = (short)silk_SMULWB(gain_Q16, data_in[data_in_ptr + i]);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void silk_scale_vector32_Q26_lshift_18(int[] data1, int data1_ptr, int gain_Q26, int dataSize)
		{
			for (int i = data1_ptr; i < data1_ptr + dataSize; i++)
			{
				data1[i] = (int)silk_RSHIFT64(silk_SMULL(data1[i], gain_Q26), 8);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_inner_prod(short[] inVec1, int inVec1_ptr, short[] inVec2, int inVec2_ptr, int len)
		{
			int num = 0;
			for (int i = 0; i < len; i++)
			{
				num = MAC16_16(num, inVec1[inVec1_ptr + i], inVec2[inVec2_ptr + i]);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int silk_inner_prod_self(short[] inVec, int inVec_ptr, int len)
		{
			int num = 0;
			for (int i = inVec_ptr; i < inVec_ptr + len; i++)
			{
				num = MAC16_16(num, inVec[i], inVec[i]);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long silk_inner_prod16_aligned_64(short[] inVec1, int inVec1_ptr, short[] inVec2, int inVec2_ptr, int len)
		{
			long num = 0L;
			for (int i = 0; i < len; i++)
			{
				num = silk_SMLALBB(num, inVec1[inVec1_ptr + i], inVec2[inVec2_ptr + i]);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint EC_MINI(uint a, uint b)
		{
			return a + ((b - a) & (uint)((b < a) ? (-1) : 0));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int EC_CLZ(uint x)
		{
			if (x == 0)
			{
				return 0;
			}
			x |= x >> 1;
			x |= x >> 2;
			x |= x >> 4;
			x |= x >> 8;
			x |= x >> 16;
			uint num = x - ((x >> 1) & 0x55555555);
			num = ((num >> 2) & 0x33333333) + (num & 0x33333333);
			num = ((num >> 4) + num) & 0xF0F0F0F;
			num += num >> 8;
			num += num >> 16;
			num &= 0x3F;
			return (int)(1 - num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int EC_ILOG(uint x)
		{
			if (x == 0)
			{
				return 1;
			}
			x |= x >> 1;
			x |= x >> 2;
			x |= x >> 4;
			x |= x >> 8;
			x |= x >> 16;
			uint num = x - ((x >> 1) & 0x55555555);
			num = ((num >> 2) & 0x33333333) + (num & 0x33333333);
			num = ((num >> 4) + num) & 0xF0F0F0F;
			num += num >> 8;
			num += num >> 16;
			return (int)(num & 0x3F);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int abs(int a)
		{
			if (a < 0)
			{
				return -a;
			}
			return a;
		}
	}
	internal class SpeexResampler
	{
		private class FuncDef
		{
			public double[] table;

			public int oversample;

			public static readonly double[] kaiser12_table = new double[68]
			{
				0.99859849, 1.0, 0.99859849, 0.99440475, 0.98745105, 0.97779076, 0.9654977, 0.95066529, 0.93340547, 0.91384741,
				0.89213598, 0.86843014, 0.84290116, 0.81573067, 0.78710866, 0.75723148, 0.7262997, 0.69451601, 0.66208321, 0.62920216,
				0.59606986, 0.56287762, 0.52980938, 0.49704014, 0.46473455, 0.43304576, 0.40211431, 0.37206735, 0.343018, 0.3150649,
				0.28829195, 0.26276832, 0.23854851, 0.21567274, 0.19416736, 0.17404546, 0.15530766, 0.13794294, 0.12192957, 0.10723616,
				0.09382272, 0.08164178, 0.0706395, 0.06075685, 0.05193064, 0.04409466, 0.03718069, 0.03111947, 0.02584161, 0.02127838,
				0.0173625, 0.01402878, 0.01121463, 0.00886058, 0.00691064, 0.00531256, 0.00401805, 0.00298291, 0.00216702, 0.00153438,
				0.00105297, 0.00069463, 0.00043489, 0.00025272, 0.00013031, 5.27734E-05, 1E-05, 0.0
			};

			public static readonly double[] kaiser10_table = new double[36]
			{
				0.99537781, 1.0, 0.99537781, 0.98162644, 0.95908712, 0.92831446, 0.89005583, 0.84522401, 0.79486424, 0.74011713,
				0.68217934, 0.62226347, 0.56155915, 0.5011968, 0.44221549, 0.38553619, 0.33194107, 0.28205962, 0.23636152, 0.19515633,
				0.15859932, 0.1267028, 0.09935205, 0.07632451, 0.05731132, 0.0419398, 0.02979584, 0.0204451, 0.01345224, 0.00839739,
				0.00488951, 0.00257636, 0.00115101, 0.00035515, 0.0, 0.0
			};

			public static readonly double[] kaiser8_table = new double[36]
			{
				0.99635258, 1.0, 0.99635258, 0.98548012, 0.96759014, 0.943022, 0.91223751, 0.87580811, 0.83439927, 0.78875245,
				0.73966538, 0.68797126, 0.6345175, 0.58014482, 0.52566725, 0.47185369, 0.4194115, 0.36897272, 0.32108304, 0.27619388,
				0.23465776, 0.1967267, 0.1625538, 0.13219758, 0.10562887, 0.08273982, 0.06335451, 0.04724088, 0.03412321, 0.0236949,
				0.01563093, 0.00959968, 0.00527363, 0.00233883, 0.0005, 0.0
			};

			public static readonly double[] kaiser6_table = new double[36]
			{
				0.99733006, 1.0, 0.99733006, 0.98935595, 0.97618418, 0.95799003, 0.93501423, 0.90755855, 0.87598009, 0.84068475,
				0.80211977, 0.76076565, 0.71712752, 0.67172623, 0.62508937, 0.57774224, 0.53019925, 0.48295561, 0.43647969, 0.39120616,
				0.34752997, 0.30580127, 0.26632152, 0.22934058, 0.19505503, 0.16360756, 0.13508755, 0.10953262, 0.0869312, 0.067226,
				0.0503182, 0.03607231, 0.02432151, 0.01487334, 0.00752, 0.0
			};

			public FuncDef(double[] t, int os)
			{
				table = t;
				oversample = os;
			}
		}

		private class QualityMapping
		{
			public int base_length;

			public int oversample;

			public float downsample_bandwidth;

			public float upsample_bandwidth;

			public FuncDef window_func;

			public static readonly QualityMapping[] quality_map = new QualityMapping[11]
			{
				new QualityMapping(8, 4, 0.83f, 0.86f, new FuncDef(FuncDef.kaiser6_table, 32)),
				new QualityMapping(16, 4, 0.85f, 0.88f, new FuncDef(FuncDef.kaiser6_table, 32)),
				new QualityMapping(32, 4, 0.882f, 0.91f, new FuncDef(FuncDef.kaiser6_table, 32)),
				new QualityMapping(48, 8, 0.895f, 0.917f, new FuncDef(FuncDef.kaiser8_table, 32)),
				new QualityMapping(64, 8, 0.921f, 0.94f, new FuncDef(FuncDef.kaiser8_table, 32)),
				new QualityMapping(80, 16, 0.922f, 0.94f, new FuncDef(FuncDef.kaiser10_table, 32)),
				new QualityMapping(96, 16, 0.94f, 0.945f, new FuncDef(FuncDef.kaiser10_table, 32)),
				new QualityMapping(128, 16, 0.95f, 0.95f, new FuncDef(FuncDef.kaiser10_table, 32)),
				new QualityMapping(160, 16, 0.96f, 0.96f, new FuncDef(FuncDef.kaiser10_table, 32)),
				new QualityMapping(192, 32, 0.968f, 0.968f, new FuncDef(FuncDef.kaiser12_table, 64)),
				new QualityMapping(256, 32, 0.975f, 0.975f, new FuncDef(FuncDef.kaiser12_table, 64))
			};

			private QualityMapping(int bl, int os, float dsb, float usb, FuncDef wf)
			{
				base_length = bl;
				oversample = os;
				downsample_bandwidth = dsb;
				upsample_bandwidth = usb;
				window_func = wf;
			}
		}

		private delegate int resampler_basic_func(int channel_index, short[] input, int input_ptr, ref int in_len, short[] output, int output_ptr, ref int out_len);

		private const int FIXED_STACK_ALLOC = 8192;

		private int in_rate;

		private int out_rate;

		private int num_rate;

		private int den_rate;

		private int quality;

		private int nb_channels;

		private int filt_len;

		private int mem_alloc_size;

		private int buffer_size;

		private int int_advance;

		private int frac_advance;

		private float cutoff;

		private int oversample;

		private int initialised;

		private int started;

		private int[] last_sample;

		private int[] samp_frac_num;

		private int[] magic_samples;

		private short[] mem;

		private short[] sinc_table;

		private int sinc_table_length;

		private resampler_basic_func resampler_ptr;

		private int in_stride;

		private int out_stride;

		public int Quality
		{
			get
			{
				return quality;
			}
			set
			{
				if (value > 10 || value < 0)
				{
					throw new ArgumentException("Quality must be between 0 and 10");
				}
				if (quality != value)
				{
					quality = value;
					if (initialised != 0)
					{
						update_filter();
					}
				}
			}
		}

		public int InputStride
		{
			get
			{
				return in_stride;
			}
			set
			{
				in_stride = value;
			}
		}

		public int OutputStride
		{
			get
			{
				return out_stride;
			}
			set
			{
				out_stride = value;
			}
		}

		public int InputLatency => filt_len / 2;

		public int OutputLatency => (filt_len / 2 * den_rate + (num_rate >> 1)) / num_rate;

		private static short WORD2INT(float x)
		{
			if (!(x < -32768f))
			{
				if (!(x > 32767f))
				{
					return (short)x;
				}
				return short.MaxValue;
			}
			return short.MinValue;
		}

		private static double compute_func(float x, FuncDef func)
		{
			float num = x * (float)func.oversample;
			int num2 = (int)Math.Floor(num);
			float num3 = num - (float)num2;
			double num4 = -0.1666666667 * (double)num3 + 0.1666666667 * (double)(num3 * num3 * num3);
			double num5 = (double)num3 + 0.5 * (double)(num3 * num3) - 0.5 * (double)(num3 * num3 * num3);
			double num6 = -0.3333333333 * (double)num3 + 0.5 * (double)(num3 * num3) - 0.1666666667 * (double)(num3 * num3 * num3);
			double num7 = 1.0 - num4 - num5 - num6;
			return num6 * func.table[num2] + num7 * func.table[num2 + 1] + num5 * func.table[num2 + 2] + num4 * func.table[num2 + 3];
		}

		private static short sinc(float cutoff, float x, int N, FuncDef window_func)
		{
			float num = x * cutoff;
			if (Math.Abs(x) < 1E-06f)
			{
				return WORD2INT(32768f * cutoff);
			}
			if (Math.Abs(x) > 0.5f * (float)N)
			{
				return 0;
			}
			return WORD2INT(32768f * cutoff * (float)Math.Sin((float)Math.PI * num) / ((float)Math.PI * num) * (float)compute_func(Math.Abs(2f * x / (float)N), window_func));
		}

		private static void cubic_coef(short x, out short interp0, out short interp1, out short interp2, out short interp3)
		{
			short num = Inlines.MULT16_16_P15(x, x);
			short num2 = Inlines.MULT16_16_P15(x, num);
			interp0 = (short)Inlines.PSHR32(Inlines.MULT16_16(Inlines.QCONST16(-0.16667f, 15), x) + Inlines.MULT16_16(Inlines.QCONST16(0.16667f, 15), num2), 15);
			interp1 = Inlines.EXTRACT16(Inlines.EXTEND32(x) + Inlines.SHR32(Inlines.SUB32(Inlines.EXTEND32(num), Inlines.EXTEND32(num2)), 1));
			interp3 = (short)Inlines.PSHR32(Inlines.MULT16_16(Inlines.QCONST16(-0.33333f, 15), x) + Inlines.MULT16_16(Inlines.QCONST16(0.5f, 15), num) - Inlines.MULT16_16(Inlines.QCONST16(0.16667f, 15), num2), 15);
			interp2 = (short)(32767 - interp0 - interp1 - interp3);
			if (interp2 < short.MaxValue)
			{
				interp2++;
			}
		}

		private int resampler_basic_direct_single(int channel_index, short[] input, int input_ptr, ref int in_len, short[] output, int output_ptr, ref int out_len)
		{
			int num = filt_len;
			int num2 = 0;
			int num3 = last_sample[channel_index];
			int num4 = samp_frac_num[channel_index];
			while (num3 < in_len && num2 < out_len)
			{
				int num5 = num4 * num;
				int num6 = input_ptr + num3;
				int num7 = 0;
				for (int i = 0; i < num; i++)
				{
					num7 += Inlines.MULT16_16(sinc_table[num5 + i], input[num6 + i]);
				}
				output[output_ptr + out_stride * num2++] = Inlines.SATURATE16(Inlines.PSHR32(num7, 15));
				num3 += int_advance;
				num4 += frac_advance;
				if (num4 >= den_rate)
				{
					num4 -= den_rate;
					num3++;
				}
			}
			last_sample[channel_index] = num3;
			samp_frac_num[channel_index] = num4;
			return num2;
		}

		private int resampler_basic_interpolate_single(int channel_index, short[] input, int input_ptr, ref int in_len, short[] output, int output_ptr, ref int out_len)
		{
			int num = filt_len;
			int num2 = 0;
			int num3 = last_sample[channel_index];
			int num4 = samp_frac_num[channel_index];
			while (num3 < in_len && num2 < out_len)
			{
				int num5 = input_ptr + num3;
				int num6 = num4 * oversample / den_rate;
				short x = (short)Inlines.PDIV32(Inlines.SHL32(num4 * oversample % den_rate, 15), den_rate);
				int num7 = 0;
				int num8 = 0;
				int num9 = 0;
				int num10 = 0;
				for (int i = 0; i < num; i++)
				{
					short a = input[num5 + i];
					num7 += Inlines.MULT16_16(a, sinc_table[4 + (i + 1) * oversample - num6 - 2]);
					num8 += Inlines.MULT16_16(a, sinc_table[4 + (i + 1) * oversample - num6 - 1]);
					num9 += Inlines.MULT16_16(a, sinc_table[4 + (i + 1) * oversample - num6]);
					num10 += Inlines.MULT16_16(a, sinc_table[4 + (i + 1) * oversample - num6 + 1]);
				}
				cubic_coef(x, out var interp, out var interp2, out var interp3, out var interp4);
				int a2 = Inlines.MULT16_32_Q15(interp, Inlines.SHR32(num7, 1)) + Inlines.MULT16_32_Q15(interp2, Inlines.SHR32(num8, 1)) + Inlines.MULT16_32_Q15(interp3, Inlines.SHR32(num9, 1)) + Inlines.MULT16_32_Q15(interp4, Inlines.SHR32(num10, 1));
				output[output_ptr + out_stride * num2++] = Inlines.SATURATE16(Inlines.PSHR32(a2, 14));
				num3 += int_advance;
				num4 += frac_advance;
				if (num4 >= den_rate)
				{
					num4 -= den_rate;
					num3++;
				}
			}
			last_sample[channel_index] = num3;
			samp_frac_num[channel_index] = num4;
			return num2;
		}

		private void update_filter()
		{
			int num = filt_len;
			oversample = QualityMapping.quality_map[quality].oversample;
			filt_len = QualityMapping.quality_map[quality].base_length;
			if (num_rate > den_rate)
			{
				cutoff = QualityMapping.quality_map[quality].downsample_bandwidth * (float)den_rate / (float)num_rate;
				filt_len = filt_len * num_rate / den_rate;
				filt_len = ((filt_len - 1) & -8) + 8;
				if (2 * den_rate < num_rate)
				{
					oversample >>= 1;
				}
				if (4 * den_rate < num_rate)
				{
					oversample >>= 1;
				}
				if (8 * den_rate < num_rate)
				{
					oversample >>= 1;
				}
				if (16 * den_rate < num_rate)
				{
					oversample >>= 1;
				}
				if (oversample < 1)
				{
					oversample = 1;
				}
			}
			else
			{
				cutoff = QualityMapping.quality_map[quality].upsample_bandwidth;
			}
			if (den_rate <= 16 * (oversample + 8))
			{
				if (sinc_table == null)
				{
					sinc_table = new short[filt_len * den_rate];
				}
				else if (sinc_table_length < filt_len * den_rate)
				{
					sinc_table = new short[filt_len * den_rate];
					sinc_table_length = filt_len * den_rate;
				}
				for (int i = 0; i < den_rate; i++)
				{
					for (int j = 0; j < filt_len; j++)
					{
						sinc_table[i * filt_len + j] = sinc(cutoff, (float)(j - filt_len / 2 + 1) - (float)i / (float)den_rate, filt_len, QualityMapping.quality_map[quality].window_func);
					}
				}
				resampler_ptr = resampler_basic_direct_single;
			}
			else
			{
				if (sinc_table == null)
				{
					sinc_table = new short[filt_len * oversample + 8];
				}
				else if (sinc_table_length < filt_len * oversample + 8)
				{
					sinc_table = new short[filt_len * oversample + 8];
					sinc_table_length = filt_len * oversample + 8;
				}
				for (int k = -4; k < oversample * filt_len + 4; k++)
				{
					sinc_table[k + 4] = sinc(cutoff, (float)k / (float)oversample - (float)(filt_len / 2), filt_len, QualityMapping.quality_map[quality].window_func);
				}
				resampler_ptr = resampler_basic_interpolate_single;
			}
			int_advance = num_rate / den_rate;
			frac_advance = num_rate % den_rate;
			if (mem == null)
			{
				mem_alloc_size = filt_len - 1 + buffer_size;
				mem = new short[nb_channels * mem_alloc_size];
				for (int l = 0; l < nb_channels * mem_alloc_size; l++)
				{
					mem[l] = 0;
				}
			}
			else if (started == 0)
			{
				mem_alloc_size = filt_len - 1 + buffer_size;
				mem = new short[nb_channels * mem_alloc_size];
				for (int m = 0; m < nb_channels * mem_alloc_size; m++)
				{
					mem[m] = 0;
				}
			}
			else if (filt_len > num)
			{
				int num2 = mem_alloc_size;
				if (filt_len - 1 + buffer_size > mem_alloc_size)
				{
					mem_alloc_size = filt_len - 1 + buffer_size;
					mem = new short[nb_channels * mem_alloc_size];
				}
				for (int num3 = nb_channels - 1; num3 >= 0; num3--)
				{
					int num4 = num;
					num4 = num + 2 * magic_samples[num3];
					for (int num5 = num - 2 + magic_samples[num3]; num5 >= 0; num5--)
					{
						mem[num3 * mem_alloc_size + num5 + magic_samples[num3]] = mem[num3 * num2 + num5];
					}
					for (int num5 = 0; num5 < magic_samples[num3]; num5++)
					{
						mem[num3 * mem_alloc_size + num5] = 0;
					}
					magic_samples[num3] = 0;
					if (filt_len > num4)
					{
						int num5;
						for (num5 = 0; num5 < num4 - 1; num5++)
						{
							mem[num3 * mem_alloc_size + (filt_len - 2 - num5)] = mem[num3 * mem_alloc_size + (num4 - 2 - num5)];
						}
						for (; num5 < filt_len - 1; num5++)
						{
							mem[num3 * mem_alloc_size + (filt_len - 2 - num5)] = 0;
						}
						last_sample[num3] += (filt_len - num4) / 2;
					}
					else
					{
						magic_samples[num3] = (num4 - filt_len) / 2;
						for (int num5 = 0; num5 < filt_len - 1 + magic_samples[num3]; num5++)
						{
							mem[num3 * mem_alloc_size + num5] = mem[num3 * mem_alloc_size + num5 + magic_samples[num3]];
						}
					}
				}
			}
			else
			{
				if (filt_len >= num)
				{
					return;
				}
				for (int n = 0; n < nb_channels; n++)
				{
					int num6 = magic_samples[n];
					magic_samples[n] = (num - filt_len) / 2;
					for (int num7 = 0; num7 < filt_len - 1 + magic_samples[n] + num6; num7++)
					{
						mem[n * mem_alloc_size + num7] = mem[n * mem_alloc_size + num7 + magic_samples[n]];
					}
					magic_samples[n] += num6;
				}
			}
		}

		private void speex_resampler_process_native(int channel_index, ref int in_len, short[] output, int output_ptr, ref int out_len)
		{
			int num = 0;
			int num2 = filt_len;
			int num3 = 0;
			int num4 = channel_index * mem_alloc_size;
			started = 1;
			num3 = resampler_ptr(channel_index, mem, num4, ref in_len, output, output_ptr, ref out_len);
			if (last_sample[channel_index] < in_len)
			{
				in_len = last_sample[channel_index];
			}
			out_len = num3;
			last_sample[channel_index] -= in_len;
			int num5 = in_len;
			for (num = num4; num < num2 - 1 + num4; num++)
			{
				mem[num] = mem[num + num5];
			}
		}

		private int speex_resampler_magic(int channel_index, short[] output, ref int output_ptr, int out_len)
		{
			int in_len = magic_samples[channel_index];
			int num = channel_index * mem_alloc_size;
			int num2 = filt_len;
			speex_resampler_process_native(channel_index, ref in_len, output, output_ptr, ref out_len);
			magic_samples[channel_index] -= in_len;
			if (magic_samples[channel_index] != 0)
			{
				for (int i = num; i < magic_samples[channel_index] + num; i++)
				{
					mem[num2 - 1 + i] = mem[num2 - 1 + i + in_len];
				}
			}
			output_ptr += out_len * out_stride;
			return out_len;
		}

		public SpeexResampler(int nb_channels, int in_rate, int out_rate, int quality)
			: this(nb_channels, in_rate, out_rate, in_rate, out_rate, quality)
		{
		}

		public SpeexResampler(int nb_channels, int ratio_num, int ratio_den, int in_rate, int out_rate, int quality)
		{
			if (quality > 10 || quality < 0)
			{
				throw new ArgumentException("Quality must be between 0 and 10");
			}
			initialised = 0;
			started = 0;
			this.in_rate = 0;
			this.out_rate = 0;
			num_rate = 0;
			den_rate = 0;
			this.quality = -1;
			sinc_table_length = 0;
			mem_alloc_size = 0;
			filt_len = 0;
			mem = null;
			resampler_ptr = null;
			cutoff = 1f;
			this.nb_channels = nb_channels;
			in_stride = 1;
			out_stride = 1;
			buffer_size = 160;
			last_sample = new int[nb_channels];
			magic_samples = new int[nb_channels];
			samp_frac_num = new int[nb_channels];
			for (int i = 0; i < nb_channels; i++)
			{
				last_sample[i] = 0;
				magic_samples[i] = 0;
				samp_frac_num[i] = 0;
			}
			Quality = quality;
			SetRateFraction(ratio_num, ratio_den, in_rate, out_rate);
			update_filter();
			initialised = 1;
		}

		public static SpeexResampler Create(int nb_channels, int in_rate, int out_rate, int quality)
		{
			return new SpeexResampler(nb_channels, in_rate, out_rate, in_rate, out_rate, quality);
		}

		public static SpeexResampler Create(int nb_channels, int ratio_num, int ratio_den, int in_rate, int out_rate, int quality)
		{
			return new SpeexResampler(nb_channels, ratio_num, ratio_den, in_rate, out_rate, quality);
		}

		public void Process(int channel_index, short[] input, int input_ptr, ref int in_len, short[] output, int output_ptr, ref int out_len)
		{
			int num = in_len;
			int num2 = out_len;
			int num3 = channel_index * mem_alloc_size;
			int num4 = filt_len - 1;
			int num5 = mem_alloc_size - num4;
			int num6 = in_stride;
			if (magic_samples[channel_index] != 0)
			{
				num2 -= speex_resampler_magic(channel_index, output, ref output_ptr, num2);
			}
			if (magic_samples[channel_index] == 0)
			{
				while (num != 0 && num2 != 0)
				{
					int in_len2 = ((num > num5) ? num5 : num);
					int out_len2 = num2;
					if (input != null)
					{
						for (int i = 0; i < in_len2; i++)
						{
							mem[num3 + i + num4] = input[input_ptr + i * num6];
						}
					}
					else
					{
						for (int i = 0; i < in_len2; i++)
						{
							mem[num3 + i + num4] = 0;
						}
					}
					speex_resampler_process_native(channel_index, ref in_len2, output, output_ptr, ref out_len2);
					num -= in_len2;
					num2 -= out_len2;
					output_ptr += out_len2 * out_stride;
					if (input != null)
					{
						input_ptr += in_len2 * num6;
					}
				}
			}
			in_len -= num;
			out_len -= num2;
		}

		public void Process(int channel_index, float[] input, int input_ptr, ref int in_len, float[] output, int output_ptr, ref int out_len)
		{
			int num = in_stride;
			int num2 = out_stride;
			int num3 = in_len;
			int num4 = out_len;
			int num5 = channel_index * mem_alloc_size;
			int num6 = mem_alloc_size - (filt_len - 1);
			int num7 = ((num4 < 8192) ? num4 : 8192);
			short[] array = new short[num7];
			out_stride = 1;
			while (num3 != 0 && num4 != 0)
			{
				int output_ptr2 = 0;
				int in_len2 = ((num3 > num6) ? num6 : num3);
				int out_len2 = ((num4 > num7) ? num7 : num4);
				int num8 = 0;
				if (magic_samples[channel_index] != 0)
				{
					num8 = speex_resampler_magic(channel_index, array, ref output_ptr2, out_len2);
					out_len2 -= num8;
					num4 -= num8;
				}
				if (magic_samples[channel_index] == 0)
				{
					if (input != null)
					{
						for (int i = 0; i < in_len2; i++)
						{
							mem[num5 + i + filt_len - 1] = WORD2INT(input[input_ptr + i * num]);
						}
					}
					else
					{
						for (int i = 0; i < in_len2; i++)
						{
							mem[num5 + i + filt_len - 1] = 0;
						}
					}
					speex_resampler_process_native(channel_index, ref in_len2, array, output_ptr2, ref out_len2);
				}
				else
				{
					in_len2 = 0;
					out_len2 = 0;
				}
				for (int i = 0; i < out_len2 + num8; i++)
				{
					output[output_ptr + i * num2] = array[i];
				}
				num3 -= in_len2;
				num4 -= out_len2;
				output_ptr += (out_len2 + num8) * num2;
				if (input != null)
				{
					input_ptr += in_len2 * num;
				}
			}
			out_stride = num2;
			in_len -= num3;
			out_len -= num4;
		}

		public void ProcessInterleaved(float[] input, int input_ptr, ref int in_len, float[] output, int output_ptr, ref int out_len)
		{
			int num = out_len;
			int num2 = in_len;
			int num3 = in_stride;
			int num4 = out_stride;
			in_stride = (out_stride = nb_channels);
			for (int i = 0; i < nb_channels; i++)
			{
				out_len = num;
				in_len = num2;
				if (input != null)
				{
					Process(i, input, input_ptr + i, ref in_len, output, output_ptr + i, ref out_len);
				}
				else
				{
					Process(i, null, 0, ref in_len, output, output_ptr + i, ref out_len);
				}
			}
			in_stride = num3;
			out_stride = num4;
		}

		public void ProcessInterleaved(short[] input, int input_ptr, ref int in_len, short[] output, int output_ptr, ref int out_len)
		{
			int num = out_len;
			int num2 = in_len;
			int num3 = in_stride;
			int num4 = out_stride;
			in_stride = (out_stride = nb_channels);
			for (int i = 0; i < nb_channels; i++)
			{
				out_len = num;
				in_len = num2;
				if (input != null)
				{
					Process(i, input, input_ptr + i, ref in_len, output, output_ptr + i, ref out_len);
				}
				else
				{
					Process(i, null, 0, ref in_len, output, output_ptr + i, ref out_len);
				}
			}
			in_stride = num3;
			out_stride = num4;
		}

		public void SkipZeroes()
		{
			for (int i = 0; i < nb_channels; i++)
			{
				last_sample[i] = filt_len / 2;
			}
		}

		public void ResetMem()
		{
			for (int i = 0; i < nb_channels; i++)
			{
				last_sample[i] = 0;
				magic_samples[i] = 0;
				samp_frac_num[i] = 0;
			}
			for (int i = 0; i < nb_channels * (filt_len - 1); i++)
			{
				mem[i] = 0;
			}
		}

		public void SetRates(int in_rate, int out_rate)
		{
			SetRateFraction(in_rate, out_rate, in_rate, out_rate);
		}

		public void GetRates(out int in_rate, out int out_rate)
		{
			in_rate = this.in_rate;
			out_rate = this.out_rate;
		}

		public void SetRateFraction(int ratio_num, int ratio_den, int in_rate, int out_rate)
		{
			if (this.in_rate == in_rate && this.out_rate == out_rate && num_rate == ratio_num && den_rate == ratio_den)
			{
				return;
			}
			int num = den_rate;
			this.in_rate = in_rate;
			this.out_rate = out_rate;
			num_rate = ratio_num;
			den_rate = ratio_den;
			for (int i = 2; i <= Inlines.IMIN(num_rate, den_rate); i++)
			{
				while (num_rate % i == 0 && den_rate % i == 0)
				{
					num_rate /= i;
					den_rate /= i;
				}
			}
			if (num > 0)
			{
				for (int j = 0; j < nb_channels; j++)
				{
					samp_frac_num[j] = samp_frac_num[j] * den_rate / num;
					if (samp_frac_num[j] >= den_rate)
					{
						samp_frac_num[j] = den_rate - 1;
					}
				}
			}
			if (initialised != 0)
			{
				update_filter();
			}
		}

		public void GetRateFraction(out int ratio_num, out int ratio_den)
		{
			ratio_num = num_rate;
			ratio_den = den_rate;
		}
	}
}
namespace Concentus.Common.CPlusPlus
{
	internal static class Arrays
	{
		internal static T[][] InitTwoDimensionalArray<T>(int x, int y)
		{
			T[][] array = new T[x][];
			for (int i = 0; i < x; i++)
			{
				array[i] = new T[y];
			}
			return array;
		}

		internal static Pointer<Pointer<T>> InitTwoDimensionalArrayPointer<T>(int x, int y)
		{
			Pointer<Pointer<T>> pointer = Pointer.Malloc<Pointer<T>>(x);
			for (int i = 0; i < x; i++)
			{
				pointer[i] = Pointer.Malloc<T>(y);
			}
			return pointer;
		}

		internal static T[][][] InitThreeDimensionalArray<T>(int x, int y, int z)
		{
			T[][][] array = new T[x][][];
			for (int i = 0; i < x; i++)
			{
				array[i] = new T[y][];
				for (int j = 0; j < y; j++)
				{
					array[i][j] = new T[z];
				}
			}
			return array;
		}

		internal static void MemSetByte(byte[] array, byte value)
		{
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = value;
			}
		}

		internal static void MemSetInt(int[] array, int value, int length)
		{
			for (int i = 0; i < length; i++)
			{
				array[i] = value;
			}
		}

		internal static void MemSetShort(short[] array, short value, int length)
		{
			for (int i = 0; i < length; i++)
			{
				array[i] = value;
			}
		}

		internal static void MemSetFloat(float[] array, float value, int length)
		{
			for (int i = 0; i < length; i++)
			{
				array[i] = value;
			}
		}

		internal static void MemSetSbyte(sbyte[] array, sbyte value, int length)
		{
			for (int i = 0; i < length; i++)
			{
				array[i] = value;
			}
		}

		internal static void MemSetWithOffset<T>(T[] array, T value, int offset, int length)
		{
			for (int i = offset; i < offset + length; i++)
			{
				array[i] = value;
			}
		}

		internal static void MemMove<T>(T[] array, int src_idx, int dst_idx, int length)
		{
			if (src_idx == dst_idx || length == 0)
			{
				return;
			}
			if (src_idx + length > dst_idx || dst_idx + length > src_idx)
			{
				if (dst_idx < src_idx)
				{
					for (int i = 0; i < length; i++)
					{
						array[i + dst_idx] = array[i + src_idx];
					}
					return;
				}
				for (int num = length - 1; num >= 0; num--)
				{
					array[num + dst_idx] = array[num + src_idx];
				}
			}
			else
			{
				Array.Copy(array, src_idx, array, dst_idx, length);
			}
		}

		internal static void MemMoveInt(int[] array, int src_idx, int dst_idx, int length)
		{
			if (src_idx == dst_idx || length == 0)
			{
				return;
			}
			if (src_idx + length > dst_idx || dst_idx + length > src_idx)
			{
				if (dst_idx < src_idx)
				{
					for (int i = 0; i < length; i++)
					{
						array[i + dst_idx] = array[i + src_idx];
					}
					return;
				}
				for (int num = length - 1; num >= 0; num--)
				{
					array[num + dst_idx] = array[num + src_idx];
				}
			}
			else
			{
				Array.Copy(array, src_idx, array, dst_idx, length);
			}
		}

		internal static void MemMoveShort(short[] array, int src_idx, int dst_idx, int length)
		{
			if (src_idx == dst_idx || length == 0)
			{
				return;
			}
			if (src_idx + length > dst_idx || dst_idx + length > src_idx)
			{
				if (dst_idx < src_idx)
				{
					for (int i = 0; i < length; i++)
					{
						array[i + dst_idx] = array[i + src_idx];
					}
					return;
				}
				for (int num = length - 1; num >= 0; num--)
				{
					array[num + dst_idx] = array[num + src_idx];
				}
			}
			else
			{
				Array.Copy(array, src_idx, array, dst_idx, length);
			}
		}
	}
	internal class BoxedValueInt
	{
		public int Val;

		public BoxedValueInt(int v = 0)
		{
			Val = v;
		}

		public override string ToString()
		{
			return Val.ToString();
		}
	}
	internal class BoxedValueShort
	{
		public short Val;

		public BoxedValueShort(short v = 0)
		{
			Val = v;
		}

		public override string ToString()
		{
			return Val.ToString();
		}
	}
	internal class BoxedValueSbyte
	{
		public sbyte Val;

		public BoxedValueSbyte(sbyte v = 0)
		{
			Val = v;
		}

		public override string ToString()
		{
			return Val.ToString();
		}
	}
	internal class BoxedValue<T>
	{
		public T Val;

		public BoxedValue(T v = default(T))
		{
			Val = v;
		}

		public override string ToString()
		{
			if (Val != null)
			{
				return Val.ToString();
			}
			return "null";
		}
	}
	internal class Pointer<T>
	{
		private const bool CHECK_UNINIT_MEM = false;

		private T[] _array;

		private int _offset;

		public int Offset => _offset;

		public T[] Data => _array;

		public T this[int index]
		{
			get
			{
				return _array[index + _offset];
			}
			set
			{
				_array[index + _offset] = value;
			}
		}

		public T this[uint index]
		{
			get
			{
				return this[(int)index];
			}
			set
			{
				this[(int)index] = value;
			}
		}

		public Pointer(int capacity)
		{
			_array = new T[capacity];
			_offset = 0;
		}

		public Pointer(T[] buffer)
		{
			_array = buffer;
			_offset = 0;
		}

		public Pointer(T[] buffer, int absoluteOffset)
		{
			_array = buffer;
			_offset = absoluteOffset;
		}

		public Pointer<T> Iterate(out T returnVal)
		{
			returnVal = _array[_offset];
			return Point(1);
		}

		public Pointer<T> Point(int relativeOffset)
		{
			if (relativeOffset == 0)
			{
				return this;
			}
			return new Pointer<T>(_array, _offset + relativeOffset);
		}

		public Pointer<T> Point(uint relativeOffset)
		{
			if (relativeOffset == 0)
			{
				return this;
			}
			return new Pointer<T>(_array, _offset + (int)relativeOffset);
		}

		private static string invert_endianness(string hexstring)
		{
			StringBuilder stringBuilder = new StringBuilder(hexstring.Length);
			for (int i = 0; i < hexstring.Length / 2; i++)
			{
				stringBuilder.Append(hexstring.Substring(hexstring.Length - (i + 1) * 2, 2));
			}
			return stringBuilder.ToString();
		}

		private static void PrintMemCopy<E>(E[] source, int sourceOffset, int length)
		{
			if ((object)typeof(E) == typeof(int) || (object)typeof(E) == typeof(uint))
			{
				string text = string.Empty;
				for (int i = 0; i < length; i++)
				{
					text += invert_endianness($"{source[i + sourceOffset]:x8}");
				}
			}
			else if ((object)typeof(E) == typeof(short) || (object)typeof(E) == typeof(ushort))
			{
				string text2 = string.Empty;
				for (int j = 0; j < length; j++)
				{
					text2 += invert_endianness($"{source[j + sourceOffset]:x4}");
				}
			}
			else if ((object)typeof(E) == typeof(byte) || (object)typeof(E) == typeof(sbyte))
			{
				string text3 = string.Empty;
				for (int k = 0; k < length; k++)
				{
					text3 += invert_endianness($"{source[k + sourceOffset]:x2}");
				}
			}
		}

		public void MemCopyTo(Pointer<T> destination, int length)
		{
			if (destination != null)
			{
				Array.Copy(_array, _offset, destination._array, destination.Offset, length);
				return;
			}
			for (int i = 0; i < length; i++)
			{
				destination[i] = _array[i + _offset];
			}
		}

		public void MemCopyTo(T[] destination, int offset, int length)
		{
			Array.Copy(_array, _offset, destination, offset, length);
		}

		public void MemCopyFrom(T[] source, int sourceOffset, int length)
		{
			Array.Copy(source, sourceOffset, _array, _offset, length);
		}

		public void MemSet(T value, int length)
		{
			MemSet(value, (uint)length);
		}

		public void MemSet(T value, uint length)
		{
			for (int i = _offset; i < _offset + length; i++)
			{
				_array[i] = value;
			}
		}

		public void MemMoveTo(Pointer<T> other, int length)
		{
			if (_array == other._array)
			{
				MemMove(other.Offset - Offset, length);
			}
			else
			{
				MemCopyTo(other, length);
			}
		}

		public void MemMove(int move_dist, int length)
		{
			Arrays.MemMove(_array, _offset, _offset + move_dist, length);
		}

		public override bool Equals(object obj)
		{
			if (obj == null || (object)GetType() != obj.GetType())
			{
				return false;
			}
			Pointer<T> pointer = (Pointer<T>)obj;
			if (pointer._offset == _offset)
			{
				return pointer._array == _array;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return _array.GetHashCode() + _offset.GetHashCode();
		}
	}
	internal static class Pointer
	{
		public static Pointer<E> Malloc<E>(int capacity)
		{
			return new Pointer<E>(capacity);
		}

		public static Pointer<E> GetPointer<E>(this E[] memory, int offset = 0)
		{
			if (memory == null)
			{
				return null;
			}
			return new Pointer<E>(memory, offset);
		}
	}
}
namespace Concentus.Celt
{
	internal static class Bands
	{
		public class band_ctx
		{
			public int encode;

			public CeltMode m;

			public int i;

			public int intensity;

			public int spread;

			public int tf_change;

			public EntropyCoder ec;

			public int remaining_bits;

			public int[][] bandE;

			public uint seed;
		}

		public class split_ctx
		{
			public int inv;

			public int imid;

			public int iside;

			public int delta;

			public int itheta;

			public int qalloc;
		}

		private static readonly byte[] bit_interleave_table = new byte[16]
		{
			0, 1, 1, 1, 2, 3, 3, 3, 2, 3,
			3, 3, 2, 3, 3, 3
		};

		private static readonly byte[] bit_deinterleave_table = new byte[16]
		{
			0, 3, 12, 15, 48, 51, 60, 63, 192, 195,
			204, 207, 240, 243, 252, 255
		};

		internal static int hysteresis_decision(int val, int[] thresholds, int[] hysteresis, int N, int prev)
		{
			int i;
			for (i = 0; i < N && val >= thresholds[i]; i++)
			{
			}
			if (i > prev && val < thresholds[prev] + hysteresis[prev])
			{
				i = prev;
			}
			if (i < prev && val > thresholds[prev - 1] - hysteresis[prev - 1])
			{
				i = prev;
			}
			return i;
		}

		internal static uint celt_lcg_rand(uint seed)
		{
			return 1664525 * seed + 1013904223;
		}

		internal static int bitexact_cos(int x)
		{
			int num = 4096 + x * x >> 13;
			num = 32767 - num + Inlines.FRAC_MUL16(num, -7651 + Inlines.FRAC_MUL16(num, 8277 + Inlines.FRAC_MUL16(-626, num)));
			return 1 + num;
		}

		internal static int bitexact_log2tan(int isin, int icos)
		{
			int num = Inlines.EC_ILOG((uint)icos);
			int num2 = Inlines.EC_ILOG((uint)isin);
			icos <<= 15 - num;
			isin <<= 15 - num2;
			return (num2 - num) * 2048 + Inlines.FRAC_MUL16(isin, Inlines.FRAC_MUL16(isin, -2597) + 7932) - Inlines.FRAC_MUL16(icos, Inlines.FRAC_MUL16(icos, -2597) + 7932);
		}

		internal static void compute_band_energies(CeltMode m, int[][] X, int[][] bandE, int end, int C, int LM)
		{
			short[] eBands = m.eBands;
			_ = m.shortMdctSize;
			int num = 0;
			do
			{
				for (int i = 0; i < end; i++)
				{
					int num2 = 0;
					int num3 = 0;
					num2 = Inlines.celt_maxabs32(X[num], eBands[i] << LM, eBands[i + 1] - eBands[i] << LM);
					if (num2 > 0)
					{
						int num4 = Inlines.celt_ilog2(num2) - 14 + ((m.logN[i] >> 3) + LM + 1 >> 1);
						int num5 = eBands[i] << LM;
						if (num4 > 0)
						{
							do
							{
								num3 = Inlines.MAC16_16(num3, Inlines.EXTRACT16(Inlines.SHR32(X[num][num5], num4)), Inlines.EXTRACT16(Inlines.SHR32(X[num][num5], num4)));
							}
							while (++num5 < eBands[i + 1] << LM);
						}
						else
						{
							do
							{
								num3 = Inlines.MAC16_16(num3, Inlines.EXTRACT16(Inlines.SHL32(X[num][num5], -num4)), Inlines.EXTRACT16(Inlines.SHL32(X[num][num5], -num4)));
							}
							while (++num5 < eBands[i + 1] << LM);
						}
						bandE[num][i] = 1 + Inlines.VSHR32(Inlines.celt_sqrt(num3), -num4);
					}
					else
					{
						bandE[num][i] = 1;
					}
				}
			}
			while (++num < C);
		}

		internal static void normalise_bands(CeltMode m, int[][] freq, int[][] X, int[][] bandE, int end, int C, int M)
		{
			short[] eBands = m.eBands;
			int num = 0;
			do
			{
				int num2 = 0;
				do
				{
					int num3 = Inlines.celt_zlog2(bandE[num][num2]) - 13;
					int b = Inlines.EXTRACT16(Inlines.celt_rcp(Inlines.SHL32(Inlines.VSHR32(bandE[num][num2], num3), 3)));
					int num4 = M * eBands[num2];
					do
					{
						X[num][num4] = Inlines.MULT16_16_Q15(Inlines.VSHR32(freq[num][num4], num3 - 1), b);
					}
					while (++num4 < M * eBands[num2 + 1]);
				}
				while (++num2 < end);
			}
			while (++num < C);
		}

		internal static void denormalise_bands(CeltMode m, int[] X, int[] freq, int freq_ptr, int[] bandLogE, int bandLogE_ptr, int start, int end, int M, int downsample, int silence)
		{
			short[] eBands = m.eBands;
			int num = M * m.shortMdctSize;
			int num2 = M * eBands[end];
			if (downsample != 1)
			{
				num2 = Inlines.IMIN(num2, num / downsample);
			}
			if (silence != 0)
			{
				num2 = 0;
				start = (end = 0);
			}
			int num3 = freq_ptr;
			int num4 = M * eBands[start];
			for (int i = 0; i < M * eBands[start]; i++)
			{
				freq[num3++] = 0;
			}
			for (int i = start; i < end; i++)
			{
				int num5 = M * eBands[i];
				int num6 = M * eBands[i + 1];
				int num7 = Inlines.ADD16(bandLogE[bandLogE_ptr + i], Inlines.SHL16(Tables.eMeans[i], 6));
				int num8 = 16 - (num7 >> 10);
				int b;
				if (num8 > 31)
				{
					num8 = 0;
					b = 0;
				}
				else
				{
					b = Inlines.celt_exp2_frac(num7 & 0x3FF);
				}
				if (num8 < 0)
				{
					if (num8 < -2)
					{
						b = 32767;
						num8 = -2;
					}
					do
					{
						freq[num3] = Inlines.SHR32(Inlines.MULT16_16(X[num4], b), -num8);
					}
					while (++num5 < num6);
				}
				else
				{
					do
					{
						freq[num3++] = Inlines.SHR32(Inlines.MULT16_16(X[num4++], b), num8);
					}
					while (++num5 < num6);
				}
			}
			Arrays.MemSetWithOffset(freq, 0, freq_ptr + num2, num - num2);
		}

		internal static void anti_collapse(CeltMode m, int[][] X_, byte[] collapse_masks, int LM, int C, int size, int start, int end, int[] logE, int[] prev1logE, int[] prev2logE, int[] pulses, uint seed)
		{
			for (int i = start; i < end; i++)
			{
				int num = m.eBands[i + 1] - m.eBands[i];
				int a = Inlines.celt_udiv(1 + pulses[i], m.eBands[i + 1] - m.eBands[i]) >> LM;
				int b = Inlines.SHR32(Inlines.celt_exp2(-Inlines.SHL16(a, 7)), 1);
				int a2 = Inlines.MULT16_32_Q15((short)16384, Inlines.MIN32(32767, b));
				int num2 = num << LM;
				int num3 = Inlines.celt_ilog2(num2) >> 1;
				int a3 = Inlines.celt_rsqrt_norm(Inlines.SHL32(num2, 7 - num3 << 1));
				int num4 = 0;
				do
				{
					int num5 = 0;
					int a4 = prev1logE[num4 * m.nbEBands + i];
					int num6 = prev2logE[num4 * m.nbEBands + i];
					if (C == 1)
					{
						a4 = Inlines.MAX16(a4, prev1logE[m.nbEBands + i]);
						num6 = Inlines.MAX16(num6, prev2logE[m.nbEBands + i]);
					}
					int b2 = Inlines.EXTEND32(logE[num4 * m.nbEBands + i]) - Inlines.EXTEND32(Inlines.MIN16(a4, num6));
					b2 = Inlines.MAX32(0, b2);
					int b4;
					if (b2 < 16384)
					{
						int b3 = Inlines.SHR32(Inlines.celt_exp2((short)(-Inlines.EXTRACT16(b2))), 1);
						b4 = 2 * Inlines.MIN16(16383, b3);
					}
					else
					{
						b4 = 0;
					}
					if (LM == 3)
					{
						b4 = Inlines.MULT16_16_Q14(23170, Inlines.MIN32(23169, b4));
					}
					b4 = Inlines.SHR16(Inlines.MIN16(a2, b4), 1);
					b4 = Inlines.SHR32(Inlines.MULT16_16_Q15(a3, b4), num3);
					int num7 = m.eBands[i] << LM;
					for (int j = 0; j < 1 << LM; j++)
					{
						if ((collapse_masks[i * C + num4] & (1 << j)) == 0)
						{
							int num8 = num7 + j;
							for (int k = 0; k < num; k++)
							{
								seed = celt_lcg_rand(seed);
								X_[num4][num8 + (k << LM)] = (((seed & 0x8000) != 0) ? b4 : (-b4));
							}
							num5 = 1;
						}
					}
					if (num5 != 0)
					{
						VQ.renormalise_vector(X_[num4], num7, num << LM, 32767);
					}
				}
				while (++num4 < C);
			}
		}

		internal static void intensity_stereo(CeltMode m, int[] X, int X_ptr, int[] Y, int Y_ptr, int[][] bandE, int bandID, int N)
		{
			int shift = Inlines.celt_zlog2(Inlines.MAX32(bandE[0][bandID], bandE[1][bandID])) - 13;
			int num = Inlines.VSHR32(bandE[0][bandID], shift);
			int num2 = Inlines.VSHR32(bandE[1][bandID], shift);
			int b = 1 + Inlines.celt_sqrt(1 + Inlines.MULT16_16(num, num) + Inlines.MULT16_16(num2, num2));
			int a = Inlines.DIV32_16(Inlines.SHL32(num, 14), b);
			int a2 = Inlines.DIV32_16(Inlines.SHL32(num2, 14), b);
			for (int i = 0; i < N; i++)
			{
				int b2 = X[X_ptr + i];
				int b3 = Y[Y_ptr + i];
				X[X_ptr + i] = Inlines.EXTRACT16(Inlines.SHR32(Inlines.MAC16_16(Inlines.MULT16_16(a, b2), a2, b3), 14));
			}
		}

		private static void stereo_split(int[] X, int X_ptr, int[] Y, int Y_ptr, int N)
		{
			for (int i = 0; i < N; i++)
			{
				int num = Inlines.MULT16_16(23170, X[X_ptr + i]);
				int num2 = Inlines.MULT16_16(23170, Y[Y_ptr + i]);
				X[X_ptr + i] = Inlines.EXTRACT16(Inlines.SHR32(Inlines.ADD32(num, num2), 15));
				Y[Y_ptr + i] = Inlines.EXTRACT16(Inlines.SHR32(Inlines.SUB32(num2, num), 15));
			}
		}

		private static void stereo_merge(int[] X, int X_ptr, int[] Y, int Y_ptr, int mid, int N)
		{
			Kernels.dual_inner_prod(Y, Y_ptr, X, X_ptr, Y, Y_ptr, N, out var xy, out var xy2);
			xy = Inlines.MULT16_32_Q15(mid, xy);
			int num = Inlines.SHR16(mid, 1);
			int num2 = Inlines.MULT16_16(num, num) + xy2 - 2 * xy;
			int num3 = Inlines.MULT16_16(num, num) + xy2 + 2 * xy;
			if (num3 < 161061 || num2 < 161061)
			{
				Array.Copy(X, X_ptr, Y, Y_ptr, N);
				return;
			}
			int num4 = Inlines.celt_ilog2(num2) >> 1;
			int num5 = Inlines.celt_ilog2(num3) >> 1;
			int a = Inlines.celt_rsqrt_norm(Inlines.VSHR32(num2, num4 - 7 << 1));
			int a2 = Inlines.celt_rsqrt_norm(Inlines.VSHR32(num3, num5 - 7 << 1));
			if (num4 < 7)
			{
				num4 = 7;
			}
			if (num5 < 7)
			{
				num5 = 7;
			}
			for (int i = 0; i < N; i++)
			{
				int a3 = Inlines.MULT16_16_P15(mid, X[X_ptr + i]);
				int b = Y[Y_ptr + i];
				X[X_ptr + i] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.MULT16_16(a, Inlines.SUB16(a3, b)), num4 + 1));
				Y[Y_ptr + i] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.MULT16_16(a2, Inlines.ADD16(a3, b)), num5 + 1));
			}
		}

		internal static int spreading_decision(CeltMode m, int[][] X, ref int average, int last_decision, ref int hf_average, ref int tapset_decision, int update_hf, int end, int C, int M)
		{
			int num = 0;
			int num2 = 0;
			short[] eBands = m.eBands;
			int num3 = 0;
			if (M * (eBands[end] - eBands[end - 1]) <= 8)
			{
				return 0;
			}
			int num4 = 0;
			do
			{
				for (int i = 0; i < end; i++)
				{
					int num5 = 0;
					int[] array = new int[3];
					int[] array2 = X[num4];
					int num6 = M * eBands[i];
					int num7 = M * (eBands[i + 1] - eBands[i]);
					if (num7 <= 8)
					{
						continue;
					}
					for (int j = num6; j < num7 + num6; j++)
					{
						int num8 = Inlines.MULT16_16(Inlines.MULT16_16_Q15(array2[j], array2[j]), num7);
						if (num8 < 2048)
						{
							array[0]++;
						}
						if (num8 < 512)
						{
							array[1]++;
						}
						if (num8 < 128)
						{
							array[2]++;
						}
					}
					if (i > m.nbEBands - 4)
					{
						num3 += Inlines.celt_udiv(32 * (array[1] + array[0]), num7);
					}
					num5 = ((2 * array[2] >= num7) ? 1 : 0) + ((2 * array[1] >= num7) ? 1 : 0) + ((2 * array[0] >= num7) ? 1 : 0);
					num += num5 * 256;
					num2++;
				}
			}
			while (++num4 < C);
			if (update_hf != 0)
			{
				if (num3 != 0)
				{
					num3 = Inlines.celt_udiv(num3, C * (4 - m.nbEBands + end));
				}
				hf_average = hf_average + num3 >> 1;
				num3 = hf_average;
				if (tapset_decision == 2)
				{
					num3 += 4;
				}
				else if (tapset_decision == 0)
				{
					num3 -= 4;
				}
				if (num3 > 22)
				{
					tapset_decision = 2;
				}
				else if (num3 > 18)
				{
					tapset_decision = 1;
				}
				else
				{
					tapset_decision = 0;
				}
			}
			num = Inlines.celt_udiv(num, num2);
			num = 3 * (average = num + average >> 1) + ((3 - last_decision << 7) + 64) + 2 >> 2;
			if (num < 80)
			{
				return 3;
			}
			if (num < 256)
			{
				return 2;
			}
			if (num < 384)
			{
				return 1;
			}
			return 0;
		}

		internal static void deinterleave_hadamard(int[] X, int X_ptr, int N0, int stride, int hadamard)
		{
			int num = N0 * stride;
			int[] array = new int[num];
			if (hadamard != 0)
			{
				int num2 = stride - 2;
				for (int i = 0; i < stride; i++)
				{
					for (int j = 0; j < N0; j++)
					{
						array[Tables.ordery_table[num2 + i] * N0 + j] = X[j * stride + i + X_ptr];
					}
				}
			}
			else
			{
				for (int i = 0; i < stride; i++)
				{
					for (int j = 0; j < N0; j++)
					{
						array[i * N0 + j] = X[j * stride + i + X_ptr];
					}
				}
			}
			Array.Copy(array, 0, X, X_ptr, num);
		}

		internal static void interleave_hadamard(int[] X, int X_ptr, int N0, int stride, int hadamard)
		{
			int num = N0 * stride;
			int[] array = new int[num];
			if (hadamard != 0)
			{
				int num2 = stride - 2;
				for (int i = 0; i < stride; i++)
				{
					for (int j = 0; j < N0; j++)
					{
						array[j * stride + i] = X[Tables.ordery_table[num2 + i] * N0 + j + X_ptr];
					}
				}
			}
			else
			{
				for (int i = 0; i < stride; i++)
				{
					for (int j = 0; j < N0; j++)
					{
						array[j * stride + i] = X[i * N0 + j + X_ptr];
					}
				}
			}
			Array.Copy(array, 0, X, X_ptr, num);
		}

		internal static void haar1(int[] X, int X_ptr, int N0, int stride)
		{
			N0 >>= 1;
			for (int i = 0; i < stride; i++)
			{
				for (int j = 0; j < N0; j++)
				{
					int num = X_ptr + i + stride * 2 * j;
					int a = Inlines.MULT16_16(23170, X[num]);
					int b = Inlines.MULT16_16(23170, X[num + stride]);
					X[num] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.ADD32(a, b), 15));
					X[num + stride] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.SUB32(a, b), 15));
				}
			}
		}

		internal static void haar1ZeroOffset(int[] X, int N0, int stride)
		{
			N0 >>= 1;
			for (int i = 0; i < stride; i++)
			{
				for (int j = 0; j < N0; j++)
				{
					int num = i + stride * 2 * j;
					int a = Inlines.MULT16_16(23170, X[num]);
					int b = Inlines.MULT16_16(23170, X[num + stride]);
					X[num] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.ADD32(a, b), 15));
					X[num + stride] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.SUB32(a, b), 15));
				}
			}
		}

		internal static int compute_qn(int N, int b, int offset, int pulse_cap, int stereo)
		{
			short[] array = new short[8] { 16384, 17866, 19483, 21247, 23170, 25267, 27554, 30048 };
			int num = 2 * N - 1;
			if (stereo != 0 && N == 2)
			{
				num--;
			}
			int b2 = Inlines.celt_sudiv(b + num * offset, num);
			b2 = Inlines.IMIN(b - pulse_cap - 32, b2);
			b2 = Inlines.IMIN(64, b2);
			if (b2 < 4)
			{
				return 1;
			}
			int num2 = array[b2 & 7] >> 14 - (b2 >> 3);
			return num2 + 1 >> 1 << 1;
		}

		internal static void compute_theta(band_ctx ctx, split_ctx sctx, int[] X, int X_ptr, int[] Y, int Y_ptr, int N, ref int b, int B, int B0, int LM, int stereo, ref int fill)
		{
			int num = 0;
			int num2 = 0;
			int encode = ctx.encode;
			CeltMode m = ctx.m;
			int i = ctx.i;
			int intensity = ctx.intensity;
			EntropyCoder ec = ctx.ec;
			int[][] bandE = ctx.bandE;
			int num3 = m.logN[i] + LM * 8;
			int offset = (num3 >> 1) - ((stereo != 0 && N == 2) ? 16 : 4);
			int num4 = compute_qn(N, b, offset, num3, stereo);
			if (stereo != 0 && i >= intensity)
			{
				num4 = 1;
			}
			if (encode != 0)
			{
				num = VQ.stereo_itheta(X, X_ptr, Y, Y_ptr, stereo, N);
			}
			int num5 = (int)ec.tell_frac();
			if (num4 != 1)
			{
				if (encode != 0)
				{
					num = num * num4 + 8192 >> 14;
				}
				if (stereo != 0 && N > 2)
				{
					int num6 = 3;
					int num7 = num;
					int num8 = num4 / 2;
					uint ft = (uint)(num6 * (num8 + 1) + num8);
					if (encode != 0)
					{
						ec.encode((uint)((num7 <= num8) ? (num6 * num7) : (num7 - 1 - num8 + (num8 + 1) * num6)), (uint)((num7 <= num8) ? (num6 * (num7 + 1)) : (num7 - num8 + (num8 + 1) * num6)), ft);
					}
					else
					{
						int num9 = (int)ec.decode(ft);
						num7 = ((num9 >= (num8 + 1) * num6) ? (num8 + 1 + (num9 - (num8 + 1) * num6)) : (num9 / num6));
						ec.dec_update((uint)((num7 <= num8) ? (num6 * num7) : (num7 - 1 - num8 + (num8 + 1) * num6)), (uint)((num7 <= num8) ? (num6 * (num7 + 1)) : (num7 - num8 + (num8 + 1) * num6)), ft);
						num = num7;
					}
				}
				else if (B0 > 1 || stereo != 0)
				{
					if (encode != 0)
					{
						ec.enc_uint((uint)num, (uint)(num4 + 1));
					}
					else
					{
						num = (int)ec.dec_uint((uint)(num4 + 1));
					}
				}
				else
				{
					int num10 = 1;
					int num11 = ((num4 >> 1) + 1) * ((num4 >> 1) + 1);
					if (encode != 0)
					{
						num10 = ((num <= num4 >> 1) ? (num + 1) : (num4 + 1 - num));
						int num12 = ((num <= num4 >> 1) ? (num * (num + 1) >> 1) : (num11 - ((num4 + 1 - num) * (num4 + 2 - num) >> 1)));
						ec.encode((uint)num12, (uint)(num12 + num10), (uint)num11);
					}
					else
					{
						int num13 = 0;
						int num14 = (int)ec.decode((uint)num11);
						if (num14 < (num4 >> 1) * ((num4 >> 1) + 1) >> 1)
						{
							num = (int)(Inlines.isqrt32((uint)(8 * num14 + 1)) - 1) >> 1;
							num10 = num + 1;
							num13 = num * (num + 1) >> 1;
						}
						else
						{
							num = (int)(2 * (num4 + 1) - Inlines.isqrt32((uint)(8 * (num11 - num14 - 1) + 1))) >> 1;
							num10 = num4 + 1 - num;
							num13 = num11 - ((num4 + 1 - num) * (num4 + 2 - num) >> 1);
						}
						ec.dec_update((uint)num13, (uint)(num13 + num10), (uint)num11);
					}
				}
				num = Inlines.celt_udiv(num * 16384, num4);
				if (encode != 0 && stereo != 0)
				{
					if (num == 0)
					{
						intensity_stereo(m, X, X_ptr, Y, Y_ptr, bandE, i, N);
					}
					else
					{
						stereo_split(X, X_ptr, Y, Y_ptr, N);
					}
				}
			}
			else if (stereo != 0)
			{
				if (encode != 0)
				{
					num2 = ((num > 8192) ? 1 : 0);
					if (num2 != 0)
					{
						for (int j = 0; j < N; j++)
						{
							Y[Y_ptr + j] = -Y[Y_ptr + j];
						}
					}
					intensity_stereo(m, X, X_ptr, Y, Y_ptr, bandE, i, N);
				}
				if (b > 16 && ctx.remaining_bits > 16)
				{
					if (encode != 0)
					{
						ec.enc_bit_logp(num2, 2u);
					}
					else
					{
						num2 = ec.dec_bit_logp(2u);
					}
				}
				else
				{
					num2 = 0;
				}
				num = 0;
			}
			int num15 = (int)ec.tell_frac() - num5;
			b -= num15;
			int num16;
			int num17;
			int delta;
			switch (num)
			{
			case 0:
				num16 = 32767;
				num17 = 0;
				fill &= (1 << B) - 1;
				delta = -16384;
				break;
			case 16384:
				num16 = 0;
				num17 = 32767;
				fill &= (1 << B) - 1 << B;
				delta = 16384;
				break;
			default:
				num16 = bitexact_cos((short)num);
				num17 = bitexact_cos((short)(16384 - num));
				delta = Inlines.FRAC_MUL16(N - 1 << 7, bitexact_log2tan(num17, num16));
				break;
			}
			sctx.inv = num2;
			sctx.imid = num16;
			sctx.iside = num17;
			sctx.delta = delta;
			sctx.itheta = num;
			sctx.qalloc = num15;
		}

		internal static uint quant_band_n1(band_ctx ctx, int[] X, int X_ptr, int[] Y, int Y_ptr, int b, int[] lowband_out, int lowband_out_ptr)
		{
			int num = ((ctx.encode == 0) ? 1 : 0);
			int[] array = X;
			int num2 = X_ptr;
			int encode = ctx.encode;
			EntropyCoder ec = ctx.ec;
			int num3 = ((Y != null) ? 1 : 0);
			int num4 = 0;
			do
			{
				int num5 = 0;
				if (ctx.remaining_bits >= 8)
				{
					if (encode != 0)
					{
						num5 = ((array[num2] < 0) ? 1 : 0);
						ec.enc_bits((uint)num5, 1u);
					}
					else
					{
						num5 = (int)ec.dec_bits(1u);
					}
					ctx.remaining_bits -= 8;
					b -= 8;
				}
				if (num != 0)
				{
					array[num2] = ((num5 != 0) ? (-16384) : 16384);
				}
				array = Y;
				num2 = Y_ptr;
			}
			while (++num4 < 1 + num3);
			if (lowband_out != null)
			{
				lowband_out[lowband_out_ptr] = Inlines.SHR16(X[X_ptr], 4);
			}
			return 1u;
		}

		internal static uint quant_partition(band_ctx ctx, int[] X, int X_ptr, int N, int b, int B, int[] lowband, int lowband_ptr, int LM, int gain, int fill)
		{
			int num = 0;
			int num2 = B;
			int num3 = 0;
			int num4 = 0;
			uint result = 0u;
			int num5 = ((ctx.encode == 0) ? 1 : 0);
			int num6 = 0;
			int encode = ctx.encode;
			CeltMode m = ctx.m;
			int i = ctx.i;
			int spread = ctx.spread;
			EntropyCoder ec = ctx.ec;
			byte[] bits = m.cache.bits;
			int num7 = m.cache.index[(LM + 1) * m.nbEBands + i];
			if (LM != -1 && b > bits[num7 + bits[num7]] + 12 && N > 2)
			{
				split_ctx split_ctx = new split_ctx();
				int lowband_ptr2 = 0;
				N >>= 1;
				num6 = X_ptr + N;
				LM--;
				if (B == 1)
				{
					fill = (fill & 1) | (fill << 1);
				}
				B = B + 1 >> 1;
				compute_theta(ctx, split_ctx, X, X_ptr, X, num6, N, ref b, B, num2, LM, 0, ref fill);
				num = split_ctx.imid;
				int iside = split_ctx.iside;
				int num8 = split_ctx.delta;
				int itheta = split_ctx.itheta;
				int qalloc = split_ctx.qalloc;
				num3 = num;
				num4 = iside;
				if (num2 > 1 && (itheta & 0x3FFF) != 0)
				{
					num8 = ((itheta <= 8192) ? Inlines.IMIN(0, num8 + (N << 3 >> 5 - LM)) : (num8 - (num8 >> 4 - LM)));
				}
				int num9 = Inlines.IMAX(0, Inlines.IMIN(b, (b - num8) / 2));
				int num10 = b - num9;
				ctx.remaining_bits -= qalloc;
				if (lowband != null)
				{
					lowband_ptr2 = lowband_ptr + N;
				}
				int remaining_bits = ctx.remaining_bits;
				if (num9 >= num10)
				{
					result = quant_partition(ctx, X, X_ptr, N, num9, B, lowband, lowband_ptr, LM, Inlines.MULT16_16_P15(gain, num3), fill);
					remaining_bits = num9 - (remaining_bits - ctx.remaining_bits);
					if (remaining_bits > 24 && itheta != 0)
					{
						num10 += remaining_bits - 24;
					}
					result |= quant_partition(ctx, X, num6, N, num10, B, lowband, lowband_ptr2, LM, Inlines.MULT16_16_P15(gain, num4), fill >> B) << (num2 >> 1);
				}
				else
				{
					result = quant_partition(ctx, X, num6, N, num10, B, lowband, lowband_ptr2, LM, Inlines.MULT16_16_P15(gain, num4), fill >> B) << (num2 >> 1);
					remaining_bits = num10 - (remaining_bits - ctx.remaining_bits);
					if (remaining_bits > 24 && itheta != 16384)
					{
						num9 += remaining_bits - 24;
					}
					result |= quant_partition(ctx, X, X_ptr, N, num9, B, lowband, lowband_ptr, LM, Inlines.MULT16_16_P15(gain, num3), fill);
				}
			}
			else
			{
				int num11 = Rate.bits2pulses(m, i, LM, b);
				int num12 = Rate.pulses2bits(m, i, LM, num11);
				ctx.remaining_bits -= num12;
				while (ctx.remaining_bits < 0 && num11 > 0)
				{
					ctx.remaining_bits += num12;
					num11--;
					num12 = Rate.pulses2bits(m, i, LM, num11);
					ctx.remaining_bits -= num12;
				}
				if (num11 != 0)
				{
					int k = Rate.get_pulses(num11);
					result = ((encode == 0) ? VQ.alg_unquant(X, X_ptr, N, k, spread, B, ec, gain) : VQ.alg_quant(X, X_ptr, N, k, spread, B, ec));
				}
				else if (num5 != 0)
				{
					uint num13 = (uint)((int)(1L << B) - 1);
					fill &= (int)num13;
					if (fill == 0)
					{
						Arrays.MemSetWithOffset(X, 0, X_ptr, N);
					}
					else
					{
						if (lowband == null)
						{
							for (int j = 0; j < N; j++)
							{
								ctx.seed = celt_lcg_rand(ctx.seed);
								X[X_ptr + j] = (int)ctx.seed >> 20;
							}
							result = num13;
						}
						else
						{
							for (int j = 0; j < N; j++)
							{
								ctx.seed = celt_lcg_rand(ctx.seed);
								int num14 = 4;
								num14 = (((ctx.seed & 0x8000) != 0) ? num14 : (-num14));
								X[X_ptr + j] = lowband[lowband_ptr + j] + num14;
							}
							result = (uint)fill;
						}
						VQ.renormalise_vector(X, X_ptr, N, gain);
					}
				}
			}
			return result;
		}

		internal static uint quant_band(band_ctx ctx, int[] X, int X_ptr, int N, int b, int B, int[] lowband, int lowband_ptr, int LM, int[] lowband_out, int lowband_out_ptr, int gain, int[] lowband_scratch, int lowband_scratch_ptr, int fill)
		{
			int n = N;
			int num = B;
			int num2 = 0;
			int num3 = 0;
			uint num4 = 0u;
			int num5 = ((ctx.encode == 0) ? 1 : 0);
			int encode = ctx.encode;
			int num6 = ctx.tf_change;
			int hadamard = ((num == 1) ? 1 : 0);
			n = Inlines.celt_udiv(n, B);
			if (N == 1)
			{
				return quant_band_n1(ctx, X, X_ptr, null, 0, b, lowband_out, lowband_out_ptr);
			}
			if (num6 > 0)
			{
				num3 = num6;
			}
			if (lowband_scratch != null && lowband != null && (num3 != 0 || ((n & 1) == 0 && num6 < 0) || num > 1))
			{
				Array.Copy(lowband, lowband_ptr, lowband_scratch, lowband_scratch_ptr, N);
				lowband = lowband_scratch;
				lowband_ptr = lowband_scratch_ptr;
			}
			for (int i = 0; i < num3; i++)
			{
				if (encode != 0)
				{
					haar1(X, X_ptr, N >> i, 1 << i);
				}
				if (lowband != null)
				{
					haar1(lowband, lowband_ptr, N >> i, 1 << i);
				}
				fill = bit_interleave_table[fill & 0xF] | (bit_interleave_table[fill >> 4] << 2);
			}
			B >>= num3;
			n <<= num3;
			while ((n & 1) == 0 && num6 < 0)
			{
				if (encode != 0)
				{
					haar1(X, X_ptr, n, B);
				}
				if (lowband != null)
				{
					haar1(lowband, lowband_ptr, n, B);
				}
				fill |= fill << B;
				B <<= 1;
				n >>= 1;
				num2++;
				num6++;
			}
			num = B;
			int num7 = n;
			if (num > 1)
			{
				if (encode != 0)
				{
					deinterleave_hadamard(X, X_ptr, n >> num3, num << num3, hadamard);
				}
				if (lowband != null)
				{
					deinterleave_hadamard(lowband, lowband_ptr, n >> num3, num << num3, hadamard);
				}
			}
			num4 = quant_partition(ctx, X, X_ptr, N, b, B, lowband, lowband_ptr, LM, gain, fill);
			if (num5 != 0)
			{
				if (num > 1)
				{
					interleave_hadamard(X, X_ptr, n >> num3, num << num3, hadamard);
				}
				n = num7;
				B = num;
				for (int i = 0; i < num2; i++)
				{
					B >>= 1;
					n <<= 1;
					num4 |= num4 >> B;
					haar1(X, X_ptr, n, B);
				}
				for (int i = 0; i < num3; i++)
				{
					num4 = bit_deinterleave_table[num4];
					haar1(X, X_ptr, N >> i, 1 << i);
				}
				B <<= num3;
				if (lowband_out != null)
				{
					int a = Inlines.celt_sqrt(Inlines.SHL32(N, 22));
					for (int j = 0; j < N; j++)
					{
						lowband_out[lowband_out_ptr + j] = Inlines.MULT16_16_Q15(a, X[X_ptr + j]);
					}
				}
				num4 &= (uint)((1 << B) - 1);
			}
			return num4;
		}

		internal static uint quant_band_stereo(band_ctx ctx, int[] X, int X_ptr, int[] Y, int Y_ptr, int N, int b, int B, int[] lowband, int lowband_ptr, int LM, int[] lowband_out, int lowband_out_ptr, int[] lowband_scratch, int lowband_scratch_ptr, int fill)
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			uint num5 = 0u;
			int num6 = ((ctx.encode == 0) ? 1 : 0);
			split_ctx split_ctx = new split_ctx();
			int encode = ctx.encode;
			EntropyCoder ec = ctx.ec;
			if (N == 1)
			{
				return quant_band_n1(ctx, X, X_ptr, Y, Y_ptr, b, lowband_out, lowband_out_ptr);
			}
			int fill2 = fill;
			compute_theta(ctx, split_ctx, X, X_ptr, Y, Y_ptr, N, ref b, B, B, LM, 1, ref fill);
			num2 = split_ctx.inv;
			num = split_ctx.imid;
			int iside = split_ctx.iside;
			int delta = split_ctx.delta;
			int itheta = split_ctx.itheta;
			int qalloc = split_ctx.qalloc;
			num3 = num;
			num4 = iside;
			if (N == 2)
			{
				int num7 = 0;
				int num8 = b;
				int num9 = 0;
				if (itheta != 0 && itheta != 16384)
				{
					num9 = 8;
				}
				num8 -= num9;
				bool num10 = itheta > 8192;
				ctx.remaining_bits -= qalloc + num9;
				int[] array;
				int num11;
				int[] array2;
				if (num10)
				{
					array = Y;
					num11 = Y_ptr;
					array2 = X;
				}
				else
				{
					array = X;
					num11 = X_ptr;
					array2 = Y;
				}
				if (num9 != 0)
				{
					if (encode != 0)
					{
						num7 = ((array[num11] * array2[Y_ptr + 1] - array[num11 + 1] * array2[Y_ptr] < 0) ? 1 : 0);
						ec.enc_bits((uint)num7, 1u);
					}
					else
					{
						num7 = (int)ec.dec_bits(1u);
					}
				}
				num7 = 1 - 2 * num7;
				num5 = quant_band(ctx, array, num11, N, num8, B, lowband, lowband_ptr, LM, lowband_out, lowband_out_ptr, 32767, lowband_scratch, lowband_scratch_ptr, fill2);
				array2[Y_ptr] = -num7 * array[num11 + 1];
				array2[Y_ptr + 1] = num7 * array[num11];
				if (num6 != 0)
				{
					X[X_ptr] = Inlines.MULT16_16_Q15(num3, X[X_ptr]);
					X[X_ptr + 1] = Inlines.MULT16_16_Q15(num3, X[X_ptr + 1]);
					Y[Y_ptr] = Inlines.MULT16_16_Q15(num4, Y[Y_ptr]);
					Y[Y_ptr + 1] = Inlines.MULT16_16_Q15(num4, Y[Y_ptr + 1]);
					int a = X[X_ptr];
					X[X_ptr] = Inlines.SUB16(a, Y[Y_ptr]);
					Y[Y_ptr] = Inlines.ADD16(a, Y[Y_ptr]);
					a = X[X_ptr + 1];
					X[X_ptr + 1] = Inlines.SUB16(a, Y[Y_ptr + 1]);
					Y[Y_ptr + 1] = Inlines.ADD16(a, Y[Y_ptr + 1]);
				}
			}
			else
			{
				int num8 = Inlines.IMAX(0, Inlines.IMIN(b, (b - delta) / 2));
				int num9 = b - num8;
				ctx.remaining_bits -= qalloc;
				int remaining_bits = ctx.remaining_bits;
				if (num8 >= num9)
				{
					num5 = quant_band(ctx, X, X_ptr, N, num8, B, lowband, lowband_ptr, LM, lowband_out, lowband_out_ptr, 32767, lowband_scratch, lowband_scratch_ptr, fill);
					remaining_bits = num8 - (remaining_bits - ctx.remaining_bits);
					if (remaining_bits > 24 && itheta != 0)
					{
						num9 += remaining_bits - 24;
					}
					num5 |= quant_band(ctx, Y, Y_ptr, N, num9, B, null, 0, LM, null, 0, num4, null, 0, fill >> B);
				}
				else
				{
					num5 = quant_band(ctx, Y, Y_ptr, N, num9, B, null, 0, LM, null, 0, num4, null, 0, fill >> B);
					remaining_bits = num9 - (remaining_bits - ctx.remaining_bits);
					if (remaining_bits > 24 && itheta != 16384)
					{
						num8 += remaining_bits - 24;
					}
					num5 |= quant_band(ctx, X, X_ptr, N, num8, B, lowband, lowband_ptr, LM, lowband_out, lowband_out_ptr, 32767, lowband_scratch, lowband_scratch_ptr, fill);
				}
			}
			if (num6 != 0)
			{
				if (N != 2)
				{
					stereo_merge(X, X_ptr, Y, Y_ptr, num3, N);
				}
				if (num2 != 0)
				{
					for (int i = Y_ptr; i < N + Y_ptr; i++)
					{
						Y[i] = (short)(-Y[i]);
					}
				}
			}
			return num5;
		}

		internal static void quant_all_bands(int encode, CeltMode m, int start, int end, int[] X_, int[] Y_, byte[] collapse_masks, int[][] bandE, int[] pulses, int shortBlocks, int spread, int dual_stereo, int intensity, int[] tf_res, int total_bits, int balance, EntropyCoder ec, int LM, int codedBands, ref uint seed)
		{
			short[] eBands = m.eBands;
			int num = 1;
			int num2 = ((Y_ == null) ? 1 : 2);
			int num3 = ((encode == 0) ? 1 : 0);
			band_ctx band_ctx = new band_ctx();
			int num4 = 1 << LM;
			int num5 = ((shortBlocks == 0) ? 1 : num4);
			int num6 = num4 * eBands[start];
			int[] array = new int[num2 * (num4 * eBands[m.nbEBands - 1] - num6)];
			int num7 = num4 * eBands[m.nbEBands - 1] - num6;
			int[] lowband_scratch = X_;
			int lowband_scratch_ptr = num4 * eBands[m.nbEBands - 1];
			int num8 = 0;
			band_ctx.bandE = bandE;
			band_ctx.ec = ec;
			band_ctx.encode = encode;
			band_ctx.intensity = intensity;
			band_ctx.m = m;
			band_ctx.seed = seed;
			band_ctx.spread = spread;
			for (int i = start; i < end; i++)
			{
				int num9 = -1;
				int num10 = 0;
				int num11 = 0;
				band_ctx.i = i;
				int num12 = ((i == end - 1) ? 1 : 0);
				int[] x = X_;
				int x_ptr = num4 * eBands[i];
				int[] array2;
				if (Y_ != null)
				{
					array2 = Y_;
					num10 = num4 * eBands[i];
				}
				else
				{
					array2 = null;
				}
				int num13 = num4 * eBands[i + 1] - num4 * eBands[i];
				int num14 = (int)ec.tell_frac();
				if (i != start)
				{
					balance -= num14;
				}
				int num15 = (band_ctx.remaining_bits = total_bits - num14 - 1);
				int num17;
				if (i <= codedBands - 1)
				{
					int num16 = Inlines.celt_sudiv(balance, Inlines.IMIN(3, codedBands - i));
					num17 = Inlines.IMAX(0, Inlines.IMIN(16383, Inlines.IMIN(num15 + 1, pulses[i] + num16)));
				}
				else
				{
					num17 = 0;
				}
				if (num3 != 0 && num4 * eBands[i] - num13 >= num4 * eBands[start] && (num != 0 || num8 == 0))
				{
					num8 = i;
				}
				num11 = (band_ctx.tf_change = tf_res[i]);
				if (i >= m.effEBands)
				{
					x = array;
					x_ptr = 0;
					if (Y_ != null)
					{
						array2 = array;
						num10 = 0;
					}
					lowband_scratch = null;
				}
				if (i == end - 1)
				{
					lowband_scratch = null;
				}
				uint num20;
				uint num21;
				if (num8 != 0 && (spread != 3 || num5 > 1 || num11 < 0))
				{
					num9 = Inlines.IMAX(0, num4 * eBands[num8] - num6 - num13);
					int num18 = num8;
					while (num4 * eBands[--num18] > num9 + num6)
					{
					}
					int num19 = num8 - 1;
					while (num4 * eBands[++num19] < num9 + num6 + num13)
					{
					}
					num20 = (num21 = 0u);
					int num22 = num18;
					do
					{
						num20 |= collapse_masks[num22 * num2];
						num21 |= collapse_masks[num22 * num2 + num2 - 1];
					}
					while (++num22 < num19);
				}
				else
				{
					num20 = (num21 = (uint)((1 << num5) - 1));
				}
				if (dual_stereo != 0 && i == intensity)
				{
					dual_stereo = 0;
					if (num3 != 0)
					{
						for (int j = 0; j < num4 * eBands[i] - num6; j++)
						{
							array[j] = Inlines.HALF32(array[j] + array[num7 + j]);
						}
					}
				}
				if (dual_stereo != 0)
				{
					num20 = quant_band(band_ctx, x, x_ptr, num13, num17 / 2, num5, (num9 != -1) ? array : null, num9, LM, (num12 != 0) ? null : array, num4 * eBands[i] - num6, 32767, lowband_scratch, lowband_scratch_ptr, (int)num20);
					num21 = quant_band(band_ctx, array2, num10, num13, num17 / 2, num5, (num9 != -1) ? array : null, num7 + num9, LM, (num12 != 0) ? null : array, num7 + (num4 * eBands[i] - num6), 32767, lowband_scratch, lowband_scratch_ptr, (int)num21);
				}
				else
				{
					num20 = ((array2 == null) ? quant_band(band_ctx, x, x_ptr, num13, num17, num5, (num9 != -1) ? array : null, num9, LM, (num12 != 0) ? null : array, num4 * eBands[i] - num6, 32767, lowband_scratch, lowband_scratch_ptr, (int)(num20 | num21)) : quant_band_stereo(band_ctx, x, x_ptr, array2, num10, num13, num17, num5, (num9 != -1) ? array : null, num9, LM, (num12 != 0) ? null : array, num4 * eBands[i] - num6, lowband_scratch, lowband_scratch_ptr, (int)(num20 | num21)));
					num21 = num20;
				}
				collapse_masks[i * num2] = (byte)(num20 & 0xFF);
				collapse_masks[i * num2 + num2 - 1] = (byte)(num21 & 0xFF);
				balance += pulses[i] + num14;
				num = ((num17 > num13 << 3) ? 1 : 0);
			}
			seed = band_ctx.seed;
		}
	}
	internal class CeltCommon
	{
		private static readonly byte[] inv_table = new byte[128]
		{
			255, 255, 156, 110, 86, 70, 59, 51, 45, 40,
			37, 33, 31, 28, 26, 25, 23, 22, 21, 20,
			19, 18, 17, 16, 16, 15, 15, 14, 13, 13,
			12, 12, 12, 12, 11, 11, 11, 10, 10, 10,
			9, 9, 9, 9, 9, 9, 8, 8, 8, 8,
			8, 7, 7, 7, 7, 7, 7, 6, 6, 6,
			6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
			6, 6, 6, 5, 5, 5, 5, 5, 5, 5,
			5, 5, 5, 5, 5, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
			3, 3, 3, 3, 3, 3, 3, 2
		};

		private static readonly short[][] gains = new short[3][]
		{
			new short[3] { 10048, 7112, 4248 },
			new short[3] { 15200, 8784, 0 },
			new short[3] { 26208, 3280, 0 }
		};

		private static readonly sbyte[][] tf_select_table = new sbyte[4][]
		{
			new sbyte[8] { 0, -1, 0, -1, 0, -1, 0, -1 },
			new sbyte[8] { 0, -1, 0, -2, 1, 0, 1, -1 },
			new sbyte[8] { 0, -2, 0, -3, 2, 0, 1, -1 },
			new sbyte[8] { 0, -2, 0, -3, 3, 0, 1, -1 }
		};

		internal static int compute_vbr(CeltMode mode, AnalysisInfo analysis, int base_target, int LM, int bitrate, int lastCodedBands, int C, int intensity, int constrained_vbr, int stereo_saving, int tot_boost, int tf_estimate, int pitch_change, int maxDepth, OpusFramesize variable_duration, int lfe, int has_surround_mask, int surround_masking, int temporal_vbr)
		{
			int nbEBands = mode.nbEBands;
			short[] eBands = mode.eBands;
			int num = ((lastCodedBands != 0) ? lastCodedBands : nbEBands);
			int num2 = eBands[num] << LM;
			if (C == 2)
			{
				num2 += eBands[Inlines.IMIN(intensity, num)] << LM;
			}
			int num3 = base_target;
			if (analysis.valid != 0 && (double)analysis.activity < 0.4)
			{
				num3 -= (int)((float)(num2 << 3) * (0.4f - analysis.activity));
			}
			if (C == 2)
			{
				int num4 = Inlines.IMIN(intensity, num);
				int num5 = (eBands[num4] << LM) - num4;
				int a = Inlines.DIV32_16(Inlines.MULT16_16(26214, num5), num2);
				stereo_saving = Inlines.MIN16(stereo_saving, 256);
				num3 -= Inlines.MIN32(Inlines.MULT16_32_Q15(a, num3), Inlines.SHR32(Inlines.MULT16_16(stereo_saving - 26, num5 << 3), 8));
			}
			num3 += tot_boost - (16 << LM);
			int num6 = ((variable_duration == OpusFramesize.OPUS_FRAMESIZE_VARIABLE) ? 328 : 655);
			num3 += Inlines.SHL32(Inlines.MULT16_32_Q15(tf_estimate - num6, num3), 1);
			if (analysis.valid != 0 && lfe == 0)
			{
				float num7 = Inlines.MAX16(0f, analysis.tonality - 0.15f) - 0.09f;
				int num8 = num3 + (int)((float)(num2 << 3) * 1.2f * num7);
				if (pitch_change != 0)
				{
					num8 += (int)((float)(num2 << 3) * 0.8f);
				}
				num3 = num8;
			}
			if (has_surround_mask != 0 && lfe == 0)
			{
				int b = num3 + Inlines.SHR32(Inlines.MULT16_16(surround_masking, num2 << 3), 10);
				num3 = Inlines.IMAX(num3 / 4, b);
			}
			int num9 = eBands[nbEBands - 2] << LM;
			int a2 = Inlines.SHR32(Inlines.MULT16_16(C * num9 << 3, maxDepth), 10);
			a2 = Inlines.IMAX(a2, num3 >> 2);
			num3 = Inlines.IMIN(num3, a2);
			if ((has_surround_mask == 0 || lfe != 0) && (constrained_vbr != 0 || bitrate < 64000))
			{
				int a3 = Inlines.MAX16(0, bitrate - 32000);
				if (constrained_vbr != 0)
				{
					a3 = Inlines.MIN16(a3, 21955);
				}
				num3 = base_target + Inlines.MULT16_32_Q15(a3, num3 - base_target);
			}
			if (has_surround_mask == 0 && tf_estimate < 3277)
			{
				int b2 = Inlines.MULT16_16_Q15(3329, Inlines.IMAX(0, Inlines.IMIN(32000, 96000 - bitrate)));
				int a4 = Inlines.SHR32(Inlines.MULT16_16(temporal_vbr, b2), 10);
				num3 += Inlines.MULT16_32_Q15(a4, num3);
			}
			return Inlines.IMIN(2 * base_target, num3);
		}

		internal static int transient_analysis(int[][] input, int len, int C, out int tf_estimate, out int tf_chan)
		{
			int num = 0;
			tf_chan = 0;
			int[] array = new int[len];
			int num2 = len / 2;
			for (int i = 0; i < C; i++)
			{
				int num3 = 0;
				int a = 0;
				int num4 = 0;
				for (int j = 0; j < len; j++)
				{
					int num5 = Inlines.SHR32(input[i][j], 12);
					int num6 = Inlines.ADD32(a, num5);
					a = num4 + num6 - Inlines.SHL32(num5, 1);
					num4 = num5 - Inlines.SHR32(num6, 1);
					array[j] = Inlines.EXTRACT16(Inlines.SHR32(num6, 2));
				}
				Arrays.MemSetInt(array, 0, 12);
				int num7 = 0;
				num7 = 14 - Inlines.celt_ilog2(1 + Inlines.celt_maxabs32(array, 0, len));
				if (num7 != 0)
				{
					for (int j = 0; j < len; j++)
					{
						array[j] = Inlines.SHL16(array[j], num7);
					}
				}
				int num8 = 0;
				a = 0;
				for (int j = 0; j < num2; j++)
				{
					int num9 = Inlines.PSHR32(Inlines.MULT16_16(array[2 * j], array[2 * j]) + Inlines.MULT16_16(array[2 * j + 1], array[2 * j + 1]), 16);
					num8 += num9;
					array[j] = a + Inlines.PSHR32(num9 - a, 4);
					a = array[j];
				}
				a = 0;
				int a2 = 0;
				for (int j = num2 - 1; j >= 0; j--)
				{
					array[j] = a + Inlines.PSHR32(array[j] - a, 3);
					a = array[j];
					a2 = Inlines.MAX16(a2, a);
				}
				num8 = Inlines.MULT16_16(Inlines.celt_sqrt(num8), Inlines.celt_sqrt(Inlines.MULT16_16(a2, num2 >> 1)));
				int b = Inlines.SHL32(num2, 20) / Inlines.ADD32(1, Inlines.SHR32(num8, 1));
				num3 = 0;
				for (int j = 12; j < num2 - 5; j += 4)
				{
					int num10 = Inlines.MAX32(0, Inlines.MIN32(127, Inlines.MULT16_32_Q15(array[j] + 1, b)));
					num3 += inv_table[num10];
				}
				num3 = 64 * num3 * 4 / (6 * (num2 - 17));
				if (num3 > num)
				{
					tf_chan = i;
					num = num3;
				}
			}
			bool result = num > 200;
			int b2 = Inlines.MAX16(0, Inlines.celt_sqrt(27 * num) - 42);
			tf_estimate = Inlines.celt_sqrt(Inlines.MAX32(0, Inlines.SHL32(Inlines.MULT16_16(113, Inlines.MIN16(163, b2)), 14) - 37312528));
			return result ? 1 : 0;
		}

		internal static int patch_transient_decision(int[][] newE, int[][] oldE, int nbEBands, int start, int end, int C)
		{
			int a = 0;
			int[] array = new int[26];
			if (C == 1)
			{
				array[start] = oldE[0][start];
				for (int i = start + 1; i < end; i++)
				{
					array[i] = Inlines.MAX16(array[i - 1] - 1024, oldE[0][i]);
				}
			}
			else
			{
				array[start] = Inlines.MAX16(oldE[0][start], oldE[1][start]);
				for (int i = start + 1; i < end; i++)
				{
					array[i] = Inlines.MAX16(array[i - 1] - 1024, Inlines.MAX16(oldE[0][i], oldE[1][i]));
				}
			}
			for (int i = end - 2; i >= start; i--)
			{
				array[i] = Inlines.MAX16(array[i], array[i + 1] - 1024);
			}
			int num = 0;
			do
			{
				for (int i = Inlines.IMAX(2, start); i < end - 1; i++)
				{
					int a2 = Inlines.MAX16(0, newE[num][i]);
					int b = Inlines.MAX16(0, array[i]);
					a = Inlines.ADD32(a, Inlines.MAX16(0, Inlines.SUB16(a2, b)));
				}
			}
			while (++num < C);
			a = Inlines.DIV32(a, C * (end - 1 - Inlines.IMAX(2, start)));
			if (a <= 1024)
			{
				return 0;
			}
			return 1;
		}

		internal static void compute_mdcts(CeltMode mode, int shortBlocks, int[][] input, int[][] output, int C, int CC, int LM, int upsample)
		{
			int overlap = mode.overlap;
			int num;
			int num2;
			int shift;
			if (shortBlocks != 0)
			{
				num = shortBlocks;
				num2 = mode.shortMdctSize;
				shift = mode.maxLM;
			}
			else
			{
				num = 1;
				num2 = mode.shortMdctSize << LM;
				shift = mode.maxLM - LM;
			}
			int num3 = 0;
			do
			{
				for (int i = 0; i < num; i++)
				{
					MDCT.clt_mdct_forward(mode.mdct, input[num3], i * num2, output[num3], i, mode.window, overlap, shift, num);
				}
			}
			while (++num3 < CC);
			if (CC == 2 && C == 1)
			{
				for (int j = 0; j < num * num2; j++)
				{
					output[0][j] = Inlines.ADD32(Inlines.HALF32(output[0][j]), Inlines.HALF32(output[1][j]));
				}
			}
			if (upsample == 1)
			{
				return;
			}
			num3 = 0;
			do
			{
				int num4 = num * num2 / upsample;
				for (int j = 0; j < num4; j++)
				{
					output[num3][j] *= upsample;
				}
				Arrays.MemSetWithOffset(output[num3], 0, num4, num * num2 - num4);
			}
			while (++num3 < C);
		}

		internal static void celt_preemphasis(short[] pcmp, int pcmp_ptr, int[] inp, int inp_ptr, int N, int CC, int upsample, int[] coef, ref int mem, int clip)
		{
			int a = coef[0];
			int num = mem;
			if (coef[1] == 0 && upsample == 1 && clip == 0)
			{
				for (int i = 0; i < N; i++)
				{
					int num2 = pcmp[pcmp_ptr + CC * i];
					inp[inp_ptr + i] = Inlines.SHL32(num2, 12) - num;
					num = Inlines.SHR32(Inlines.MULT16_16(a, num2), 3);
				}
				mem = num;
				return;
			}
			int num3 = N / upsample;
			if (upsample != 1)
			{
				Arrays.MemSetWithOffset(inp, 0, inp_ptr, N);
			}
			for (int i = 0; i < num3; i++)
			{
				inp[inp_ptr + i * upsample] = pcmp[pcmp_ptr + CC * i];
			}
			for (int i = 0; i < N; i++)
			{
				int num4 = inp[inp_ptr + i];
				inp[inp_ptr + i] = Inlines.SHL32(num4, 12) - num;
				num = Inlines.SHR32(Inlines.MULT16_16(a, num4), 3);
			}
			mem = num;
		}

		internal static void celt_preemphasis(short[] pcmp, int[] inp, int inp_ptr, int N, int CC, int upsample, int[] coef, BoxedValueInt mem, int clip)
		{
			int a = coef[0];
			int num = mem.Val;
			if (coef[1] == 0 && upsample == 1 && clip == 0)
			{
				for (int i = 0; i < N; i++)
				{
					int num2 = pcmp[CC * i];
					inp[inp_ptr + i] = Inlines.SHL32(num2, 12) - num;
					num = Inlines.SHR32(Inlines.MULT16_16(a, num2), 3);
				}
				mem.Val = num;
				return;
			}
			int num3 = N / upsample;
			if (upsample != 1)
			{
				Arrays.MemSetWithOffset(inp, 0, inp_ptr, N);
			}
			for (int i = 0; i < num3; i++)
			{
				inp[inp_ptr + i * upsample] = pcmp[CC * i];
			}
			for (int i = 0; i < N; i++)
			{
				int num4 = inp[inp_ptr + i];
				inp[inp_ptr + i] = Inlines.SHL32(num4, 12) - num;
				num = Inlines.SHR32(Inlines.MULT16_16(a, num4), 3);
			}
			mem.Val = num;
		}

		internal static int l1_metric(int[] tmp, int N, int LM, int bias)
		{
			int num = 0;
			for (int i = 0; i < N; i++)
			{
				num += Inlines.EXTEND32(Inlines.ABS32(tmp[i]));
			}
			return Inlines.MAC16_32_Q15(num, LM * bias, num);
		}

		internal static int tf_analysis(CeltMode m, int len, int isTransient, int[] tf_res, int lambda, int[][] X, int N0, int LM, out int tf_sum, int tf_estimate, int tf_chan)
		{
			int[] array = new int[2];
			int num = 0;
			int bias = Inlines.MULT16_16_Q14(1311, Inlines.MAX16(-4096, 8192 - tf_estimate));
			int[] array2 = new int[len];
			int[] array3 = new int[m.eBands[len] - m.eBands[len - 1] << LM];
			int[] array4 = new int[m.eBands[len] - m.eBands[len - 1] << LM];
			int[] array5 = new int[len];
			int[] array6 = new int[len];
			tf_sum = 0;
			for (int i = 0; i < len; i++)
			{
				int num2 = 0;
				int num3 = m.eBands[i + 1] - m.eBands[i] << LM;
				int num4 = ((m.eBands[i + 1] - m.eBands[i] == 1) ? 1 : 0);
				Array.Copy(X[tf_chan], m.eBands[i] << LM, array3, 0, num3);
				int num5 = l1_metric(array3, num3, (isTransient != 0) ? LM : 0, bias);
				int num6 = num5;
				if (isTransient != 0 && num4 == 0)
				{
					Array.Copy(array3, 0, array4, 0, num3);
					Bands.haar1ZeroOffset(array4, num3 >> LM, 1 << LM);
					num5 = l1_metric(array4, num3, LM + 1, bias);
					if (num5 < num6)
					{
						num6 = num5;
						num2 = -1;
					}
				}
				for (int j = 0; j < LM + ((isTransient == 0 && num4 == 0) ? 1 : 0); j++)
				{
					int lM = ((isTransient == 0) ? (j + 1) : (LM - j - 1));
					Bands.haar1ZeroOffset(array3, num3 >> j, 1 << j);
					num5 = l1_metric(array3, num3, lM, bias);
					if (num5 < num6)
					{
						num6 = num5;
						num2 = j + 1;
					}
				}
				if (isTransient != 0)
				{
					array2[i] = 2 * num2;
				}
				else
				{
					array2[i] = -2 * num2;
				}
				tf_sum += ((isTransient != 0) ? LM : 0) - array2[i] / 2;
				if (num4 != 0 && (array2[i] == 0 || array2[i] == -2 * LM))
				{
					array2[i]--;
				}
			}
			num = 0;
			int num7;
			int num8;
			for (int k = 0; k < 2; k++)
			{
				num7 = 0;
				num8 = ((isTransient == 0) ? lambda : 0);
				for (int i = 1; i < len; i++)
				{
					int num9 = Inlines.IMIN(num7, num8 + lambda);
					int num10 = Inlines.IMIN(num7 + lambda, num8);
					num7 = num9 + Inlines.abs(array2[i] - 2 * Tables.tf_select_table[LM][4 * isTransient + 2 * k]);
					num8 = num10 + Inlines.abs(array2[i] - 2 * Tables.tf_select_table[LM][4 * isTransient + 2 * k + 1]);
				}
				num7 = Inlines.IMIN(num7, num8);
				array[k] = num7;
			}
			if (array[1] < array[0] && isTransient != 0)
			{
				num = 1;
			}
			num7 = 0;
			num8 = ((isTransient == 0) ? lambda : 0);
			for (int i = 1; i < len; i++)
			{
				int num11 = num7;
				int num12 = num8 + lambda;
				int num13;
				if (num11 < num12)
				{
					num13 = num11;
					array5[i] = 0;
				}
				else
				{
					num13 = num12;
					array5[i] = 1;
				}
				num11 = num7 + lambda;
				num12 = num8;
				int num14;
				if (num11 < num12)
				{
					num14 = num11;
					array6[i] = 0;
				}
				else
				{
					num14 = num12;
					array6[i] = 1;
				}
				num7 = num13 + Inlines.abs(array2[i] - 2 * Tables.tf_select_table[LM][4 * isTransient + 2 * num]);
				num8 = num14 + Inlines.abs(array2[i] - 2 * Tables.tf_select_table[LM][4 * isTransient + 2 * num + 1]);
			}
			tf_res[len - 1] = ((num7 >= num8) ? 1 : 0);
			for (int i = len - 2; i >= 0; i--)
			{
				if (tf_res[i + 1] == 1)
				{
					tf_res[i] = array6[i + 1];
				}
				else
				{
					tf_res[i] = array5[i + 1];
				}
			}
			return num;
		}

		internal static void tf_encode(int start, int end, int isTransient, int[] tf_res, int LM, int tf_select, EntropyCoder enc)
		{
			uint num = enc.storage * 8;
			uint num2 = (uint)enc.tell();
			int num3 = ((isTransient != 0) ? 2 : 4);
			int num4 = ((LM > 0 && num2 + num3 + 1 <= num) ? 1 : 0);
			num -= (uint)num4;
			int num6;
			int num5 = (num6 = 0);
			for (int i = start; i < end; i++)
			{
				if (num2 + num3 <= num)
				{
					enc.enc_bit_logp(tf_res[i] ^ num5, (uint)num3);
					num2 = (uint)enc.tell();
					num5 = tf_res[i];
					num6 |= num5;
				}
				else
				{
					tf_res[i] = num5;
				}
				num3 = ((isTransient != 0) ? 4 : 5);
			}
			if (num4 != 0 && Tables.tf_select_table[LM][4 * isTransient + num6] != Tables.tf_select_table[LM][4 * isTransient + 2 + num6])
			{
				enc.enc_bit_logp(tf_select, 1u);
			}
			else
			{
				tf_select = 0;
			}
			for (int i = start; i < end; i++)
			{
				tf_res[i] = Tables.tf_select_table[LM][4 * isTransient + 2 * tf_select + tf_res[i]];
			}
		}

		internal static int alloc_trim_analysis(CeltMode m, int[][] X, int[][] bandLogE, int end, int LM, int C, AnalysisInfo analysis, ref int stereo_saving, int tf_estimate, int intensity, int surround_trim)
		{
			int num = 0;
			int num2 = 1280;
			if (C == 2)
			{
				int num3 = 0;
				for (int i = 0; i < 8; i++)
				{
					int a = Kernels.celt_inner_prod(X[0], m.eBands[i] << LM, X[1], m.eBands[i] << LM, m.eBands[i + 1] - m.eBands[i] << LM);
					num3 = Inlines.ADD16(num3, Inlines.EXTRACT16(Inlines.SHR32(a, 18)));
				}
				num3 = Inlines.MULT16_16_Q15(4096, num3);
				num3 = Inlines.MIN16(1024, Inlines.ABS32(num3));
				int num4 = num3;
				for (int i = 8; i < intensity; i++)
				{
					int a2 = Kernels.celt_inner_prod(X[0], m.eBands[i] << LM, X[1], m.eBands[i] << LM, m.eBands[i + 1] - m.eBands[i] << LM);
					num4 = Inlines.MIN16(num4, Inlines.ABS16(Inlines.EXTRACT16(Inlines.SHR32(a2, 18))));
				}
				num4 = Inlines.MIN16(1024, Inlines.ABS32(num4));
				int num5 = Inlines.celt_log2(1049625 - Inlines.MULT16_16(num3, num3));
				int num6 = Inlines.MAX16(Inlines.HALF16(num5), Inlines.celt_log2(1049625 - Inlines.MULT16_16(num4, num4)));
				num5 = Inlines.PSHR32(num5 - 6144, 2);
				num6 = Inlines.PSHR32(num6 - 6144, 2);
				num2 += Inlines.MAX16(-1024, Inlines.MULT16_16_Q15(24576, num5));
				stereo_saving = Inlines.MIN16(stereo_saving + 64, -Inlines.HALF16(num6));
			}
			int num7 = 0;
			do
			{
				for (int i = 0; i < end - 1; i++)
				{
					num += bandLogE[num7][i] * (2 + 2 * i - end);
				}
			}
			while (++num7 < C);
			num /= C * (end - 1);
			num2 -= Inlines.MAX16(Inlines.NEG16((short)512), Inlines.MIN16(512, Inlines.SHR16(num + 1024, 2) / 6));
			num2 -= Inlines.SHR16(surround_trim, 2);
			num2 -= 2 * Inlines.SHR16(tf_estimate, 6);
			if (analysis.valid != 0)
			{
				num2 -= Inlines.MAX16(-512, Inlines.MIN16(512, (int)(512f * (analysis.tonality_slope + 0.05f))));
			}
			int b = Inlines.PSHR32(num2, 8);
			return Inlines.IMAX(0, Inlines.IMIN(10, b));
		}

		internal static int stereo_analysis(CeltMode m, int[][] X, int LM)
		{
			int num = 1;
			int num2 = 1;
			for (int i = 0; i < 13; i++)
			{
				for (int j = m.eBands[i] << LM; j < m.eBands[i + 1] << LM; j++)
				{
					int num3 = Inlines.EXTEND32(X[0][j]);
					int num4 = Inlines.EXTEND32(X[1][j]);
					int x = Inlines.ADD32(num3, num4);
					int x2 = Inlines.SUB32(num3, num4);
					num = Inlines.ADD32(num, Inlines.ADD32(Inlines.ABS32(num3), Inlines.ABS32(num4)));
					num2 = Inlines.ADD32(num2, Inlines.ADD32(Inlines.ABS32(x), Inlines.ABS32(x2)));
				}
			}
			num2 = Inlines.MULT16_32_Q15((short)23170, num2);
			int num5 = 13;
			if (LM <= 1)
			{
				num5 -= 8;
			}
			if (Inlines.MULT16_32_Q15((m.eBands[13] << LM + 1) + num5, num2) <= Inlines.MULT16_32_Q15(m.eBands[13] << LM + 1, num))
			{
				return 0;
			}
			return 1;
		}

		internal static int median_of_5(int[] x, int x_ptr)
		{
			int num = x[x_ptr + 2];
			int num3;
			int num2;
			if (x[x_ptr] > x[x_ptr + 1])
			{
				num2 = x[x_ptr + 1];
				num3 = x[x_ptr];
			}
			else
			{
				num2 = x[x_ptr];
				num3 = x[x_ptr + 1];
			}
			int num4;
			int num5;
			if (x[x_ptr + 3] > x[x_ptr + 4])
			{
				num4 = x[x_ptr + 4];
				num5 = x[x_ptr + 3];
			}
			else
			{
				num4 = x[x_ptr + 3];
				num5 = x[x_ptr + 4];
			}
			if (num2 > num4)
			{
				int num6 = num4;
				num4 = num2;
				num2 = num6;
				int num7 = num5;
				num5 = num3;
				num3 = num7;
			}
			if (num > num3)
			{
				if (num3 < num4)
				{
					return Inlines.MIN16(num, num4);
				}
				return Inlines.MIN16(num5, num3);
			}
			if (num < num4)
			{
				return Inlines.MIN16(num3, num4);
			}
			return Inlines.MIN16(num, num5);
		}

		internal static int median_of_3(int[] x, int x_ptr)
		{
			int num;
			int num2;
			if (x[x_ptr] > x[x_ptr + 1])
			{
				num = x[x_ptr + 1];
				num2 = x[x_ptr];
			}
			else
			{
				num = x[x_ptr];
				num2 = x[x_ptr + 1];
			}
			int num3 = x[x_ptr + 2];
			if (num2 < num3)
			{
				return num2;
			}
			if (num < num3)
			{
				return num3;
			}
			return num;
		}

		internal static int dynalloc_analysis(int[][] bandLogE, int[][] bandLogE2, int nbEBands, int start, int end, int C, int[] offsets, int lsb_depth, short[] logN, int isTransient, int vbr, int constrained_vbr, short[] eBands, int LM, int effectiveBytes, out int tot_boost_, int lfe, int[] surround_dynalloc)
		{
			int num = 0;
			int[][] array = Arrays.InitTwoDimensionalArray<int>(2, nbEBands);
			int[] array2 = new int[C * nbEBands];
			Arrays.MemSetInt(offsets, 0, nbEBands);
			int num2 = -32666;
			for (int i = 0; i < end; i++)
			{
				array2[i] = Inlines.MULT16_16((short)64, logN[i]) + 512 + Inlines.SHL16(9 - lsb_depth, 10) - Inlines.SHL16(Tables.eMeans[i], 6) + Inlines.MULT16_16(6, (i + 5) * (i + 5));
			}
			int num3 = 0;
			do
			{
				for (int i = 0; i < end; i++)
				{
					num2 = Inlines.MAX16(num2, bandLogE[num3][i] - array2[i]);
				}
			}
			while (++num3 < C);
			if (effectiveBytes > 50 && LM >= 1 && lfe == 0)
			{
				int num4 = 0;
				num3 = 0;
				do
				{
					int[] array3 = array[num3];
					array3[0] = bandLogE2[num3][0];
					for (int i = 1; i < end; i++)
					{
						if (bandLogE2[num3][i] > bandLogE2[num3][i - 1] + 512)
						{
							num4 = i;
						}
						array3[i] = Inlines.MIN16(array3[i - 1] + 1536, bandLogE2[num3][i]);
					}
					for (int i = num4 - 1; i >= 0; i--)
					{
						array3[i] = Inlines.MIN16(array3[i], Inlines.MIN16(array3[i + 1] + 2048, bandLogE2[num3][i]));
					}
					int num5 = 1024;
					for (int i = 2; i < end - 2; i++)
					{
						array3[i] = Inlines.MAX16(array3[i], median_of_5(bandLogE2[num3], i - 2) - num5);
					}
					int b = median_of_3(bandLogE2[num3], 0) - num5;
					array3[0] = Inlines.MAX16(array3[0], b);
					array3[1] = Inlines.MAX16(array3[1], b);
					b = median_of_3(bandLogE2[num3], end - 3) - num5;
					array3[end - 2] = Inlines.MAX16(array3[end - 2], b);
					array3[end - 1] = Inlines.MAX16(array3[end - 1], b);
					for (int i = 0; i < end; i++)
					{
						array3[i] = Inlines.MAX16(array3[i], array2[i]);
					}
				}
				while (++num3 < C);
				if (C == 2)
				{
					for (int i = start; i < end; i++)
					{
						array[1][i] = Inlines.MAX16(array[1][i], array[0][i] - 4096);
						array[0][i] = Inlines.MAX16(array[0][i], array[1][i] - 4096);
						array[0][i] = Inlines.HALF16(Inlines.MAX16(0, bandLogE[0][i] - array[0][i]) + Inlines.MAX16(0, bandLogE[1][i] - array[1][i]));
					}
				}
				else
				{
					for (int i = start; i < end; i++)
					{
						array[0][i] = Inlines.MAX16(0, bandLogE[0][i] - array[0][i]);
					}
				}
				for (int i = start; i < end; i++)
				{
					array[0][i] = Inlines.MAX16(array[0][i], surround_dynalloc[i]);
				}
				if ((vbr == 0 || constrained_vbr != 0) && isTransient == 0)
				{
					for (int i = start; i < end; i++)
					{
						array[0][i] = Inlines.HALF16(array[0][i]);
					}
				}
				for (int i = start; i < end; i++)
				{
					if (i < 8)
					{
						array[0][i] *= 2;
					}
					if (i >= 12)
					{
						array[0][i] = Inlines.HALF16(array[0][i]);
					}
					array[0][i] = Inlines.MIN16(array[0][i], 4096);
					int num6 = C * (eBands[i + 1] - eBands[i]) << LM;
					int num7;
					int num8;
					if (num6 < 6)
					{
						num7 = Inlines.SHR32(array[0][i], 10);
						num8 = num7 * num6 << 3;
					}
					else if (num6 > 48)
					{
						num7 = Inlines.SHR32(array[0][i] * 8, 10);
						num8 = (num7 * num6 << 3) / 8;
					}
					else
					{
						num7 = Inlines.SHR32(array[0][i] * num6 / 6, 10);
						num8 = num7 * 6 << 3;
					}
					if ((vbr == 0 || (constrained_vbr != 0 && isTransient == 0)) && num + num8 >> 3 >> 3 > effectiveBytes / 4)
					{
						int num9 = effectiveBytes / 4 << 3 << 3;
						offsets[i] = num9 - num;
						num = num9;
						break;
					}
					offsets[i] = num7;
					num += num8;
				}
			}
			tot_boost_ = num;
			return num2;
		}

		internal static void deemphasis(int[][] input, int[] input_ptrs, short[] pcm, int pcm_ptr, int N, int C, int downsample, int[] coef, int[] mem, int accum)
		{
			int num = 0;
			if (downsample == 1 && C == 2 && accum == 0)
			{
				deemphasis_stereo_simple(input, input_ptrs, pcm, pcm_ptr, N, coef[0], mem);
				return;
			}
			int[] array = new int[N];
			int a = coef[0];
			int num2 = N / downsample;
			int num3 = 0;
			do
			{
				int num4 = mem[num3];
				int[] array2 = input[num3];
				int num5 = input_ptrs[num3];
				int num6 = pcm_ptr + num3;
				if (downsample > 1)
				{
					for (int i = 0; i < N; i++)
					{
						int num7 = array2[num5 + i] + num4;
						num4 = Inlines.MULT16_32_Q15(a, num7);
						array[i] = num7;
					}
					num = 1;
				}
				else if (accum != 0)
				{
					for (int i = 0; i < N; i++)
					{
						int num8 = array2[num5 + i] + num4;
						num4 = Inlines.MULT16_32_Q15(a, num8);
						pcm[num6 + i * C] = Inlines.SAT16(Inlines.ADD32(pcm[num6 + i * C], Inlines.SIG2WORD16(num8)));
					}
				}
				else
				{
					for (int i = 0; i < N; i++)
					{
						int num9 = array2[num5 + i] + num4;
						if (array2[num5 + i] > 0 && num4 > 0 && num9 < 0)
						{
							num9 = int.MaxValue;
							num4 = int.MaxValue;
						}
						else
						{
							num4 = Inlines.MULT16_32_Q15(a, num9);
						}
						pcm[num6 + i * C] = Inlines.SIG2WORD16(num9);
					}
				}
				mem[num3] = num4;
				if (num != 0)
				{
					for (int i = 0; i < num2; i++)
					{
						pcm[num6 + i * C] = Inlines.SIG2WORD16(array[i * downsample]);
					}
				}
			}
			while (++num3 < C);
		}

		internal static void deemphasis_stereo_simple(int[][] input, int[] input_ptrs, short[] pcm, int pcm_ptr, int N, int coef0, int[] mem)
		{
			int[] array = input[0];
			int[] array2 = input[1];
			int num = input_ptrs[0];
			int num2 = input_ptrs[1];
			int num3 = mem[0];
			int num4 = mem[1];
			for (int i = 0; i < N; i++)
			{
				int num5 = array[num + i] + num3;
				int num6 = array2[num2 + i] + num4;
				num3 = Inlines.MULT16_32_Q15(coef0, num5);
				num4 = Inlines.MULT16_32_Q15(coef0, num6);
				pcm[pcm_ptr + 2 * i] = Inlines.SIG2WORD16(num5);
				pcm[pcm_ptr + 2 * i + 1] = Inlines.SIG2WORD16(num6);
			}
			mem[0] = num3;
			mem[1] = num4;
		}

		internal static void celt_synthesis(CeltMode mode, int[][] X, int[][] out_syn, int[] out_syn_ptrs, int[] oldBandE, int start, int effEnd, int C, int CC, int isTransient, int LM, int downsample, int silence)
		{
			int overlap = mode.overlap;
			int nbEBands = mode.nbEBands;
			int num = mode.shortMdctSize << LM;
			int[] array = new int[num];
			int num2 = 1 << LM;
			int num3;
			int num4;
			int shift;
			if (isTransient != 0)
			{
				num3 = num2;
				num4 = mode.shortMdctSize;
				shift = mode.maxLM;
			}
			else
			{
				num3 = 1;
				num4 = mode.shortMdctSize << LM;
				shift = mode.maxLM - LM;
			}
			if (CC == 2 && C == 1)
			{
				Bands.denormalise_bands(mode, X[0], array, 0, oldBandE, 0, start, effEnd, num2, downsample, silence);
				int num5 = out_syn_ptrs[1] + overlap / 2;
				Array.Copy(array, 0, out_syn[1], num5, num);
				for (int i = 0; i < num3; i++)
				{
					MDCT.clt_mdct_backward(mode.mdct, out_syn[1], num5 + i, out_syn[0], out_syn_ptrs[0] + num4 * i, mode.window, overlap, shift, num3);
				}
				for (int i = 0; i < num3; i++)
				{
					MDCT.clt_mdct_backward(mode.mdct, array, i, out_syn[1], out_syn_ptrs[1] + num4 * i, mode.window, overlap, shift, num3);
				}
				return;
			}
			if (CC == 1 && C == 2)
			{
				int num6 = out_syn_ptrs[0] + overlap / 2;
				Bands.denormalise_bands(mode, X[0], array, 0, oldBandE, 0, start, effEnd, num2, downsample, silence);
				Bands.denormalise_bands(mode, X[1], out_syn[0], num6, oldBandE, nbEBands, start, effEnd, num2, downsample, silence);
				for (int j = 0; j < num; j++)
				{
					array[j] = Inlines.HALF32(Inlines.ADD32(array[j], out_syn[0][num6 + j]));
				}
				for (int i = 0; i < num3; i++)
				{
					MDCT.clt_mdct_backward(mode.mdct, array, i, out_syn[0], out_syn_ptrs[0] + num4 * i, mode.window, overlap, shift, num3);
				}
				return;
			}
			int num7 = 0;
			do
			{
				Bands.denormalise_bands(mode, X[num7], array, 0, oldBandE, num7 * nbEBands, start, effEnd, num2, downsample, silence);
				for (int i = 0; i < num3; i++)
				{
					MDCT.clt_mdct_backward(mode.mdct, array, i, out_syn[num7], out_syn_ptrs[num7] + num4 * i, mode.window, overlap, shift, num3);
				}
			}
			while (++num7 < CC);
		}

		internal static void tf_decode(int start, int end, int isTransient, int[] tf_res, int LM, EntropyCoder dec)
		{
			uint num = dec.storage * 8;
			uint num2 = (uint)dec.tell();
			int num3 = ((isTransient != 0) ? 2 : 4);
			int num4 = ((LM > 0 && num2 + num3 + 1 <= num) ? 1 : 0);
			num -= (uint)num4;
			int num6;
			int num5 = (num6 = 0);
			for (int i = start; i < end; i++)
			{
				if (num2 + num3 <= num)
				{
					num6 ^= dec.dec_bit_logp((uint)num3);
					num2 = (uint)dec.tell();
					num5 |= num6;
				}
				tf_res[i] = num6;
				num3 = ((isTransient != 0) ? 4 : 5);
			}
			int num7 = 0;
			if (num4 != 0 && Tables.tf_select_table[LM][4 * isTransient + num5] != Tables.tf_select_table[LM][4 * isTransient + 2 + num5])
			{
				num7 = dec.dec_bit_logp(1u);
			}
			for (int i = start; i < end; i++)
			{
				tf_res[i] = Tables.tf_select_table[LM][4 * isTransient + 2 * num7 + tf_res[i]];
			}
		}

		internal static int celt_plc_pitch_search(int[][] decode_mem, int C)
		{
			int[] array = new int[1024];
			Pitch.pitch_downsample(decode_mem, array, 2048, C);
			Pitch.pitch_search(array, 360, array, 1328, 620, out var pitch);
			return 720 - pitch;
		}

		internal static int resampling_factor(int rate)
		{
			return rate switch
			{
				48000 => 1, 
				24000 => 2, 
				16000 => 3, 
				12000 => 4, 
				8000 => 6, 
				_ => 0, 
			};
		}

		internal static void comb_filter_const(int[] y, int y_ptr, int[] x, int x_ptr, int T, int N, int g10, int g11, int g12)
		{
			int num = x_ptr - T;
			int b = x[num - 2];
			int num2 = x[num - 1];
			int num3 = x[num];
			int num4 = x[num + 1];
			for (int i = 0; i < N; i++)
			{
				int num5 = x[num + i + 2];
				y[y_ptr + i] = x[x_ptr + i] + Inlines.MULT16_32_Q15(g10, num3) + Inlines.MULT16_32_Q15(g11, Inlines.ADD32(num4, num2)) + Inlines.MULT16_32_Q15(g12, Inlines.ADD32(num5, b));
				b = num2;
				num2 = num3;
				num3 = num4;
				num4 = num5;
			}
		}

		internal static void comb_filter(int[] y, int y_ptr, int[] x, int x_ptr, int T0, int T1, int N, int g0, int g1, int tapset0, int tapset1, int[] window, int overlap)
		{
			if (g0 != 0 || g1 != 0)
			{
				int b = Inlines.MULT16_16_P15(g0, gains[tapset0][0]);
				int b2 = Inlines.MULT16_16_P15(g0, gains[tapset0][1]);
				int b3 = Inlines.MULT16_16_P15(g0, gains[tapset0][2]);
				int num = Inlines.MULT16_16_P15(g1, gains[tapset1][0]);
				int num2 = Inlines.MULT16_16_P15(g1, gains[tapset1][1]);
				int num3 = Inlines.MULT16_16_P15(g1, gains[tapset1][2]);
				int num4 = x[x_ptr - T1 + 1];
				int num5 = x[x_ptr - T1];
				int num6 = x[x_ptr - T1 - 1];
				int b4 = x[x_ptr - T1 - 2];
				if (g0 == g1 && T0 == T1 && tapset0 == tapset1)
				{
					overlap = 0;
				}
				int i;
				for (i = 0; i < overlap; i++)
				{
					int num7 = x[x_ptr + i - T1 + 2];
					int num8 = Inlines.MULT16_16_Q15(window[i], window[i]);
					y[y_ptr + i] = x[x_ptr + i] + Inlines.MULT16_32_Q15(Inlines.MULT16_16_Q15((short)(32767 - num8), b), x[x_ptr + i - T0]) + Inlines.MULT16_32_Q15(Inlines.MULT16_16_Q15((short)(32767 - num8), b2), Inlines.ADD32(x[x_ptr + i - T0 + 1], x[x_ptr + i - T0 - 1])) + Inlines.MULT16_32_Q15(Inlines.MULT16_16_Q15((short)(32767 - num8), b3), Inlines.ADD32(x[x_ptr + i - T0 + 2], x[x_ptr + i - T0 - 2])) + Inlines.MULT16_32_Q15(Inlines.MULT16_16_Q15(num8, num), num5) + Inlines.MULT16_32_Q15(Inlines.MULT16_16_Q15(num8, num2), Inlines.ADD32(num4, num6)) + Inlines.MULT16_32_Q15(Inlines.MULT16_16_Q15(num8, num3), Inlines.ADD32(num7, b4));
					b4 = num6;
					num6 = num5;
					num5 = num4;
					num4 = num7;
				}
				if (g1 != 0)
				{
					comb_filter_const(y, y_ptr + i, x, x_ptr + i, T1, N - i, num, num2, num3);
				}
			}
		}

		internal static void init_caps(CeltMode m, int[] cap, int LM, int C)
		{
			for (int i = 0; i < m.nbEBands; i++)
			{
				int num = m.eBands[i + 1] - m.eBands[i] << LM;
				cap[i] = (m.cache.caps[m.nbEBands * (2 * LM + C - 1) + i] + 64) * C * num >> 2;
			}
		}
	}
	internal static class CeltConstants
	{
		public const int Q15ONE = 32767;

		public const float CELT_SIG_SCALE = 32768f;

		public const int SIG_SHIFT = 12;

		public const int NORM_SCALING = 16384;

		public const int DB_SHIFT = 10;

		public const int EPSILON = 1;

		public const int VERY_SMALL = 0;

		public const short VERY_LARGE16 = short.MaxValue;

		public const short Q15_ONE = short.MaxValue;

		public const int COMBFILTER_MAXPERIOD = 1024;

		public const int COMBFILTER_MINPERIOD = 15;

		public const int DECODE_BUFFER_SIZE = 2048;

		public const int BITALLOC_SIZE = 11;

		public const int MAX_PERIOD = 1024;

		public const int TOTAL_MODES = 1;

		public const int MAX_PSEUDO = 40;

		public const int LOG_MAX_PSEUDO = 6;

		public const int CELT_MAX_PULSES = 128;

		public const int MAX_FINE_BITS = 8;

		public const int FINE_OFFSET = 21;

		public const int QTHETA_OFFSET = 4;

		public const int QTHETA_OFFSET_TWOPHASE = 16;

		public const int PLC_PITCH_LAG_MAX = 720;

		public const int PLC_PITCH_LAG_MIN = 100;

		public const int LPC_ORDER = 24;
	}
	internal static class CeltLPC
	{
		internal static void celt_lpc(int[] _lpc, int[] ac, int p)
		{
			int num = ac[0];
			int[] array = new int[p];
			if (ac[0] != 0)
			{
				for (int i = 0; i < p; i++)
				{
					int num2 = 0;
					for (int j = 0; j < i; j++)
					{
						num2 += Inlines.MULT32_32_Q31(array[j], ac[i - j]);
					}
					num2 += Inlines.SHR32(ac[i + 1], 3);
					int num3 = -Inlines.frac_div32(Inlines.SHL32(num2, 3), num);
					array[i] = Inlines.SHR32(num3, 3);
					for (int j = 0; j < i + 1 >> 1; j++)
					{
						int num4 = array[j];
						int num5 = array[i - 1 - j];
						array[j] = num4 + Inlines.MULT32_32_Q31(num3, num5);
						array[i - 1 - j] = num5 + Inlines.MULT32_32_Q31(num3, num4);
					}
					num -= Inlines.MULT32_32_Q31(Inlines.MULT32_32_Q31(num3, num3), num);
					if (num < Inlines.SHR32(ac[0], 10))
					{
						break;
					}
				}
			}
			for (int i = 0; i < p; i++)
			{
				_lpc[i] = Inlines.ROUND16(array[i], 16);
			}
		}

		internal static void celt_iir(int[] _x, int _x_ptr, int[] den, int[] _y, int _y_ptr, int N, int ord, int[] mem)
		{
			int[] array = new int[ord];
			int[] array2 = new int[N + ord];
			int i;
			for (i = 0; i < ord; i++)
			{
				array[i] = den[ord - i - 1];
			}
			for (i = 0; i < ord; i++)
			{
				array2[i] = -mem[ord - i - 1];
			}
			for (; i < N + ord; i++)
			{
				array2[i] = 0;
			}
			for (i = 0; i < N - 3; i += 4)
			{
				int sum = _x[_x_ptr + i];
				int sum2 = _x[_x_ptr + i + 1];
				int sum3 = _x[_x_ptr + i + 2];
				int sum4 = _x[_x_ptr + i + 3];
				Kernels.xcorr_kernel(array, array2, i, ref sum, ref sum2, ref sum3, ref sum4, ord);
				array2[i + ord] = -Inlines.ROUND16(sum, 12);
				_y[_y_ptr + i] = sum;
				sum2 = Inlines.MAC16_16(sum2, array2[i + ord], den[0]);
				array2[i + ord + 1] = -Inlines.ROUND16(sum2, 12);
				_y[_y_ptr + i + 1] = sum2;
				sum3 = Inlines.MAC16_16(sum3, array2[i + ord + 1], den[0]);
				sum3 = Inlines.MAC16_16(sum3, array2[i + ord], den[1]);
				array2[i + ord + 2] = -Inlines.ROUND16(sum3, 12);
				_y[_y_ptr + i + 2] = sum3;
				sum4 = Inlines.MAC16_16(sum4, array2[i + ord + 2], den[0]);
				sum4 = Inlines.MAC16_16(sum4, array2[i + ord + 1], den[1]);
				sum4 = Inlines.MAC16_16(sum4, array2[i + ord], den[2]);
				array2[i + ord + 3] = -Inlines.ROUND16(sum4, 12);
				_y[_y_ptr + i + 3] = sum4;
			}
			for (; i < N; i++)
			{
				int num = _x[_x_ptr + i];
				for (int j = 0; j < ord; j++)
				{
					num -= Inlines.MULT16_16(array[j], array2[i + j]);
				}
				array2[i + ord] = Inlines.ROUND16(num, 12);
				_y[_y_ptr + i] = num;
			}
			for (i = 0; i < ord; i++)
			{
				mem[i] = _y[_y_ptr + N - i - 1];
			}
		}
	}
	internal static class CeltPitchXCorr
	{
		internal static int pitch_xcorr(int[] _x, int[] _y, int[] xcorr, int len, int max_pitch)
		{
			int num = 1;
			int i;
			for (i = 0; i < max_pitch - 3; i += 4)
			{
				int sum = 0;
				int sum2 = 0;
				int sum3 = 0;
				int sum4 = 0;
				Kernels.xcorr_kernel(_x, _y, i, ref sum, ref sum2, ref sum3, ref sum4, len);
				xcorr[i] = sum;
				xcorr[i + 1] = sum2;
				xcorr[i + 2] = sum3;
				xcorr[i + 3] = sum4;
				sum = Inlines.MAX32(sum, sum2);
				sum3 = Inlines.MAX32(sum3, sum4);
				sum = Inlines.MAX32(sum, sum3);
				num = Inlines.MAX32(num, sum);
			}
			for (; i < max_pitch; i++)
			{
				num = Inlines.MAX32(num, xcorr[i] = Kernels.celt_inner_prod(_x, 0, _y, i, len));
			}
			return num;
		}

		internal static int pitch_xcorr(short[] _x, int _x_ptr, short[] _y, int _y_ptr, int[] xcorr, int len, int max_pitch)
		{
			int num = 1;
			int i;
			for (i = 0; i < max_pitch - 3; i += 4)
			{
				int sum = 0;
				int sum2 = 0;
				int sum3 = 0;
				int sum4 = 0;
				Kernels.xcorr_kernel(_x, _x_ptr, _y, _y_ptr + i, ref sum, ref sum2, ref sum3, ref sum4, len);
				xcorr[i] = sum;
				xcorr[i + 1] = sum2;
				xcorr[i + 2] = sum3;
				xcorr[i + 3] = sum4;
				sum = Inlines.MAX32(sum, sum2);
				sum3 = Inlines.MAX32(sum3, sum4);
				sum = Inlines.MAX32(sum, sum3);
				num = Inlines.MAX32(num, sum);
			}
			for (; i < max_pitch; i++)
			{
				num = Inlines.MAX32(num, xcorr[i] = Kernels.celt_inner_prod(_x, _x_ptr, _y, _y_ptr + i, len));
			}
			return num;
		}

		internal static int pitch_xcorr(short[] _x, short[] _y, int[] xcorr, int len, int max_pitch)
		{
			int num = 1;
			int i;
			for (i = 0; i < max_pitch - 3; i += 4)
			{
				int sum = 0;
				int sum2 = 0;
				int sum3 = 0;
				int sum4 = 0;
				Kernels.xcorr_kernel(_x, 0, _y, i, ref sum, ref sum2, ref sum3, ref sum4, len);
				xcorr[i] = sum;
				xcorr[i + 1] = sum2;
				xcorr[i + 2] = sum3;
				xcorr[i + 3] = sum4;
				sum = Inlines.MAX32(sum, sum2);
				sum3 = Inlines.MAX32(sum3, sum4);
				sum = Inlines.MAX32(sum, sum3);
				num = Inlines.MAX32(num, sum);
			}
			for (; i < max_pitch; i++)
			{
				num = Inlines.MAX32(num, xcorr[i] = Kernels.celt_inner_prod(_x, _y, i, len));
			}
			return num;
		}
	}
	internal static class CWRS
	{
		internal static readonly uint[] CELT_PVQ_U_ROW = new uint[15]
		{
			0u, 176u, 351u, 525u, 698u, 870u, 1041u, 1131u, 1178u, 1207u,
			1226u, 1240u, 1248u, 1254u, 1257u
		};

		private static uint CELT_PVQ_U(int _n, int _k)
		{
			return Tables.CELT_PVQ_U_DATA[CELT_PVQ_U_ROW[Inlines.IMIN(_n, _k)] + Inlines.IMAX(_n, _k)];
		}

		private static uint CELT_PVQ_V(int _n, int _k)
		{
			return CELT_PVQ_U(_n, _k) + CELT_PVQ_U(_n, _k + 1);
		}

		internal static uint icwrs(int _n, int[] _y)
		{
			int num = _n - 1;
			uint num2 = ((_y[num] < 0) ? 1u : 0u);
			int num3 = Inlines.abs(_y[num]);
			do
			{
				num--;
				num2 += CELT_PVQ_U(_n - num, num3);
				num3 += Inlines.abs(_y[num]);
				if (_y[num] < 0)
				{
					num2 += CELT_PVQ_U(_n - num, num3 + 1);
				}
			}
			while (num > 0);
			return num2;
		}

		internal static void encode_pulses(int[] _y, int _n, int _k, EntropyCoder _enc)
		{
			_enc.enc_uint(icwrs(_n, _y), CELT_PVQ_V(_n, _k));
		}

		internal static int cwrsi(int _n, int _k, uint _i, int[] _y)
		{
			int c = 0;
			int num = 0;
			uint num3;
			int num5;
			int num4;
			short num7;
			while (_n > 2)
			{
				if (_k >= _n)
				{
					uint num2 = CELT_PVQ_U_ROW[_n];
					num3 = Tables.CELT_PVQ_U_DATA[num2 + _k + 1];
					num4 = -((_i >= num3) ? 1 : 0);
					_i -= num3 & (uint)num4;
					num5 = _k;
					uint num6 = Tables.CELT_PVQ_U_DATA[num2 + _n];
					if (num6 > _i)
					{
						_k = _n;
						do
						{
							num3 = Tables.CELT_PVQ_U_DATA[CELT_PVQ_U_ROW[--_k] + _n];
						}
						while (num3 > _i);
					}
					else
					{
						for (num3 = Tables.CELT_PVQ_U_DATA[num2 + _k]; num3 > _i; num3 = Tables.CELT_PVQ_U_DATA[num2 + _k])
						{
							_k--;
						}
					}
					_i -= num3;
					num7 = (short)((num5 - _k + num4) ^ num4);
					_y[num++] = num7;
					c = Inlines.MAC16_16(c, num7, num7);
				}
				else
				{
					num3 = Tables.CELT_PVQ_U_DATA[CELT_PVQ_U_ROW[_k] + _n];
					uint num6 = Tables.CELT_PVQ_U_DATA[CELT_PVQ_U_ROW[_k + 1] + _n];
					if (num3 <= _i && _i < num6)
					{
						_i -= num3;
						_y[num++] = 0;
					}
					else
					{
						num4 = -((_i >= num6) ? 1 : 0);
						_i -= num6 & (uint)num4;
						num5 = _k;
						do
						{
							num3 = Tables.CELT_PVQ_U_DATA[CELT_PVQ_U_ROW[--_k] + _n];
						}
						while (num3 > _i);
						_i -= num3;
						num7 = (short)((num5 - _k + num4) ^ num4);
						_y[num++] = num7;
						c = Inlines.MAC16_16(c, num7, num7);
					}
				}
				_n--;
			}
			num3 = (uint)(2 * _k + 1);
			num4 = -((_i >= num3) ? 1 : 0);
			_i -= num3 & (uint)num4;
			num5 = _k;
			_k = (int)(_i + 1 >> 1);
			if (_k != 0)
			{
				_i -= (uint)(2 * _k - 1);
			}
			num7 = (short)((num5 - _k + num4) ^ num4);
			_y[num++] = num7;
			c = Inlines.MAC16_16(c, num7, num7);
			num4 = (int)(0 - _i);
			num7 = (short)(_y[num] = (short)((_k + num4) ^ num4));
			return Inlines.MAC16_16(c, num7, num7);
		}

		internal static int decode_pulses(int[] _y, int _n, int _k, EntropyCoder _dec)
		{
			return cwrsi(_n, _k, _dec.dec_uint(CELT_PVQ_V(_n, _k)), _y);
		}
	}
	internal static class Kernels
	{
		internal static void celt_fir(short[] x, int x_ptr, short[] num, short[] y, int y_ptr, int N, int ord, short[] mem)
		{
			short[] array = new short[ord];
			short[] array2 = new short[N + ord];
			int i;
			for (i = 0; i < ord; i++)
			{
				array[i] = num[ord - i - 1];
			}
			for (i = 0; i < ord; i++)
			{
				array2[i] = mem[ord - i - 1];
			}
			for (i = 0; i < N; i++)
			{
				array2[i + ord] = x[x_ptr + i];
			}
			for (i = 0; i < ord; i++)
			{
				mem[i] = x[x_ptr + N - i - 1];
			}
			for (i = 0; i < N - 3; i += 4)
			{
				int sum = 0;
				int sum2 = 0;
				int sum3 = 0;
				int sum4 = 0;
				xcorr_kernel(array, 0, array2, i, ref sum, ref sum2, ref sum3, ref sum4, ord);
				y[y_ptr + i] = Inlines.SATURATE16(Inlines.ADD32(Inlines.EXTEND32(x[x_ptr + i]), Inlines.PSHR32(sum, 12)));
				y[y_ptr + i + 1] = Inlines.SATURATE16(Inlines.ADD32(Inlines.EXTEND32(x[x_ptr + i + 1]), Inlines.PSHR32(sum2, 12)));
				y[y_ptr + i + 2] = Inlines.SATURATE16(Inlines.ADD32(Inlines.EXTEND32(x[x_ptr + i + 2]), Inlines.PSHR32(sum3, 12)));
				y[y_ptr + i + 3] = Inlines.SATURATE16(Inlines.ADD32(Inlines.EXTEND32(x[x_ptr + i + 3]), Inlines.PSHR32(sum4, 12)));
			}
			for (; i < N; i++)
			{
				int num2 = 0;
				for (int j = 0; j < ord; j++)
				{
					num2 = Inlines.MAC16_16(num2, array[j], array2[i + j]);
				}
				y[y_ptr + i] = Inlines.SATURATE16(Inlines.ADD32(Inlines.EXTEND32(x[x_ptr + i]), Inlines.PSHR32(num2, 12)));
			}
		}

		internal static void celt_fir(int[] x, int x_ptr, int[] num, int num_ptr, int[] y, int y_ptr, int N, int ord, int[] mem)
		{
			int[] array = new int[ord];
			int[] array2 = new int[N + ord];
			int i;
			for (i = 0; i < ord; i++)
			{
				array[i] = num[num_ptr + ord - i - 1];
			}
			for (i = 0; i < ord; i++)
			{
				array2[i] = mem[ord - i - 1];
			}
			for (i = 0; i < N; i++)
			{
				array2[i + ord] = x[x_ptr + i];
			}
			for (i = 0; i < ord; i++)
			{
				mem[i] = x[x_ptr + N - i - 1];
			}
			for (i = 0; i < N - 3; i += 4)
			{
				int sum = 0;
				int sum2 = 0;
				int sum3 = 0;
				int sum4 = 0;
				xcorr_kernel(array, array2, i, ref sum, ref sum2, ref sum3, ref sum4, ord);
				y[y_ptr + i] = Inlines.SATURATE16(Inlines.ADD32(Inlines.EXTEND32(x[x_ptr + i]), Inlines.PSHR32(sum, 12)));
				y[y_ptr + i + 1] = Inlines.SATURATE16(Inlines.ADD32(Inlines.EXTEND32(x[x_ptr + i + 1]), Inlines.PSHR32(sum2, 12)));
				y[y_ptr + i + 2] = Inlines.SATURATE16(Inlines.ADD32(Inlines.EXTEND32(x[x_ptr + i + 2]), Inlines.PSHR32(sum3, 12)));
				y[y_ptr + i + 3] = Inlines.SATURATE16(Inlines.ADD32(Inlines.EXTEND32(x[x_ptr + i + 3]), Inlines.PSHR32(sum4, 12)));
			}
			for (; i < N; i++)
			{
				int num2 = 0;
				for (int j = 0; j < ord; j++)
				{
					num2 = Inlines.MAC16_16(num2, array[j], array2[i + j]);
				}
				y[y_ptr + i] = Inlines.SATURATE16(Inlines.ADD32(Inlines.EXTEND32(x[x_ptr + i]), Inlines.PSHR32(num2, 12)));
			}
		}

		internal static void xcorr_kernel(short[] x, int x_ptr, short[] y, int y_ptr, ref int sum0, ref int sum1, ref int sum2, ref int sum3, int len)
		{
			short b = 0;
			short b2 = y[y_ptr++];
			short b3 = y[y_ptr++];
			short b4 = y[y_ptr++];
			int i;
			for (i = 0; i < len - 3; i += 4)
			{
				short a = x[x_ptr++];
				b = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a, b2);
				sum1 = Inlines.MAC16_16(sum1, a, b3);
				sum2 = Inlines.MAC16_16(sum2, a, b4);
				sum3 = Inlines.MAC16_16(sum3, a, b);
				a = x[x_ptr++];
				b2 = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a, b3);
				sum1 = Inlines.MAC16_16(sum1, a, b4);
				sum2 = Inlines.MAC16_16(sum2, a, b);
				sum3 = Inlines.MAC16_16(sum3, a, b2);
				a = x[x_ptr++];
				b3 = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a, b4);
				sum1 = Inlines.MAC16_16(sum1, a, b);
				sum2 = Inlines.MAC16_16(sum2, a, b2);
				sum3 = Inlines.MAC16_16(sum3, a, b3);
				a = x[x_ptr++];
				b4 = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a, b);
				sum1 = Inlines.MAC16_16(sum1, a, b2);
				sum2 = Inlines.MAC16_16(sum2, a, b3);
				sum3 = Inlines.MAC16_16(sum3, a, b4);
			}
			if (i++ < len)
			{
				short a2 = x[x_ptr++];
				b = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a2, b2);
				sum1 = Inlines.MAC16_16(sum1, a2, b3);
				sum2 = Inlines.MAC16_16(sum2, a2, b4);
				sum3 = Inlines.MAC16_16(sum3, a2, b);
			}
			if (i++ < len)
			{
				short a3 = x[x_ptr++];
				b2 = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a3, b3);
				sum1 = Inlines.MAC16_16(sum1, a3, b4);
				sum2 = Inlines.MAC16_16(sum2, a3, b);
				sum3 = Inlines.MAC16_16(sum3, a3, b2);
			}
			if (i < len)
			{
				short a4 = x[x_ptr++];
				b3 = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a4, b4);
				sum1 = Inlines.MAC16_16(sum1, a4, b);
				sum2 = Inlines.MAC16_16(sum2, a4, b2);
				sum3 = Inlines.MAC16_16(sum3, a4, b3);
			}
		}

		internal static void xcorr_kernel(int[] x, int[] y, int y_ptr, ref int sum0, ref int sum1, ref int sum2, ref int sum3, int len)
		{
			int num = 0;
			int b = 0;
			int b2 = y[y_ptr++];
			int b3 = y[y_ptr++];
			int b4 = y[y_ptr++];
			int i;
			for (i = 0; i < len - 3; i += 4)
			{
				int a = x[num++];
				b = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a, b2);
				sum1 = Inlines.MAC16_16(sum1, a, b3);
				sum2 = Inlines.MAC16_16(sum2, a, b4);
				sum3 = Inlines.MAC16_16(sum3, a, b);
				a = x[num++];
				b2 = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a, b3);
				sum1 = Inlines.MAC16_16(sum1, a, b4);
				sum2 = Inlines.MAC16_16(sum2, a, b);
				sum3 = Inlines.MAC16_16(sum3, a, b2);
				a = x[num++];
				b3 = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a, b4);
				sum1 = Inlines.MAC16_16(sum1, a, b);
				sum2 = Inlines.MAC16_16(sum2, a, b2);
				sum3 = Inlines.MAC16_16(sum3, a, b3);
				a = x[num++];
				b4 = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a, b);
				sum1 = Inlines.MAC16_16(sum1, a, b2);
				sum2 = Inlines.MAC16_16(sum2, a, b3);
				sum3 = Inlines.MAC16_16(sum3, a, b4);
			}
			if (i++ < len)
			{
				int a2 = x[num++];
				b = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a2, b2);
				sum1 = Inlines.MAC16_16(sum1, a2, b3);
				sum2 = Inlines.MAC16_16(sum2, a2, b4);
				sum3 = Inlines.MAC16_16(sum3, a2, b);
			}
			if (i++ < len)
			{
				int a3 = x[num++];
				b2 = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a3, b3);
				sum1 = Inlines.MAC16_16(sum1, a3, b4);
				sum2 = Inlines.MAC16_16(sum2, a3, b);
				sum3 = Inlines.MAC16_16(sum3, a3, b2);
			}
			if (i < len)
			{
				int a4 = x[num++];
				b3 = y[y_ptr++];
				sum0 = Inlines.MAC16_16(sum0, a4, b4);
				sum1 = Inlines.MAC16_16(sum1, a4, b);
				sum2 = Inlines.MAC16_16(sum2, a4, b2);
				sum3 = Inlines.MAC16_16(sum3, a4, b3);
			}
		}

		internal static int celt_inner_prod(short[] x, int x_ptr, short[] y, int y_ptr, int N)
		{
			int num = 0;
			for (int i = 0; i < N; i++)
			{
				num = Inlines.MAC16_16(num, x[x_ptr + i], y[y_ptr + i]);
			}
			return num;
		}

		internal static int celt_inner_prod(short[] x, short[] y, int y_ptr, int N)
		{
			int num = 0;
			for (int i = 0; i < N; i++)
			{
				num = Inlines.MAC16_16(num, x[i], y[y_ptr + i]);
			}
			return num;
		}

		internal static int celt_inner_prod(int[] x, int x_ptr, int[] y, int y_ptr, int N)
		{
			int num = 0;
			for (int i = 0; i < N; i++)
			{
				num = Inlines.MAC16_16(num, x[x_ptr + i], y[y_ptr + i]);
			}
			return num;
		}

		internal static void dual_inner_prod(int[] x, int x_ptr, int[] y01, int y01_ptr, int[] y02, int y02_ptr, int N, out int xy1, out int xy2)
		{
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < N; i++)
			{
				num = Inlines.MAC16_16(num, x[x_ptr + i], y01[y01_ptr + i]);
				num2 = Inlines.MAC16_16(num2, x[x_ptr + i], y02[y02_ptr + i]);
			}
			xy1 = num;
			xy2 = num2;
		}
	}
	internal static class KissFFT
	{
		internal const int MAXFACTORS = 8;

		internal static int S_MUL(int a, int b)
		{
			return Inlines.MULT16_32_Q15(b, a);
		}

		internal static int S_MUL(int a, short b)
		{
			return Inlines.MULT16_32_Q15(b, a);
		}

		internal static int HALF_OF(int x)
		{
			return x >> 1;
		}

		internal static void kf_bfly2(int[] Fout, int fout_ptr, int m, int N)
		{
			short b = 23170;
			for (int i = 0; i < N; i++)
			{
				int num = fout_ptr + 8;
				int num2 = Fout[num];
				int num3 = Fout[num + 1];
				Fout[num] = Fout[fout_ptr] - num2;
				Fout[num + 1] = Fout[fout_ptr + 1] - num3;
				Fout[fout_ptr] += num2;
				Fout[fout_ptr + 1] += num3;
				num2 = S_MUL(Fout[num + 2] + Fout[num + 3], b);
				num3 = S_MUL(Fout[num + 3] - Fout[num + 2], b);
				Fout[num + 2] = Fout[fout_ptr + 2] - num2;
				Fout[num + 3] = Fout[fout_ptr + 3] - num3;
				Fout[fout_ptr + 2] += num2;
				Fout[fout_ptr + 3] += num3;
				num2 = Fout[num + 5];
				num3 = -Fout[num + 4];
				Fout[num + 4] = Fout[fout_ptr + 4] - num2;
				Fout[num + 5] = Fout[fout_ptr + 5] - num3;
				Fout[fout_ptr + 4] += num2;
				Fout[fout_ptr + 5] += num3;
				num2 = S_MUL(Fout[num + 7] - Fout[num + 6], b);
				num3 = S_MUL(-Fout[num + 7] - Fout[num + 6], b);
				Fout[num + 6] = Fout[fout_ptr + 6] - num2;
				Fout[num + 7] = Fout[fout_ptr + 7] - num3;
				Fout[fout_ptr + 6] += num2;
				Fout[fout_ptr + 7] += num3;
				fout_ptr += 16;
			}
		}

		internal static void kf_bfly4(int[] Fout, int fout_ptr, int fstride, FFTState st, int m, int N, int mm)
		{
			if (m == 1)
			{
				for (int i = 0; i < N; i++)
				{
					int num = Fout[fout_ptr] - Fout[fout_ptr + 4];
					int num2 = Fout[fout_ptr + 1] - Fout[fout_ptr + 5];
					Fout[fout_ptr] += Fout[fout_ptr + 4];
					Fout[fout_ptr + 1] += Fout[fout_ptr + 5];
					int num3 = Fout[fout_ptr + 2] + Fout[fout_ptr + 6];
					int num4 = Fout[fout_ptr + 3] + Fout[fout_ptr + 7];
					Fout[fout_ptr + 4] = Fout[fout_ptr] - num3;
					Fout[fout_ptr + 5] = Fout[fout_ptr + 1] - num4;
					Fout[fout_ptr] += num3;
					Fout[fout_ptr + 1] += num4;
					num3 = Fout[fout_ptr + 2] - Fout[fout_ptr + 6];
					num4 = Fout[fout_ptr + 3] - Fout[fout_ptr + 7];
					Fout[fout_ptr + 2] = num + num4;
					Fout[fout_ptr + 3] = num2 - num3;
					Fout[fout_ptr + 6] = num - num4;
					Fout[fout_ptr + 7] = num2 + num3;
					fout_ptr += 8;
				}
				return;
			}
			int num5 = fout_ptr;
			for (int i = 0; i < N; i++)
			{
				fout_ptr = num5 + 2 * i * mm;
				int num6 = fout_ptr + 2 * m;
				int num7 = fout_ptr + 4 * m;
				int num8 = fout_ptr + 6 * m;
				int num10;
				int num11;
				int num9 = (num10 = (num11 = 0));
				for (int j = 0; j < m; j++)
				{
					int num12 = S_MUL(Fout[num6], st.twiddles[num11]) - S_MUL(Fout[num6 + 1], st.twiddles[num11 + 1]);
					int num13 = S_MUL(Fout[num6], st.twiddles[num11 + 1]) + S_MUL(Fout[num6 + 1], st.twiddles[num11]);
					int num14 = S_MUL(Fout[num7], st.twiddles[num10]) - S_MUL(Fout[num7 + 1], st.twiddles[num10 + 1]);
					int num15 = S_MUL(Fout[num7], st.twiddles[num10 + 1]) + S_MUL(Fout[num7 + 1], st.twiddles[num10]);
					int num16 = S_MUL(Fout[num8], st.twiddles[num9]) - S_MUL(Fout[num8 + 1], st.twiddles[num9 + 1]);
					int num17 = S_MUL(Fout[num8], st.twiddles[num9 + 1]) + S_MUL(Fout[num8 + 1], st.twiddles[num9]);
					int num18 = Fout[fout_ptr] - num14;
					int num19 = Fout[fout_ptr + 1] - num15;
					Fout[fout_ptr] += num14;
					Fout[fout_ptr + 1] += num15;
					int num20 = num12 + num16;
					int num21 = num13 + num17;
					int num22 = num12 - num16;
					int num23 = num13 - num17;
					Fout[num7] = Fout[fout_ptr] - num20;
					Fout[num7 + 1] = Fout[fout_ptr + 1] - num21;
					num11 += fstride * 2;
					num10 += fstride * 4;
					num9 += fstride * 6;
					Fout[fout_ptr] += num20;
					Fout[fout_ptr + 1] += num21;
					Fout[num6] = num18 + num23;
					Fout[num6 + 1] = num19 - num22;
					Fout[num8] = num18 - num23;
					Fout[num8 + 1] = num19 + num22;
					fout_ptr += 2;
					num6 += 2;
					num7 += 2;
					num8 += 2;
				}
			}
		}

		internal static void kf_bfly3(int[] Fout, int fout_ptr, int fstride, FFTState st, int m, int N, int mm)
		{
			int num = 2 * m;
			int num2 = 4 * m;
			int num3 = fout_ptr;
			for (int i = 0; i < N; i++)
			{
				fout_ptr = num3 + 2 * i * mm;
				int num5;
				int num4 = (num5 = 0);
				int num6 = m;
				do
				{
					int num7 = S_MUL(Fout[fout_ptr + num], st.twiddles[num4]) - S_MUL(Fout[fout_ptr + num + 1], st.twiddles[num4 + 1]);
					int num8 = S_MUL(Fout[fout_ptr + num], st.twiddles[num4 + 1]) + S_MUL(Fout[fout_ptr + num + 1], st.twiddles[num4]);
					int num9 = S_MUL(Fout[fout_ptr + num2], st.twiddles[num5]) - S_MUL(Fout[fout_ptr + num2 + 1], st.twiddles[num5 + 1]);
					int num10 = S_MUL(Fout[fout_ptr + num2], st.twiddles[num5 + 1]) + S_MUL(Fout[fout_ptr + num2 + 1], st.twiddles[num5]);
					int num11 = num7 + num9;
					int num12 = num8 + num10;
					int a = num7 - num9;
					int a2 = num8 - num10;
					num4 += fstride * 2;
					num5 += fstride * 4;
					Fout[fout_ptr + num] = Fout[fout_ptr] - HALF_OF(num11);
					Fout[fout_ptr + num + 1] = Fout[fout_ptr + 1] - HALF_OF(num12);
					a = S_MUL(a, -28378);
					a2 = S_MUL(a2, -28378);
					Fout[fout_ptr] += num11;
					Fout[fout_ptr + 1] += num12;
					Fout[fout_ptr + num2] = Fout[fout_ptr + num] + a2;
					Fout[fout_ptr + num2 + 1] = Fout[fout_ptr + num + 1] - a;
					Fout[fout_ptr + num] -= a2;
					Fout[fout_ptr + num + 1] += a;
					fout_ptr += 2;
				}
				while (--num6 != 0);
			}
		}

		internal static void kf_bfly5(int[] Fout, int fout_ptr, int fstride, FFTState st, int m, int N, int mm)
		{
			int num = fout_ptr;
			short b = 10126;
			short b2 = -31164;
			short b3 = -26510;
			short b4 = -19261;
			for (int i = 0; i < N; i++)
			{
				int num3;
				int num4;
				int num5;
				int num2 = (num3 = (num4 = (num5 = 0)));
				fout_ptr = num + 2 * i * mm;
				int num6 = fout_ptr;
				int num7 = fout_ptr + 2 * m;
				int num8 = fout_ptr + 4 * m;
				int num9 = fout_ptr + 6 * m;
				int num10 = fout_ptr + 8 * m;
				for (int j = 0; j < m; j++)
				{
					int num11 = Fout[num6];
					int num12 = Fout[num6 + 1];
					int num13 = S_MUL(Fout[num7], st.twiddles[num2]) - S_MUL(Fout[num7 + 1], st.twiddles[num2 + 1]);
					int num14 = S_MUL(Fout[num7], st.twiddles[num2 + 1]) + S_MUL(Fout[num7 + 1], st.twiddles[num2]);
					int num15 = S_MUL(Fout[num8], st.twiddles[num3]) - S_MUL(Fout[num8 + 1], st.twiddles[num3 + 1]);
					int num16 = S_MUL(Fout[num8], st.twiddles[num3 + 1]) + S_MUL(Fout[num8 + 1], st.twiddles[num3]);
					int num17 = S_MUL(Fout[num9], st.twiddles[num4]) - S_MUL(Fout[num9 + 1], st.twiddles[num4 + 1]);
					int num18 = S_MUL(Fout[num9], st.twiddles[num4 + 1]) + S_MUL(Fout[num9 + 1], st.twiddles[num4]);
					int num19 = S_MUL(Fout[num10], st.twiddles[num5]) - S_MUL(Fout[num10 + 1], st.twiddles[num5 + 1]);
					int num20 = S_MUL(Fout[num10], st.twiddles[num5 + 1]) + S_MUL(Fout[num10 + 1], st.twiddles[num5]);
					num2 += 2 * fstride;
					num3 += 4 * fstride;
					num4 += 6 * fstride;
					num5 += 8 * fstride;
					int num21 = num13 + num19;
					int num22 = num14 + num20;
					int a = num13 - num19;
					int a2 = num14 - num20;
					int num23 = num15 + num17;
					int num24 = num16 + num18;
					int a3 = num15 - num17;
					int a4 = num16 - num18;
					Fout[num6] += num21 + num23;
					Fout[num6 + 1] += num22 + num24;
					int num25 = num11 + S_MUL(num21, b) + S_MUL(num23, b3);
					int num26 = num12 + S_MUL(num22, b) + S_MUL(num24, b3);
					int num27 = S_MUL(a2, b2) + S_MUL(a4, b4);
					int num28 = -S_MUL(a, b2) - S_MUL(a3, b4);
					Fout[num7] = num25 - num27;
					Fout[num7 + 1] = num26 - num28;
					Fout[num10] = num25 + num27;
					Fout[num10 + 1] = num26 + num28;
					int num29 = num11 + S_MUL(num21, b3) + S_MUL(num23, b);
					int num30 = num12 + S_MUL(num22, b3) + S_MUL(num24, b);
					int num31 = -S_MUL(a2, b4) + S_MUL(a4, b2);
					int num32 = S_MUL(a, b4) - S_MUL(a3, b2);
					Fout[num8] = num29 + num31;
					Fout[num8 + 1] = num30 + num32;
					Fout[num9] = num29 - num31;
					Fout[num9 + 1] = num30 - num32;
					num6 += 2;
					num7 += 2;
					num8 += 2;
					num9 += 2;
					num10 += 2;
				}
			}
		}

		internal static void opus_fft_impl(FFTState st, int[] fout, int fout_ptr)
		{
			int[] array = new int[8];
			int num = ((st.shift > 0) ? st.shift : 0);
			array[0] = 1;
			int num2 = 0;
			int num4;
			do
			{
				int num3 = st.factors[2 * num2];
				num4 = st.factors[2 * num2 + 1];
				array[num2 + 1] = array[num2] * num3;
				num2++;
			}
			while (num4 != 1);
			num4 = st.factors[2 * num2 - 1];
			for (int num5 = num2 - 1; num5 >= 0; num5--)
			{
				int num6 = ((num5 == 0) ? 1 : st.factors[2 * num5 - 1]);
				switch (st.factors[2 * num5])
				{
				case 2:
					kf_bfly2(fout, fout_ptr, num4, array[num5]);
					break;
				case 4:
					kf_bfly4(fout, fout_ptr, array[num5] << num, st, num4, array[num5], num6);
					break;
				case 3:
					kf_bfly3(fout, fout_ptr, array[num5] << num, st, num4, array[num5], num6);
					break;
				case 5:
					kf_bfly5(fout, fout_ptr, array[num5] << num, st, num4, array[num5], num6);
					break;
				}
				num4 = num6;
			}
		}

		internal static void opus_fft(FFTState st, int[] fin, int[] fout)
		{
			int shift = st.scale_shift - 1;
			short scale = st.scale;
			for (int i = 0; i < st.nfft; i++)
			{
				fout[2 * st.bitrev[i]] = Inlines.SHR32(Inlines.MULT16_32_Q16(scale, fin[2 * i]), shift);
				fout[2 * st.bitrev[i] + 1] = Inlines.SHR32(Inlines.MULT16_32_Q16(scale, fin[2 * i + 1]), shift);
			}
			opus_fft_impl(st, fout, 0);
		}
	}
	internal static class Laplace
	{
		private const int LAPLACE_LOG_MINP = 0;

		private const uint LAPLACE_MINP = 1u;

		private const int LAPLACE_NMIN = 16;

		internal static uint ec_laplace_get_freq1(uint fs0, int decay)
		{
			return (uint)((32736 - fs0) * (16384 - decay) >> 15);
		}

		internal static void ec_laplace_encode(EntropyCoder enc, ref int value, uint fs, int decay)
		{
			int num = value;
			uint num2 = 0u;
			if (num != 0)
			{
				int num3 = 0 - ((num < 0) ? 1 : 0);
				num = (num + num3) ^ num3;
				num2 = fs;
				fs = ec_laplace_get_freq1(fs, decay);
				int num4 = 1;
				while (fs != 0 && num4 < num)
				{
					fs *= 2;
					num2 += fs + 2;
					fs = (uint)(fs * decay >> 15);
					num4++;
				}
				if (fs == 0)
				{
					int num5 = (int)(32768 - num2 + 1 - 1);
					num5 = num5 - num3 >> 1;
					int num6 = Inlines.IMIN(num - num4, num5 - 1);
					num2 += (uint)(2 * num6 + 1 + num3);
					fs = Inlines.IMIN(1u, 32768 - num2);
					value = (num4 + num6 + num3) ^ num3;
				}
				else
				{
					fs++;
					num2 += (uint)(int)(fs & ~num3);
				}
			}
			enc.encode_bin(num2, num2 + fs, 15u);
		}

		internal static int ec_laplace_decode(EntropyCoder dec, uint fs, int decay)
		{
			int num = 0;
			uint num2 = dec.decode_bin(15u);
			uint num3 = 0u;
			if (num2 >= fs)
			{
				num++;
				num3 = fs;
				fs = ec_laplace_get_freq1(fs, decay) + 1;
				while (fs > 1 && num2 >= num3 + 2 * fs)
				{
					fs *= 2;
					num3 += fs;
					fs = (uint)((fs - 2) * decay >> 15);
					fs++;
					num++;
				}
				if (fs <= 1)
				{
					int num4 = (int)(num2 - num3) >> 1;
					num += num4;
					num3 += (uint)(2 * num4);
				}
				if (num2 < num3 + fs)
				{
					num = -num;
				}
				else
				{
					num3 += fs;
				}
			}
			dec.dec_update(num3, Inlines.IMIN(num3 + fs, 32768u), 32768u);
			return num;
		}
	}
	internal static class MDCT
	{
		internal static void clt_mdct_forward(MDCTLookup l, int[] input, int input_ptr, int[] output, int output_ptr, int[] window, int overlap, int shift, int stride)
		{
			FFTState fFTState = l.kfft[shift];
			int num = 0;
			int shift2 = fFTState.scale_shift - 1;
			int scale = fFTState.scale;
			int num2 = l.n;
			short[] trig = l.trig;
			int i;
			for (i = 0; i < shift; i++)
			{
				num2 >>= 1;
				num += num2;
			}
			int num3 = num2 >> 1;
			int num4 = num2 >> 2;
			int[] array = new int[num3];
			int[] array2 = new int[num4 * 2];
			int num5 = input_ptr + (overlap >> 1);
			int num6 = input_ptr + num3 - 1 + (overlap >> 1);
			int num7 = 0;
			int num8 = overlap >> 1;
			int num9 = (overlap >> 1) - 1;
			for (i = 0; i < overlap + 3 >> 2; i++)
			{
				array[num7++] = Inlines.MULT16_32_Q15(window[num9], input[num5 + num3]) + Inlines.MULT16_32_Q15(window[num8], input[num6]);
				array[num7++] = Inlines.MULT16_32_Q15(window[num8], input[num5]) - Inlines.MULT16_32_Q15(window[num9], input[num6 - num3]);
				num5 += 2;
				num6 -= 2;
				num8 += 2;
				num9 -= 2;
			}
			num8 = 0;
			num9 = overlap - 1;
			for (; i < num4 - (overlap + 3 >> 2); i++)
			{
				array[num7++] = input[num6];
				array[num7++] = input[num5];
				num5 += 2;
				num6 -= 2;
			}
			for (; i < num4; i++)
			{
				array[num7++] = Inlines.MULT16_32_Q15(window[num9], input[num6]) - Inlines.MULT16_32_Q15(window[num8], input[num5 - num3]);
				array[num7++] = Inlines.MULT16_32_Q15(window[num9], input[num5]) + Inlines.MULT16_32_Q15(window[num8], input[num6 + num3]);
				num5 += 2;
				num6 -= 2;
				num8 += 2;
				num9 -= 2;
			}
			int num10 = 0;
			int num11 = num;
			for (i = 0; i < num4; i++)
			{
				short b = trig[num11 + i];
				short b2 = trig[num11 + num4 + i];
				int a = array[num10++];
				int a2 = array[num10++];
				int b3 = KissFFT.S_MUL(a, b) - KissFFT.S_MUL(a2, b2);
				int b4 = KissFFT.S_MUL(a2, b) + KissFFT.S_MUL(a, b2);
				array2[2 * fFTState.bitrev[i]] = Inlines.PSHR32(Inlines.MULT16_32_Q16(scale, b3), shift2);
				array2[2 * fFTState.bitrev[i] + 1] = Inlines.PSHR32(Inlines.MULT16_32_Q16(scale, b4), shift2);
			}
			KissFFT.opus_fft_impl(fFTState, array2, 0);
			int num12 = 0;
			int num13 = output_ptr;
			int num14 = output_ptr + stride * (num3 - 1);
			int num15 = num;
			for (i = 0; i < num4; i++)
			{
				int num16 = KissFFT.S_MUL(array2[num12 + 1], trig[num15 + num4 + i]) - KissFFT.S_MUL(array2[num12], trig[num15 + i]);
				int num17 = KissFFT.S_MUL(array2[num12], trig[num15 + num4 + i]) + KissFFT.S_MUL(array2[num12 + 1], trig[num15 + i]);
				output[num13] = num16;
				output[num14] = num17;
				num12 += 2;
				num13 += 2 * stride;
				num14 -= 2 * stride;
			}
		}

		internal static void clt_mdct_backward(MDCTLookup l, int[] input, int input_ptr, int[] output, int output_ptr, int[] window, int overlap, int shift, int stride)
		{
			int num = 0;
			int num2 = l.n;
			for (int i = 0; i < shift; i++)
			{
				num2 >>= 1;
				num += num2;
			}
			int num3 = num2 >> 1;
			int num4 = num2 >> 2;
			int num5 = input_ptr + stride * (num3 - 1);
			int num6 = output_ptr + (overlap >> 1);
			short[] bitrev = l.kfft[shift].bitrev;
			int num7 = 0;
			for (int i = 0; i < num4; i++)
			{
				int num8 = bitrev[num7++];
				int num9 = num6 + 2 * num8;
				output[num9 + 1] = KissFFT.S_MUL(input[num5], l.trig[num + i]) + KissFFT.S_MUL(input[input_ptr], l.trig[num + num4 + i]);
				output[num9] = KissFFT.S_MUL(input[input_ptr], l.trig[num + i]) - KissFFT.S_MUL(input[num5], l.trig[num + num4 + i]);
				input_ptr += 2 * stride;
				num5 -= 2 * stride;
			}
			KissFFT.opus_fft_impl(l.kfft[shift], output, output_ptr + (overlap >> 1));
			int num10 = output_ptr + (overlap >> 1);
			int num11 = output_ptr + (overlap >> 1) + num3 - 2;
			int num12 = num;
			int num13 = num12 + num4 - 1;
			int num14 = num12 + num3 - 1;
			for (int i = 0; i < num4 + 1 >> 1; i++)
			{
				int a = output[num10 + 1];
				int a2 = output[num10];
				short b = l.trig[num12 + i];
				short b2 = l.trig[num12 + num4 + i];
				int num15 = KissFFT.S_MUL(a, b) + KissFFT.S_MUL(a2, b2);
				int num16 = KissFFT.S_MUL(a, b2) - KissFFT.S_MUL(a2, b);
				int a3 = output[num11 + 1];
				a2 = output[num11];
				output[num10] = num15;
				output[num11 + 1] = num16;
				b = l.trig[num13 - i];
				b2 = l.trig[num14 - i];
				num15 = KissFFT.S_MUL(a3, b) + KissFFT.S_MUL(a2, b2);
				num16 = KissFFT.S_MUL(a3, b2) - KissFFT.S_MUL(a2, b);
				output[num11] = num15;
				output[num10 + 1] = num16;
				num10 += 2;
				num11 -= 2;
			}
			int num17 = output_ptr + overlap - 1;
			num11 = output_ptr;
			int num18 = 0;
			int num19 = overlap - 1;
			for (int i = 0; i < overlap / 2; i++)
			{
				int b3 = output[num17];
				int b4 = output[num11];
				output[num11++] = Inlines.MULT16_32_Q15(window[num19], b4) - Inlines.MULT16_32_Q15(window[num18], b3);
				output[num17--] = Inlines.MULT16_32_Q15(window[num18], b4) + Inlines.MULT16_32_Q15(window[num19], b3);
				num18++;
				num19--;
			}
		}
	}
	internal static class Pitch
	{
		private static readonly int[] second_check = new int[16]
		{
			0, 0, 3, 2, 3, 2, 5, 2, 3, 2,
			3, 2, 5, 2, 3, 2
		};

		internal static void find_best_pitch(int[] xcorr, int[] y, int len, int max_pitch, int[] best_pitch, int yshift, int maxcorr)
		{
			int num = 1;
			int shift = Inlines.celt_ilog2(maxcorr) - 14;
			int num2 = -1;
			int a = -1;
			int num3 = 0;
			int b = 0;
			best_pitch[0] = 0;
			best_pitch[1] = 1;
			for (int i = 0; i < len; i++)
			{
				num = Inlines.ADD32(num, Inlines.SHR32(Inlines.MULT16_16(y[i], y[i]), yshift));
			}
			for (int j = 0; j < max_pitch; j++)
			{
				if (xcorr[j] > 0)
				{
					short num4 = Inlines.EXTRACT16(Inlines.VSHR32(xcorr[j], shift));
					int num5 = Inlines.MULT16_16_Q15((int)num4, (int)num4);
					if (Inlines.MULT16_32_Q15(num5, b) > Inlines.MULT16_32_Q15(a, num))
					{
						if (Inlines.MULT16_32_Q15(num5, num3) > Inlines.MULT16_32_Q15(num2, num))
						{
							a = num2;
							b = num3;
							best_pitch[1] = best_pitch[0];
							num2 = num5;
							num3 = num;
							best_pitch[0] = j;
						}
						else
						{
							a = num5;
							b = num;
							best_pitch[1] = j;
						}
					}
				}
				num += Inlines.SHR32(Inlines.MULT16_16(y[j + len], y[j + len]), yshift) - Inlines.SHR32(Inlines.MULT16_16(y[j], y[j]), yshift);
				num = Inlines.MAX32(1, num);
			}
		}

		internal static void celt_fir5(int[] x, int[] num, int[] y, int N, int[] mem)
		{
			int a = num[0];
			int a2 = num[1];
			int a3 = num[2];
			int a4 = num[3];
			int a5 = num[4];
			int num2 = mem[0];
			int num3 = mem[1];
			int num4 = mem[2];
			int num5 = mem[3];
			int num6 = mem[4];
			for (int i = 0; i < N; i++)
			{
				int c = Inlines.SHL32(Inlines.EXTEND32(x[i]), 12);
				c = Inlines.MAC16_16(c, a, num2);
				c = Inlines.MAC16_16(c, a2, num3);
				c = Inlines.MAC16_16(c, a3, num4);
				c = Inlines.MAC16_16(c, a4, num5);
				c = Inlines.MAC16_16(c, a5, num6);
				num6 = num5;
				num5 = num4;
				num4 = num3;
				num3 = num2;
				num2 = x[i];
				y[i] = Inlines.ROUND16(c, 12);
			}
			mem[0] = num2;
			mem[1] = num3;
			mem[2] = num4;
			mem[3] = num5;
			mem[4] = num6;
		}

		internal static void pitch_downsample(int[][] x, int[] x_lp, int len, int C)
		{
			int[] array = new int[5];
			int b = 32767;
			int[] array2 = new int[4];
			int[] mem = new int[5];
			int[] array3 = new int[5];
			int a = 26214;
			int num = Inlines.celt_maxabs32(x[0], 0, len);
			if (C == 2)
			{
				int b2 = Inlines.celt_maxabs32(x[1], 0, len);
				num = Inlines.MAX32(num, b2);
			}
			if (num < 1)
			{
				num = 1;
			}
			int num2 = Inlines.celt_ilog2(num) - 10;
			if (num2 < 0)
			{
				num2 = 0;
			}
			if (C == 2)
			{
				num2++;
			}
			int num3 = len >> 1;
			for (int i = 1; i < num3; i++)
			{
				x_lp[i] = Inlines.SHR32(Inlines.HALF32(Inlines.HALF32(x[0][2 * i - 1] + x[0][2 * i + 1]) + x[0][2 * i]), num2);
			}
			x_lp[0] = Inlines.SHR32(Inlines.HALF32(Inlines.HALF32(x[0][1]) + x[0][0]), num2);
			if (C == 2)
			{
				for (int i = 1; i < num3; i++)
				{
					x_lp[i] += Inlines.SHR32(Inlines.HALF32(Inlines.HALF32(x[1][2 * i - 1] + x[1][2 * i + 1]) + x[1][2 * i]), num2);
				}
				x_lp[0] += Inlines.SHR32(Inlines.HALF32(Inlines.HALF32(x[1][1]) + x[1][0]), num2);
			}
			Autocorrelation._celt_autocorr(x_lp, array, null, 0, 4, num3);
			array[0] += Inlines.SHR32(array[0], 13);
			for (int i = 1; i <= 4; i++)
			{
				array[i] -= Inlines.MULT16_32_Q15(2 * i * i, array[i]);
			}
			CeltLPC.celt_lpc(array2, array, 4);
			for (int i = 0; i < 4; i++)
			{
				b = Inlines.MULT16_16_Q15(29491, b);
				array2[i] = Inlines.MULT16_16_Q15(array2[i], b);
			}
			array3[0] = array2[0] + 3277;
			array3[1] = array2[1] + Inlines.MULT16_16_Q15(a, array2[0]);
			array3[2] = array2[2] + Inlines.MULT16_16_Q15(a, array2[1]);
			array3[3] = array2[3] + Inlines.MULT16_16_Q15(a, array2[2]);
			array3[4] = Inlines.MULT16_16_Q15(a, array2[3]);
			celt_fir5(x_lp, array3, x_lp, num3, mem);
		}

		internal static void pitch_search(int[] x_lp, int x_lp_ptr, int[] y, int len, int max_pitch, out int pitch)
		{
			int[] array = new int[2];
			int num = 0;
			int num2 = len + max_pitch;
			int[] array2 = new int[len >> 2];
			int[] array3 = new int[num2 >> 2];
			int[] array4 = new int[max_pitch >> 1];
			for (int i = 0; i < len >> 2; i++)
			{
				array2[i] = x_lp[x_lp_ptr + 2 * i];
			}
			for (int i = 0; i < num2 >> 2; i++)
			{
				array3[i] = y[2 * i];
			}
			int a = Inlines.celt_maxabs32(array2, 0, len >> 2);
			int b = Inlines.celt_maxabs32(array3, 0, num2 >> 2);
			num = Inlines.celt_ilog2(Inlines.MAX32(1, Inlines.MAX32(a, b))) - 11;
			if (num > 0)
			{
				for (int i = 0; i < len >> 2; i++)
				{
					array2[i] = Inlines.SHR16(array2[i], num);
				}
				for (int i = 0; i < num2 >> 2; i++)
				{
					array3[i] = Inlines.SHR16(array3[i], num);
				}
				num *= 2;
			}
			else
			{
				num = 0;
			}
			int maxcorr = CeltPitchXCorr.pitch_xcorr(array2, array3, array4, len >> 2, max_pitch >> 2);
			find_best_pitch(array4, array3, len >> 2, max_pitch >> 2, array, 0, maxcorr);
			maxcorr = 1;
			for (int j = 0; j < max_pitch >> 1; j++)
			{
				array4[j] = 0;
				if (Inlines.abs(j - 2 * array[0]) <= 2 || Inlines.abs(j - 2 * array[1]) <= 2)
				{
					int num3 = 0;
					for (int i = 0; i < len >> 1; i++)
					{
						num3 += Inlines.SHR32(Inlines.MULT16_16(x_lp[x_lp_ptr + i], y[j + i]), num);
					}
					array4[j] = Inlines.MAX32(-1, num3);
					maxcorr = Inlines.MAX32(maxcorr, num3);
				}
			}
			find_best_pitch(array4, y, len >> 1, max_pitch >> 1, array, num + 1, maxcorr);
			int num7;
			if (array[0] > 0 && array[0] < (max_pitch >> 1) - 1)
			{
				int num4 = array4[array[0] - 1];
				int num5 = array4[array[0]];
				int num6 = array4[array[0] + 1];
				num7 = ((num6 - num4 > Inlines.MULT16_32_Q15((short)22938, num5 - num4)) ? 1 : ((num4 - num6 > Inlines.MULT16_32_Q15((short)22938, num5 - num6)) ? (-1) : 0));
			}
			else
			{
				num7 = 0;
			}
			pitch = 2 * array[0] - num7;
		}

		internal static int remove_doubling(int[] x, int maxperiod, int minperiod, int N, ref int T0_, int prev_period, int prev_gain)
		{
			int[] array = new int[3];
			int num = minperiod;
			maxperiod /= 2;
			minperiod /= 2;
			T0_ /= 2;
			prev_period /= 2;
			N /= 2;
			int num2 = maxperiod;
			if (T0_ >= maxperiod)
			{
				T0_ = maxperiod - 1;
			}
			int num4;
			int num3 = (num4 = T0_);
			int[] array2 = new int[maxperiod + 1];
			Kernels.dual_inner_prod(x, num2, x, num2, x, num2 - num4, N, out var xy, out var xy2);
			array2[0] = xy;
			int num5 = xy;
			for (int i = 1; i <= maxperiod; i++)
			{
				int num6 = num2 - i;
				num5 = num5 + Inlines.MULT16_16(x[num6], x[num6]) - Inlines.MULT16_16(x[num6 + N], x[num6 + N]);
				array2[i] = Inlines.MAX32(0, num5);
			}
			num5 = array2[num4];
			int b = xy2;
			int num7 = num5;
			int num8 = 1 + Inlines.HALF32(Inlines.MULT32_32_Q31(xy, num5));
			int num9 = Inlines.celt_ilog2(num8) >> 1;
			int num10 = Inlines.VSHR32(Inlines.MULT16_32_Q15(Inlines.celt_rsqrt_norm(Inlines.VSHR32(num8, 2 * (num9 - 7))), xy2), num9 + 1);
			int b2 = num10;
			for (int j = 2; j <= 15; j++)
			{
				int num11 = 0;
				int num12 = Inlines.celt_udiv(2 * num4 + j, 2 * j);
				if (num12 < minperiod)
				{
					break;
				}
				int num13 = ((j != 2) ? Inlines.celt_udiv(2 * second_check[j] * num4 + j, 2 * j) : ((num12 + num4 <= maxperiod) ? (num4 + num12) : num4));
				Kernels.dual_inner_prod(x, num2, x, num2 - num12, x, num2 - num13, N, out xy2, out var xy3);
				xy2 += xy3;
				num5 = array2[num12] + array2[num13];
				int num14 = 1 + Inlines.MULT32_32_Q31(xy, num5);
				int num15 = Inlines.celt_ilog2(num14) >> 1;
				int num16 = Inlines.VSHR32(Inlines.MULT16_32_Q15(Inlines.celt_rsqrt_norm(Inlines.VSHR32(num14, 2 * (num15 - 7))), xy2), num15 + 1);
				num11 = ((Inlines.abs(num12 - prev_period) <= 1) ? prev_gain : ((Inlines.abs(num12 - prev_period) <= 2 && 5 * j * j < num4) ? Inlines.HALF16(prev_gain) : 0));
				int num17 = Inlines.MAX16(9830, Inlines.MULT16_16_Q15(22938, b2) - num11);
				if (num12 < 3 * minperiod)
				{
					num17 = Inlines.MAX16(13107, Inlines.MULT16_16_Q15(27853, b2) - num11);
				}
				else if (num12 < 2 * minperiod)
				{
					num17 = Inlines.MAX16(16384, Inlines.MULT16_16_Q15(29491, b2) - num11);
				}
				if (num16 > num17)
				{
					b = xy2;
					num7 = num5;
					num3 = num12;
					num10 = num16;
				}
			}
			b = Inlines.MAX32(0, b);
			int num18 = ((num7 > b) ? Inlines.SHR32(Inlines.frac_div32(b, num7 + 1), 16) : 32767);
			for (int j = 0; j < 3; j++)
			{
				array[j] = Kernels.celt_inner_prod(x, num2, x, num2 - (num3 + j - 1), N);
			}
			int num19 = ((array[2] - array[0] > Inlines.MULT16_32_Q15((short)22938, array[1] - array[0])) ? 1 : ((array[0] - array[2] > Inlines.MULT16_32_Q15((short)22938, array[1] - array[2])) ? (-1) : 0));
			if (num18 > num10)
			{
				num18 = num10;
			}
			T0_ = 2 * num3 + num19;
			if (T0_ < num)
			{
				T0_ = num;
			}
			return num18;
		}
	}
	internal static class QuantizeBands
	{
		private static readonly int[] pred_coef = new int[4] { 29440, 26112, 21248, 16384 };

		private static readonly int[] beta_coef = new int[4] { 30147, 22282, 12124, 6554 };

		private static readonly int beta_intra = 4915;

		private static byte[] small_energy_icdf = new byte[3] { 2, 1, 0 };

		internal static int loss_distortion(int[][] eBands, int[][] oldEBands, int start, int end, int len, int C)
		{
			int num = 0;
			int num2 = 0;
			do
			{
				for (int i = start; i < end; i++)
				{
					int num3 = Inlines.SUB16(Inlines.SHR16(eBands[num2][i], 3), Inlines.SHR16(oldEBands[num2][i], 3));
					num = Inlines.MAC16_16(num, num3, num3);
				}
			}
			while (++num2 < C);
			return Inlines.MIN32(200, Inlines.SHR32(num, 14));
		}

		internal static int quant_coarse_energy_impl(CeltMode m, int start, int end, int[][] eBands, int[][] oldEBands, int budget, int tell, byte[] prob_model, int[][] error, EntropyCoder enc, int C, int LM, int intra, int max_decay, int lfe)
		{
			int num = 0;
			int[] array = new int[2];
			if (tell + 3 <= budget)
			{
				enc.enc_bit_logp(intra, 3u);
			}
			int a;
			int a2;
			if (intra != 0)
			{
				a = 0;
				a2 = beta_intra;
			}
			else
			{
				a2 = beta_coef[LM];
				a = pred_coef[LM];
			}
			for (int i = start; i < end; i++)
			{
				int num2 = 0;
				do
				{
					int num3 = eBands[num2][i];
					int b = Inlines.MAX16(-9216, oldEBands[num2][i]);
					int num4 = Inlines.SHL32(Inlines.EXTEND32(num3), 7) - Inlines.PSHR32(Inlines.MULT16_16(a, b), 8) - array[num2];
					int value = num4 + 65536 >> 17;
					int num5 = Inlines.EXTRACT16(Inlines.MAX32(-28672, Inlines.SUB32(oldEBands[num2][i], max_decay)));
					if (value < 0 && num3 < num5)
					{
						value += Inlines.SHR16(Inlines.SUB16(num5, num3), 10);
						if (value > 0)
						{
							value = 0;
						}
					}
					int num6 = value;
					tell = enc.tell();
					int num7 = budget - tell - 3 * C * (end - i);
					if (i != start && num7 < 30)
					{
						if (num7 < 24)
						{
							value = Inlines.IMIN(1, value);
						}
						if (num7 < 16)
						{
							value = Inlines.IMAX(-1, value);
						}
					}
					if (lfe != 0 && i >= 2)
					{
						value = Inlines.IMIN(value, 0);
					}
					if (budget - tell >= 15)
					{
						int num8 = 2 * Inlines.IMIN(i, 20);
						Laplace.ec_laplace_encode(enc, ref value, (uint)(prob_model[num8] << 7), prob_model[num8 + 1] << 6);
					}
					else if (budget - tell >= 2)
					{
						value = Inlines.IMAX(-1, Inlines.IMIN(value, 1));
						enc.enc_icdf((2 * value) ^ (0 - ((value < 0) ? 1 : 0)), small_energy_icdf, 2u);
					}
					else if (budget - tell >= 1)
					{
						value = Inlines.IMIN(0, value);
						enc.enc_bit_logp(-value, 1u);
					}
					else
					{
						value = -1;
					}
					error[num2][i] = Inlines.PSHR32(num4, 7) - Inlines.SHL16(value, 10);
					num += Inlines.abs(num6 - value);
					int a3 = Inlines.SHL32(value, 10);
					int b2 = Inlines.PSHR32(Inlines.MULT16_16(a, b), 8) + array[num2] + Inlines.SHL32(a3, 7);
					b2 = Inlines.MAX32(-3670016, b2);
					oldEBands[num2][i] = Inlines.PSHR32(b2, 7);
					array[num2] = array[num2] + Inlines.SHL32(a3, 7) - Inlines.MULT16_16(a2, Inlines.PSHR32(a3, 8));
				}
				while (++num2 < C);
			}
			if (lfe == 0)
			{
				return num;
			}
			return 0;
		}

		internal static void quant_coarse_energy(CeltMode m, int start, int end, int effEnd, int[][] eBands, int[][] oldEBands, uint budget, int[][] error, EntropyCoder enc, int C, int LM, int nbAvailableBytes, int force_intra, ref int delayedIntra, int two_pass, int loss_rate, int lfe)
		{
			EntropyCoder entropyCoder = new EntropyCoder();
			int num = 0;
			int num2 = ((force_intra != 0 || (two_pass == 0 && delayedIntra > 2 * C * (end - start) && nbAvailableBytes > (end - start) * C)) ? 1 : 0);
			int num3 = (int)(budget * delayedIntra * loss_rate / (C * 512));
			int num4 = loss_distortion(eBands, oldEBands, start, effEnd, m.nbEBands, C);
			uint num5 = (uint)enc.tell();
			if (num5 + 3 > budget)
			{
				two_pass = (num2 = 0);
			}
			int num6 = 16384;
			if (end - start > 10)
			{
				num6 = Inlines.MIN32(num6, Inlines.SHL32(nbAvailableBytes, 7));
			}
			if (lfe != 0)
			{
				num6 = 3072;
			}
			entropyCoder.Assign(enc);
			int[][] array = Arrays.InitTwoDimensionalArray<int>(C, m.nbEBands);
			int[][] array2 = Arrays.InitTwoDimensionalArray<int>(C, m.nbEBands);
			Array.Copy(oldEBands[0], 0, array[0], 0, m.nbEBands);
			if (C == 2)
			{
				Array.Copy(oldEBands[1], 0, array[1], 0, m.nbEBands);
			}
			if (two_pass != 0 || num2 != 0)
			{
				num = quant_coarse_energy_impl(m, start, end, eBands, array, (int)budget, (int)num5, Tables.e_prob_model[LM][1], array2, enc, C, LM, 1, num6, lfe);
			}
			if (num2 == 0)
			{
				EntropyCoder entropyCoder2 = new EntropyCoder();
				byte[] array3 = null;
				int num7 = (int)enc.tell_frac();
				entropyCoder2.Assign(enc);
				uint num8 = entropyCoder.range_bytes();
				uint num9 = entropyCoder2.range_bytes();
				int num10 = entropyCoder2.buf_ptr + (int)num8;
				uint num11 = num9 - num8;
				if (num11 != 0)
				{
					array3 = new byte[num11];
					Array.Copy(entropyCoder2.buf, num10, array3, 0, (int)num11);
				}
				enc.Assign(entropyCoder);
				int num12 = quant_coarse_energy_impl(m, start, end, eBands, oldEBands, (int)budget, (int)num5, Tables.e_prob_model[LM][num2], error, enc, C, LM, 0, num6, lfe);
				if (two_pass != 0 && (num < num12 || (num == num12 && (int)enc.tell_frac() + num3 > num7)))
				{
					enc.Assign(entropyCoder2);
					if (array3 != null)
					{
						Array.Copy(array3, 0, entropyCoder2.buf, num10, (int)(num9 - num8));
					}
					Array.Copy(array[0], 0, oldEBands[0], 0, m.nbEBands);
					Array.Copy(array2[0], 0, error[0], 0, m.nbEBands);
					if (C == 2)
					{
						Array.Copy(array[1], 0, oldEBands[1], 0, m.nbEBands);
						Array.Copy(array2[1], 0, error[1], 0, m.nbEBands);
					}
					num2 = 1;
				}
			}
			else
			{
				Array.Copy(array[0], 0, oldEBands[0], 0, m.nbEBands);
				Array.Copy(array2[0], 0, error[0], 0, m.nbEBands);
				if (C == 2)
				{
					Array.Copy(array[1], 0, oldEBands[1], 0, m.nbEBands);
					Array.Copy(array2[1], 0, error[1], 0, m.nbEBands);
				}
			}
			if (num2 != 0)
			{
				delayedIntra = num4;
			}
			else
			{
				delayedIntra = Inlines.ADD32(Inlines.MULT16_32_Q15(Inlines.MULT16_16_Q15(pred_coef[LM], pred_coef[LM]), delayedIntra), num4);
			}
		}

		internal static void quant_fine_energy(CeltMode m, int start, int end, int[][] oldEBands, int[][] error, int[] fine_quant, EntropyCoder enc, int C)
		{
			for (int i = start; i < end; i++)
			{
				int num = 1 << fine_quant[i];
				if (fine_quant[i] <= 0)
				{
					continue;
				}
				int num2 = 0;
				do
				{
					int num3 = error[num2][i] + 512 >> 10 - fine_quant[i];
					if (num3 > num - 1)
					{
						num3 = num - 1;
					}
					if (num3 < 0)
					{
						num3 = 0;
					}
					enc.enc_bits((uint)num3, (uint)fine_quant[i]);
					int num4 = Inlines.SUB16(Inlines.SHR32(Inlines.SHL32(num3, 10) + 512, fine_quant[i]), 512);
					oldEBands[num2][i] += num4;
					error[num2][i] -= num4;
				}
				while (++num2 < C);
			}
		}

		internal static void quant_energy_finalise(CeltMode m, int start, int end, int[][] oldEBands, int[][] error, int[] fine_quant, int[] fine_priority, int bits_left, EntropyCoder enc, int C)
		{
			for (int i = 0; i < 2; i++)
			{
				for (int j = start; j < end; j++)
				{
					if (bits_left < C)
					{
						break;
					}
					if (fine_quant[j] < 8 && fine_priority[j] == i)
					{
						int num = 0;
						do
						{
							int num2 = ((error[num][j] >= 0) ? 1 : 0);
							enc.enc_bits((uint)num2, 1u);
							int num3 = Inlines.SHR16(Inlines.SHL16(num2, 10) - 512, fine_quant[j] + 1);
							oldEBands[num][j] += num3;
							bits_left--;
						}
						while (++num < C);
					}
				}
			}
		}

		internal static void unquant_coarse_energy(CeltMode m, int start, int end, int[] oldEBands, int intra, EntropyCoder dec, int C, int LM)
		{
			byte[] array = Tables.e_prob_model[LM][intra];
			int[] array2 = new int[2];
			int a;
			int a2;
			if (intra != 0)
			{
				a = 0;
				a2 = beta_intra;
			}
			else
			{
				a2 = beta_coef[LM];
				a = pred_coef[LM];
			}
			int num = (int)(dec.storage * 8);
			for (int i = start; i < end; i++)
			{
				int num2 = 0;
				do
				{
					int num3 = dec.tell();
					int a3;
					if (num - num3 >= 15)
					{
						int num4 = 2 * Inlines.IMIN(i, 20);
						a3 = Laplace.ec_laplace_decode(dec, (uint)(array[num4] << 7), array[num4 + 1] << 6);
					}
					else if (num - num3 < 2)
					{
						a3 = ((num - num3 < 1) ? (-1) : (-dec.dec_bit_logp(1u)));
					}
					else
					{
						a3 = dec.dec_icdf(small_energy_icdf, 2u);
						a3 = (a3 >> 1) ^ -(a3 & 1);
					}
					int a4 = Inlines.SHL32(a3, 10);
					oldEBands[i + num2 * m.nbEBands] = Inlines.MAX16(-9216, oldEBands[i + num2 * m.nbEBands]);
					int b = Inlines.PSHR32(Inlines.MULT16_16(a, oldEBands[i + num2 * m.nbEBands]), 8) + array2[num2] + Inlines.SHL32(a4, 7);
					b = Inlines.MAX32(-3670016, b);
					oldEBands[i + num2 * m.nbEBands] = Inlines.PSHR32(b, 7);
					array2[num2] = array2[num2] + Inlines.SHL32(a4, 7) - Inlines.MULT16_16(a2, Inlines.PSHR32(a4, 8));
				}
				while (++num2 < C);
			}
		}

		internal static void unquant_fine_energy(CeltMode m, int start, int end, int[] oldEBands, int[] fine_quant, EntropyCoder dec, int C)
		{
			for (int i = start; i < end; i++)
			{
				if (fine_quant[i] > 0)
				{
					int num = 0;
					do
					{
						int num2 = Inlines.SUB16(Inlines.SHR32(Inlines.SHL32((int)dec.dec_bits((uint)fine_quant[i]), 10) + 512, fine_quant[i]), 512);
						oldEBands[i + num * m.nbEBands] += num2;
					}
					while (++num < C);
				}
			}
		}

		internal static void unquant_energy_finalise(CeltMode m, int start, int end, int[] oldEBands, int[] fine_quant, int[] fine_priority, int bits_left, EntropyCoder dec, int C)
		{
			for (int i = 0; i < 2; i++)
			{
				for (int j = start; j < end; j++)
				{
					if (bits_left < C)
					{
						break;
					}
					if (fine_quant[j] < 8 && fine_priority[j] == i)
					{
						int num = 0;
						do
						{
							int num2 = Inlines.SHR16(Inlines.SHL16((int)dec.dec_bits(1u), 10) - 512, fine_quant[j] + 1);
							oldEBands[j + num * m.nbEBands] += num2;
							bits_left--;
						}
						while (++num < C);
					}
				}
			}
		}

		internal static void amp2Log2(CeltMode m, int effEnd, int end, int[][] bandE, int[][] bandLogE, int C)
		{
			int num = 0;
			do
			{
				for (int i = 0; i < effEnd; i++)
				{
					bandLogE[num][i] = Inlines.celt_log2(Inlines.SHL32(bandE[num][i], 2)) - Inlines.SHL16((int)Tables.eMeans[i], 6);
				}
				for (int i = effEnd; i < end; i++)
				{
					bandLogE[num][i] = -14336;
				}
			}
			while (++num < C);
		}

		internal static void amp2Log2(CeltMode m, int effEnd, int end, int[] bandE, int[] bandLogE, int bandLogE_ptr, int C)
		{
			int num = 0;
			do
			{
				for (int i = 0; i < effEnd; i++)
				{
					bandLogE[bandLogE_ptr + num * m.nbEBands + i] = Inlines.celt_log2(Inlines.SHL32(bandE[i + num * m.nbEBands], 2)) - Inlines.SHL16((int)Tables.eMeans[i], 6);
				}
				for (int i = effEnd; i < end; i++)
				{
					bandLogE[bandLogE_ptr + num * m.nbEBands + i] = -14336;
				}
			}
			while (++num < C);
		}
	}
	internal static class Rate
	{
		private static readonly byte[] LOG2_FRAC_TABLE = new byte[24]
		{
			0, 8, 13, 16, 19, 21, 23, 24, 26, 27,
			28, 29, 30, 31, 32, 32, 33, 34, 34, 35,
			36, 36, 37, 37
		};

		private const int ALLOC_STEPS = 6;

		internal static int get_pulses(int i)
		{
			if (i >= 8)
			{
				return 8 + (i & 7) << (i >> 3) - 1;
			}
			return i;
		}

		internal static int bits2pulses(CeltMode m, int band, int LM, int bits)
		{
			LM++;
			byte[] bits2 = m.cache.bits;
			int num = m.cache.index[LM * m.nbEBands + band];
			int num2 = 0;
			int num3 = bits2[num];
			bits--;
			for (int i = 0; i < 6; i++)
			{
				int num4 = num2 + num3 + 1 >> 1;
				if (bits2[num + num4] >= bits)
				{
					num3 = num4;
				}
				else
				{
					num2 = num4;
				}
			}
			if (bits - ((num2 == 0) ? (-1) : bits2[num + num2]) <= bits2[num + num3] - bits)
			{
				return num2;
			}
			return num3;
		}

		internal static int pulses2bits(CeltMode m, int band, int LM, int pulses)
		{
			LM++;
			if (pulses != 0)
			{
				return m.cache.bits[m.cache.index[LM * m.nbEBands + band] + pulses] + 1;
			}
			return 0;
		}

		internal static int interp_bits2pulses(CeltMode m, int start, int end, int skip_start, int[] bits1, int[] bits2, int[] thresh, int[] cap, int total, out int _balance, int skip_rsv, ref int intensity, int intensity_rsv, ref int dual_stereo, int dual_stereo_rsv, int[] bits, int[] ebits, int[] fine_priority, int C, int LM, EntropyCoder ec, int encode, int prev, int signalBandwidth)
		{
			int num = -1;
			int num2 = C << 3;
			int num3 = ((C > 1) ? 1 : 0);
			int num4 = LM << 3;
			int num5 = 0;
			int num6 = 64;
			int num9;
			int num8;
			int num10;
			for (int i = 0; i < 6; i++)
			{
				int num7 = num5 + num6 >> 1;
				num8 = 0;
				num9 = 0;
				num10 = end;
				while (num10-- > start)
				{
					int num11 = bits1[num10] + (num7 * bits2[num10] >> 6);
					if (num11 >= thresh[num10] || num9 != 0)
					{
						num9 = 1;
						num8 += Inlines.IMIN(num11, cap[num10]);
					}
					else if (num11 >= num2)
					{
						num8 += num2;
					}
				}
				if (num8 > total)
				{
					num6 = num7;
				}
				else
				{
					num5 = num7;
				}
			}
			num8 = 0;
			num9 = 0;
			num10 = end;
			while (num10-- > start)
			{
				int num12 = bits1[num10] + (num5 * bits2[num10] >> 6);
				if (num12 < thresh[num10] && num9 == 0)
				{
					num12 = ((num12 >= num2) ? num2 : 0);
				}
				else
				{
					num9 = 1;
				}
				num8 += (bits[num10] = Inlines.IMIN(num12, cap[num10]));
			}
			num = end;
			int num14;
			int num13;
			while (true)
			{
				num10 = num - 1;
				if (num10 <= skip_start)
				{
					total += skip_rsv;
					break;
				}
				num13 = total - num8;
				num14 = Inlines.celt_udiv(num13, m.eBands[num] - m.eBands[start]);
				num13 -= (m.eBands[num] - m.eBands[start]) * num14;
				int num15 = Inlines.IMAX(num13 - (m.eBands[num10] - m.eBands[start]), 0);
				int num16 = m.eBands[num] - m.eBands[num10];
				int num17 = bits[num10] + num14 * num16 + num15;
				if (num17 >= Inlines.IMAX(thresh[num10], num2 + 8))
				{
					if (encode != 0)
					{
						if (num <= start + 2 || (num17 > ((num10 < prev) ? 7 : 9) * num16 << LM << 3 >> 4 && num10 <= signalBandwidth))
						{
							ec.enc_bit_logp(1, 1u);
							break;
						}
						ec.enc_bit_logp(0, 1u);
					}
					else if (ec.dec_bit_logp(1u) != 0)
					{
						break;
					}
					num8 += 8;
					num17 -= 8;
				}
				num8 -= bits[num10] + intensity_rsv;
				if (intensity_rsv > 0)
				{
					intensity_rsv = LOG2_FRAC_TABLE[num10 - start];
				}
				num8 += intensity_rsv;
				if (num17 >= num2)
				{
					num8 += num2;
					bits[num10] = num2;
				}
				else
				{
					bits[num10] = 0;
				}
				num--;
			}
			if (intensity_rsv > 0)
			{
				if (encode != 0)
				{
					intensity = Inlines.IMIN(intensity, num);
					ec.enc_uint((uint)(intensity - start), (uint)(num + 1 - start));
				}
				else
				{
					intensity = start + (int)ec.dec_uint((uint)(num + 1 - start));
				}
			}
			else
			{
				intensity = 0;
			}
			if (intensity <= start)
			{
				total += dual_stereo_rsv;
				dual_stereo_rsv = 0;
			}
			if (dual_stereo_rsv > 0)
			{
				if (encode != 0)
				{
					ec.enc_bit_logp(dual_stereo, 1u);
				}
				else
				{
					dual_stereo = ec.dec_bit_logp(1u);
				}
			}
			else
			{
				dual_stereo = 0;
			}
			num13 = total - num8;
			num14 = Inlines.celt_udiv(num13, m.eBands[num] - m.eBands[start]);
			num13 -= (m.eBands[num] - m.eBands[start]) * num14;
			for (num10 = start; num10 < num; num10++)
			{
				bits[num10] += num14 * (m.eBands[num10 + 1] - m.eBands[num10]);
			}
			for (num10 = start; num10 < num; num10++)
			{
				int num18 = Inlines.IMIN(num13, m.eBands[num10 + 1] - m.eBands[num10]);
				bits[num10] += num18;
				num13 -= num18;
			}
			int num19 = 0;
			for (num10 = start; num10 < num; num10++)
			{
				int num20 = m.eBands[num10 + 1] - m.eBands[num10] << LM;
				int num21 = bits[num10] + num19;
				int num22;
				if (num20 > 1)
				{
					num22 = Inlines.MAX32(num21 - cap[num10], 0);
					bits[num10] = num21 - num22;
					int num23 = C * num20 + ((C == 2 && num20 > 2 && dual_stereo == 0 && num10 < intensity) ? 1 : 0);
					int num24 = num23 * (m.logN[num10] + num4);
					int num25 = (num24 >> 1) - num23 * 21;
					if (num20 == 2)
					{
						num25 += num23 << 3 >> 2;
					}
					if (bits[num10] + num25 < num23 * 2 << 3)
					{
						num25 += num24 >> 2;
					}
					else if (bits[num10] + num25 < num23 * 3 << 3)
					{
						num25 += num24 >> 3;
					}
					ebits[num10] = Inlines.IMAX(0, bits[num10] + num25 + (num23 << 2));
					ebits[num10] = Inlines.celt_udiv(ebits[num10], num23) >> 3;
					if (C * ebits[num10] > bits[num10] >> 3)
					{
						ebits[num10] = bits[num10] >> num3 >> 3;
					}
					ebits[num10] = Inlines.IMIN(ebits[num10], 8);
					fine_priority[num10] = ((ebits[num10] * (num23 << 3) >= bits[num10] + num25) ? 1 : 0);
					bits[num10] -= C * ebits[num10] << 3;
				}
				else
				{
					num22 = Inlines.MAX32(0, num21 - (C << 3));
					bits[num10] = num21 - num22;
					ebits[num10] = 0;
					fine_priority[num10] = 1;
				}
				if (num22 > 0)
				{
					int num26 = Inlines.IMIN(num22 >> num3 + 3, 8 - ebits[num10]);
					ebits[num10] += num26;
					int num27 = num26 * C << 3;
					fine_priority[num10] = ((num27 >= num22 - num19) ? 1 : 0);
					num22 -= num27;
				}
				num19 = num22;
			}
			_balance = num19;
			for (; num10 < end; num10++)
			{
				ebits[num10] = bits[num10] >> num3 >> 3;
				bits[num10] = 0;
				fine_priority[num10] = ((ebits[num10] < 1) ? 1 : 0);
			}
			return num;
		}

		internal static int compute_allocation(CeltMode m, int start, int end, int[] offsets, int[] cap, int alloc_trim, ref int intensity, ref int dual_stereo, int total, out int balance, int[] pulses, int[] ebits, int[] fine_priority, int C, int LM, EntropyCoder ec, int encode, int prev, int signalBandwidth)
		{
			total = Inlines.IMAX(total, 0);
			int nbEBands = m.nbEBands;
			int skip_start = start;
			int num = ((total >= 8) ? 8 : 0);
			total -= num;
			int num3;
			int num2 = (num3 = 0);
			if (C == 2)
			{
				num2 = LOG2_FRAC_TABLE[end - start];
				if (num2 > total)
				{
					num2 = 0;
				}
				else
				{
					total -= num2;
					num3 = ((total >= 8) ? 8 : 0);
					total -= num3;
				}
			}
			int[] array = new int[nbEBands];
			int[] array2 = new int[nbEBands];
			int[] array3 = new int[nbEBands];
			int[] array4 = new int[nbEBands];
			for (int i = start; i < end; i++)
			{
				array3[i] = Inlines.IMAX(C << 3, 3 * (m.eBands[i + 1] - m.eBands[i]) << LM << 3 >> 4);
				array4[i] = C * (m.eBands[i + 1] - m.eBands[i]) * (alloc_trim - 5 - LM) * (end - i - 1) * (1 << LM + 3) >> 6;
				if (m.eBands[i + 1] - m.eBands[i] << LM == 1)
				{
					array4[i] -= C << 3;
				}
			}
			int num4 = 1;
			int num5 = m.nbAllocVectors - 1;
			do
			{
				int num6 = 0;
				int num7 = 0;
				int num8 = num4 + num5 >> 1;
				int i = end;
				while (i-- > start)
				{
					int num9 = m.eBands[i + 1] - m.eBands[i];
					int num10 = C * num9 * m.allocVectors[num8 * nbEBands + i] << LM >> 2;
					if (num10 > 0)
					{
						num10 = Inlines.IMAX(0, num10 + array4[i]);
					}
					num10 += offsets[i];
					if (num10 >= array3[i] || num6 != 0)
					{
						num6 = 1;
						num7 += Inlines.IMIN(num10, cap[i]);
					}
					else if (num10 >= C << 3)
					{
						num7 += C << 3;
					}
				}
				if (num7 > total)
				{
					num5 = num8 - 1;
				}
				else
				{
					num4 = num8 + 1;
				}
			}
			while (num4 <= num5);
			num5 = num4--;
			for (int i = start; i < end; i++)
			{
				int num11 = m.eBands[i + 1] - m.eBands[i];
				int num12 = C * num11 * m.allocVectors[num4 * nbEBands + i] << LM >> 2;
				int num13 = ((num5 >= m.nbAllocVectors) ? cap[i] : (C * num11 * m.allocVectors[num5 * nbEBands + i] << LM >> 2));
				if (num12 > 0)
				{
					num12 = Inlines.IMAX(0, num12 + array4[i]);
				}
				if (num13 > 0)
				{
					num13 = Inlines.IMAX(0, num13 + array4[i]);
				}
				if (num4 > 0)
				{
					num12 += offsets[i];
				}
				num13 += offsets[i];
				if (offsets[i] > 0)
				{
					skip_start = i;
				}
				num13 = Inlines.IMAX(0, num13 - num12);
				array[i] = num12;
				array2[i] = num13;
			}
			return interp_bits2pulses(m, start, end, skip_start, array, array2, array3, cap, total, out balance, num, ref intensity, num2, ref dual_stereo, num3, pulses, ebits, fine_priority, C, LM, ec, encode, prev, signalBandwidth);
		}
	}
	internal static class Tables
	{
		internal static readonly byte[] eMeans = new byte[25]
		{
			103, 100, 92, 85, 81, 77, 72, 70, 78, 75,
			73, 71, 78, 74, 69, 72, 70, 74, 76, 71,
			60, 60, 60, 60, 60
		};

		internal static readonly int[] ordery_table = new int[30]
		{
			1, 0, 3, 0, 2, 1, 7, 0, 4, 3,
			6, 1, 5, 2, 15, 0, 8, 7, 12, 3,
			11, 4, 14, 1, 9, 6, 13, 2, 10, 5
		};

		internal static readonly short[] eband5ms = new short[22]
		{
			0, 1, 2, 3, 4, 5, 6, 7, 8, 10,
			12, 14, 16, 20, 24, 28, 34, 40, 48, 60,
			78, 100
		};

		internal static readonly byte[][][] e_prob_model = new byte[4][][]
		{
			new byte[2][]
			{
				new byte[42]
				{
					72, 127, 65, 129, 66, 128, 65, 128, 64, 128,
					62, 128, 64, 128, 64, 128, 92, 78, 92, 79,
					92, 78, 90, 79, 116, 41, 115, 40, 114, 40,
					132, 26, 132, 26, 145, 17, 161, 12, 176, 10,
					177, 11
				},
				new byte[42]
				{
					24, 179, 48, 138, 54, 135, 54, 132, 53, 134,
					56, 133, 55, 132, 55, 132, 61, 114, 70, 96,
					74, 88, 75, 88, 87, 74, 89, 66, 91, 67,
					100, 59, 108, 50, 120, 40, 122, 37, 97, 43,
					78, 50
				}
			},
			new byte[2][]
			{
				new byte[42]
				{
					83, 78, 84, 81, 88, 75, 86, 74, 87, 71,
					90, 73, 93, 74, 93, 74, 109, 40, 114, 36,
					117, 34, 117, 34, 143, 17, 145, 18, 146, 19,
					162, 12, 165, 10, 178, 7, 189, 6, 190, 8,
					177, 9
				},
				new byte[42]
				{
					23, 178, 54, 115, 63, 102, 66, 98, 69, 99,
					74, 89, 71, 91, 73, 91, 78, 89, 86, 80,
					92, 66, 93, 64, 102, 59, 103, 60, 104, 60,
					117, 52, 123, 44, 138, 35, 133, 31, 97, 38,
					77, 45
				}
			},
			new byte[2][]
			{
				new byte[42]
				{
					61, 90, 93, 60, 105, 42, 107, 41, 110, 45,
					116, 38, 113, 38, 112, 38, 124, 26, 132, 27,
					136, 19, 140, 20, 155, 14, 159, 16, 158, 18,
					170, 13, 177, 10, 187, 8, 192, 6, 175, 9,
					159, 10
				},
				new byte[42]
				{
					21, 178, 59, 110, 71, 86, 75, 85, 84, 83,
					91, 66, 88, 73, 87, 72, 92, 75, 98, 72,
					105, 58, 107, 54, 115, 52, 114, 55, 112, 56,
					129, 51, 132, 40, 150, 33, 140, 29, 98, 35,
					77, 42
				}
			},
			new byte[2][]
			{
				new byte[42]
				{
					42, 121, 96, 66, 108, 43, 111, 40, 117, 44,
					123, 32, 120, 36, 119, 33, 127, 33, 134, 34,
					139, 21, 147, 23, 152, 20, 158, 25, 154, 26,
					166, 21, 173, 16, 184, 13, 184, 10, 150, 13,
					139, 15
				},
				new byte[42]
				{
					22, 178, 63, 114, 74, 82, 84, 83, 92, 82,
					103, 62, 96, 72, 96, 67, 101, 73, 107, 72,
					113, 55, 118, 52, 125, 52, 118, 52, 117, 55,
					135, 49, 137, 39, 157, 32, 145, 29, 97, 33,
					77, 40
				}
			}
		};

		internal static readonly sbyte[][] tf_select_table = new sbyte[4][]
		{
			new sbyte[8] { 0, -1, 0, -1, 0, -1, 0, -1 },
			new sbyte[8] { 0, -1, 0, -2, 1, 0, 1, -1 },
			new sbyte[8] { 0, -2, 0, -3, 2, 0, 1, -1 },
			new sbyte[8] { 0, -2, 0, -3, 3, 0, 1, -1 }
		};

		internal static readonly byte[] trim_icdf = new byte[11]
		{
			126, 124, 119, 109, 87, 41, 19, 9, 4, 2,
			0
		};

		internal static readonly byte[] spread_icdf = new byte[4] { 25, 23, 2, 0 };

		internal static readonly byte[] tapset_icdf = new byte[3] { 2, 1, 0 };

		internal static readonly byte[] band_allocation = new byte[231]
		{
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			0, 90, 80, 75, 69, 63, 56, 49, 40, 34,
			29, 20, 18, 10, 0, 0, 0, 0, 0, 0,
			0, 0, 110, 100, 90, 84, 78, 71, 65, 58,
			51, 45, 39, 32, 26, 20, 12, 0, 0, 0,
			0, 0, 0, 118, 110, 103, 93, 86, 80, 75,
			70, 65, 59, 53, 47, 40, 31, 23, 15, 4,
			0, 0, 0, 0, 126, 119, 112, 104, 95, 89,
			83, 78, 72, 66, 60, 54, 47, 39, 32, 25,
			17, 12, 1, 0, 0, 134, 127, 120, 114, 103,
			97, 91, 85, 78, 72, 66, 60, 54, 47, 41,
			35, 29, 23, 16, 10, 1, 144, 137, 130, 124,
			113, 107, 101, 95, 88, 82, 76, 70, 64, 57,
			51, 45, 39, 33, 26, 15, 1, 152, 145, 138,
			132, 123, 117, 111, 105, 98, 92, 86, 80, 74,
			67, 61, 55, 49, 43, 36, 20, 1, 162, 155,
			148, 142, 133, 127, 121, 115, 108, 102, 96, 90,
			84, 77, 71, 65, 59, 53, 46, 30, 1, 172,
			165, 158, 152, 143, 137, 131, 125, 118, 112, 106,
			100, 94, 87, 81, 75, 69, 63, 56, 45, 20,
			200, 200, 200, 200, 200, 200, 200, 200, 198, 193,
			188, 183, 178, 173, 168, 163, 158, 153, 148, 129,
			104
		};

		internal static readonly uint[] CELT_PVQ_U_DATA = new uint[1272]
		{
			1u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
			0u, 0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
			1u, 1u, 1u, 3u, 5u, 7u, 9u, 11u, 13u, 15u,
			17u, 19u, 21u, 23u, 25u, 27u, 29u, 31u, 33u, 35u,
			37u, 39u, 41u, 43u, 45u, 47u, 49u, 51u, 53u, 55u,
			57u, 59u, 61u, 63u, 65u, 67u, 69u, 71u, 73u, 75u,
			77u, 79u, 81u, 83u, 85u, 87u, 89u, 91u, 93u, 95u,
			97u, 99u, 101u, 103u, 105u, 107u, 109u, 111u, 113u, 115u,
			117u, 119u, 121u, 123u, 125u, 127u, 129u, 131u, 133u, 135u,
			137u, 139u, 141u, 143u, 145u, 147u, 149u, 151u, 153u, 155u,
			157u, 159u, 161u, 163u, 165u, 167u, 169u, 171u, 173u, 175u,
			177u, 179u, 181u, 183u, 185u, 187u, 189u, 191u, 193u, 195u,
			197u, 199u, 201u, 203u, 205u, 207u, 209u, 211u, 213u, 215u,
			217u, 219u, 221u, 223u, 225u, 227u, 229u, 231u, 233u, 235u,
			237u, 239u, 241u, 243u, 245u, 247u, 249u, 251u, 253u, 255u,
			257u, 259u, 261u, 263u, 265u, 267u, 269u, 271u, 273u, 275u,
			277u, 279u, 281u, 283u, 285u, 287u, 289u, 291u, 293u, 295u,
			297u, 299u, 301u, 303u, 305u, 307u, 309u, 311u, 313u, 315u,
			317u, 319u, 321u, 323u, 325u, 327u, 329u, 331u, 333u, 335u,
			337u, 339u, 341u, 343u, 345u, 347u, 349u, 351u, 13u, 25u,
			41u, 61u, 85u, 113u, 145u, 181u, 221u, 265u, 313u, 365u,
			421u, 481u, 545u, 613u, 685u, 761u, 841u, 925u, 1013u, 1105u,
			1201u, 1301u, 1405u, 1513u, 1625u, 1741u, 1861u, 1985u, 2113u, 2245u,
			2381u, 2521u, 2665u, 2813u, 2965u, 3121u, 3281u, 3445u, 3613u, 3785u,
			3961u, 4141u, 4325u, 4513u, 4705u, 4901u, 5101u, 5305u, 5513u, 5725u,
			5941u, 6161u, 6385u, 6613u, 6845u, 7081u, 7321u, 7565u, 7813u, 8065u,
			8321u, 8581u, 8845u, 9113u, 9385u, 9661u, 9941u, 10225u, 10513u, 10805u,
			11101u, 11401u, 11705u, 12013u, 12325u, 12641u, 12961u, 13285u, 13613u, 13945u,
			14281u, 14621u, 14965u, 15313u, 15665u, 16021u, 16381u, 16745u, 17113u, 17485u,
			17861u, 18241u, 18625u, 19013u, 19405u, 19801u, 20201u, 20605u, 21013u, 21425u,
			21841u, 22261u, 22685u, 23113u, 23545u, 23981u, 24421u, 24865u, 25313u, 25765u,
			26221u, 26681u, 27145u, 27613u, 28085u, 28561u, 29041u, 29525u, 30013u, 30505u,
			31001u, 31501u, 32005u, 32513u, 33025u, 33541u, 34061u, 34585u, 35113u, 35645u,
			36181u, 36721u, 37265u, 37813u, 38365u, 38921u, 39481u, 40045u, 40613u, 41185u,
			41761u, 42341u, 42925u, 43513u, 44105u, 44701u, 45301u, 45905u, 46513u, 47125u,
			47741u, 48361u, 48985u, 49613u, 50245u, 50881u, 51521u, 52165u, 52813u, 53465u,
			54121u, 54781u, 55445u, 56113u, 56785u, 57461u, 58141u, 58825u, 59513u, 60205u,
			60901u, 61601u, 63u, 129u, 231u, 377u, 575u, 833u, 1159u, 1561u,
			2047u, 2625u, 3303u, 4089u, 4991u, 6017u, 7175u, 8473u, 9919u, 11521u,
			13287u, 15225u, 17343u, 19649u, 22151u, 24857u, 27775u, 30913u, 34279u, 37881u,
			41727u, 45825u, 50183u, 54809u, 59711u, 64897u, 70375u, 76153u, 82239u, 88641u,
			95367u, 102425u, 109823u, 117569u, 125671u, 134137u, 142975u, 152193u, 161799u, 171801u,
			182207u, 193025u, 204263u, 215929u, 228031u, 240577u, 253575u, 267033u, 280959u, 295361u,
			310247u, 325625u, 341503u, 357889u, 374791u, 392217u, 410175u, 428673u, 447719u, 467321u,
			487487u, 508225u, 529543u, 551449u, 573951u, 597057u, 620775u, 645113u, 670079u, 695681u,
			721927u, 748825u, 776383u, 804609u, 833511u, 863097u, 893375u, 924353u, 956039u, 988441u,
			1021567u, 1055425u, 1090023u, 1125369u, 1161471u, 1198337u, 1235975u, 1274393u, 1313599u, 1353601u,
			1394407u, 1436025u, 1478463u, 1521729u, 1565831u, 1610777u, 1656575u, 1703233u, 1750759u, 1799161u,
			1848447u, 1898625u, 1949703u, 2001689u, 2054591u, 2108417u, 2163175u, 2218873u, 2275519u, 2333121u,
			2391687u, 2451225u, 2511743u, 2573249u, 2635751u, 2699257u, 2763775u, 2829313u, 2895879u, 2963481u,
			3032127u, 3101825u, 3172583u, 3244409u, 3317311u, 3391297u, 3466375u, 3542553u, 3619839u, 3698241u,
			3777767u, 3858425u, 3940223u, 4023169u, 4107271u, 4192537u, 4278975u, 4366593u, 4455399u, 4545401u,
			4636607u, 4729025u, 4822663u, 4917529u, 5013631u, 5110977u, 5209575u, 5309433u, 5410559u, 5512961u,
			5616647u, 5721625u, 5827903u, 5935489u, 6044391u, 6154617u, 6266175u, 6379073u, 6493319u, 6608921u,
			6725887u, 6844225u, 6963943u, 7085049u, 7207551u, 321u, 681u, 1289u, 2241u, 3649u,
			5641u, 8361u, 11969u, 16641u, 22569u, 29961u, 39041u, 50049u, 63241u, 78889u,
			97281u, 118721u, 143529u, 172041u, 204609u, 241601u, 283401u, 330409u, 383041u, 441729u,
			506921u, 579081u, 658689u, 746241u, 842249u, 947241u, 1061761u, 1186369u, 1321641u, 1468169u,
			1626561u, 1797441u, 1981449u, 2179241u, 2391489u, 2618881u, 2862121u, 3121929u, 3399041u, 3694209u,
			4008201u, 4341801u, 4695809u, 5071041u, 5468329u, 5888521u, 6332481u, 6801089u, 7295241u, 7815849u,
			8363841u, 8940161u, 9545769u, 10181641u, 10848769u, 11548161u, 12280841u, 13047849u, 13850241u, 14689089u,
			15565481u, 16480521u, 17435329u, 18431041u, 19468809u, 20549801u, 21675201u, 22846209u, 24064041u, 25329929u,
			26645121u, 28010881u, 29428489u, 30899241u, 32424449u, 34005441u, 35643561u, 37340169u, 39096641u, 40914369u,
			42794761u, 44739241u, 46749249u, 48826241u, 50971689u, 53187081u, 55473921u, 57833729u, 60268041u, 62778409u,
			65366401u, 68033601u, 70781609u, 73612041u, 76526529u, 79526721u, 82614281u, 85790889u, 89058241u, 92418049u,
			95872041u, 99421961u, 103069569u, 106816641u, 110664969u, 114616361u, 118672641u, 122835649u, 127107241u, 131489289u,
			135983681u, 140592321u, 145317129u, 150160041u, 155123009u, 160208001u, 165417001u, 170752009u, 176215041u, 181808129u,
			187533321u, 193392681u, 199388289u, 205522241u, 211796649u, 218213641u, 224775361u, 231483969u, 238341641u, 245350569u,
			252512961u, 259831041u, 267307049u, 274943241u, 282741889u, 290705281u, 298835721u, 307135529u, 315607041u, 324252609u,
			333074601u, 342075401u, 351257409u, 360623041u, 370174729u, 379914921u, 389846081u, 399970689u, 410291241u, 420810249u,
			431530241u, 442453761u, 453583369u, 464921641u, 476471169u, 488234561u, 500214441u, 512413449u, 524834241u, 537479489u,
			550351881u, 563454121u, 576788929u, 590359041u, 604167209u, 618216201u, 632508801u, 1683u, 3653u, 7183u,
			13073u, 22363u, 36365u, 56695u, 85305u, 124515u, 177045u, 246047u, 335137u, 448427u,
			590557u, 766727u, 982729u, 1244979u, 1560549u, 1937199u, 2383409u, 2908411u, 3522221u, 4235671u,
			5060441u, 6009091u, 7095093u, 8332863u, 9737793u, 11326283u, 13115773u, 15124775u, 17372905u, 19880915u,
			22670725u, 25765455u, 29189457u, 32968347u, 37129037u, 41699767u, 46710137u, 52191139u, 58175189u, 64696159u,
			71789409u, 79491819u, 87841821u, 96879431u, 106646281u, 117185651u, 128542501u, 140763503u, 153897073u, 167993403u,
			183104493u, 199284183u, 216588185u, 235074115u, 254801525u, 275831935u, 298228865u, 322057867u, 347386557u, 374284647u,
			402823977u, 433078547u, 465124549u, 499040399u, 534906769u, 572806619u, 612825229u, 655050231u, 699571641u, 746481891u,
			795875861u, 847850911u, 902506913u, 959946283u, 1020274013u, 1083597703u, 1150027593u, 1219676595u, 1292660325u, 1369097135u,
			1449108145u, 1532817275u, 1620351277u, 1711839767u, 1807415257u, 1907213187u, 2011371957u, 2120032959u, 8989u, 19825u,
			40081u, 75517u, 134245u, 227305u, 369305u, 579125u, 880685u, 1303777u, 1884961u, 2668525u,
			3707509u, 5064793u, 6814249u, 9041957u, 11847485u, 15345233u, 19665841u, 24957661u, 31388293u, 39146185u,
			48442297u, 59511829u, 72616013u, 88043969u, 106114625u, 127178701u, 151620757u, 179861305u, 212358985u, 249612805u,
			292164445u, 340600625u, 395555537u, 457713341u, 527810725u, 606639529u, 695049433u, 793950709u, 904317037u, 1027188385u,
			1163673953u, 1314955181u, 1482288821u, 1667010073u, 1870535785u, 2094367717u, 48639u, 108545u, 224143u, 433905u,
			795455u, 1392065u, 2340495u, 3800305u, 5984767u, 9173505u, 13726991u, 20103025u, 28875327u, 40754369u,
			56610575u, 77500017u, 104692735u, 139703809u, 184327311u, 240673265u, 311207743u, 398796225u, 506750351u, 638878193u,
			799538175u, 993696769u, 1226990095u, 1505789553u, 1837271615u, 2229491905u, 265729u, 598417u, 1256465u, 2485825u,
			4673345u, 8405905u, 14546705u, 24331777u, 39490049u, 62390545u, 96220561u, 145198913u, 214828609u, 312193553u,
			446304145u, 628496897u, 872893441u, 1196924561u, 1621925137u, 2173806145u, 1462563u, 3317445u, 7059735u, 14218905u,
			27298155u, 50250765u, 89129247u, 152951073u, 254831667u, 413442773u, 654862247u, 1014889769u, 1541911931u, 2300409629u,
			3375210671u, 8097453u, 18474633u, 39753273u, 81270333u, 158819253u, 298199265u, 540279585u, 948062325u, 1616336765u,
			45046719u, 103274625u, 224298231u, 464387817u, 921406335u, 1759885185u, 3248227095u, 251595969u, 579168825u, 1267854873u,
			2653649025u, 1409933619u
		};

		internal static readonly int[] window120 = new int[120]
		{
			2, 20, 55, 108, 178, 266, 372, 494, 635, 792,
			966, 1157, 1365, 1590, 1831, 2089, 2362, 2651, 2956, 3276,
			3611, 3961, 4325, 4703, 5094, 5499, 5916, 6346, 6788, 7241,
			7705, 8179, 8663, 9156, 9657, 10167, 10684, 11207, 11736, 12271,
			12810, 13353, 13899, 14447, 14997, 15547, 16098, 16648, 17197, 17744,
			18287, 18827, 19363, 19893, 20418, 20936, 21447, 21950, 22445, 22931,
			23407, 23874, 24330, 24774, 25208, 25629, 26039, 26435, 26819, 27190,
			27548, 27893, 28224, 28541, 28845, 29135, 29411, 29674, 29924, 30160,
			30384, 30594, 30792, 30977, 31151, 31313, 31463, 31602, 31731, 31849,
			31958, 32057, 32148, 32229, 32303, 32370, 32429, 32481, 32528, 32568,
			32604, 32634, 32661, 32683, 32701, 32717, 32729, 32740, 32748, 32754,
			32758, 32762, 32764, 32766, 32767, 32767, 32767, 32767, 32767, 32767
		};

		internal static readonly short[] logN400 = new short[21]
		{
			0, 0, 0, 0, 0, 0, 0, 0, 8, 8,
			8, 8, 16, 16, 16, 21, 21, 24, 29, 34,
			36
		};

		internal static readonly short[] cache_index50 = new short[105]
		{
			-1, -1, -1, -1, -1, -1, -1, -1, 0, 0,
			0, 0, 41, 41, 41, 82, 82, 123, 164, 200,
			222, 0, 0, 0, 0, 0, 0, 0, 0, 41,
			41, 41, 41, 123, 123, 123, 164, 164, 240, 266,
			283, 295, 41, 41, 41, 41, 41, 41, 41, 41,
			123, 123, 123, 123, 240, 240, 240, 266, 266, 305,
			318, 328, 336, 123, 123, 123, 123, 123, 123, 123,
			123, 240, 240, 240, 240, 305, 305, 305, 318, 318,
			343, 351, 358, 364, 240, 240, 240, 240, 240, 240,
			240, 240, 305, 305, 305, 305, 343, 343, 343, 351,
			351, 370, 376, 382, 387
		};

		internal static readonly byte[] cache_bits50 = new byte[392]
		{
			40, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			7, 40, 15, 23, 28, 31, 34, 36, 38, 39,
			41, 42, 43, 44, 45, 46, 47, 47, 49, 50,
			51, 52, 53, 54, 55, 55, 57, 58, 59, 60,
			61, 62, 63, 63, 65, 66, 67, 68, 69, 70,
			71, 71, 40, 20, 33, 41, 48, 53, 57, 61,
			64, 66, 69, 71, 73, 75, 76, 78, 80, 82,
			85, 87, 89, 91, 92, 94, 96, 98, 101, 103,
			105, 107, 108, 110, 112, 114, 117, 119, 121, 123,
			124, 126, 128, 40, 23, 39, 51, 60, 67, 73,
			79, 83, 87, 91, 94, 97, 100, 102, 105, 107,
			111, 115, 118, 121, 124, 126, 129, 131, 135, 139,
			142, 145, 148, 150, 153, 155, 159, 163, 166, 169,
			172, 174, 177, 179, 35, 28, 49, 65, 78, 89,
			99, 107, 114, 120, 126, 132, 136, 141, 145, 149,
			153, 159, 165, 171, 176, 180, 185, 189, 192, 199,
			205, 211, 216, 220, 225, 229, 232, 239, 245, 251,
			21, 33, 58, 79, 97, 112, 125, 137, 148, 157,
			166, 174, 182, 189, 195, 201, 207, 217, 227, 235,
			243, 251, 17, 35, 63, 86, 106, 123, 139, 152,
			165, 177, 187, 197, 206, 214, 222, 230, 237, 250,
			25, 31, 55, 75, 91, 105, 117, 128, 138, 146,
			154, 161, 168, 174, 180, 185, 190, 200, 208, 215,
			222, 229, 235, 240, 245, 255, 16, 36, 65, 89,
			110, 128, 144, 159, 173, 185, 196, 207, 217, 226,
			234, 242, 250, 11, 41, 74, 103, 128, 151, 172,
			191, 209, 225, 241, 255, 9, 43, 79, 110, 138,
			163, 186, 207, 227, 246, 12, 39, 71, 99, 123,
			144, 164, 182, 198, 214, 228, 241, 253, 9, 44,
			81, 113, 142, 168, 192, 214, 235, 255, 7, 49,
			90, 127, 160, 191, 220, 247, 6, 51, 95, 134,
			170, 203, 234, 7, 47, 87, 123, 155, 184, 212,
			237, 6, 52, 97, 137, 174, 208, 240, 5, 57,
			106, 151, 192, 231, 5, 59, 111, 158, 202, 243,
			5, 55, 103, 147, 187, 224, 5, 60, 113, 161,
			206, 248, 4, 65, 122, 175, 224, 4, 67, 127,
			182, 234
		};

		internal static readonly byte[] cache_caps50 = new byte[168]
		{
			224, 224, 224, 224, 224, 224, 224, 224, 160, 160,
			160, 160, 185, 185, 185, 178, 178, 168, 134, 61,
			37, 224, 224, 224, 224, 224, 224, 224, 224, 240,
			240, 240, 240, 207, 207, 207, 198, 198, 183, 144,
			66, 40, 160, 160, 160, 160, 160, 160, 160, 160,
			185, 185, 185, 185, 193, 193, 193, 183, 183, 172,
			138, 64, 38, 240, 240, 240, 240, 240, 240, 240,
			240, 207, 207, 207, 207, 204, 204, 204, 193, 193,
			180, 143, 66, 40, 185, 185, 185, 185, 185, 185,
			185, 185, 193, 193, 193, 193, 193, 193, 193, 183,
			183, 172, 138, 65, 39, 207, 207, 207, 207, 207,
			207, 207, 207, 204, 204, 204, 204, 201, 201, 201,
			188, 188, 176, 141, 66, 40, 193, 193, 193, 193,
			193, 193, 193, 193, 193, 193, 193, 193, 194, 194,
			194, 184, 184, 173, 139, 65, 39, 204, 204, 204,
			204, 204, 204, 204, 204, 201, 201, 201, 201, 198,
			198, 198, 187, 187, 175, 140, 66, 40
		};

		internal static readonly short[] fft_twiddles48000_960 = new short[960]
		{
			32767, 0, 32766, -429, 32757, -858, 32743, -1287, 32724, -1715,
			32698, -2143, 32667, -2570, 32631, -2998, 32588, -3425, 32541, -3851,
			32488, -4277, 32429, -4701, 32364, -5125, 32295, -5548, 32219, -5971,
			32138, -6393, 32051, -6813, 31960, -7231, 31863, -7650, 31760, -8067,
			31652, -8481, 31539, -8895, 31419, -9306, 31294, -9716, 31165, -10126,
			31030, -10532, 30889, -10937, 30743, -11340, 30592, -11741, 30436, -12141,
			30274, -12540, 30107, -12935, 29936, -13328, 29758, -13718, 29577, -14107,
			29390, -14493, 29197, -14875, 29000, -15257, 28797, -15635, 28590, -16010,
			28379, -16384, 28162, -16753, 27940, -17119, 27714, -17484, 27482, -17845,
			27246, -18205, 27006, -18560, 26760, -18911, 26510, -19260, 26257, -19606,
			25997, -19947, 25734, -20286, 25466, -20621, 25194, -20952, 24918, -21281,
			24637, -21605, 24353, -21926, 24063, -22242, 23770, -22555, 23473, -22865,
			23171, -23171, 22866, -23472, 22557, -23769, 22244, -24063, 21927, -24352,
			21606, -24636, 21282, -24917, 20954, -25194, 20622, -25465, 20288, -25733,
			19949, -25997, 19607, -26255, 19261, -26509, 18914, -26760, 18561, -27004,
			18205, -27246, 17846, -27481, 17485, -27713, 17122, -27940, 16755, -28162,
			16385, -28378, 16012, -28590, 15636, -28797, 15258, -28999, 14878, -29197,
			14494, -29389, 14108, -29576, 13720, -29757, 13329, -29934, 12937, -30107,
			12540, -30274, 12142, -30435, 11744, -30592, 11342, -30743, 10939, -30889,
			10534, -31030, 10127, -31164, 9718, -31294, 9307, -31418, 8895, -31537,
			8482, -31652, 8067, -31759, 7650, -31862, 7233, -31960, 6815, -32051,
			6393, -32138, 5973, -32219, 5549, -32294, 5127, -32364, 4703, -32429,
			4278, -32487, 3852, -32541, 3426, -32588, 2999, -32630, 2572, -32667,
			2144, -32698, 1716, -32724, 1287, -32742, 860, -32757, 430, -32766,
			0, -32767, -429, -32766, -858, -32757, -1287, -32743, -1715, -32724,
			-2143, -32698, -2570, -32667, -2998, -32631, -3425, -32588, -3851, -32541,
			-4277, -32488, -4701, -32429, -5125, -32364, -5548, -32295, -5971, -32219,
			-6393, -32138, -6813, -32051, -7231, -31960, -7650, -31863, -8067, -31760,
			-8481, -31652, -8895, -31539, -9306, -31419, -9716, -31294, -10126, -31165,
			-10532, -31030, -10937, -30889, -11340, -30743, -11741, -30592, -12141, -30436,
			-12540, -30274, -12935, -30107, -13328, -29936, -13718, -29758, -14107, -29577,
			-14493, -29390, -14875, -29197, -15257, -29000, -15635, -28797, -16010, -28590,
			-16384, -28379, -16753, -28162, -17119, -27940, -17484, -27714, -17845, -27482,
			-18205, -27246, -18560, -27006, -18911, -26760, -19260, -26510, -19606, -26257,
			-19947, -25997, -20286, -25734, -20621, -25466, -20952, -25194, -21281, -24918,
			-21605, -24637, -21926, -24353, -22242, -24063, -22555, -23770, -22865, -23473,
			-23171, -23171, -23472, -22866, -23769, -22557, -24063, -22244, -24352, -21927,
			-24636, -21606, -24917, -21282, -25194, -20954, -25465, -20622, -25733, -20288,
			-25997, -19949, -26255, -19607, -26509, -19261, -26760, -18914, -27004, -18561,
			-27246, -18205, -27481, -17846, -27713, -17485, -27940, -17122, -28162, -16755,
			-28378, -16385, -28590, -16012, -28797, -15636, -28999, -15258, -29197, -14878,
			-29389, -14494, -29576, -14108, -29757, -13720, -29934, -13329, -30107, -12937,
			-30274, -12540, -30435, -12142, -30592, -11744, -30743, -11342, -30889, -10939,
			-31030, -10534, -31164, -10127, -31294, -9718, -31418, -9307, -31537, -8895,
			-31652, -8482, -31759, -8067, -31862, -7650, -31960, -7233, -32051, -6815,
			-32138, -6393, -32219, -5973, -32294, -5549, -32364, -5127, -32429, -4703,
			-32487, -4278, -32541, -3852, -32588, -3426, -32630, -2999, -32667, -2572,
			-32698, -2144, -32724, -1716, -32742, -1287, -32757, -860, -32766, -430,
			-32767, 0, -32766, 429, -32757, 858, -32743, 1287, -32724, 1715,
			-32698, 2143, -32667, 2570, -32631, 2998, -32588, 3425, -32541, 3851,
			-32488, 4277, -32429, 4701, -32364, 5125, -32295, 5548, -32219, 5971,
			-32138, 6393, -32051, 6813, -31960, 7231, -31863, 7650, -31760, 8067,
			-31652, 8481, -31539, 8895, -31419, 9306, -31294, 9716, -31165, 10126,
			-31030, 10532, -30889, 10937, -30743, 11340, -30592, 11741, -30436, 12141,
			-30274, 12540, -30107, 12935, -29936, 13328, -29758, 13718, -29577, 14107,
			-29390, 14493, -29197, 14875, -29000, 15257, -28797, 15635, -28590, 16010,
			-28379, 16384, -28162, 16753, -27940, 17119, -27714, 17484, -27482, 17845,
			-27246, 18205, -27006, 18560, -26760, 18911, -26510, 19260, -26257, 19606,
			-25997, 19947, -25734, 20286, -25466, 20621, -25194, 20952, -24918, 21281,
			-24637, 21605, -24353, 21926, -24063, 22242, -23770, 22555, -23473, 22865,
			-23171, 23171, -22866, 23472, -22557, 23769, -22244, 24063, -21927, 24352,
			-21606, 24636, -21282, 24917, -20954, 25194, -20622, 25465, -20288, 25733,
			-19949, 25997, -19607, 26255, -19261, 26509, -18914, 26760, -18561, 27004,
			-18205, 27246, -17846, 27481, -17485, 27713, -17122, 27940, -16755, 28162,
			-16385, 28378, -16012, 28590, -15636, 28797, -15258, 28999, -14878, 29197,
			-14494, 29389, -14108, 29576, -13720, 29757, -13329, 29934, -12937, 30107,
			-12540, 30274, -12142, 30435, -11744, 30592, -11342, 30743, -10939, 30889,
			-10534, 31030, -10127, 31164, -9718, 31294, -9307, 31418, -8895, 31537,
			-8482, 31652, -8067, 31759, -7650, 31862, -7233, 31960, -6815, 32051,
			-6393, 32138, -5973, 32219, -5549, 32294, -5127, 32364, -4703, 32429,
			-4278, 32487, -3852, 32541, -3426, 32588, -2999, 32630, -2572, 32667,
			-2144, 32698, -1716, 32724, -1287, 32742, -860, 32757, -430, 32766,
			0, 32767, 429, 32766, 858, 32757, 1287, 32743, 1715, 32724,
			2143, 32698, 2570, 32667, 2998, 32631, 3425, 32588, 3851, 32541,
			4277, 32488, 4701, 32429, 5125, 32364, 5548, 32295, 5971, 32219,
			6393, 32138, 6813, 32051, 7231, 31960, 7650, 31863, 8067, 31760,
			8481, 31652, 8895, 31539, 9306, 31419, 9716, 31294, 10126, 31165,
			10532, 31030, 10937, 30889, 11340, 30743, 11741, 30592, 12141, 30436,
			12540, 30274, 12935, 30107, 13328, 29936, 13718, 29758, 14107, 29577,
			14493, 29390, 14875, 29197, 15257, 29000, 15635, 28797, 16010, 28590,
			16384, 28379, 16753, 28162, 17119, 27940, 17484, 27714, 17845, 27482,
			18205, 27246, 18560, 27006, 18911, 26760, 19260, 26510, 19606, 26257,
			19947, 25997, 20286, 25734, 20621, 25466, 20952, 25194, 21281, 24918,
			21605, 24637, 21926, 24353, 22242, 24063, 22555, 23770, 22865, 23473,
			23171, 23171, 23472, 22866, 23769, 22557, 24063, 22244, 24352, 21927,
			24636, 21606, 24917, 21282, 25194, 20954, 25465, 20622, 25733, 20288,
			25997, 19949, 26255, 19607, 26509, 19261, 26760, 18914, 27004, 18561,
			27246, 18205, 27481, 17846, 27713, 17485, 27940, 17122, 28162, 16755,
			28378, 16385, 28590, 16012, 28797, 15636, 28999, 15258, 29197, 14878,
			29389, 14494, 29576, 14108, 29757, 13720, 29934, 13329, 30107, 12937,
			30274, 12540, 30435, 12142, 30592, 11744, 30743, 11342, 30889, 10939,
			31030, 10534, 31164, 10127, 31294, 9718, 31418, 9307, 31537, 8895,
			31652, 8482, 31759, 8067, 31862, 7650, 31960, 7233, 32051, 6815,
			32138, 6393, 32219, 5973, 32294, 5549, 32364, 5127, 32429, 4703,
			32487, 4278, 32541, 3852, 32588, 3426, 32630, 2999, 32667, 2572,
			32698, 2144, 32724, 1716, 32742, 1287, 32757, 860, 32766, 430
		};

		internal static readonly short[] fft_bitrev480 = new short[480]
		{
			0, 96, 192, 288, 384, 32, 128, 224, 320, 416,
			64, 160, 256, 352, 448, 8, 104, 200, 296, 392,
			40, 136, 232, 328, 424, 72, 168, 264, 360, 456,
			16, 112, 208, 304, 400, 48, 144, 240, 336, 432,
			80, 176, 272, 368, 464, 24, 120, 216, 312, 408,
			56, 152, 248, 344, 440, 88, 184, 280, 376, 472,
			4, 100, 196, 292, 388, 36, 132, 228, 324, 420,
			68, 164, 260, 356, 452, 12, 108, 204, 300, 396,
			44, 140, 236, 332, 428, 76, 172, 268, 364, 460,
			20, 116, 212, 308, 404, 52, 148, 244, 340, 436,
			84, 180, 276, 372, 468, 28, 124, 220, 316, 412,
			60, 156, 252, 348, 444, 92, 188, 284, 380, 476,
			1, 97, 193, 289, 385, 33, 129, 225, 321, 417,
			65, 161, 257, 353, 449, 9, 105, 201, 297, 393,
			41, 137, 233, 329, 425, 73, 169, 265, 361, 457,
			17, 113, 209, 305, 401, 49, 145, 241, 337, 433,
			81, 177, 273, 369, 465, 25, 121, 217, 313, 409,
			57, 153, 249, 345, 441, 89, 185, 281, 377, 473,
			5, 101, 197, 293, 389, 37, 133, 229, 325, 421,
			69, 165, 261, 357, 453, 13, 109, 205, 301, 397,
			45, 141, 237, 333, 429, 77, 173, 269, 365, 461,
			21, 117, 213, 309, 405, 53, 149, 245, 341, 437,
			85, 181, 277, 373, 469, 29, 125, 221, 317, 413,
			61, 157, 253, 349, 445, 93, 189, 285, 381, 477,
			2, 98, 194, 290, 386, 34, 130, 226, 322, 418,
			66, 162, 258, 354, 450, 10, 106, 202, 298, 394,
			42, 138, 234, 330, 426, 74, 170, 266, 362, 458,
			18, 114, 210, 306, 402, 50, 146, 242, 338, 434,
			82, 178, 274, 370, 466, 26, 122, 218, 314, 410,
			58, 154, 250, 346, 442, 90, 186, 282, 378, 474,
			6, 102, 198, 294, 390, 38, 134, 230, 326, 422,
			70, 166, 262, 358, 454, 14, 110, 206, 302, 398,
			46, 142, 238, 334, 430, 78, 174, 270, 366, 462,
			22, 118, 214, 310, 406, 54, 150, 246, 342, 438,
			86, 182, 278, 374, 470, 30, 126, 222, 318, 414,
			62, 158, 254, 350, 446, 94, 190, 286, 382, 478,
			3, 99, 195, 291, 387, 35, 131, 227, 323, 419,
			67, 163, 259, 355, 451, 11, 107, 203, 299, 395,
			43, 139, 235, 331, 427, 75, 171, 267, 363, 459,
			19, 115, 211, 307, 403, 51, 147, 243, 339, 435,
			83, 179, 275, 371, 467, 27, 123, 219, 315, 411,
			59, 155, 251, 347, 443, 91, 187, 283, 379, 475,
			7, 103, 199, 295, 391, 39, 135, 231, 327, 423,
			71, 167, 263, 359, 455, 15, 111, 207, 303, 399,
			47, 143, 239, 335, 431, 79, 175, 271, 367, 463,
			23, 119, 215, 311, 407, 55, 151, 247, 343, 439,
			87, 183, 279, 375, 471, 31, 127, 223, 319, 415,
			63, 159, 255, 351, 447, 95, 191, 287, 383, 479
		};

		internal static readonly short[] fft_bitrev240 = new short[240]
		{
			0, 48, 96, 144, 192, 16, 64, 112, 160, 208,
			32, 80, 128, 176, 224, 4, 52, 100, 148, 196,
			20, 68, 116, 164, 212, 36, 84, 132, 180, 228,
			8, 56, 104, 152, 200, 24, 72, 120, 168, 216,
			40, 88, 136, 184, 232, 12, 60, 108, 156, 204,
			28, 76, 124, 172, 220, 44, 92, 140, 188, 236,
			1, 49, 97, 145, 193, 17, 65, 113, 161, 209,
			33, 81, 129, 177, 225, 5, 53, 101, 149, 197,
			21, 69, 117, 165, 213, 37, 85, 133, 181, 229,
			9, 57, 105, 153, 201, 25, 73, 121, 169, 217,
			41, 89, 137, 185, 233, 13, 61, 109, 157, 205,
			29, 77, 125, 173, 221, 45, 93, 141, 189, 237,
			2, 50, 98, 146, 194, 18, 66, 114, 162, 210,
			34, 82, 130, 178, 226, 6, 54, 102, 150, 198,
			22, 70, 118, 166, 214, 38, 86, 134, 182, 230,
			10, 58, 106, 154, 202, 26, 74, 122, 170, 218,
			42, 90, 138, 186, 234, 14, 62, 110, 158, 206,
			30, 78, 126, 174, 222, 46, 94, 142, 190, 238,
			3, 51, 99, 147, 195, 19, 67, 115, 163, 211,
			35, 83, 131, 179, 227, 7, 55, 103, 151, 199,
			23, 71, 119, 167, 215, 39, 87, 135, 183, 231,
			11, 59, 107, 155, 203, 27, 75, 123, 171, 219,
			43, 91, 139, 187, 235, 15, 63, 111, 159, 207,
			31, 79, 127, 175, 223, 47, 95, 143, 191, 239
		};

		internal static readonly short[] fft_bitrev120 = new short[120]
		{
			0, 24, 48, 72, 96, 8, 32, 56, 80, 104,
			16, 40, 64, 88, 112, 4, 28, 52, 76, 100,
			12, 36, 60, 84, 108, 20, 44, 68, 92, 116,
			1, 25, 49, 73, 97, 9, 33, 57, 81, 105,
			17, 41, 65, 89, 113, 5, 29, 53, 77, 101,
			13, 37, 61, 85, 109, 21, 45, 69, 93, 117,
			2, 26, 50, 74, 98, 10, 34, 58, 82, 106,
			18, 42, 66, 90, 114, 6, 30, 54, 78, 102,
			14, 38, 62, 86, 110, 22, 46, 70, 94, 118,
			3, 27, 51, 75, 99, 11, 35, 59, 83, 107,
			19, 43, 67, 91, 115, 7, 31, 55, 79, 103,
			15, 39, 63, 87, 111, 23, 47, 71, 95, 119
		};

		internal static readonly short[] fft_bitrev60 = new short[60]
		{
			0, 12, 24, 36, 48, 4, 16, 28, 40, 52,
			8, 20, 32, 44, 56, 1, 13, 25, 37, 49,
			5, 17, 29, 41, 53, 9, 21, 33, 45, 57,
			2, 14, 26, 38, 50, 6, 18, 30, 42, 54,
			10, 22, 34, 46, 58, 3, 15, 27, 39, 51,
			7, 19, 31, 43, 55, 11, 23, 35, 47, 59
		};

		internal static readonly FFTState fft_state48000_960_0 = new FFTState
		{
			nfft = 480,
			scale = 17476,
			scale_shift = 8,
			shift = -1,
			factors = new short[16]
			{
				5, 96, 3, 32, 4, 8, 2, 4, 4, 1,
				0, 0, 0, 0, 0, 0
			},
			bitrev = fft_bitrev480,
			twiddles = fft_twiddles48000_960
		};

		internal static readonly FFTState fft_state48000_960_1 = new FFTState
		{
			nfft = 240,
			scale = 17476,
			scale_shift = 7,
			shift = 1,
			factors = new short[16]
			{
				5, 48, 3, 16, 4, 4, 4, 1, 0, 0,
				0, 0, 0, 0, 0, 0
			},
			bitrev = fft_bitrev240,
			twiddles = fft_twiddles48000_960
		};

		internal static readonly FFTState fft_state48000_960_2 = new FFTState
		{
			nfft = 120,
			scale = 17476,
			scale_shift = 6,
			shift = 2,
			factors = new short[16]
			{
				5, 24, 3, 8, 2, 4, 4, 1, 0, 0,
				0, 0, 0, 0, 0, 0
			},
			bitrev = fft_bitrev120,
			twiddles = fft_twiddles48000_960
		};

		internal static readonly FFTState fft_state48000_960_3 = new FFTState
		{
			nfft = 60,
			scale = 17476,
			scale_shift = 5,
			shift = 3,
			factors = new short[16]
			{
				5, 12, 3, 4, 4, 1, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0
			},
			bitrev = fft_bitrev60,
			twiddles = fft_twiddles48000_960
		};

		internal static readonly short[] mdct_twiddles960 = new short[1800]
		{
			32767, 32767, 32767, 32766, 32765, 32763, 32761, 32759, 32756, 32753,
			32750, 32746, 32742, 32738, 32733, 32728, 32722, 32717, 32710, 32704,
			32697, 32690, 32682, 32674, 32666, 32657, 32648, 32639, 32629, 32619,
			32609, 32598, 32587, 32576, 32564, 32552, 32539, 32526, 32513, 32500,
			32486, 32472, 32457, 32442, 32427, 32411, 32395, 32379, 32362, 32345,
			32328, 32310, 32292, 32274, 32255, 32236, 32217, 32197, 32177, 32157,
			32136, 32115, 32093, 32071, 32049, 32027, 32004, 31981, 31957, 31933,
			31909, 31884, 31859, 31834, 31809, 31783, 31756, 31730, 31703, 31676,
			31648, 31620, 31592, 31563, 31534, 31505, 31475, 31445, 31415, 31384,
			31353, 31322, 31290, 31258, 31226, 31193, 31160, 31127, 31093, 31059,
			31025, 30990, 30955, 30920, 30884, 30848, 30812, 30775, 30738, 30701,
			30663, 30625, 30587, 30548, 30509, 30470, 30430, 30390, 30350, 30309,
			30269, 30227, 30186, 30144, 30102, 30059, 30016, 29973, 29930, 29886,
			29842, 29797, 29752, 29707, 29662, 29616, 29570, 29524, 29477, 29430,
			29383, 29335, 29287, 29239, 29190, 29142, 29092, 29043, 28993, 28943,
			28892, 28842, 28791, 28739, 28688, 28636, 28583, 28531, 28478, 28425,
			28371, 28317, 28263, 28209, 28154, 28099, 28044, 27988, 27932, 27876,
			27820, 27763, 27706, 27648, 27591, 27533, 27474, 27416, 27357, 27298,
			27238, 27178, 27118, 27058, 26997, 26936, 26875, 26814, 26752, 26690,
			26628, 26565, 26502, 26439, 26375, 26312, 26247, 26183, 26119, 26054,
			25988, 25923, 25857, 25791, 25725, 25658, 25592, 25524, 25457, 25389,
			25322, 25253, 25185, 25116, 25047, 24978, 24908, 24838, 24768, 24698,
			24627, 24557, 24485, 24414, 24342, 24270, 24198, 24126, 24053, 23980,
			23907, 23834, 23760, 23686, 23612, 23537, 23462, 23387, 23312, 23237,
			23161, 23085, 23009, 22932, 22856, 22779, 22701, 22624, 22546, 22468,
			22390, 22312, 22233, 22154, 22075, 21996, 21916, 21836, 21756, 21676,
			21595, 21515, 21434, 21352, 21271, 21189, 21107, 21025, 20943, 20860,
			20777, 20694, 20611, 20528, 20444, 20360, 20276, 20192, 20107, 20022,
			19937, 19852, 19767, 19681, 19595, 19509, 19423, 19336, 19250, 19163,
			19076, 18988, 18901, 18813, 18725, 18637, 18549, 18460, 18372, 18283,
			18194, 18104, 18015, 17925, 17835, 17745, 17655, 17565, 17474, 17383,
			17292, 17201, 17110, 17018, 16927, 16835, 16743, 16650, 16558, 16465,
			16372, 16279, 16186, 16093, 15999, 15906, 15812, 15718, 15624, 15529,
			15435, 15340, 15245, 15150, 15055, 14960, 14864, 14769, 14673, 14577,
			14481, 14385, 14288, 14192, 14095, 13998, 13901, 13804, 13706, 13609,
			13511, 13414, 13316, 13218, 13119, 13021, 12923, 12824, 12725, 12626,
			12527, 12428, 12329, 12230, 12130, 12030, 11930, 11831, 11730, 11630,
			11530, 11430, 11329, 11228, 11128, 11027, 10926, 10824, 10723, 10622,
			10520, 10419, 10317, 10215, 10113, 10011, 9909, 9807, 9704, 9602,
			9499, 9397, 9294, 9191, 9088, 8985, 8882, 8778, 8675, 8572,
			8468, 8364, 8261, 8157, 8053, 7949, 7845, 7741, 7637, 7532,
			7428, 7323, 7219, 7114, 7009, 6905, 6800, 6695, 6590, 6485,
			6380, 6274, 6169, 6064, 5958, 5853, 5747, 5642, 5536, 5430,
			5325, 5219, 5113, 5007, 4901, 4795, 4689, 4583, 4476, 4370,
			4264, 4157, 4051, 3945, 3838, 3732, 3625, 3518, 3412, 3305,
			3198, 3092, 2985, 2878, 2771, 2664, 2558, 2451, 2344, 2237,
			2130, 2023, 1916, 1809, 1702, 1594, 1487, 1380, 1273, 1166,
			1059, 952, 844, 737, 630, 523, 416, 308, 201, 94,
			-13, -121, -228, -335, -442, -550, -657, -764, -871, -978,
			-1086, -1193, -1300, -1407, -1514, -1621, -1728, -1835, -1942, -2049,
			-2157, -2263, -2370, -2477, -2584, -2691, -2798, -2905, -3012, -3118,
			-3225, -3332, -3439, -3545, -3652, -3758, -3865, -3971, -4078, -4184,
			-4290, -4397, -4503, -4609, -4715, -4821, -4927, -5033, -5139, -5245,
			-5351, -5457, -5562, -5668, -5774, -5879, -5985, -6090, -6195, -6301,
			-6406, -6511, -6616, -6721, -6826, -6931, -7036, -7140, -7245, -7349,
			-7454, -7558, -7663, -7767, -7871, -7975, -8079, -8183, -8287, -8390,
			-8494, -8597, -8701, -8804, -8907, -9011, -9114, -9217, -9319, -9422,
			-9525, -9627, -9730, -9832, -9934, -10037, -10139, -10241, -10342, -10444,
			-10546, -10647, -10748, -10850, -10951, -11052, -11153, -11253, -11354, -11455,
			-11555, -11655, -11756, -11856, -11955, -12055, -12155, -12254, -12354, -12453,
			-12552, -12651, -12750, -12849, -12947, -13046, -13144, -13242, -13340, -13438,
			-13536, -13633, -13731, -13828, -13925, -14022, -14119, -14216, -14312, -14409,
			-14505, -14601, -14697, -14793, -14888, -14984, -15079, -15174, -15269, -15364,
			-15459, -15553, -15647, -15741, -15835, -15929, -16023, -16116, -16210, -16303,
			-16396, -16488, -16581, -16673, -16766, -16858, -16949, -17041, -17133, -17224,
			-17315, -17406, -17497, -17587, -17678, -17768, -17858, -17948, -18037, -18127,
			-18216, -18305, -18394, -18483, -18571, -18659, -18747, -18835, -18923, -19010,
			-19098, -19185, -19271, -19358, -19444, -19531, -19617, -19702, -19788, -19873,
			-19959, -20043, -20128, -20213, -20297, -20381, -20465, -20549, -20632, -20715,
			-20798, -20881, -20963, -21046, -21128, -21210, -21291, -21373, -21454, -21535,
			-21616, -21696, -21776, -21856, -21936, -22016, -22095, -22174, -22253, -22331,
			-22410, -22488, -22566, -22643, -22721, -22798, -22875, -22951, -23028, -23104,
			-23180, -23256, -23331, -23406, -23481, -23556, -23630, -23704, -23778, -23852,
			-23925, -23998, -24071, -24144, -24216, -24288, -24360, -24432, -24503, -24574,
			-24645, -24716, -24786, -24856, -24926, -24995, -25064, -25133, -25202, -25270,
			-25339, -25406, -25474, -25541, -25608, -25675, -25742, -25808, -25874, -25939,
			-26005, -26070, -26135, -26199, -26264, -26327, -26391, -26455, -26518, -26581,
			-26643, -26705, -26767, -26829, -26891, -26952, -27013, -27073, -27133, -27193,
			-27253, -27312, -27372, -27430, -27489, -27547, -27605, -27663, -27720, -27777,
			-27834, -27890, -27946, -28002, -28058, -28113, -28168, -28223, -28277, -28331,
			-28385, -28438, -28491, -28544, -28596, -28649, -28701, -28752, -28803, -28854,
			-28905, -28955, -29006, -29055, -29105, -29154, -29203, -29251, -29299, -29347,
			-29395, -29442, -29489, -29535, -29582, -29628, -29673, -29719, -29764, -29808,
			-29853, -29897, -29941, -29984, -30027, -30070, -30112, -30154, -30196, -30238,
			-30279, -30320, -30360, -30400, -30440, -30480, -30519, -30558, -30596, -30635,
			-30672, -30710, -30747, -30784, -30821, -30857, -30893, -30929, -30964, -30999,
			-31033, -31068, -31102, -31135, -31168, -31201, -31234, -31266, -31298, -31330,
			-31361, -31392, -31422, -31453, -31483, -31512, -31541, -31570, -31599, -31627,
			-31655, -31682, -31710, -31737, -31763, -31789, -31815, -31841, -31866, -31891,
			-31915, -31939, -31963, -31986, -32010, -32032, -32055, -32077, -32099, -32120,
			-32141, -32162, -32182, -32202, -32222, -32241, -32260, -32279, -32297, -32315,
			-32333, -32350, -32367, -32383, -32399, -32415, -32431, -32446, -32461, -32475,
			-32489, -32503, -32517, -32530, -32542, -32555, -32567, -32579, -32590, -32601,
			-32612, -32622, -32632, -32641, -32651, -32659, -32668, -32676, -32684, -32692,
			-32699, -32706, -32712, -32718, -32724, -32729, -32734, -32739, -32743, -32747,
			-32751, -32754, -32757, -32760, -32762, -32764, -32765, -32767, -32767, -32767,
			32767, 32767, 32765, 32761, 32756, 32750, 32742, 32732, 32722, 32710,
			32696, 32681, 32665, 32647, 32628, 32608, 32586, 32562, 32538, 32512,
			32484, 32455, 32425, 32393, 32360, 32326, 32290, 32253, 32214, 32174,
			32133, 32090, 32046, 32001, 31954, 31906, 31856, 31805, 31753, 31700,
			31645, 31588, 31530, 31471, 31411, 31349, 31286, 31222, 31156, 31089,
			31020, 30951, 30880, 30807, 30733, 30658, 30582, 30504, 30425, 30345,
			30263, 30181, 30096, 30011, 29924, 29836, 29747, 29656, 29564, 29471,
			29377, 29281, 29184, 29086, 28987, 28886, 28784, 28681, 28577, 28471,
			28365, 28257, 28147, 28037, 27925, 27812, 27698, 27583, 27467, 27349,
			27231, 27111, 26990, 26868, 26744, 26620, 26494, 26367, 26239, 26110,
			25980, 25849, 25717, 25583, 25449, 25313, 25176, 25038, 24900, 24760,
			24619, 24477, 24333, 24189, 24044, 23898, 23751, 23602, 23453, 23303,
			23152, 22999, 22846, 22692, 22537, 22380, 22223, 22065, 21906, 21746,
			21585, 21423, 21261, 21097, 20933, 20767, 20601, 20434, 20265, 20096,
			19927, 19756, 19584, 19412, 19239, 19065, 18890, 18714, 18538, 18361,
			18183, 18004, 17824, 17644, 17463, 17281, 17098, 16915, 16731, 16546,
			16361, 16175, 15988, 15800, 15612, 15423, 15234, 15043, 14852, 14661,
			14469, 14276, 14083, 13889, 13694, 13499, 13303, 13107, 12910, 12713,
			12515, 12317, 12118, 11918, 11718, 11517, 11316, 11115, 10913, 10710,
			10508, 10304, 10100, 9896, 9691, 9486, 9281, 9075, 8869, 8662,
			8455, 8248, 8040, 7832, 7623, 7415, 7206, 6996, 6787, 6577,
			6366, 6156, 5945, 5734, 5523, 5311, 5100, 4888, 4675, 4463,
			4251, 4038, 3825, 3612, 3399, 3185, 2972, 2758, 2544, 2330,
			2116, 1902, 1688, 1474, 1260, 1045, 831, 617, 402, 188,
			-27, -241, -456, -670, -885, -1099, -1313, -1528, -1742, -1956,
			-2170, -2384, -2598, -2811, -3025, -3239, -3452, -3665, -3878, -4091,
			-4304, -4516, -4728, -4941, -5153, -5364, -5576, -5787, -5998, -6209,
			-6419, -6629, -6839, -7049, -7258, -7467, -7676, -7884, -8092, -8300,
			-8507, -8714, -8920, -9127, -9332, -9538, -9743, -9947, -10151, -10355,
			-10558, -10761, -10963, -11165, -11367, -11568, -11768, -11968, -12167, -12366,
			-12565, -12762, -12960, -13156, -13352, -13548, -13743, -13937, -14131, -14324,
			-14517, -14709, -14900, -15091, -15281, -15470, -15659, -15847, -16035, -16221,
			-16407, -16593, -16777, -16961, -17144, -17326, -17508, -17689, -17869, -18049,
			-18227, -18405, -18582, -18758, -18934, -19108, -19282, -19455, -19627, -19799,
			-19969, -20139, -20308, -20475, -20642, -20809, -20974, -21138, -21301, -21464,
			-21626, -21786, -21946, -22105, -22263, -22420, -22575, -22730, -22884, -23037,
			-23189, -23340, -23490, -23640, -23788, -23935, -24080, -24225, -24369, -24512,
			-24654, -24795, -24934, -25073, -25211, -25347, -25482, -25617, -25750, -25882,
			-26013, -26143, -26272, -26399, -26526, -26651, -26775, -26898, -27020, -27141,
			-27260, -27379, -27496, -27612, -27727, -27841, -27953, -28065, -28175, -28284,
			-28391, -28498, -28603, -28707, -28810, -28911, -29012, -29111, -29209, -29305,
			-29401, -29495, -29587, -29679, -29769, -29858, -29946, -30032, -30118, -30201,
			-30284, -30365, -30445, -30524, -30601, -30677, -30752, -30825, -30897, -30968,
			-31038, -31106, -31172, -31238, -31302, -31365, -31426, -31486, -31545, -31602,
			-31658, -31713, -31766, -31818, -31869, -31918, -31966, -32012, -32058, -32101,
			-32144, -32185, -32224, -32262, -32299, -32335, -32369, -32401, -32433, -32463,
			-32491, -32518, -32544, -32568, -32591, -32613, -32633, -32652, -32669, -32685,
			-32700, -32713, -32724, -32735, -32744, -32751, -32757, -32762, -32766, -32767,
			32767, 32764, 32755, 32741, 32720, 32694, 32663, 32626, 32583, 32535,
			32481, 32421, 32356, 32286, 32209, 32128, 32041, 31948, 31850, 31747,
			31638, 31523, 31403, 31278, 31148, 31012, 30871, 30724, 30572, 30415,
			30253, 30086, 29913, 29736, 29553, 29365, 29172, 28974, 28771, 28564,
			28351, 28134, 27911, 27684, 27452, 27216, 26975, 26729, 26478, 26223,
			25964, 25700, 25432, 25159, 24882, 24601, 24315, 24026, 23732, 23434,
			23133, 22827, 22517, 22204, 21886, 21565, 21240, 20912, 20580, 20244,
			19905, 19563, 19217, 18868, 18516, 18160, 17802, 17440, 17075, 16708,
			16338, 15964, 15588, 15210, 14829, 14445, 14059, 13670, 13279, 12886,
			12490, 12093, 11693, 11291, 10888, 10482, 10075, 9666, 9255, 8843,
			8429, 8014, 7597, 7180, 6760, 6340, 5919, 5496, 5073, 4649,
			4224, 3798, 3372, 2945, 2517, 2090, 1661, 1233, 804, 375,
			-54, -483, -911, -1340, -1768, -2197, -2624, -3052, -3479, -3905,
			-4330, -4755, -5179, -5602, -6024, -6445, -6865, -7284, -7702, -8118,
			-8533, -8946, -9358, -9768, -10177, -10584, -10989, -11392, -11793, -12192,
			-12589, -12984, -13377, -13767, -14155, -14541, -14924, -15305, -15683, -16058,
			-16430, -16800, -17167, -17531, -17892, -18249, -18604, -18956, -19304, -19649,
			-19990, -20329, -20663, -20994, -21322, -21646, -21966, -22282, -22595, -22904,
			-23208, -23509, -23806, -24099, -24387, -24672, -24952, -25228, -25499, -25766,
			-26029, -26288, -26541, -26791, -27035, -27275, -27511, -27741, -27967, -28188,
			-28405, -28616, -28823, -29024, -29221, -29412, -29599, -29780, -29957, -30128,
			-30294, -30455, -30611, -30761, -30906, -31046, -31181, -31310, -31434, -31552,
			-31665, -31773, -31875, -31972, -32063, -32149, -32229, -32304, -32373, -32437,
			-32495, -32547, -32594, -32635, -32671, -32701, -32726, -32745, -32758, -32766,
			32767, 32754, 32717, 32658, 32577, 32473, 32348, 32200, 32029, 31837,
			31624, 31388, 31131, 30853, 30553, 30232, 29891, 29530, 29148, 28746,
			28324, 27883, 27423, 26944, 26447, 25931, 25398, 24847, 24279, 23695,
			23095, 22478, 21846, 21199, 20538, 19863, 19174, 18472, 17757, 17030,
			16291, 15541, 14781, 14010, 13230, 12441, 11643, 10837, 10024, 9204,
			8377, 7545, 6708, 5866, 5020, 4171, 3319, 2464, 1608, 751,
			-107, -965, -1822, -2678, -3532, -4383, -5232, -6077, -6918, -7754,
			-8585, -9409, -10228, -11039, -11843, -12639, -13426, -14204, -14972, -15730,
			-16477, -17213, -17937, -18648, -19347, -20033, -20705, -21363, -22006, -22634,
			-23246, -23843, -24423, -24986, -25533, -26062, -26573, -27066, -27540, -27995,
			-28431, -28848, -29245, -29622, -29979, -30315, -30630, -30924, -31197, -31449,
			-31679, -31887, -32074, -32239, -32381, -32501, -32600, -32675, -32729, -32759
		};

		internal static readonly int[] intensity_thresholds = new int[21]
		{
			1, 2, 3, 4, 5, 6, 7, 8, 16, 24,
			36, 44, 50, 56, 62, 67, 72, 79, 88, 106,
			134
		};

		internal static readonly int[] intensity_histeresis = new int[21]
		{
			1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
			2, 2, 2, 2, 3, 3, 4, 5, 6, 8,
			8
		};
	}
	internal static class VQ
	{
		private static int[] SPREAD_FACTOR = new int[3] { 15, 10, 5 };

		internal static void exp_rotation1(int[] X, int X_ptr, int len, int stride, int c, int s)
		{
			int num = X_ptr;
			int a = Inlines.NEG16(s);
			for (int i = 0; i < len - stride; i++)
			{
				int b = X[num];
				int b2 = X[num + stride];
				X[num + stride] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.MAC16_16(Inlines.MULT16_16(c, b2), s, b), 15));
				X[num] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.MAC16_16(Inlines.MULT16_16(c, b), a, b2), 15));
				num++;
			}
			num = X_ptr + (len - 2 * stride - 1);
			for (int i = len - 2 * stride - 1; i >= 0; i--)
			{
				int b3 = X[num];
				int b4 = X[num + stride];
				X[num + stride] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.MAC16_16(Inlines.MULT16_16(c, b4), s, b3), 15));
				X[num] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.MAC16_16(Inlines.MULT16_16(c, b3), a, b4), 15));
				num--;
			}
		}

		internal static void exp_rotation(int[] X, int X_ptr, int len, int dir, int stride, int K, int spread)
		{
			int i = 0;
			if (2 * K >= len || spread == 0)
			{
				return;
			}
			int num = SPREAD_FACTOR[spread - 1];
			int num2 = Inlines.celt_div(Inlines.MULT16_16(32767, len), len + num * K);
			int num3 = Inlines.HALF16(Inlines.MULT16_16_Q15(num2, num2));
			int num4 = Inlines.celt_cos_norm(Inlines.EXTEND32(num3));
			int num5 = Inlines.celt_cos_norm(Inlines.EXTEND32(Inlines.SUB16(32767, num3)));
			if (len >= 8 * stride)
			{
				for (i = 1; (i * i + i) * stride + (stride >> 2) < len; i++)
				{
				}
			}
			len = Inlines.celt_udiv(len, stride);
			for (int j = 0; j < stride; j++)
			{
				if (dir < 0)
				{
					if (i != 0)
					{
						exp_rotation1(X, X_ptr + j * len, len, i, num5, num4);
					}
					exp_rotation1(X, X_ptr + j * len, len, 1, num4, num5);
				}
				else
				{
					exp_rotation1(X, X_ptr + j * len, len, 1, num4, (short)(-num5));
					if (i != 0)
					{
						exp_rotation1(X, X_ptr + j * len, len, i, num5, (short)(-num4));
					}
				}
			}
		}

		internal static void normalise_residual(int[] iy, int[] X, int X_ptr, int N, int Ryy, int gain)
		{
			int num = Inlines.celt_ilog2(Ryy) >> 1;
			int a = Inlines.MULT16_16_P15(Inlines.celt_rsqrt_norm(Inlines.VSHR32(Ryy, 2 * (num - 7))), gain);
			int num2 = 0;
			do
			{
				X[X_ptr + num2] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.MULT16_16(a, iy[num2]), num + 1));
			}
			while (++num2 < N);
		}

		internal static uint extract_collapse_mask(int[] iy, int N, int B)
		{
			if (B <= 1)
			{
				return 1u;
			}
			int num = Inlines.celt_udiv(N, B);
			uint num2 = 0u;
			int num3 = 0;
			do
			{
				uint num4 = 0u;
				int num5 = 0;
				do
				{
					num4 |= (uint)iy[num3 * num + num5];
				}
				while (++num5 < num);
				num2 |= (uint)(((num4 != 0) ? 1 : 0) << num3);
			}
			while (++num3 < B);
			return num2;
		}

		internal static uint alg_quant(int[] X, int X_ptr, int N, int K, int spread, int B, EntropyCoder enc)
		{
			int[] array = new int[N];
			int[] array2 = new int[N];
			int[] array3 = new int[N];
			exp_rotation(X, X_ptr, N, 1, B, K, spread);
			int num = 0;
			int num2 = 0;
			do
			{
				int num3 = X_ptr + num2;
				array3[num2] = ((X[num3] > 0) ? 1 : (-1));
				X[num3] = Inlines.ABS16(X[num3]);
				array2[num2] = 0;
				array[num2] = 0;
			}
			while (++num2 < N);
			int num5;
			int num4 = (num5 = 0);
			int num6 = K;
			if (K > N >> 1)
			{
				num2 = 0;
				do
				{
					num += X[X_ptr + num2];
				}
				while (++num2 < N);
				if (num <= K)
				{
					X[X_ptr] = 16384;
					num2 = X_ptr + 1;
					do
					{
						X[num2] = 0;
					}
					while (++num2 < N + X_ptr);
					num = 16384;
				}
				int b = Inlines.EXTRACT16(Inlines.MULT16_32_Q16(K - 1, Inlines.celt_rcp(num)));
				num2 = 0;
				do
				{
					array2[num2] = Inlines.MULT16_16_Q15(X[X_ptr + num2], b);
					array[num2] = array2[num2];
					num5 = Inlines.MAC16_16(num5, array[num2], array[num2]);
					num4 = Inlines.MAC16_16(num4, X[X_ptr + num2], array[num2]);
					array[num2] *= 2;
					num6 -= array2[num2];
				}
				while (++num2 < N);
			}
			if (num6 > N + 3)
			{
				int num7 = num6;
				num5 = Inlines.MAC16_16(num5, num7, num7);
				num5 = Inlines.MAC16_16(num5, num7, array[0]);
				array2[0] += num6;
				num6 = 0;
			}
			int num8 = 1;
			for (int i = 0; i < num6; i++)
			{
				int b2 = -32767;
				int a = 0;
				int shift = 1 + Inlines.celt_ilog2(K - num6 + i + 1);
				int num9 = 0;
				num5 = Inlines.ADD16(num5, 1);
				num2 = 0;
				do
				{
					int num10 = Inlines.EXTRACT16(Inlines.SHR32(Inlines.ADD32(num4, Inlines.EXTEND32(X[X_ptr + num2])), shift));
					int num11 = Inlines.ADD16(num5, array[num2]);
					num10 = Inlines.MULT16_16_Q15(num10, num10);
					if (Inlines.MULT16_16(a, num10) > Inlines.MULT16_16(num11, b2))
					{
						a = num11;
						b2 = num10;
						num9 = num2;
					}
				}
				while (++num2 < N);
				num4 = Inlines.ADD32(num4, Inlines.EXTEND32(X[X_ptr + num9]));
				num5 = Inlines.ADD16(num5, array[num9]);
				array[num9] += 2 * num8;
				array2[num9]++;
			}
			num2 = 0;
			do
			{
				X[X_ptr + num2] = Inlines.MULT16_16(array3[num2], X[X_ptr + num2]);
				array2[num2] = ((array3[num2] < 0) ? (-array2[num2]) : array2[num2]);
			}
			while (++num2 < N);
			CWRS.encode_pulses(array2, N, K, enc);
			return extract_collapse_mask(array2, N, B);
		}

		internal static uint alg_unquant(int[] X, int X_ptr, int N, int K, int spread, int B, EntropyCoder dec, int gain)
		{
			int[] array = new int[N];
			int ryy = CWRS.decode_pulses(array, N, K, dec);
			normalise_residual(array, X, X_ptr, N, ryy, gain);
			exp_rotation(X, X_ptr, N, -1, B, K, spread);
			return extract_collapse_mask(array, N, B);
		}

		internal static void renormalise_vector(int[] X, int X_ptr, int N, int gain)
		{
			int num = 1 + Kernels.celt_inner_prod(X, X_ptr, X, X_ptr, N);
			int num2 = Inlines.celt_ilog2(num) >> 1;
			int a = Inlines.MULT16_16_P15(Inlines.celt_rsqrt_norm(Inlines.VSHR32(num, 2 * (num2 - 7))), gain);
			int num3 = X_ptr;
			for (int i = 0; i < N; i++)
			{
				X[num3] = Inlines.EXTRACT16(Inlines.PSHR32(Inlines.MULT16_16(a, X[num3]), num2 + 1));
				num3++;
			}
		}

		internal static int stereo_itheta(int[] X, int X_ptr, int[] Y, int Y_ptr, int stereo, int N)
		{
			int num2;
			int num = (num2 = 1);
			if (stereo != 0)
			{
				for (int i = 0; i < N; i++)
				{
					int num3 = Inlines.ADD16(Inlines.SHR16(X[X_ptr + i], 1), Inlines.SHR16(Y[Y_ptr + i], 1));
					int num4 = Inlines.SUB16(Inlines.SHR16(X[X_ptr + i], 1), Inlines.SHR16(Y[Y_ptr + i], 1));
					num = Inlines.MAC16_16(num, num3, num3);
					num2 = Inlines.MAC16_16(num2, num4, num4);
				}
			}
			else
			{
				num += Kernels.celt_inner_prod(X, X_ptr, X, X_ptr, N);
				num2 += Kernels.celt_inner_prod(Y, Y_ptr, Y, Y_ptr, N);
			}
			int x = Inlines.celt_sqrt(num);
			int y = Inlines.celt_sqrt(num2);
			return Inlines.MULT16_16_Q15(20861, Inlines.celt_atan2p(y, x));
		}
	}
}
namespace Concentus.Celt.Structs
{
	internal class AnalysisInfo
	{
		internal int valid;

		internal float tonality;

		internal float tonality_slope;

		internal float noisiness;

		internal float activity;

		internal float music_prob;

		internal int bandwidth;

		internal AnalysisInfo()
		{
		}

		internal void Assign(AnalysisInfo other)
		{
			valid = other.valid;
			tonality = other.tonality;
			tonality_slope = other.tonality_slope;
			noisiness = other.noisiness;
			activity = other.activity;
			music_prob = other.music_prob;
			bandwidth = other.bandwidth;
		}

		internal void Reset()
		{
			valid = 0;
			tonality = 0f;
			tonality_slope = 0f;
			noisiness = 0f;
			activity = 0f;
			music_prob = 0f;
			bandwidth = 0;
		}
	}
	internal class CeltDecoder
	{
		internal CeltMode mode;

		internal int overlap;

		internal int channels;

		internal int stream_channels;

		internal int downsample;

		internal int start;

		internal int end;

		internal int signalling;

		internal uint rng;

		internal int error;

		internal int last_pitch_index;

		internal int loss_count;

		internal int postfilter_period;

		internal int postfilter_period_old;

		internal int postfilter_gain;

		internal int postfilter_gain_old;

		internal int postfilter_tapset;

		internal int postfilter_tapset_old;

		internal readonly int[] preemph_memD = new int[2];

		internal int[][] decode_mem;

		internal int[][] lpc;

		internal int[] oldEBands;

		internal int[] oldLogE;

		internal int[] oldLogE2;

		internal int[] backgroundLogE;

		private void Reset()
		{
			mode = null;
			overlap = 0;
			channels = 0;
			stream_channels = 0;
			downsample = 0;
			start = 0;
			end = 0;
			signalling = 0;
			PartialReset();
		}

		private void PartialReset()
		{
			rng = 0u;
			error = 0;
			last_pitch_index = 0;
			loss_count = 0;
			postfilter_period = 0;
			postfilter_period_old = 0;
			postfilter_gain = 0;
			postfilter_gain_old = 0;
			postfilter_tapset = 0;
			postfilter_tapset_old = 0;
			Arrays.MemSetInt(preemph_memD, 0, 2);
			decode_mem = null;
			lpc = null;
			oldEBands = null;
			oldLogE = null;
			oldLogE2 = null;
			backgroundLogE = null;
		}

		internal void ResetState()
		{
			PartialReset();
			decode_mem = new int[channels][];
			lpc = new int[channels][];
			for (int i = 0; i < channels; i++)
			{
				decode_mem[i] = new int[2048 + mode.overlap];
				lpc[i] = new int[24];
			}
			oldEBands = new int[2 * mode.nbEBands];
			oldLogE = new int[2 * mode.nbEBands];
			oldLogE2 = new int[2 * mode.nbEBands];
			backgroundLogE = new int[2 * mode.nbEBands];
			for (int j = 0; j < 2 * mode.nbEBands; j++)
			{
				oldLogE[j] = (oldLogE2[j] = -28672);
			}
		}

		internal int celt_decoder_init(int sampling_rate, int channels)
		{
			int num = opus_custom_decoder_init(CeltMode.mode48000_960_120, channels);
			if (num != 0)
			{
				return num;
			}
			downsample = CeltCommon.resampling_factor(sampling_rate);
			if (downsample == 0)
			{
				return -1;
			}
			return 0;
		}

		private int opus_custom_decoder_init(CeltMode mode, int channels)
		{
			if (channels < 0 || channels > 2)
			{
				return -1;
			}
			if (this == null)
			{
				return -7;
			}
			Reset();
			this.mode = mode;
			overlap = mode.overlap;
			stream_channels = (this.channels = channels);
			downsample = 1;
			start = 0;
			end = this.mode.effEBands;
			signalling = 1;
			loss_count = 0;
			ResetState();
			return 0;
		}

		internal void celt_decode_lost(int N, int LM)
		{
			int num = channels;
			int[][] array = new int[2][];
			int[] array2 = new int[2];
			CeltMode celtMode = mode;
			int nbEBands = celtMode.nbEBands;
			int num2 = celtMode.overlap;
			short[] eBands = celtMode.eBands;
			int num3 = 0;
			do
			{
				array[num3] = decode_mem[num3];
				array2[num3] = 2048 - N;
			}
			while (++num3 < num);
			if (loss_count >= 5 || ((start != 0) ? true : false))
			{
				int num4 = end;
				int num5 = Inlines.IMAX(start, Inlines.IMIN(num4, celtMode.effEBands));
				int[][] array3 = Arrays.InitTwoDimensionalArray<int>(num, N);
				int num6 = ((loss_count == 0) ? 1536 : 512);
				num3 = 0;
				do
				{
					for (int i = start; i < num4; i++)
					{
						oldEBands[num3 * nbEBands + i] = Inlines.MAX16(backgroundLogE[num3 * nbEBands + i], oldEBands[num3 * nbEBands + i] - num6);
					}
				}
				while (++num3 < num);
				uint num7 = rng;
				for (num3 = 0; num3 < num; num3++)
				{
					for (int i = start; i < num5; i++)
					{
						int num8 = eBands[i] << LM;
						int num9 = eBands[i + 1] - eBands[i] << LM;
						for (int j = 0; j < num9; j++)
						{
							num7 = Bands.celt_lcg_rand(num7);
							array3[num3][num8 + j] = (int)num7 >> 20;
						}
						VQ.renormalise_vector(array3[num3], 0, num9, 32767);
					}
				}
				rng = num7;
				num3 = 0;
				do
				{
					Arrays.MemMoveInt(decode_mem[num3], N, 0, 2048 - N + (num2 >> 1));
				}
				while (++num3 < num);
				CeltCommon.celt_synthesis(celtMode, array3, array, array2, oldEBands, start, num5, num, num, 0, LM, downsample, 0);
			}
			else
			{
				int a = 32767;
				int num10;
				if (loss_count == 0)
				{
					num10 = (last_pitch_index = CeltCommon.celt_plc_pitch_search(decode_mem, num));
				}
				else
				{
					num10 = last_pitch_index;
					a = 26214;
				}
				int[] array4 = new int[num2];
				int[] array5 = new int[1024];
				int[] window = celtMode.window;
				num3 = 0;
				do
				{
					int num11 = 0;
					int[] array6 = decode_mem[num3];
					int i;
					for (i = 0; i < 1024; i++)
					{
						array5[i] = Inlines.ROUND16(array6[1024 + i], 12);
					}
					if (loss_count == 0)
					{
						int[] array7 = new int[25];
						Autocorrelation._celt_autocorr(array5, array7, window, num2, 24, 1024);
						array7[0] += Inlines.SHR32(array7[0], 13);
						for (i = 1; i <= 24; i++)
						{
							array7[i] -= Inlines.MULT16_32_Q15(2 * i * i, array7[i]);
						}
						CeltLPC.celt_lpc(lpc[num3], array7, 24);
					}
					int num12 = Inlines.IMIN(2 * num10, 1024);
					int[] array8 = new int[24];
					for (i = 0; i < 24; i++)
					{
						array8[i] = Inlines.ROUND16(array6[2048 - num12 - 1 - i], 12);
					}
					Kernels.celt_fir(array5, 1024 - num12, lpc[num3], 0, array5, 1024 - num12, num12, 24, array8);
					int num13 = 1;
					int num14 = 1;
					int shift = Inlines.IMAX(0, 2 * Inlines.celt_zlog2(Inlines.celt_maxabs16(array5, 1024 - num12, num12)) - 20);
					int num15 = num12 >> 1;
					for (i = 0; i < num15; i++)
					{
						int num16 = array5[1024 - num15 + i];
						num13 += Inlines.SHR32(Inlines.MULT16_16(num16, num16), shift);
						num16 = array5[1024 - 2 * num15 + i];
						num14 += Inlines.SHR32(Inlines.MULT16_16(num16, num16), shift);
					}
					num13 = Inlines.MIN32(num13, num14);
					int b = Inlines.celt_sqrt(Inlines.frac_div32(Inlines.SHR32(num13, 1), num14));
					Arrays.MemMoveInt(array6, N, 0, 2048 - N);
					int num17 = 1024 - num10;
					int num18 = N + num2;
					int a2 = Inlines.MULT16_16_Q15(a, b);
					int num19;
					i = (num19 = 0);
					while (i < num18)
					{
						if (num19 >= num10)
						{
							num19 -= num10;
							a2 = Inlines.MULT16_16_Q15(a2, b);
						}
						array6[2048 - N + i] = Inlines.SHL32(Inlines.MULT16_16_Q15(a2, array5[num17 + num19]), 12);
						int num20 = Inlines.ROUND16(array6[1024 - N + num17 + num19], 12);
						num11 += Inlines.SHR32(Inlines.MULT16_16(num20, num20), 8);
						i++;
						num19++;
					}
					int[] array9 = new int[24];
					for (i = 0; i < 24; i++)
					{
						array9[i] = Inlines.ROUND16(array6[2048 - N - 1 - i], 12);
					}
					CeltLPC.celt_iir(array6, 2048 - N, lpc[num3], array6, 2048 - N, num18, 24, array9);
					int num21 = 0;
					for (i = 0; i < num18; i++)
					{
						int num22 = Inlines.ROUND16(array6[2048 - N + i], 12);
						num21 += Inlines.SHR32(Inlines.MULT16_16(num22, num22), 8);
					}
					if (num11 <= Inlines.SHR32(num21, 2))
					{
						for (i = 0; i < num18; i++)
						{
							array6[2048 - N + i] = 0;
						}
					}
					else if (num11 < num21)
					{
						int num23 = Inlines.celt_sqrt(Inlines.frac_div32(Inlines.SHR32(num11, 1) + 1, num21 + 1));
						for (i = 0; i < num2; i++)
						{
							int a3 = 32767 - Inlines.MULT16_16_Q15(window[i], 32767 - num23);
							array6[2048 - N + i] = Inlines.MULT16_32_Q15(a3, array6[2048 - N + i]);
						}
						for (i = num2; i < num18; i++)
						{
							array6[2048 - N + i] = Inlines.MULT16_32_Q15(num23, array6[2048 - N + i]);
						}
					}
					CeltCommon.comb_filter(array4, 0, array6, 2048, postfilter_period, postfilter_period, num2, -postfilter_gain, -postfilter_gain, postfilter_tapset, postfilter_tapset, null, 0);
					for (i = 0; i < num2 / 2; i++)
					{
						array6[2048 + i] = Inlines.MULT16_32_Q15(window[i], array4[num2 - 1 - i]) + Inlines.MULT16_32_Q15(window[num2 - i - 1], array4[i]);
					}
				}
				while (++num3 < num);
			}
			loss_count++;
		}

		internal int celt_decode_with_ec(byte[] data, int data_ptr, int len, short[] pcm, int pcm_ptr, int frame_size, EntropyCoder dec, int accum)
		{
			int[][] array = new int[2][];
			int[] array2 = new int[2];
			int num = channels;
			int intensity = 0;
			int dual_stereo = 0;
			int num2 = 0;
			int num3 = stream_channels;
			CeltMode celtMode = mode;
			int nbEBands = celtMode.nbEBands;
			int num4 = celtMode.overlap;
			short[] eBands = celtMode.eBands;
			int num5 = start;
			int num6 = end;
			frame_size *= downsample;
			int[] array3 = oldEBands;
			int[] array4 = oldLogE;
			int[] array5 = oldLogE2;
			int[] array6 = backgroundLogE;
			int i;
			for (i = 0; i <= celtMode.maxLM && celtMode.shortMdctSize << i != frame_size; i++)
			{
			}
			if (i > celtMode.maxLM)
			{
				return -1;
			}
			int num7 = 1 << i;
			if (len < 0 || len > 1275 || pcm == null)
			{
				return -1;
			}
			int num8 = num7 * celtMode.shortMdctSize;
			int num9 = 0;
			do
			{
				array[num9] = decode_mem[num9];
				array2[num9] = 2048 - num8;
			}
			while (++num9 < num);
			int num10 = num6;
			if (num10 > celtMode.effEBands)
			{
				num10 = celtMode.effEBands;
			}
			if (data == null || len <= 1)
			{
				celt_decode_lost(num8, i);
				CeltCommon.deemphasis(array, array2, pcm, pcm_ptr, num8, num, downsample, celtMode.preemph, preemph_memD, accum);
				return frame_size / downsample;
			}
			if (dec == null)
			{
				dec = new EntropyCoder();
				dec.dec_init(data, data_ptr, (uint)len);
			}
			if (num3 == 1)
			{
				for (int j = 0; j < nbEBands; j++)
				{
					array3[j] = Inlines.MAX16(array3[j], array3[nbEBands + j]);
				}
			}
			int num11 = len * 8;
			int num12 = dec.tell();
			int num13 = ((num12 >= num11) ? 1 : ((num12 == 1) ? dec.dec_bit_logp(15u) : 0));
			if (num13 != 0)
			{
				num12 = len * 8;
				dec.nbits_total += num12 - dec.tell();
			}
			int g = 0;
			int t = 0;
			int tapset = 0;
			if (num5 == 0 && num12 + 16 <= num11)
			{
				if (dec.dec_bit_logp(1u) != 0)
				{
					int num14 = (int)dec.dec_uint(6u);
					t = (16 << num14) + (int)dec.dec_bits((uint)(4 + num14)) - 1;
					int num15 = (int)dec.dec_bits(3u);
					if (dec.tell() + 2 <= num11)
					{
						tapset = dec.dec_icdf(Tables.tapset_icdf, 2u);
					}
					g = 3072 * (num15 + 1);
				}
				num12 = dec.tell();
			}
			int num16;
			if (i > 0 && num12 + 3 <= num11)
			{
				num16 = dec.dec_bit_logp(3u);
				num12 = dec.tell();
			}
			else
			{
				num16 = 0;
			}
			int shortBlocks = ((num16 != 0) ? num7 : 0);
			int intra = ((num12 + 3 <= num11) ? dec.dec_bit_logp(3u) : 0);
			QuantizeBands.unquant_coarse_energy(celtMode, num5, num6, array3, intra, dec, num3, i);
			int[] tf_res = new int[nbEBands];
			CeltCommon.tf_decode(num5, num6, num16, tf_res, i, dec);
			num12 = dec.tell();
			int spread = 2;
			if (num12 + 4 <= num11)
			{
				spread = dec.dec_icdf(Tables.spread_icdf, 5u);
			}
			int[] array7 = new int[nbEBands];
			CeltCommon.init_caps(celtMode, array7, i, num3);
			int[] array8 = new int[nbEBands];
			int num17 = 6;
			num11 <<= 3;
			num12 = (int)dec.tell_frac();
			for (int j = num5; j < num6; j++)
			{
				int num18 = num3 * (eBands[j + 1] - eBands[j]) << i;
				int num19 = Inlines.IMIN(num18 << 3, Inlines.IMAX(48, num18));
				int num20 = num17;
				int num21 = 0;
				while (num12 + (num20 << 3) < num11 && num21 < array7[j])
				{
					int num22 = dec.dec_bit_logp((uint)num20);
					num12 = (int)dec.tell_frac();
					if (num22 == 0)
					{
						break;
					}
					num21 += num19;
					num11 -= num19;
					num20 = 1;
				}
				array8[j] = num21;
				if (num21 > 0)
				{
					num17 = Inlines.IMAX(2, num17 - 1);
				}
			}
			int[] array9 = new int[nbEBands];
			int alloc_trim = ((num12 + 48 <= num11) ? dec.dec_icdf(Tables.trim_icdf, 7u) : 5);
			int num23 = (len * 8 << 3) - (int)dec.tell_frac() - 1;
			int num24 = ((num16 != 0 && i >= 2 && num23 >= i + 2 << 3) ? 8 : 0);
			num23 -= num24;
			int[] pulses = new int[nbEBands];
			int[] fine_priority = new int[nbEBands];
			int balance;
			int codedBands = Rate.compute_allocation(celtMode, num5, num6, array8, array7, alloc_trim, ref intensity, ref dual_stereo, num23, out balance, pulses, array9, fine_priority, num3, i, dec, 0, 0, 0);
			QuantizeBands.unquant_fine_energy(celtMode, num5, num6, array3, array9, dec, num3);
			num9 = 0;
			do
			{
				Arrays.MemMoveInt(decode_mem[num9], num8, 0, 2048 - num8 + num4 / 2);
			}
			while (++num9 < num);
			byte[] collapse_masks = new byte[num3 * nbEBands];
			int[][] array10 = Arrays.InitTwoDimensionalArray<int>(num3, num8);
			Bands.quant_all_bands(0, celtMode, num5, num6, array10[0], (num3 == 2) ? array10[1] : null, collapse_masks, null, pulses, shortBlocks, spread, dual_stereo, intensity, tf_res, len * 64 - num24, balance, dec, i, codedBands, ref rng);
			if (num24 > 0)
			{
				num2 = (int)dec.dec_bits(1u);
			}
			QuantizeBands.unquant_energy_finalise(celtMode, num5, num6, array3, array9, fine_priority, len * 8 - dec.tell(), dec, num3);
			if (num2 != 0)
			{
				Bands.anti_collapse(celtMode, array10, collapse_masks, i, num3, num8, num5, num6, array3, array4, array5, pulses, rng);
			}
			if (num13 != 0)
			{
				for (int j = 0; j < num3 * nbEBands; j++)
				{
					array3[j] = -28672;
				}
			}
			CeltCommon.celt_synthesis(celtMode, array10, array, array2, array3, num5, num10, num3, num, num16, i, downsample, num13);
			num9 = 0;
			do
			{
				postfilter_period = Inlines.IMAX(postfilter_period, 15);
				postfilter_period_old = Inlines.IMAX(postfilter_period_old, 15);
				CeltCommon.comb_filter(array[num9], array2[num9], array[num9], array2[num9], postfilter_period_old, postfilter_period, celtMode.shortMdctSize, postfilter_gain_old, postfilter_gain, postfilter_tapset_old, postfilter_tapset, celtMode.window, num4);
				if (i != 0)
				{
					CeltCommon.comb_filter(array[num9], array2[num9] + celtMode.shortMdctSize, array[num9], array2[num9] + celtMode.shortMdctSize, postfilter_period, t, num8 - celtMode.shortMdctSize, postfilter_gain, g, postfilter_tapset, tapset, celtMode.window, num4);
				}
			}
			while (++num9 < num);
			postfilter_period_old = postfilter_period;
			postfilter_gain_old = postfilter_gain;
			postfilter_tapset_old = postfilter_tapset;
			postfilter_period = t;
			postfilter_gain = g;
			postfilter_tapset = tapset;
			if (i != 0)
			{
				postfilter_period_old = postfilter_period;
				postfilter_gain_old = postfilter_gain;
				postfilter_tapset_old = postfilter_tapset;
			}
			if (num3 == 1)
			{
				Array.Copy(array3, 0, array3, nbEBands, nbEBands);
			}
			if (num16 == 0)
			{
				Array.Copy(array4, array5, 2 * nbEBands);
				Array.Copy(array3, array4, 2 * nbEBands);
				int num25 = ((loss_count >= 10) ? 1024 : num7);
				for (int j = 0; j < 2 * nbEBands; j++)
				{
					array6[j] = Inlines.MIN16(array6[j] + num25, array3[j]);
				}
			}
			else
			{
				for (int j = 0; j < 2 * nbEBands; j++)
				{
					array4[j] = Inlines.MIN16(array4[j], array3[j]);
				}
			}
			num9 = 0;
			do
			{
				for (int j = 0; j < num5; j++)
				{
					array3[num9 * nbEBands + j] = 0;
					array4[num9 * nbEBands + j] = (array5[num9 * nbEBands + j] = -28672);
				}
				for (int j = num6; j < nbEBands; j++)
				{
					array3[num9 * nbEBands + j] = 0;
					array4[num9 * nbEBands + j] = (array5[num9 * nbEBands + j] = -28672);
				}
			}
			while (++num9 < 2);
			rng = dec.rng;
			CeltCommon.deemphasis(array, array2, pcm, pcm_ptr, num8, num, downsample, celtMode.preemph, preemph_memD, accum);
			loss_count = 0;
			if (dec.tell() > 8 * len)
			{
				return -3;
			}
			if (dec.get_error() != 0)
			{
				error = 1;
			}
			return frame_size / downsample;
		}

		internal void SetStartBand(int value)
		{
			if (value < 0 || value >= mode.nbEBands)
			{
				throw new ArgumentException("Start band above max number of ebands (or negative)");
			}
			start = value;
		}

		internal void SetEndBand(int value)
		{
			if (value < 1 || value > mode.nbEBands)
			{
				throw new ArgumentException("End band above max number of ebands (or less than 1)");
			}
			end = value;
		}

		internal void SetChannels(int value)
		{
			if (value < 1 || value > 2)
			{
				throw new ArgumentException("Channel count must be 1 or 2");
			}
			stream_channels = value;
		}

		internal int GetAndClearError()
		{
			int result = error;
			error = 0;
			return result;
		}

		public int GetLookahead()
		{
			return overlap / downsample;
		}

		public int GetPitch()
		{
			return postfilter_period;
		}

		public CeltMode GetMode()
		{
			return mode;
		}

		public void SetSignalling(int value)
		{
			signalling = value;
		}

		public uint GetFinalRange()
		{
			return rng;
		}
	}
	internal class CeltEncoder
	{
		internal CeltMode mode;

		internal int channels;

		internal int stream_channels;

		internal int force_intra;

		internal int clip;

		internal int disable_pf;

		internal int complexity;

		internal int upsample;

		internal int start;

		internal int end;

		internal int bitrate;

		internal int vbr;

		internal int signalling;

		internal int constrained_vbr;

		internal int loss_rate;

		internal int lsb_depth;

		internal OpusFramesize variable_duration;

		internal int lfe;

		internal uint rng;

		internal int spread_decision;

		internal int delayedIntra;

		internal int tonal_average;

		internal int lastCodedBands;

		internal int hf_average;

		internal int tapset_decision;

		internal int prefilter_period;

		internal int prefilter_gain;

		internal int prefilter_tapset;

		internal int consec_transient;

		internal AnalysisInfo analysis = new AnalysisInfo();

		internal readonly int[] preemph_memE = new int[2];

		internal readonly int[] preemph_memD = new int[2];

		internal int vbr_reservoir;

		internal int vbr_drift;

		internal int vbr_offset;

		internal int vbr_count;

		internal int overlap_max;

		internal int stereo_saving;

		internal int intensity;

		internal int[] energy_mask;

		internal int spec_avg;

		internal int[][] in_mem;

		internal int[][] prefilter_mem;

		internal int[][] oldBandE;

		internal int[][] oldLogE;

		internal int[][] oldLogE2;

		private void Reset()
		{
			mode = null;
			channels = 0;
			stream_channels = 0;
			force_intra = 0;
			clip = 0;
			disable_pf = 0;
			complexity = 0;
			upsample = 0;
			start = 0;
			end = 0;
			bitrate = 0;
			vbr = 0;
			signalling = 0;
			constrained_vbr = 0;
			loss_rate = 0;
			lsb_depth = 0;
			variable_duration = (OpusFramesize)0;
			lfe = 0;
			PartialReset();
		}

		private void PartialReset()
		{
			rng = 0u;
			spread_decision = 0;
			delayedIntra = 0;
			tonal_average = 0;
			lastCodedBands = 0;
			hf_average = 0;
			tapset_decision = 0;
			prefilter_period = 0;
			prefilter_gain = 0;
			prefilter_tapset = 0;
			consec_transient = 0;
			analysis.Reset();
			preemph_memE[0] = 0;
			preemph_memE[1] = 0;
			preemph_memD[0] = 0;
			preemph_memD[1] = 0;
			vbr_reservoir = 0;
			vbr_drift = 0;
			vbr_offset = 0;
			vbr_count = 0;
			overlap_max = 0;
			stereo_saving = 0;
			intensity = 0;
			energy_mask = null;
			spec_avg = 0;
			in_mem = null;
			prefilter_mem = null;
			oldBandE = null;
			oldLogE = null;
			oldLogE2 = null;
		}

		internal void ResetState()
		{
			PartialReset();
			in_mem = Arrays.InitTwoDimensionalArray<int>(channels, mode.overlap);
			prefilter_mem = Arrays.InitTwoDimensionalArray<int>(channels, 1024);
			oldBandE = Arrays.InitTwoDimensionalArray<int>(channels, mode.nbEBands);
			oldLogE = Arrays.InitTwoDimensionalArray<int>(channels, mode.nbEBands);
			oldLogE2 = Arrays.InitTwoDimensionalArray<int>(channels, mode.nbEBands);
			for (int i = 0; i < mode.nbEBands; i++)
			{
				oldLogE[0][i] = (oldLogE2[0][i] = -28672);
			}
			if (channels == 2)
			{
				for (int i = 0; i < mode.nbEBands; i++)
				{
					oldLogE[1][i] = (oldLogE2[1][i] = -28672);
				}
			}
			vbr_offset = 0;
			delayedIntra = 1;
			spread_decision = 2;
			tonal_average = 256;
			hf_average = 0;
			tapset_decision = 0;
		}

		internal int opus_custom_encoder_init_arch(CeltMode mode, int channels)
		{
			if (channels < 0 || channels > 2)
			{
				return -1;
			}
			if (this == null || mode == null)
			{
				return -7;
			}
			Reset();
			this.mode = mode;
			stream_channels = (this.channels = channels);
			upsample = 1;
			start = 0;
			end = this.mode.effEBands;
			signalling = 1;
			constrained_vbr = 1;
			clip = 1;
			bitrate = -1;
			vbr = 0;
			force_intra = 0;
			complexity = 5;
			lsb_depth = 24;
			ResetState();
			return 0;
		}

		internal int celt_encoder_init(int sampling_rate, int channels)
		{
			int num = opus_custom_encoder_init_arch(CeltMode.mode48000_960_120, channels);
			if (num != 0)
			{
				return num;
			}
			upsample = CeltCommon.resampling_factor(sampling_rate);
			return 0;
		}

		internal int run_prefilter(int[][] input, int[][] prefilter_mem, int CC, int N, int prefilter_tapset, out int pitch, out int gain, out int qgain, int enabled, int nbAvailableBytes)
		{
			int[][] array = new int[CC][];
			CeltMode celtMode = mode;
			int overlap = celtMode.overlap;
			for (int i = 0; i < CC; i++)
			{
				array[i] = new int[N + 1024];
			}
			int num = 0;
			do
			{
				Array.Copy(prefilter_mem[num], 0, array[num], 0, 1024);
				Array.Copy(input[num], overlap, array[num], 1024, N);
			}
			while (++num < CC);
			int pitch2;
			int b;
			if (enabled != 0)
			{
				int[] array2 = new int[1024 + N >> 1];
				Pitch.pitch_downsample(array, array2, 1024 + N, CC);
				Pitch.pitch_search(array2, 512, array2, N, 979, out pitch2);
				pitch2 = 1024 - pitch2;
				b = Pitch.remove_doubling(array2, 1024, 15, N, ref pitch2, prefilter_period, prefilter_gain);
				if (pitch2 > 1022)
				{
					pitch2 = 1022;
				}
				b = Inlines.MULT16_16_Q15(22938, b);
				if (loss_rate > 2)
				{
					b = Inlines.HALF32(b);
				}
				if (loss_rate > 4)
				{
					b = Inlines.HALF32(b);
				}
				if (loss_rate > 8)
				{
					b = 0;
				}
			}
			else
			{
				b = 0;
				pitch2 = 15;
			}
			int num2 = 6554;
			if (Inlines.abs(pitch2 - prefilter_period) * 10 > pitch2)
			{
				num2 += 6554;
			}
			if (nbAvailableBytes < 25)
			{
				num2 += 3277;
			}
			if (nbAvailableBytes < 35)
			{
				num2 += 3277;
			}
			if (prefilter_gain > 13107)
			{
				num2 -= 3277;
			}
			if (prefilter_gain > 18022)
			{
				num2 -= 3277;
			}
			num2 = Inlines.MAX16(num2, 6554);
			int result;
			int num3;
			if (b < num2)
			{
				b = 0;
				result = 0;
				num3 = 0;
			}
			else
			{
				if (Inlines.ABS32(b - prefilter_gain) < 3277)
				{
					b = prefilter_gain;
				}
				num3 = (b + 1536 >> 10) / 3 - 1;
				num3 = Inlines.IMAX(0, Inlines.IMIN(7, num3));
				b = 3072 * (num3 + 1);
				result = 1;
			}
			num = 0;
			do
			{
				int num4 = celtMode.shortMdctSize - overlap;
				prefilter_period = Inlines.IMAX(prefilter_period, 15);
				Array.Copy(in_mem[num], 0, input[num], 0, overlap);
				if (num4 != 0)
				{
					CeltCommon.comb_filter(input[num], overlap, array[num], 1024, prefilter_period, prefilter_period, num4, -prefilter_gain, -prefilter_gain, this.prefilter_tapset, this.prefilter_tapset, null, 0);
				}
				CeltCommon.comb_filter(input[num], overlap + num4, array[num], 1024 + num4, prefilter_period, pitch2, N - num4, -prefilter_gain, -b, this.prefilter_tapset, prefilter_tapset, celtMode.window, overlap);
				Array.Copy(input[num], N, in_mem[num], 0, overlap);
				if (N > 1024)
				{
					Array.Copy(array[num], N, prefilter_mem[num], 0, 1024);
					continue;
				}
				Arrays.MemMove(prefilter_mem[num], N, 0, 1024 - N);
				Array.Copy(array[num], 1024, prefilter_mem[num], 1024 - N, N);
			}
			while (++num < CC);
			gain = b;
			pitch = pitch2;
			qgain = num3;
			return result;
		}

		internal int celt_encode_with_ec(short[] pcm, int pcm_ptr, int frame_size, byte[] compressed, int compressed_ptr, int nbCompressedBytes, EntropyCoder enc)
		{
			int num = 0;
			int num2 = 0;
			int num3 = channels;
			int num4 = stream_channels;
			int pitch = 15;
			int gain = 0;
			int dual_stereo = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			int tf_chan = 0;
			int pitch_change = 0;
			int num8 = 0;
			int surround_masking = 0;
			int num9 = 0;
			int surround_trim = 0;
			int num10 = 510000;
			CeltMode celtMode = mode;
			int nbEBands = celtMode.nbEBands;
			int overlap = celtMode.overlap;
			short[] eBands = celtMode.eBands;
			int num11 = start;
			int num12 = end;
			int tf_estimate = 0;
			if (nbCompressedBytes < 2 || pcm == null)
			{
				return -1;
			}
			frame_size *= upsample;
			int i;
			for (i = 0; i <= celtMode.maxLM && celtMode.shortMdctSize << i != frame_size; i++)
			{
			}
			if (i > celtMode.maxLM)
			{
				return -1;
			}
			int num13 = 1 << i;
			int num14 = num13 * celtMode.shortMdctSize;
			int num16;
			int num15;
			if (enc == null)
			{
				num15 = 1;
				num16 = 0;
			}
			else
			{
				num15 = enc.tell();
				num16 = num15 + 4 >> 3;
			}
			nbCompressedBytes = Inlines.IMIN(nbCompressedBytes, 1275);
			int num17 = nbCompressedBytes - num16;
			int num19;
			int num20;
			if (vbr != 0 && bitrate != -1)
			{
				int num18 = celtMode.Fs >> 3;
				num19 = (bitrate * frame_size + (num18 >> 1)) / num18;
				num20 = num19 >> 6;
			}
			else
			{
				num19 = 0;
				int num21 = bitrate * frame_size;
				if (num15 > 1)
				{
					num21 += num15;
				}
				if (bitrate != -1)
				{
					nbCompressedBytes = Inlines.IMAX(2, Inlines.IMIN(nbCompressedBytes, (num21 + 4 * celtMode.Fs) / (8 * celtMode.Fs) - ((signalling != 0) ? 1 : 0)));
				}
				num20 = nbCompressedBytes;
			}
			if (bitrate != -1)
			{
				num10 = bitrate - (40 * num4 + 20) * ((400 >> i) - 50);
			}
			if (enc == null)
			{
				enc = new EntropyCoder();
				enc.enc_init(compressed, compressed_ptr, (uint)nbCompressedBytes);
			}
			if (num19 > 0 && constrained_vbr != 0)
			{
				int num22 = num19;
				int num23 = Inlines.IMIN(Inlines.IMAX((num15 == 1) ? 2 : 0, num19 + num22 - vbr_reservoir >> 6), num17);
				if (num23 < num17)
				{
					nbCompressedBytes = num16 + num23;
					num17 = num23;
					enc.enc_shrink((uint)nbCompressedBytes);
				}
			}
			int num24 = nbCompressedBytes * 8;
			int num25 = num12;
			if (num25 > celtMode.effEBands)
			{
				num25 = celtMode.effEBands;
			}
			int[][] array = Arrays.InitTwoDimensionalArray<int>(num3, num14 + overlap);
			int a = Inlines.MAX32(overlap_max, Inlines.celt_maxabs32(pcm, pcm_ptr, num4 * (num14 - overlap) / upsample));
			overlap_max = Inlines.celt_maxabs32(pcm, pcm_ptr + num4 * (num14 - overlap) / upsample, num4 * overlap / upsample);
			num7 = ((Inlines.MAX32(a, overlap_max) == 0) ? 1 : 0);
			if (num15 == 1)
			{
				enc.enc_bit_logp(num7, 15u);
			}
			else
			{
				num7 = 0;
			}
			if (num7 != 0)
			{
				if (num19 > 0)
				{
					num20 = (nbCompressedBytes = Inlines.IMIN(nbCompressedBytes, num16 + 2));
					num24 = nbCompressedBytes * 8;
					num17 = 2;
					enc.enc_shrink((uint)nbCompressedBytes);
				}
				num15 = nbCompressedBytes * 8;
				enc.nbits_total += num15 - enc.tell();
			}
			int num26 = 0;
			do
			{
				int num27 = 0;
				CeltCommon.celt_preemphasis(pcm, pcm_ptr + num26, array[num26], overlap, num14, num3, upsample, celtMode.preemph, ref preemph_memE[num26], num27);
			}
			while (++num26 < num3);
			int enabled = ((((lfe != 0 && num17 > 3) || num17 > 12 * num4) && num11 == 0 && num7 == 0 && disable_pf == 0 && complexity >= 5 && (consec_transient == 0 || i == 3 || variable_duration != OpusFramesize.OPUS_FRAMESIZE_VARIABLE)) ? 1 : 0);
			num5 = tapset_decision;
			int qgain;
			int num28 = run_prefilter(array, prefilter_mem, num3, num14, num5, out pitch, out gain, out qgain, enabled, num17);
			if ((gain > 13107 || prefilter_gain > 13107) && (analysis.valid == 0 || (double)analysis.tonality > 0.3) && ((double)pitch > 1.26 * (double)prefilter_period || (double)pitch < 0.79 * (double)prefilter_period))
			{
				pitch_change = 1;
			}
			if (num28 == 0)
			{
				if (num11 == 0 && num15 + 16 <= num24)
				{
					enc.enc_bit_logp(0, 1u);
				}
			}
			else
			{
				enc.enc_bit_logp(1, 1u);
				pitch++;
				int num29 = Inlines.EC_ILOG((uint)pitch) - 5;
				enc.enc_uint((uint)num29, 6u);
				enc.enc_bits((uint)(pitch - (16 << num29)), (uint)(4 + num29));
				pitch--;
				enc.enc_bits((uint)qgain, 3u);
				enc.enc_icdf(num5, Tables.tapset_icdf, 2u);
			}
			num2 = 0;
			num = 0;
			if (complexity >= 1 && lfe == 0)
			{
				num2 = CeltCommon.transient_analysis(array, num14 + overlap, num3, out tf_estimate, out tf_chan);
			}
			if (i > 0 && enc.tell() + 3 <= num24)
			{
				if (num2 != 0)
				{
					num = num13;
				}
			}
			else
			{
				num2 = 0;
				num8 = 1;
			}
			int[][] array2 = Arrays.InitTwoDimensionalArray<int>(num3, num14);
			int[][] array3 = Arrays.InitTwoDimensionalArray<int>(num3, nbEBands);
			int[][] array4 = Arrays.InitTwoDimensionalArray<int>(num3, nbEBands);
			int num30 = ((num != 0 && complexity >= 8) ? 1 : 0);
			int[][] array5 = Arrays.InitTwoDimensionalArray<int>(num3, nbEBands);
			if (num30 != 0)
			{
				CeltCommon.compute_mdcts(celtMode, 0, array, array2, num4, num3, i, upsample);
				Bands.compute_band_energies(celtMode, array2, array3, num25, num4, i);
				QuantizeBands.amp2Log2(celtMode, num25, num12, array3, array5, num4);
				for (int j = 0; j < nbEBands; j++)
				{
					array5[0][j] += Inlines.HALF16(Inlines.SHL16(i, 10));
				}
				if (num4 == 2)
				{
					for (int j = 0; j < nbEBands; j++)
					{
						array5[1][j] += Inlines.HALF16(Inlines.SHL16(i, 10));
					}
				}
			}
			CeltCommon.compute_mdcts(celtMode, num, array, array2, num4, num3, i, upsample);
			if (num3 == 2 && num4 == 1)
			{
				tf_chan = 0;
			}
			Bands.compute_band_energies(celtMode, array2, array3, num25, num4, i);
			if (lfe != 0)
			{
				for (int j = 2; j < num12; j++)
				{
					array3[0][j] = Inlines.IMIN(array3[0][j], Inlines.MULT16_32_Q15((short)3, array3[0][0]));
					array3[0][j] = Inlines.MAX32(array3[0][j], 1);
				}
			}
			QuantizeBands.amp2Log2(celtMode, num25, num12, array3, array4, num4);
			int[] array6 = new int[num4 * nbEBands];
			if (num11 == 0 && energy_mask != null && lfe == 0)
			{
				int num31 = 0;
				int num32 = 0;
				int num33 = 0;
				int num34 = Inlines.IMAX(2, lastCodedBands);
				for (num26 = 0; num26 < num4; num26++)
				{
					for (int j = 0; j < num34; j++)
					{
						int num35 = Inlines.MAX16(Inlines.MIN16(energy_mask[nbEBands * num26 + j], 256), -2048);
						if (num35 > 0)
						{
							num35 = Inlines.HALF16(num35);
						}
						num31 += Inlines.MULT16_16(num35, eBands[j + 1] - eBands[j]);
						num33 += eBands[j + 1] - eBands[j];
						num32 += Inlines.MULT16_16(num35, 1 + 2 * j - num34);
					}
				}
				num31 = Inlines.DIV32_16(num31, num33);
				num31 += 205;
				num32 = num32 * 6 / (num4 * (num34 - 1) * (num34 + 1) * num34);
				num32 = Inlines.HALF32(num32);
				num32 = Inlines.MAX32(Inlines.MIN32(num32, 32), -32);
				int k;
				for (k = 0; eBands[k + 1] < eBands[num34] / 2; k++)
				{
				}
				int num36 = 0;
				for (int j = 0; j < num34; j++)
				{
					int num37 = num31 + num32 * (j - k);
					int a2 = ((num4 != 2) ? energy_mask[j] : Inlines.MAX16(energy_mask[j], energy_mask[nbEBands + j]));
					a2 = Inlines.MIN16(a2, 0);
					a2 -= num37;
					if (a2 > 256)
					{
						array6[j] = a2 - 256;
						num36++;
					}
				}
				if (num36 >= 3)
				{
					num31 += 256;
					if (num31 > 0)
					{
						num31 = 0;
						num32 = 0;
						Arrays.MemSetInt(array6, 0, num34);
					}
					else
					{
						for (int j = 0; j < num34; j++)
						{
							array6[j] = Inlines.MAX16(0, array6[j] - 256);
						}
					}
				}
				num31 += 205;
				surround_trim = 64 * num32;
				surround_masking = num31;
			}
			if (lfe == 0)
			{
				int num38 = -10240;
				int num39 = 0;
				int num40 = ((num != 0) ? Inlines.HALF16(Inlines.SHL16(i, 10)) : 0);
				for (int j = num11; j < num12; j++)
				{
					num38 = Inlines.MAX16(num38 - 1024, array4[0][j] - num40);
					if (num4 == 2)
					{
						num38 = Inlines.MAX16(num38, array4[1][j] - num40);
					}
					num39 += num38;
				}
				num39 /= num12 - num11;
				num9 = Inlines.SUB16(num39, spec_avg);
				num9 = Inlines.MIN16(3072, Inlines.MAX16(-1536, num9));
				spec_avg += (short)Inlines.MULT16_16_Q15(655, num9);
			}
			if (num30 == 0)
			{
				Array.Copy(array4[0], array5[0], nbEBands);
				if (num4 == 2)
				{
					Array.Copy(array4[1], array5[1], nbEBands);
				}
			}
			if (i > 0 && enc.tell() + 3 <= num24 && num2 == 0 && complexity >= 5 && lfe == 0 && CeltCommon.patch_transient_decision(array4, oldBandE, nbEBands, num11, num12, num4) != 0)
			{
				num2 = 1;
				num = num13;
				CeltCommon.compute_mdcts(celtMode, num, array, array2, num4, num3, i, upsample);
				Bands.compute_band_energies(celtMode, array2, array3, num25, num4, i);
				QuantizeBands.amp2Log2(celtMode, num25, num12, array3, array4, num4);
				for (int j = 0; j < nbEBands; j++)
				{
					array5[0][j] += Inlines.HALF16(Inlines.SHL16(i, 10));
				}
				if (num4 == 2)
				{
					for (int j = 0; j < nbEBands; j++)
					{
						array5[1][j] += Inlines.HALF16(Inlines.SHL16(i, 10));
					}
				}
				tf_estimate = 3277;
			}
			if (i > 0 && enc.tell() + 3 <= num24)
			{
				enc.enc_bit_logp(num2, 3u);
			}
			int[][] array7 = Arrays.InitTwoDimensionalArray<int>(num4, num14);
			Bands.normalise_bands(celtMode, array2, array7, array3, num25, num4, num13);
			int[] array8 = new int[nbEBands];
			int tf_select;
			if (num20 >= 15 * num4 && num11 == 0 && complexity >= 2 && lfe == 0)
			{
				int num41 = ((num20 < 40) ? 12 : ((num20 < 60) ? 6 : ((num20 >= 100) ? 3 : 4)));
				num41 *= 2;
				tf_select = CeltCommon.tf_analysis(celtMode, num25, num2, array8, num41, array7, num14, i, out var _, tf_estimate, tf_chan);
				for (int j = num25; j < num12; j++)
				{
					array8[j] = array8[num25 - 1];
				}
			}
			else
			{
				int tf_sum = 0;
				for (int j = 0; j < num12; j++)
				{
					array8[j] = num2;
				}
				tf_select = 0;
			}
			int[][] error = Arrays.InitTwoDimensionalArray<int>(num4, nbEBands);
			QuantizeBands.quant_coarse_energy(celtMode, num11, num12, num25, array4, oldBandE, (uint)num24, error, enc, num4, i, num17, force_intra, ref delayedIntra, (complexity >= 4) ? 1 : 0, loss_rate, lfe);
			CeltCommon.tf_encode(num11, num12, num2, array8, i, tf_select, enc);
			if (enc.tell() + 4 <= num24)
			{
				if (lfe != 0)
				{
					tapset_decision = 0;
					spread_decision = 2;
				}
				else if (num != 0 || complexity < 3 || num17 < 10 * num4 || num11 != 0)
				{
					if (complexity == 0)
					{
						spread_decision = 0;
					}
					else
					{
						spread_decision = 2;
					}
				}
				else
				{
					spread_decision = Bands.spreading_decision(celtMode, array7, ref tonal_average, spread_decision, ref hf_average, ref tapset_decision, (num28 != 0 && num == 0) ? 1 : 0, num25, num4, num13);
				}
				enc.enc_icdf(spread_decision, Tables.spread_icdf, 5u);
			}
			int[] array9 = new int[nbEBands];
			int tot_boost_;
			int maxDepth = CeltCommon.dynalloc_analysis(array4, array5, nbEBands, num11, num12, num4, array9, lsb_depth, celtMode.logN, num2, vbr, constrained_vbr, eBands, i, num20, out tot_boost_, lfe, array6);
			if (lfe != 0)
			{
				array9[0] = Inlines.IMIN(8, num20 / 3);
			}
			int[] array10 = new int[nbEBands];
			CeltCommon.init_caps(celtMode, array10, i, num4);
			int num42 = 6;
			num24 <<= 3;
			int num43 = 0;
			num15 = (int)enc.tell_frac();
			for (int j = num11; j < num12; j++)
			{
				int num44 = num4 * (eBands[j + 1] - eBands[j]) << i;
				int num45 = Inlines.IMIN(num44 << 3, Inlines.IMAX(48, num44));
				int num46 = num42;
				int num47 = 0;
				int num48 = 0;
				while (num15 + (num46 << 3) < num24 - num43 && num47 < array10[j])
				{
					int num49 = ((num48 < array9[j]) ? 1 : 0);
					enc.enc_bit_logp(num49, (uint)num46);
					num15 = (int)enc.tell_frac();
					if (num49 == 0)
					{
						break;
					}
					num47 += num45;
					num43 += num45;
					num46 = 1;
					num48++;
				}
				if (num48 != 0)
				{
					num42 = Inlines.IMAX(2, num42 - 1);
				}
				array9[j] = num47;
			}
			if (num4 == 2)
			{
				if (i != 0)
				{
					dual_stereo = CeltCommon.stereo_analysis(celtMode, array7, i);
				}
				intensity = Bands.hysteresis_decision(num10 / 1000, Tables.intensity_thresholds, Tables.intensity_histeresis, 21, intensity);
				intensity = Inlines.IMIN(num12, Inlines.IMAX(num11, intensity));
			}
			int num50 = 5;
			if (num15 + 48 <= num24 - num43)
			{
				num50 = ((lfe == 0) ? CeltCommon.alloc_trim_analysis(celtMode, array7, array4, num12, i, num4, analysis, ref stereo_saving, tf_estimate, intensity, surround_trim) : 5);
				enc.enc_icdf(num50, Tables.trim_icdf, 7u);
				num15 = (int)enc.tell_frac();
			}
			if (num19 > 0)
			{
				int num51 = celtMode.maxLM - i;
				nbCompressedBytes = Inlines.IMIN(nbCompressedBytes, 1275 >> 3 - i);
				int num52 = num19 - (40 * num4 + 20 << 3);
				if (constrained_vbr != 0)
				{
					num52 += vbr_offset >> num51;
				}
				int num53 = CeltCommon.compute_vbr(celtMode, analysis, num52, i, num10, lastCodedBands, num4, intensity, constrained_vbr, stereo_saving, tot_boost_, tf_estimate, pitch_change, maxDepth, variable_duration, lfe, (energy_mask != null) ? 1 : 0, surround_masking, num9);
				num53 += num15;
				int a3 = (num15 + num43 + 64 - 1 >> 6) + 2 - num16;
				num17 = num53 + 32 >> 6;
				num17 = Inlines.IMAX(a3, num17);
				num17 = Inlines.IMIN(nbCompressedBytes, num17 + num16) - num16;
				int num54 = num53 - num19;
				num53 = num17 << 6;
				if (num7 != 0)
				{
					num17 = 2;
					num53 = 128;
					num54 = 0;
				}
				int a4;
				if (vbr_count < 970)
				{
					vbr_count++;
					a4 = Inlines.celt_rcp(Inlines.SHL32(vbr_count + 20, 16));
				}
				else
				{
					a4 = 33;
				}
				if (constrained_vbr != 0)
				{
					vbr_reservoir += num53 - num19;
				}
				if (constrained_vbr != 0)
				{
					vbr_drift += Inlines.MULT16_32_Q15(a4, num54 * (1 << num51) - vbr_offset - vbr_drift);
					vbr_offset = -vbr_drift;
				}
				if (constrained_vbr != 0 && vbr_reservoir < 0)
				{
					int num55 = -vbr_reservoir / 64;
					num17 += ((num7 == 0) ? num55 : 0);
					vbr_reservoir = 0;
				}
				nbCompressedBytes = Inlines.IMIN(nbCompressedBytes, num17 + num16);
				enc.enc_shrink((uint)nbCompressedBytes);
			}
			int[] array11 = new int[nbEBands];
			int[] pulses = new int[nbEBands];
			int[] fine_priority = new int[nbEBands];
			int num56 = (nbCompressedBytes * 8 << 3) - (int)enc.tell_frac() - 1;
			int num57 = ((num2 != 0 && i >= 2 && num56 >= i + 2 << 3) ? 8 : 0);
			num56 -= num57;
			int signalBandwidth = num12 - 1;
			if (analysis.valid != 0)
			{
				int b = ((num10 < 32000 * num4) ? 13 : ((num10 < 48000 * num4) ? 16 : ((num10 < 60000 * num4) ? 18 : ((num10 >= 80000 * num4) ? 20 : 19))));
				signalBandwidth = Inlines.IMAX(analysis.bandwidth, b);
			}
			if (lfe != 0)
			{
				signalBandwidth = 1;
			}
			int balance;
			int num58 = Rate.compute_allocation(celtMode, num11, num12, array9, array10, num50, ref intensity, ref dual_stereo, num56, out balance, pulses, array11, fine_priority, num4, i, enc, 1, lastCodedBands, signalBandwidth);
			if (lastCodedBands != 0)
			{
				lastCodedBands = Inlines.IMIN(lastCodedBands + 1, Inlines.IMAX(lastCodedBands - 1, num58));
			}
			else
			{
				lastCodedBands = num58;
			}
			QuantizeBands.quant_fine_energy(celtMode, num11, num12, oldBandE, error, array11, enc, num4);
			byte[] collapse_masks = new byte[num4 * nbEBands];
			Bands.quant_all_bands(1, celtMode, num11, num12, array7[0], (num4 == 2) ? array7[1] : null, collapse_masks, array3, pulses, num, spread_decision, dual_stereo, intensity, array8, nbCompressedBytes * 64 - num57, balance, enc, i, num58, ref rng);
			if (num57 > 0)
			{
				num6 = ((consec_transient < 2) ? 1 : 0);
				enc.enc_bits((uint)num6, 1u);
			}
			QuantizeBands.quant_energy_finalise(celtMode, num11, num12, oldBandE, error, array11, fine_priority, nbCompressedBytes * 8 - enc.tell(), enc, num4);
			if (num7 != 0)
			{
				for (int j = 0; j < nbEBands; j++)
				{
					oldBandE[0][j] = -28672;
				}
				if (num4 == 2)
				{
					for (int j = 0; j < nbEBands; j++)
					{
						oldBandE[1][j] = -28672;
					}
				}
			}
			prefilter_period = pitch;
			prefilter_gain = gain;
			prefilter_tapset = num5;
			if (num3 == 2 && num4 == 1)
			{
				Array.Copy(oldBandE[0], 0, oldBandE[1], 0, nbEBands);
			}
			if (num2 == 0)
			{
				Array.Copy(oldLogE[0], 0, oldLogE2[0], 0, nbEBands);
				Array.Copy(oldBandE[0], 0, oldLogE[0], 0, nbEBands);
				if (num3 == 2)
				{
					Array.Copy(oldLogE[1], 0, oldLogE2[1], 0, nbEBands);
					Array.Copy(oldBandE[1], 0, oldLogE[1], 0, nbEBands);
				}
			}
			else
			{
				for (int j = 0; j < nbEBands; j++)
				{
					oldLogE[0][j] = Inlines.MIN16(oldLogE[0][j], oldBandE[0][j]);
				}
				if (num3 == 2)
				{
					for (int j = 0; j < nbEBands; j++)
					{
						oldLogE[1][j] = Inlines.MIN16(oldLogE[1][j], oldBandE[1][j]);
					}
				}
			}
			num26 = 0;
			do
			{
				for (int j = 0; j < num11; j++)
				{
					oldBandE[num26][j] = 0;
					oldLogE[num26][j] = (oldLogE2[num26][j] = -28672);
				}
				for (int j = num12; j < nbEBands; j++)
				{
					oldBandE[num26][j] = 0;
					oldLogE[num26][j] = (oldLogE2[num26][j] = -28672);
				}
			}
			while (++num26 < num3);
			if (num2 != 0 || num8 != 0)
			{
				consec_transient++;
			}
			else
			{
				consec_transient = 0;
			}
			rng = enc.rng;
			enc.enc_done();
			if (enc.get_error() != 0)
			{
				return -3;
			}
			return nbCompressedBytes;
		}

		internal void SetComplexity(int value)
		{
			if (value < 0 || value > 10)
			{
				throw new ArgumentException("Complexity must be between 0 and 10 inclusive");
			}
			complexity = value;
		}

		internal void SetStartBand(int value)
		{
			if (value < 0 || value >= mode.nbEBands)
			{
				throw new ArgumentException("Start band above max number of ebands (or negative)");
			}
			start = value;
		}

		internal void SetEndBand(int value)
		{
			if (value < 1 || value > mode.nbEBands)
			{
				throw new ArgumentException("End band above max number of ebands (or less than 1)");
			}
			end = value;
		}

		internal void SetPacketLossPercent(int value)
		{
			if (value < 0 || value > 100)
			{
				throw new ArgumentException("Packet loss must be between 0 and 100");
			}
			loss_rate = value;
		}

		internal void SetPrediction(int value)
		{
			if (value < 0 || value > 2)
			{
				throw new ArgumentException("CELT prediction mode must be 0, 1, or 2");
			}
			disable_pf = ((value <= 1) ? 1 : 0);
			force_intra = ((value == 0) ? 1 : 0);
		}

		internal void SetVBRConstraint(bool value)
		{
			constrained_vbr = (value ? 1 : 0);
		}

		internal void SetVBR(bool value)
		{
			vbr = (value ? 1 : 0);
		}

		internal void SetBitrate(int value)
		{
			if (value <= 500 && value != -1)
			{
				throw new ArgumentException("Bitrate out of range");
			}
			value = Inlines.IMIN(value, 260000 * channels);
			bitrate = value;
		}

		internal void SetChannels(int value)
		{
			if (value < 1 || value > 2)
			{
				throw new ArgumentException("Channel count must be 1 or 2");
			}
			stream_channels = value;
		}

		internal void SetLSBDepth(int value)
		{
			if (value < 8 || value > 24)
			{
				throw new ArgumentException("Bit depth must be between 8 and 24");
			}
			lsb_depth = value;
		}

		internal int GetLSBDepth()
		{
			return lsb_depth;
		}

		internal void SetExpertFrameDuration(OpusFramesize value)
		{
			variable_duration = value;
		}

		internal void SetSignalling(int value)
		{
			signalling = value;
		}

		internal void SetAnalysis(AnalysisInfo value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("AnalysisInfo");
			}
			analysis.Assign(value);
		}

		internal CeltMode GetMode()
		{
			return mode;
		}

		internal uint GetFinalRange()
		{
			return rng;
		}

		internal void SetLFE(int value)
		{
			lfe = value;
		}

		internal void SetEnergyMask(int[] value)
		{
			energy_mask = value;
		}
	}
	internal class CeltMode
	{
		internal int Fs;

		internal int overlap;

		internal int nbEBands;

		internal int effEBands;

		internal int[] preemph = new int[4];

		internal short[] eBands;

		internal int maxLM;

		internal int nbShortMdcts;

		internal int shortMdctSize;

		internal int nbAllocVectors;

		internal byte[] allocVectors;

		internal short[] logN;

		internal int[] window;

		internal MDCTLookup mdct = new MDCTLookup();

		internal PulseCache cache = new PulseCache();

		internal static readonly CeltMode mode48000_960_120 = new CeltMode
		{
			Fs = 48000,
			overlap = 120,
			nbEBands = 21,
			effEBands = 21,
			preemph = new int[4] { 27853, 0, 4096, 8192 },
			eBands = Tables.eband5ms,
			maxLM = 3,
			nbShortMdcts = 8,
			shortMdctSize = 120,
			nbAllocVectors = 11,
			allocVectors = Tables.band_allocation,
			logN = Tables.logN400,
			window = Tables.window120,
			mdct = new MDCTLookup
			{
				n = 1920,
				maxshift = 3,
				kfft = new FFTState[4]
				{
					Tables.fft_state48000_960_0,
					Tables.fft_state48000_960_1,
					Tables.fft_state48000_960_2,
					Tables.fft_state48000_960_3
				},
				trig = Tables.mdct_twiddles960
			},
			cache = new PulseCache
			{
				size = 392,
				index = Tables.cache_index50,
				bits = Tables.cache_bits50,
				caps = Tables.cache_caps50
			}
		};

		private CeltMode()
		{
		}
	}
	internal class FFTState
	{
		internal int nfft;

		internal short scale;

		internal int scale_shift;

		internal int shift;

		internal short[] factors = new short[16];

		internal short[] bitrev;

		internal short[] twiddles;
	}
	internal class MDCTLookup
	{
		internal int n;

		internal int maxshift;

		internal FFTState[] kfft = new FFTState[4];

		internal short[] trig;

		internal MDCTLookup()
		{
		}
	}
	internal class PulseCache
	{
		internal int size;

		internal short[] index;

		internal byte[] bits;

		internal byte[] caps;

		internal void Reset()
		{
			size = 0;
			index = null;
			bits = null;
			caps = null;
		}
	}
}
namespace Concentus.Celt.Enums
{
	internal static class Spread
	{
		public const int SPREAD_NONE = 0;

		public const int SPREAD_LIGHT = 1;

		public const int SPREAD_NORMAL = 2;

		public const int SPREAD_AGGRESSIVE = 3;
	}
}
namespace UIManager
{
	internal static class UIRoot
	{
		private static Harmony _harmony;

		private static bool _initialized;

		private static ButtonSfx _sfxTemplate;

		private static UIRootHost _host;

		public const int FrontSortingOrder = 2000;

		public static Transform Front { get; private set; }

		public static Transform Back { get; private set; }

		public static bool IsReady => (Object)(object)Front != (Object)null;

		public static bool IsHeadless => (int)SystemInfo.graphicsDeviceType == 4;

		public static int UILayer
		{
			get
			{
				int num = LayerMask.NameToLayer("UI");
				if (num < 0)
				{
					return 5;
				}
				return num;
			}
		}

		internal static UIRootHost Host
		{
			get
			{
				EnsureHost();
				return _host;
			}
		}

		public static event Action OnReady;

		public static void Init(ManualLogSource log = null, Harmony harmony = null)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (!_initialized)
			{
				_initialized = true;
				if (log != null)
				{
					UILog.Use(log);
				}
				if (IsHeadless)
				{
					UILog.Debug("headless - skipping GUI setup");
					return;
				}
				string text = "uimanager." + typeof(UIRoot).Assembly.GetName().Name.ToLowerInvariant();
				_harmony = (Harmony)(((object)harmony) ?? ((object)new Harmony(text)));
				_harmony.PatchAll(typeof(UIRoot));
				_harmony.PatchAll(typeof(InputBlocker));
				_harmony.PatchAll(typeof(UIPanels));
				SceneManager.sceneLoaded += OnSceneLoaded;
				EnsureHost();
				TryCreateGui();
			}
		}

		private static void EnsureHost()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			if (!((Object)(object)_host != (Object)null))
			{
				GameObject val = new GameObject("UIManager.Host [" + typeof(UIRoot).Assembly.GetName().Name + "]")
				{
					hideFlags = (HideFlags)61
				};
				Object.DontDestroyOnLoad((Object)val);
				_host = val.AddComponent<UIRootHost>();
			}
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (!(((Scene)(ref scene)).name != "start") || !(((Scene)(ref scene)).name != "main"))
			{
				GameAssets.Index(force: true);
				if ((Object)(object)_host != (Object)null)
				{
					((MonoBehaviour)_host).StartCoroutine(WaitAndCreate());
				}
			}
		}

		private static IEnumerator WaitAndCreate()
		{
			for (int i = 0; i < 300; i++)
			{
				if (IsReady)
				{
					break;
				}
				TryCreateGui();
				if (IsReady)
				{
					break;
				}
				yield return null;
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "SetupGui")]
		[HarmonyPostfix]
		private static void FejdStartupSetupGuiPostfix()
		{
			TryCreateGui();
		}

		[HarmonyPatch(typeof(Game), "Start")]
		[HarmonyPostfix]
		private static void GameStartPostfix()
		{
			TryCreateGui();
		}

		public static void TryCreateGui()
		{
			if (IsReady || IsHeadless)
			{
				return;
			}
			Transform val = FindGuiRoot();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GameAssets.Index(force: true);
			VanillaUI.Harvest(force: true);
			string name = typeof(UIRoot).Assembly.GetName().Name;
			Back = CreateCanvas("UIManager.Back [" + name + "]", 0, val).transform;
			Back.SetAsFirstSibling();
			Front = CreateCanvas("UIManager.Front [" + name + "]", 2000, val).transform;
			Front.SetAsLastSibling();
			UILog.Debug("GUI canvases created under " + UIExtensions.PathOf(val));
			try
			{
				UIRoot.OnReady?.Invoke();
			}
			catch (Exception e)
			{
				UILog.Error("a UIRoot.OnReady handler threw", e);
			}
		}

		private static void SetLayerRecursively(GameObject target, int layer)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			target.layer = layer;
			foreach (Transform item in target.transform)
			{
				SetLayerRecursively(((Component)item).gameObject, layer);
			}
		}

		private static Transform FindGuiRoot()
		{
			GameObject val = GameObject.Find("GuiRoot/GUI");
			if ((Object)(object)val != (Object)null)
			{
				return val.transform;
			}
			GameObject val2 = GameObject.Find("_GameMain/LoadingGUI");
			if ((Object)(object)val2 != (Object)null)
			{
				return val2.transform;
			}
			return null;
		}

		private static GameObject CreateCanvas(string name, int sortingOrder, Transform parent)
		{
			//IL_0048: 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)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_007b: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[5]
			{
				typeof(RectTransform),
				typeof(Canvas),
				typeof(CanvasScaler),
				typeof(GraphicRaycaster),
				typeof(GuiPixelFix)
			})
			{
				layer = UILayer
			};
			val.transform.SetParent(parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			((Transform)val2).localScale = Vector3.one;
			Canvas component = val.GetComponent<Canvas>();
			component.renderMode = (RenderMode)0;
			component.overrideSorting = true;
			component.sortingOrder = sortingOrder;
			component.additionalShaderChannels = (AdditionalCanvasShaderChannels)25;
			val.GetComponent<CanvasScaler>().referencePixelsPerUnit = 50f;
			return val;
		}

		public static GameObject Instantiate(GameObject prefab, Transform parent = null, bool style = true, StyleOptions options = null)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				UILog.Error("cannot instantiate a null prefab");
				return null;
			}
			if ((Object)(object)parent == (Object)null)
			{
				parent = Front;
			}
			if ((Object)(object)parent == (Object)null)
			{
				UILog.Error("the GUI is not up yet - hook UIRoot.OnReady before instantiating '" + ((Object)prefab).name + "'");
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(prefab, parent, false);
			((Object)val).name = ((Object)prefab).name;
			SetLayerRecursively(val, UILayer);
			if (style)
			{
				Styler.Apply(val, options);
			}
			return val;
		}

		public static Canvas RaiseAbove(GameObject target, int extra = 100)
		{
			if ((Object)(object)target == (Object)null)
			{
				return null;
			}
			Canvas obj = target.GetComponent<Canvas>() ?? target.AddComponent<Canvas>();
			obj.overrideSorting = true;
			obj.sortingOrder = 2000 + extra;
			if ((Object)(object)target.GetComponent<GraphicRaycaster>() == (Object)null)
			{
				target.AddComponent<GraphicRaycaster>();
			}
			return obj;
		}

		public static ButtonSfx FindSfxTemplate()
		{
			if ((Object)(object)_sfxTemplate != (Object)null)
			{
				return _sfxTemplate;
			}
			ButtonSfx[] array = Resources.FindObjectsOfTypeAll<ButtonSfx>();
			foreach (ButtonSfx val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.m_sfxPrefab == (Object)null))
				{
					_sfxTemplate = val;
					break;
				}
			}
			return _sfxTemplate;
		}

		public static Coroutine Run(IEnumerator routine)
		{
			EnsureHost();
			return ((MonoBehaviour)_host).StartCoroutine(routine);
		}
	}
	internal class UIRootHost : MonoBehaviour
	{
		private void Update()
		{
			InputBlocker.Tick();
			UIPanels.Tick();
		}
	}
	internal static class GameAssets
	{
		private static readonly Dictionary<string, Sprite> SpriteIndex = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, List<Sprite>> SpriteDuplicates = new Dictionary<string, List<Sprite>>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, Font> FontIndex = new Dictionary<string, Font>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, TMP_FontAsset> TmpFontIndex = new Dictionary<string, TMP_FontAsset>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, Material> MaterialIndex = new Dictionary<string, Material>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, AudioClip> ClipIndex = new Dictionary<string, AudioClip>(StringComparer.OrdinalIgnoreCase);

		private static int _indexedFrame = -1;

		public static bool TrustedOnly;

		public static bool IsIndexed => _indexedFrame >= 0;

		public static int SpriteCount => SpriteIndex.Count;

		public static IEnumerable<string> SpriteNames => SpriteIndex.Keys;

		public static IEnumerable<string> FontNames => FontIndex.Keys;

		public static IEnumerable<string> TmpFontNames => TmpFontIndex.Keys;

		public static IEnumerable<Sprite> AllSprites => SpriteIndex.Values;

		public static void Index(bool force = false)
		{
			if (force || _indexedFrame != Time.frameCount)
			{
				SpriteIndex.Clear();
				SpriteDuplicates.Clear();
				FontIndex.Clear();
				TmpFontIndex.Clear();
				MaterialIndex.Clear();
				ClipIndex.Clear();
				Sprite[] array = Resources.FindObjectsOfTypeAll<Sprite>();
				for (int i = 0; i < array.Length; i++)
				{
					AddSprite(array[i]);
				}
				IndexAtlases();
				Font[] array2 = Resources.FindObjectsOfTypeAll<Font>();
				foreach (Font val in array2)
				{
					Put<Font>((IDictionary<string, Font>)FontIndex, ((Object)(object)val != (Object)null) ? ((Object)val).name : null, val);
				}
				TMP_FontAsset[] array3 = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
				foreach (TMP_FontAsset val2 in array3)
				{
					Put<TMP_FontAsset>((IDictionary<string, TMP_FontAsset>)TmpFontIndex, ((Object)(object)val2 != (Object)null) ? ((Object)val2).name : null, val2);
				}
				Material[] array4 = Resources.FindObjectsOfTypeAll<Material>();
				foreach (Material val3 in array4)
				{
					Put<Material>((IDictionary<string, Material>)MaterialIndex, ((Object)(object)val3 != (Object)null) ? ((Object)val3).name : null, val3);
				}
				AudioClip[] array5 = Resources.FindObjectsOfTypeAll<AudioClip>();
				foreach (AudioClip val4 in array5)
				{
					Put<AudioClip>((IDictionary<string, AudioClip>)ClipIndex, ((Object)(object)val4 != (Object)null) ? ((Object)val4).name : null, val4);
				}
				_indexedFrame = Time.frameCount;
				UILog.Debug($"indexed {SpriteIndex.Count} sprites, {FontIndex.Count} fonts, {TmpFontIndex.Count} TMP fonts, {MaterialIndex.Count} materials, {ClipIndex.Count} clips");
			}
		}

		private static void IndexAtlases()
		{
			SpriteAtlas[] array = Resources.FindObjectsOfTypeAll<SpriteAtlas>();
			foreach (SpriteAtlas val in array)
			{
				if ((Object)(object)val == (Object)null || val.spriteCount <= 0)
				{
					continue;
				}
				try
				{
					Sprite[] array2 = (Sprite[])(object)new Sprite[val.spriteCount];
					val.GetSprites(array2);
					Sprite[] array3 = array2;
					for (int j = 0; j < array3.Length; j++)
					{
						AddSprite(array3[j]);
					}
				}
				catch (Exception ex)
				{
					UILog.Debug("could not read atlas '" + ((Object)val).name + "': " + ex.Message);
				}
			}
		}

		private static void AddSprite(Sprite sprite)
		{
			if ((Object)(object)sprite == (Object)null)
			{
				return;
			}
			string text = ((Object)sprite).name;
			if (text.EndsWith("(Clone)", StringComparison.Ordinal))
			{
				text = text.Substring(0, text.Length - 7);
			}
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			if (!SpriteIndex.ContainsKey(text))
			{
				SpriteIndex[text] = sprite;
			}
			else if (!((Object)(object)SpriteIndex[text] == (Object)(object)sprite))
			{
				if (!SpriteDuplicates.TryGetValue(text, out var value))
				{
					value = (SpriteDuplicates[text] = new List<Sprite>());
				}
				if (!value.Contains(sprite))
				{
					value.Add(sprite);
				}
			}
		}

		private static void Put<T>(IDictionary<string, T> index, string name, T value) where T : Object
		{
			if (!((Object)(object)value == (Object)null) && !string.IsNullOrEmpty(name) && !index.ContainsKey(name))
			{
				index[name] = value;
			}
		}

		public static Sprite Sprite(string name)
		{
			TryGetSprite(name, out var sprite);
			return sprite;
		}

		public static bool TryGetSprite(string name, out Sprite sprite)
		{
			sprite = null;
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			if (VanillaUI.TryGetSprite(name, out sprite))
			{
				return true;
			}
			if (TrustedOnly)
			{
				return false;
			}
			if (!IsIndexed)
			{
				Index();
			}
			if (SpriteIndex.TryGetValue(name, out sprite) && (Object)(object)sprite != (Object)null)
			{
				return true;
			}
			Index(force: true);
			if (SpriteIndex.TryGetValue(name, out sprite))
			{
				return (Object)(object)sprite != (Object)null;
			}
			return false;
		}

		public static IList<Sprite> SpritesNamed(string name)
		{
			List<Sprite> list = new List<Sprite>();
			if (TryGetSprite(name, out var sprite))
			{
				list.Add(sprite);
			}
			if (SpriteDuplicates.TryGetValue(name, out var value))
			{
				list.AddRange(value);
			}
			return list;
		}

		public static Sprite FirstSprite(params string[] candidates)
		{
			for (int i = 0; i < candidates.Length; i++)
			{
				if (TryGetSprite(candidates[i], out var sprite))
				{
					return sprite;
				}
			}
			return null;
		}

		public static Font Font(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			Font val = VanillaUI.Font(name);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			if (TrustedOnly)
			{
				return null;
			}
			if (!IsIndexed)
			{
				Index();
			}
			if (FontIndex.TryGetValue(name, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			Index(force: true);
			if (!FontIndex.TryGetValue(name, out value))
			{
				return null;
			}
			return value;
		}

		public static Font FirstFont(params string[] candidates)
		{
			for (int i = 0; i < candidates.Length; i++)
			{
				Font val = Font(candidates[i]);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		public static TMP_FontAsset TmpFont(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			TMP_FontAsset val = VanillaUI.TmpFont(name);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			if (TrustedOnly)
			{
				return null;
			}
			if (!IsIndexed)
			{
				Index();
			}
			if (TmpFontIndex.TryGetValue(name, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			Index(force: true);
			if (!TmpFontIndex.TryGetValue(name, out value))
			{
				return null;
			}
			return value;
		}

		public static TMP_FontAsset FirstTmpFont(params string[] candidates)
		{
			for (int i = 0; i < candidates.Length; i++)
			{
				TMP_FontAsset val = TmpFont(candidates[i]);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		public static TMP_FontAsset AnyTmpFont()
		{
			if (!IsIndexed)
			{
				Index();
			}
			foreach (TMP_FontAsset value in TmpFontIndex.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					return value;
				}
			}
			return null;
		}

		public static Material Material(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			if (!IsIndexed)
			{
				Index();
			}
			if (!MaterialIndex.TryGetValue(name, out var value))
			{
				return null;
			}
			return value;
		}

		public static AudioClip Clip(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			if (!IsIndexed)
			{
				Index();
			}
			if (!ClipIndex.TryGetValue(name, out var value))
			{
				return null;
			}
			return value;
		}

		public static AudioClip FirstClip(params string[] candidates)
		{
			for (int i = 0; i < candidates.Length; i++)
			{
				AudioClip val = Clip(candidates[i]);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		public static IEnumerable<string> Search(string term, int limit = 60)
		{
			if (!IsIndexed)
			{
				Index();
			}
			if (string.IsNullOrEmpty(term))
			{
				return SpriteIndex.Keys.OrderBy((string k) => k).Take(limit);
			}
			return (from k in SpriteIndex.Keys
				where k.IndexOf(term, StringComparison.OrdinalIgnoreCase) >= 0
				orderby k
				select k).Take(limit);
		}
	}
	internal static class VanillaUI
	{
		private static readonly Dictionary<string, Sprite> Sprites = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, Font> Fonts = new Dictionary<string, Font>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, TMP_FontAsset> TmpFonts = new Dictionary<string, TMP_FontAsset>(StringComparer.OrdinalIgnoreCase);

		private static Material _uiMaterial;

		private static TMP_FontAsset _primaryTmpFont;

		private static TMP_FontAsset _titleTmpFont;

		private static Font _primaryFont;

		private static Scrollbar _scrollbar;

		private static ScrollRect _scrollRect;

		private static int _scrollbarScore;

		private static int _harvestedFrame = -1;

		private static int _retries;

		private static Scrollbar _reportedScrollbar;

		private const int RetryFrames = 30;

		private static bool _hooked;

		private static readonly Dictionary<TMP_FontAsset, int> _tmpFontUse = new Dictionary<TMP_FontAsset, int>();

		private static readonly Dictionary<Font, int> _fontUse = new Dictionary<Font, int>();

		private static float _largestText;

		private static readonly Dictionary<string, Sprite> AtlasSprites = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);

		private static SpriteAtlas[] _atlases;

		private static bool Incomplete
		{
			get
			{
				if (!((Object)(object)_scrollbar == (Object)null) && !((Object)(object)_scrollRect == (Object)null) && !((Object)(object)_uiMaterial == (Object)null))
				{
					return (Object)(object)_primaryTmpFont == (Object)null;
				}
				return true;
			}
		}

		public static bool IsHeadless => (int)SystemInfo.graphicsDeviceType == 4;

		public static bool IsHarvested => _harvestedFrame >= 0;

		public static int SpriteCount => Sprites.Count;

		public static Material UiMaterial
		{
			get
			{
				Harvest();
				return _uiMaterial;
			}
		}

		public static TMP_FontAsset PrimaryTmpFont
		{
			get
			{
				Harvest();
				return _primaryTmpFont;
			}
		}

		public static TMP_FontAsset TitleTmpFont
		{
			get
			{
				Harvest();
				if (!((Object)(object)_titleTmpFont != (Object)null))
				{
					return _primaryTmpFont;
				}
				return _titleTmpFont;
			}
		}

		public static Font PrimaryFont
		{
			get
			{
				Harvest();
				return _primaryFont;
			}
		}

		public static Scrollbar ScrollbarTemplate
		{
			get
			{
				Harvest();
				if (!((Object)(object)_scrollbar != (Object)null))
				{
					return null;
				}
				return _scrollbar;
			}
		}

		public static ScrollRect ScrollRectTemplate
		{
			get
			{
				Harvest();
				if (!((Object)(object)_scrollRect != (Object)null))
				{
					return null;
				}
				return _scrollRect;
			}
		}

		public static IEnumerable<string> SpriteNames
		{
			get
			{
				Harvest();
				return Sprites.Keys;
			}
		}

		public static void Invalidate()
		{
			_harvestedFrame = -1;
			_retries = 0;
			_reportedScrollbar = null;
			AtlasSprites.Clear();
			_atlases = null;
			Skin.ResetLogs();
		}

		private static void HookSceneChanges()
		{
			if (!_hooked)
			{
				_hooked = true;
				SceneManager.sceneLoaded += delegate
				{
					Invalidate();
				};
			}
		}

		public static void Harvest(bool force = false)
		{
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			if (IsHeadless)
			{
				return;
			}
			HookSceneChanges();
			if (!force)
			{
				if (_harvestedFrame == Time.frameCount)
				{
					return;
				}
				if (_harvestedFrame >= 0)
				{
					if (!Incomplete || Time.frameCount - _harvestedFrame < 30)
					{
						return;
					}
					_retries++;
				}
			}
			Sprites.Clear();
			Fonts.Clear();
			TmpFonts.Clear();
			_uiMaterial = null;
			_scrollbar = null;
			_scrollRect = null;
			_scrollbarScore = 0;
			_primaryTmpFont = null;
			_titleTmpFont = null;
			_primaryFont = null;
			Dictionary<Material, int> dictionary = new Dictionary<Material, int>();
			_tmpFontUse.Clear();
			_fontUse.Clear();
			_largestText = 0f;
			bool flag = false;
			Scrollbar val = NamedScrollbar();
			if ((Object)(object)val != (Object)null)
			{
				_scrollbar = val;
				_scrollbarScore = int.MaxValue;
				ScrollRect componentInParent = ((Component)val).GetComponentInParent<ScrollRect>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					_scrollRect = componentInParent;
				}
			}
			foreach (GameObject item in Roots())
			{
				if (!((Object)(object)item == (Object)null))
				{
					flag = true;
					Collect(item, dictionary);
				}
			}
			if (!flag)
			{
				return;
			}
			foreach (KeyValuePair<Material, int> item2 in dictionary)
			{
				if (!((Object)(object)item2.Key == (Object)null) && ((Object)item2.Key).name.StartsWith("litpanel", StringComparison.OrdinalIgnoreCase))
				{
					_uiMaterial = item2.Key;
					break;
				}
			}
			int num = 0;
			if ((Object)(object)_uiMaterial == (Object)null)
			{
				foreach (KeyValuePair<Material, int> item3 in dictionary)
				{
					if (!((Object)(object)item3.Key == (Object)null) && item3.Value > num)
					{
						num = item3.Value;
						_uiMaterial = item3.Key;
					}
				}
			}
			_primaryTmpFont = MostUsed<TMP_FontAsset>(_tmpFontUse);
			_primaryFont = MostUsed<Font>(_fontUse);
			_harvestedFrame = Time.frameCount;
			if (!Incomplete)
			{
				_retries = 0;
			}
			if ((Object)(object)_scrollbar != (Object)null && (Object)(object)_scrollbar != (Object)(object)_reportedScrollbar)
			{
				_reportedScrollbar = _scrollbar;
				Image component = ((Component)_scrollbar).GetComponent<Image>();
				UILog.Info("scrollbar template '" + UIExtensions.PathOf(((Component)_scrollbar).transform) + "' " + $"score {ScoreScrollbar(_scrollbar)}, " + "track " + (((Object)(object)component != (Object)null) ? ((object)((Graphic)component).color/*cast due to .constrained prefix*/).ToString() : "none") + ", " + $"transition {((Selectable)_scrollbar).transition}, " + "scrollrect '" + (((Object)(object)_scrollRect != (Object)null) ? UIExtensions.PathOf(((Component)_scrollRect).transform) : "none") + "' " + $"sensitivity {(((Object)(object)_scrollRect != (Object)null) ? _scrollRect.scrollSensitivity : 0f)}");
			}
			UILog.Debug($"harvested {Sprites.Count} sprites, {Fonts.Count} fonts, {TmpFonts.Count} TMP fonts from the game UI; " + "material '" + (((Object)(object)_uiMaterial != (Object)null) ? ((Object)_uiMaterial).name : "none") + "', scrollbar '" + (((Object)(object)_scrollbar != (Object)null) ? UIExtensions.PathOf(((Component)_scrollbar).transform) : "none") + "' " + $"(score {_scrollbarScore}), " + "body font '" + (((Object)(object)_primaryTmpFont != (Object)null) ? ((Object)_primaryTmpFont).name : "none") + "', title font '" + (((Object)(object)_titleTmpFont != (Object)null) ? ((Object)_titleTmpFont).name : "none") + "'");
		}

		private static T MostUsed<T>(Dictionary<T, int> counts) where T : Object
		{
			T result = default(T);
			int num = 0;
			foreach (KeyValuePair<T, int> count in counts)
			{
				if (!((Object)(object)count.Key == (Object)null) && count.Value > num)
				{
					num = count.Value;
					result = count.Key;
				}
			}
			return result;
		}

		public static IEnumerable<GameObject> RootObjects()
		{
			return Roots();
		}

		private static IEnumerable<GameObject> Roots()
		{
			yield return Instance((Component)(object)FejdStartup.instance);
			if ((Object)(object)FejdStartup.instance != (Object)null)
			{
				yield return FejdStartup.instance.m_settingsPrefab;
			}
			if ((Object)(object)Menu.instance != (Object)null)
			{
				yield return Menu.instance.m_settingsPrefab;
			}
			yield return Instance((Component)(object)InventoryGui.instance);
			yield return Instance((Component)(object)Menu.instance);
			yield return Instance((Component)(object)Hud.instance);
			yield return Instance((Component)(object)StoreGui.instance);
			yield return Instance((Component)(object)TextViewer.instance);
			yield return Instance((Component)(object)Minimap.instance);
		}

		private static GameObject Instance(Component component)
		{
			if (!((Object)(object)component != (Object)null))
			{
				return null;
			}
			return component.gameObject;
		}

		private static void Collect(GameObject root, IDictionary<Material, int> materialUse)
		{
			Image[] componentsInChildren = root.GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if ((Object)(object)val.sprite != (Object)null)
					{
						Put<Sprite>((IDictionary<string, Sprite>)Sprites, ((Object)val.sprite).name, val.sprite);
					}
					Material material = ((Graphic)val).material;
					if ((Object)(object)material != (Object)null && (Object)(object)material != (Object)(object)Graphic.defaultGraphicMaterial)
					{
						materialUse[material] = ((!materialUse.TryGetValue(material, out var value)) ? 1 : (value + 1));
					}
				}
			}
			Text[] componentsInChildren2 = root.GetComponentsInChildren<Text>(true);
			foreach (Text val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.font == (Object)null))
				{
					Put<Font>((IDictionary<string, Font>)Fonts, ((Object)val2.font).name, val2.font);
					_fontUse[val2.font] = ((!_fontUse.TryGetValue(val2.font, out var value2)) ? 1 : (value2 + 1));
				}
			}
			TMP_Text[] componentsInChildren3 = root.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val3 in componentsInChildren3)
			{
				if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val3.font == (Object)null))
				{
					Put<TMP_FontAsset>((IDictionary<string, TMP_FontAsset>)TmpFonts, ((Object)val3.font).name, val3.font);
					_tmpFontUse[val3.font] = ((!_tmpFontUse.TryGetValue(val3.font, out var value3)) ? 1 : (value3 + 1));
					if (val3.fontSize > _largestText)
					{
						_largestText = val3.fontSize;
						_titleTmpFont = val3.font;
					}
				}
			}
			if ((Object)(object)_scrollRect == (Object)null)
			{
				ScrollRect[] componentsInChildren4 = root.GetComponentsInChildren<ScrollRect>(true);
				foreach (ScrollRect val4 in componentsInChildren4)
				{
					if (!((Object)(object)val4 == (Object)null))
					{
						_scrollRect = val4;
						break;
					}
				}
			}
			Scrollbar[] componentsInChildren5 = root.GetComponentsInChildren<Scrollbar>(true);
			foreach (Scrollbar scrollbar in componentsInChildren5)
			{
				int num = ScoreScrollbar(scrollbar);
				if (num > _scrollbarScore)
				{
					_scrollbarScore = num;
					_scrollbar = scrollbar;
				}
			}
		}

		private static Scrollbar NamedScrollbar()
		{
			if ((Object)(object)FejdStartup.instance != (Object)null)
			{
				FejdStartup instance = FejdStartup.instance;
				if (Usable(InPanel(instance.m_worldListPanel), out var result))
				{
					return result;
				}
				if (Usable(InPanel(instance.m_serverListPanel), out var result2))
				{
					return result2;
				}
				if (Usable(InPanel(instance.m_characterSelectScreen), out var result3))
				{
					return result3;
				}
				if (Usable(FromSettings(instance.m_settingsPrefab), out var result4))
				{
					return result4;
				}
			}
			if ((Object)(object)InventoryGui.instance != (Object)null)
			{
				if (Usable(InventoryGui.instance.m_recipeListScroll, out var result5))
				{
					return result5;
				}
				if (Usable(InventoryGui.instance.m_trophyListScroll, out var result6))
				{
					return result6;
				}
			}
			if ((Object)(object)Menu.instance != (Object)null && Usable(FromSettings(Menu.instance.m_settingsPrefab), out var result7))
			{
				return result7;
			}
			if ((Object)(object)StoreGui.instance != (Object)null && Usable(StoreGui.instance.m_listScroll, out var result8))
			{
				return result8;
			}
			return null;
		}

		private static bool IsUnskinned(Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (color.r > 0.95f && color.g > 0.95f)
			{
				return color.b > 0.95f;
			}
			return false;
		}

		private static Scrollbar InPanel(GameObject panel)
		{
			if (!((Object)(object)panel != (Object)null))
			{
				return null;
			}
			return panel.GetComponentInChildren<Scrollbar>(true);
		}

		private static Scrollbar FromSettings(GameObject settingsPrefab)
		{
			if ((Object)(object)settingsPrefab == (Object)null)
			{
				return null;
			}
			GraphicsSettings componentInChildren = settingsPrefab.GetComponentInChildren<GraphicsSettings>(true);
			if (!((Object)(object)componentInChildren != (Object)null))
			{
				return null;
			}
			return componentInChildren.m_resolutionListScroll;
		}

		private static bool Usable(Scrollbar candidate, out Scrollbar result)
		{
			result = ((ScoreScrollbar(candidate) > 0) ? candidate : null);
			return (Object)(object)result != (Object)null;
		}

		private static int ScoreScrollbar(Scrollbar scrollbar)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Invalid comparison between Unknown and I4
			if ((Object)(object)scrollbar == (Object)null || (Object)(object)scrollbar.handleRect == (Object)null)
			{
				return 0;
			}
			Image val = (Image)(((object)((Component)scrollbar.handleRect).GetComponent<Image>()) ?? ((object)/*isinst with value type is only supported in some contexts*/));
			if ((Object)(object)val == (Object)null)
			{
				return 0;
			}
			Image component = ((Component)scrollbar).GetComponent<Image>();
			if ((Object)(object)component == (Object)null || IsUnskinned(((Graphic)component).color))
			{
				return 0;
			}
			int num = 3;
			if ((int)((Selectable)scrollbar).transition == 1)
			{
				num += 2;
			}
			if ((Object)(object)((Graphic)val).material != (Object)null && (Object)(object)((Graphic)val).material != (Object)(object)Graphic.defaultGraphicMaterial)
			{
				num += 2;
			}
			if ((Object)(object)((Component)scrollbar).GetComponentInParent<ScrollRect>() != (Object)null)
			{
				num++;
			}
			return num;
		}

		private static void Put<T>(IDictionary<string, T> index, string name, T value) where T : Object
		{
			if (!((Object)(object)value == (Object)null) && !string.IsNullOrEmpty(name) && !index.ContainsKey(name))
			{
				index[name] = value;
			}
		}

		public static bool TryGetSprite(string name, out Sprite sprite)
		{
			sprite = null;
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			Harvest();
			if (Sprites.TryGetValue(name, out sprite) && (Object)(object)sprite != (Object)null)
			{
				return true;
			}
			sprite = FromAtlas(name);
			return (Object)(object)sprite != (Object)null;
		}

		private static Sprite FromAtlas(string name)
		{
			if (IsHeadless)
			{
				return null;
			}
			if (AtlasSprites.TryGetValue(name, out var value))
			{
				return value;
			}
			SpriteAtlas[] array;
			if (_atlases == null)
			{
				List<SpriteAtlas> list = new List<SpriteAtlas>();
				array = Resources.FindObjectsOfTypeAll<SpriteAtlas>();
				foreach (SpriteAtlas val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						if (((Object)val).name == "UIAtlas" || ((Object)val).name == "IconAtlas")
						{
							list.Insert(0, val);
						}
						else
						{
							list.Add(val);
						}
					}
				}
				_atlases = list.ToArray();
			}
			array = _atlases;
			foreach (SpriteAtlas val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					Sprite sprite = val2.GetSprite(name);
					if (!((Object)(object)sprite == (Object)null))
					{
						((Object)sprite).name = name;
						AtlasSprites[name] = sprite;
						return sprite;
					}
				}
			}
			AtlasSprites[name] = null;
			return null;
		}

		public static Font Font(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			Harvest();
			if (!Fonts.TryGetValue(name, out var value))
			{
				return null;
			}
			return value;
		}

		public static TMP_FontAsset TmpFont(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			Harvest();
			if (!TmpFonts.TryGetValue(name, out var value))
			{
				return null;
			}
			return value;
		}
	}
	internal class ModBundle : IDisposable
	{
		private static readonly Dictionary<string, ModBundle> Cache = new Dictionary<string, ModBundle>(StringComparer.OrdinalIgnoreCase);

		public AssetBundle Bundle { get; private set; }

		public string Name { get; private set; }

		public IEnumerable<string> AssetNames
		{
			get
			{
				if (!((Object)(object)Bundle != (Object)null))
				{
					return Enumerable.Empty<string>();
				}
				return Bundle.GetAllAssetNames();
			}
		}

		private ModBundle(string name, AssetBundle bundle)
		{
			Name = name;
			Bundle = bundle;
		}

		public static ModBundle FromEmbeddedResource(string fileName, Assembly assembly = null)
		{
			if (Cache.TryGetValue(fileName, out var value) && (Object)(object)value.Bundle != (Object)null)
			{
				return value;
			}
			assembly = assembly ?? Assembly.GetCallingAssembly();
			string[] manifestResourceNames = assembly.GetManifestResourceNames();
			string text = manifestResourceNames.FirstOrDefault((string n) => n.EndsWith(fileName, StringComparison.OrdinalIgnoreCase));
			if (text == null)
			{
				UILog.Error("no embedded resource ending in '" + fileName + "' in " + assembly.GetName().Name + ". Found: " + ((manifestResourceNames.Length == 0) ? "none" : string.Join(", ", manifestResourceNames)));
				return null;
			}
			byte[] array;
			using (Stream stream = assembly.GetManifestResourceStream(text))
			{
				if (stream == null)
				{
					UILog.Error("could not open embedded resource '" + text + "'");
					return null;
				}
				using MemoryStream memoryStream = new MemoryStream();
				stream.CopyTo(memoryStream);
				array = memoryStream.ToArray();
			}
			AssetBundle val = AssetBundle.LoadFromMemory(array);
			if ((Object)(object)val == (Object)null)
			{
				UILog.Error("'" + text + "' is not a valid AssetBundle for this Unity version");
				return null;
			}
			ModBundle modBundle = new ModBundle(fileName, val);
			Cache[fileName] = modBundle;
			UILog.Debug($"loaded bundle '{fileName}' with {val.GetAllAssetNames().Length} assets");
			return modBundle;
		}

		public static ModBundle FromFile(string path)
		{
			if (!File.Exists(path))
			{
				UILog.Error("no bundle at '" + path + "'");
				return null;
			}
			string fileName = Path.GetFileName(path);
			if (Cache.TryGetValue(fileName, out var value) && (Object)(object)value.Bundle != (Object)null)
			{
				return value;
			}
			AssetBundle val = AssetBundle.LoadFromFile(path);
			if ((Object)(object)val == (Object)null)
			{
				UILog.Error("'" + path + "' is not a valid AssetBundle");
				return null;
			}
			ModBundle modBundle = new ModBundle(fileName, val);
			Cache[fileName] = modBundle;
			return modBundle;
		}

		public T Load<T>(string assetName) where T : Object
		{
			if ((Object)(object)Bundle == (Object)null)
			{
				return default(T);
			}
			T val = Bundle.LoadAsset<T>(assetName);
			if ((Object)(object)val == (Object)null)
			{
				UILog.Error("bundle '" + Name + "' has no " + typeof(T).Name + " called '" + assetName + "'");
			}
			return val;
		}

		public GameObject Prefab(string prefabName)
		{
			return this.Load<GameObject>(prefabName);
		}

		public GameObject Instantiate(string prefabName, Transform parent = null, bool style = true, StyleOptions options = null)
		{
			GameObject val = Prefab(prefabName);
			if (!((Object)(object)val == (Object)null))
			{
				return UIRoot.Instantiate(val, parent, style, options);
			}
			return null;
		}

		public void Dispose()
		{
			if (!((Object)(object)Bundle == (Object)null))
			{
				Cache.Remove(Name);
				Bundle.Unload(false);
				Bundle = null;
			}
		}
	}
	[Serializable]
	internal class SpriteRecord
	{
		public string name;

		public string file;

		public string texture;

		public int width;

		public int height;

		public float pixelsPerUnit;

		public float[] border = new float[4];

		public float[] pivot = new float[2];
	}
	[Serializable]
	internal class DumpManifest
	{
		public string generated;

		public string unityVersion;

		public List<SpriteRecord> sprites = new List<SpriteRecord>();

		public List<string> fonts = new List<string>();

		public List<string> tmpFonts = new List<string>();

		public List<string> materials = new List<string>();
	}
	internal static class AssetDump
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<string, string> <>9__2_0;

			public static Func<string, string> <>9__2_1;

			public static ConsoleEvent <>9__8_0;

			public static ConsoleEvent <>9__8_1;

			public static ConsoleEvent <>9__8_2;

			public static Func<string, string> <>9__8_4;

			public static Func<string, string> <>9__8_5;

			public static ConsoleEvent <>9__8_3;

			internal string <Dump>b__2_0(string n)
			{
				return n;
			}

			internal string <Dump>b__2_1(string n)
			{
				return n;
			}

			internal void <RegisterConsoleCommands>b__8_0(ConsoleEventArgs args)
			{
				string filter = ((args.Length > 1) ? args[1] : null);
				args.Context.AddString(Dump(filter));
			}

			internal void <RegisterConsoleCommands>b__8_1(ConsoleEventArgs args)
			{
				if (args.Length < 2)
				{
					args.Context.AddString("usage: uim_find <term>");
					return;
				}
				List<string> list = GameAssets.Search(args[1]).ToList();
				args.Context.AddString((list.Count == 0) ? ("no sprite matches " + args[1]) : string.Join("\n", list.ToArray()));
			}

			internal void <RegisterConsoleCommands>b__8_2(ConsoleEventArgs args)
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Expected O, but got Unknown
				if ((Object)(object)UIRoot.Front == (Object)null)
				{
					args.Context.AddString("the GUI is not up yet");
					return;
				}
				bool flag = false;
				foreach (Transform item in UIRoot.Front)
				{
					Transform val = item;
					if (((Component)val).gameObject.activeInHierarchy)
					{
						flag = true;
						string text = UILayout.Report(((Component)val).gameObject);
						args.Context.AddString(text);
						UILog.Info(Environment.NewLine + text);
					}
				}
				if (!flag)
				{
					args.Context.AddString("no visible windows on the UIManager canvas");
				}
			}

			internal void <RegisterConsoleCommands>b__8_3(ConsoleEventArgs args)
			{
				args.Context.AddString("Font: " + string.Join(", ", GameAssets.FontNames.OrderBy((string n) => n).ToArray()));
				args.Context.AddString("TMP: " + string.Join(", ", GameAssets.TmpFontNames.OrderBy((string n) => n).ToArray()));
			}

			internal string <RegisterConsoleCommands>b__8_4(string n)
			{
				return n;
			}

			internal string <RegisterConsoleCommands>b__8_5(string n)
			{
				return n;
			}
		}

		private static bool _registered;

		public static string DefaultDirectory
		{
			get
			{
				try
				{
					return Path.Combine(Paths.PluginPath, "UIManager_StyleKit");
				}
				catch
				{
					return Path.Combine(Application.dataPath, "../UIManager_StyleKit");
				}
			}
		}

		public static string Dump(string filter = null, string directory = null)
		{
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: 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_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: 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)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			directory = directory ?? DefaultDirectory;
			string text = Path.Combine(directory, "Sprites");
			Directory.CreateDirectory(text);
			GameAssets.Index(force: true);
			DumpManifest dumpManifest = new DumpManifest
			{
				generated = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
				unityVersion = Application.unityVersion
			};
			int num = 0;
			int num2 = 0;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (Sprite item in GameAssets.AllSprites.ToList())
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				string name = ((Object)item).name;
				if (!string.IsNullOrEmpty(filter) && name.IndexOf(filter, StringComparison.OrdinalIgnoreCase) < 0)
				{
					continue;
				}
				string text2 = Sanitize(name);
				if (!hashSet.Add(text2))
				{
					continue;
				}
				try
				{
					Texture2D val = Extract(item);
					if ((Object)(object)val == (Object)null)
					{
						num2++;
						continue;
					}
					string text3 = text2 + ".png";
					File.WriteAllBytes(Path.Combine(text, text3), ImageConversion.EncodeToPNG(val));
					Object.DestroyImmediate((Object)(object)val);
					List<SpriteRecord> sprites = dumpManifest.sprites;
					SpriteRecord spriteRecord = new SpriteRecord
					{
						name = name,
						file = text3,
						texture = (((Object)(object)item.texture != (Object)null) ? ((Object)item.texture).name : string.Empty)
					};
					Rect rect = item.rect;
					spriteRecord.width = Mathf.RoundToInt(((Rect)(ref rect)).width);
					rect = item.rect;
					spriteRecord.height = Mathf.RoundToInt(((Rect)(ref rect)).height);
					spriteRecord.pixelsPerUnit = item.pixelsPerUnit;
					spriteRecord.border = new float[4]
					{
						item.border.x,
						item.border.y,
						item.border.z,
						item.border.w
					};
					float[] array = new float[2];
					rect = item.rect;
					float num3;
					if (!(((Rect)(ref rect)).width > 0f))
					{
						num3 = 0.5f;
					}
					else
					{
						float x = item.pivot.x;
						rect = item.rect;
						num3 = x / ((Rect)(ref rect)).width;
					}
					array[0] = num3;
					rect = item.rect;
					float num4;
					if (!(((Rect)(ref rect)).height > 0f))
					{
						num4 = 0.5f;
					}
					else
					{
						float y = item.pivot.y;
						rect = item.rect;
						num4 = y / ((Rect)(ref rect)).height;
					}
					array[1] = num4;
					spriteRecord.pivot = array;
					sprites.Add(spriteRecord);
					num++;
				}
				catch (Exception ex)
				{
					num2++;
					UILog.Debug("could not dump sprite '" + name + "': " + ex.Message);
				}
			}
			dumpManifest.fonts.AddRange(GameAssets.FontNames.OrderBy((string n) => n));
			dumpManifest.tmpFonts.AddRange(GameAssets.TmpFontNames.OrderBy((string n) => n));
			File.WriteAllText(Path.Combine(directory, "manifest.json"), JsonUtility.ToJson((object)dumpManifest, true));
			File.WriteAllText(Path.Combine(directory, "README.txt"), Readme(dumpManifest));
			string text4 = $"dumped {num} sprites to {directory}" + ((num2 > 0) ? $" ({num2} skipped)" : string.Empty);
			UILog.Info(text4);
			return text4;
		}

		private static Texture2D Extract(Sprite sprite)
		{
			//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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			Texture2D texture = sprite.texture;
			if ((Object)(object)texture == (Object)null)
			{
				return null;
			}
			Rect val = sprite.textureRect;
			if (((Rect)(ref val)).width < 1f || ((Rect)(ref val)).height < 1f)
			{
				val = sprite.rect;
			}
			if (((Rect)(ref val)).width < 1f || ((Rect)(ref val)).height < 1f)
			{
				return null;
			}
			RenderTexture temporary = RenderTexture.GetTemporary(((Texture)texture).width, ((Texture)texture).height, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
			RenderTexture active = RenderTexture.active;
			try
			{
				Graphics.Blit((Texture)(object)texture, temporary);
				RenderTexture.active = temporary;
				Texture2D val2 = new Texture2D((int)((Rect)(ref val)).width, (int)((Rect)(ref val)).height, (TextureFormat)4, false);
				val2.ReadPixels(new Rect(((Rect)(ref val)).x, ((Rect)(ref val)).y, ((Rect)(ref val)).width, ((Rect)(ref val)).height), 0, 0);
				val2.Apply();
				return val2;
			}
			finally
			{
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
			}
		}

		private static string Sanitize(string name)
		{
			StringBuilder stringBuilder = new StringBuilder(name.Length);
			foreach (char c in name)
			{
				stringBuilder.Append((Array.IndexOf(Path.GetInvalidFileNameChars(), c) >= 0) ? '_' : c);
			}
			return stringBuilder.ToString();
		}

		private static string Readme(DumpManifest manifest)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("UIManager style kit");
			stringBuilder.AppendLine("===================");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("Generated " + manifest.generated + " from Valheim running Unity " + manifest.unityVersion + ".");
			stringBuilder.AppendLine($"{manifest.sprites.Count} sprites.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("How to use:");
			stringBuilder.AppendLine(" 1. Copy this whole folder into your Unity project.");
			stringBuilder.AppendLine(" 2. The UIManagerStyleKit editor script reads manifest.json and applies the");
			stringBuilder.AppendLine("    original 9-slice borders, pivots and pixels-per-unit to every PNG.");
			stringBuilder.AppendLine(" 3. Build your UI using these sprites. Keep the sprite ASSET names unchanged -");
			stringBuilder.AppendLine("    that name is what Styler matches on at runtime. GameObject names are yours");
			stringBuilder.AppendLine("    to prefix however you like.");
			stringBuilder.AppendLine(" 4. At runtime Styler.Apply swaps each one for the live game asset, so your UI");
			stringBuilder.AppendLine("    picks up the real atlas, material and any art changes from game patches.");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("Fonts available in game (use the same names on your Text components):");
			foreach (string font in manifest.fonts)
			{
				stringBuilder.AppendLine("  " + font);
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("TextMeshPro fonts:");
			foreach (string tmpFont in manifest.tmpFonts)
			{
				stringBuilder.AppendLine("  " + tmpFont);
			}
			return stringBuilder.ToString();
		}

		private static void Command(string name, string description, ConsoleEvent action)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (Terminal.commands != null && Terminal.commands.ContainsKey(name))
			{
				UILog.Debug("console command '" + name + "' is already registered, leaving it alone");
			}
			else
			{
				new ConsoleCommand(name, description, action, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			}
		}

		public static void RegisterConsoleCommands()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00b6: 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: Expected O, but got Unknown
			if (_registered)
			{
				return;
			}
			_registered = true;
			object obj = <>c.<>9__8_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					string filter = ((args.Length > 1) ? args[1] : null);
					args.Context.AddString(Dump(filter));
				};
				<>c.<>9__8_0 = val;
				obj = (object)val;
			}
			Command("uim_dump", "[filter] - dump Valheim UI sprites to a style kit folder", (ConsoleEvent)obj);
			object obj2 = <>c.<>9__8_1;
			if (obj2 == null)
			{
				ConsoleEvent val2 = delegate(ConsoleEventArgs args)
				{
					if (args.Length < 2)
					{
						args.Context.AddString("usage: uim_find <term>");
					}
					else
					{
						List<string> list = GameAssets.Search(args[1]).ToList();
						args.Context.AddString((list.Count == 0) ? ("no sprite matches " + args[1]) : string.Join("\n", list.ToArray()));
					}
				};
				<>c.<>9__8_1 = val2;
				obj2 = (object)val2;
			}
			Command("uim_find", "<term> - list game sprites whose name contains term", (ConsoleEvent)obj2);
			object obj3 = <>c.<>9__8_2;
			if (obj3 == null)
			{
				ConsoleEvent val3 = delegate(ConsoleEventArgs args)
				{
					//IL_0033: Unknown result type (might be due to invalid IL or missing references)
					//IL_0039: Expected O, but got Unknown
					if ((Object)(object)UIRoot.Front == (Object)null)
					{
						args.Context.AddString("the GUI is not up yet");
					}
					else
					{
						bool flag = false;
						foreach (Transform item in UIRoot.Front)
						{
							Transform val5 = item;
							if (((Component)val5).gameObject.activeInHierarchy)
							{
								flag = true;
								string text = UILayout.Report(((Component)val5).gameObject);
								args.Context.AddString(text);
								UILog.Info(Environment.NewLine + text);
							}
						}
						if (!flag)
						{
							args.Context.AddString("no visible windows on the UIManager canvas");
						}
					}
				};
				<>c.<>9__8_2 = val3;
				obj3 = (object)val3;
			}
			Command("uim_overlap", "what your windows are covering, and how far to move", (ConsoleEvent)obj3);
			object obj4 = <>c.<>9__8_3;
			if (obj4 == null)
			{
				ConsoleEvent val4 = delegate(ConsoleEventArgs args)
				{
					args.Context.AddString("Font: " + string.Join(", ", GameAssets.FontNames.OrderBy((string n) => n).ToArray()));
					args.Context.AddString("TMP: " + string.Join(", ", GameAssets.TmpFontNames.OrderBy((string n) => n).ToArray()));
				};
				<>c.<>9__8_3 = val4;
				obj4 = (object)val4;
			}
			Command("uim_fonts", "list the fonts the game has loaded", (ConsoleEvent)obj4);
		}
	}
	internal enum TextRole
	{
		Body,
		Title,
		Header,
		Label,
		Disabled
	}
	internal static class SpriteNames
	{
		public static string[] Window = new string[3] { "woodpanel_settings", "woodpanel_trophys", "woodpanel_password" };

		public static string[] Panel = new string[4] { "panel_interior_bkg_128", "woodpanel_trophys", "InventoryBkg", "Background" };

		public static string[] Button = new string[3] { "button", "button_small", "menu_button" };

		public static string[] ButtonHighlight = new string[2] { "button_highlight", "button_fill" };

		public static string[] ButtonDisabled = new string[2] { "button_disabled", "button" };

		public static string[] Field = new string[2] { "text_field", "InputFieldBackground" };

		public static string[] Checkbox = new string[1] { "checkbox" };

		public static string[] CheckboxMarker = new string[1] { "checkbox_marker" };

		public static string[] Slot = new string[3] { "item_background_sunken", "item_background", "inventory_slot" };

		public static string[] ScrollHandle = new string[3] { "scrollbar_handle", "UISprite", "button" };

		public static string[] ScrollTrack = new string[3] { "scrollbar_bkg", "Background", "UISprite" };

		public static string[] Divider = new string[2] { "line_bkg", "UISprite" };
	}
	internal static class FontNames
	{
		public static string[] Body = new string[2] { "AveriaSerifLibre-Regular", "Averia Serif Libre" };

		public static string[] Bold = new string[1] { "AveriaSerifLibre-Bold" };

		public static string[] Norse = new string[2] { "Norse", "Norsebold" };

		public static string[] NorseBold = new string[2] { "Norsebold", "Norse" };

		public static string[] TmpBody = new string[2] { "Valheim-AveriaSansLibre", "AveriaSerifLibre-Regular SDF" };

		public static string[] TmpTitle = new string[2] { "Valheim-Norse", "Norsebold SDF" };
	}
	internal static class GameColors
	{
		public static Color Orange = new Color(1f, 0.631f, 0.235f, 1f);

		public static Color Yellow = new Color(1f, 0.889f, 0f, 1f);

		public static Color Beige = new Color(0.8529f, 0.725f, 0.5331f, 1f);

		public static Color Muted = new Color(0.639f, 0.596f, 0.518f, 1f);

		public static Color Disabled = new Color(0.42f, 0.4f, 0.36f, 1f);

		public static Color Danger = new Color(0.85f, 0.27f, 0.22f, 1f);

		public static ColorBlock ButtonColors;

		static GameColors()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: 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)
			ColorBlock buttonColors = default(ColorBlock);
			((ColorBlock)(ref buttonColors)).normalColor = new Color(0.824f, 0.824f, 0.824f, 1f);
			((ColorBlock)(ref buttonColors)).highlightedColor = new Color(1.3f, 1.3f, 1.3f, 1f);
			((ColorBlock)(ref buttonColors)).pressedColor = new Color(0.537f, 0.556f, 0.556f, 1f);
			((ColorBlock)(ref buttonColors)).selectedColor = new Color(0.824f, 0.824f, 0.824f, 1f);
			((ColorBlock)(ref buttonColors)).disabledColor = new Color(0.566f, 0.566f, 0.566f, 0.502f);
			((ColorBlock)(ref buttonColors)).colorMultiplier = 1f;
			((ColorBlock)(ref buttonColors)).fadeDuration = 0.1f;
			ButtonColors = buttonColors;
		}
	}
	internal static class Skin
	{
		private static readonly Color CheckmarkColour = new Color(1f, 0.678f, 0.103f, 1f);

		private static readonly ColorBlock CheckboxColours;

		private static bool _loggedScrollbar;

		private static readonly Color TrackColour;

		private static readonly ColorBlock HandleColours;

		private static bool _loggedScrollRect;

		public const float VanillaScrollSensitivity = 3000f;

		private static readonly Color SliderFillColour;

		private static readonly Color SliderHandleColour;

		private static readonly ColorBlock SliderColours;

		public static float PixelsPerUnit
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				Scene activeScene = SceneManager.GetActiveScene();
				if (!(((Scene)(ref activeScene)).name == "start"))
				{
					return 1f;
				}
				return 2f;
			}
		}

		public static void Highlight(Image image, Color? color = null)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)image == (Object)null))
			{
				((Graphic)image).color = (Color)(((??)color) ?? GameColors.Yellow);
				((Graphic)image).material = null;
			}
		}

		public static void Window(Image image)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)image == (Object)null))
			{
				Sprite val = GameAssets.FirstSprite(SpriteNames.Window);
				if (!((Object)(object)val == (Object)null))
				{
					image.sprite = val;
					image.type = (Type)1;
					((Graphic)image).color = Color.white;
					((Graphic)image).material = null;
				}
			}
		}

		public static void Panel(Image image)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)image == (Object)null))
			{
				Sprite val = GameAssets.FirstSprite(SpriteNames.Panel);
				if (!((Object)(object)val == (Object)null))
				{
					image.sprite = val;
					image.type = (Type)1;
					((Graphic)image).color = Color.white;
				}
			}
		}

		public static void Slot(Image image)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)image == (Object)null))
			{
				Sprite val = GameAssets.FirstSprite(SpriteNames.Slot);
				if (!((Object)(object)val == (Object)null))
				{
					image.sprite = val;
					image.type = (Type)1;
					((Graphic)image).color = Color.white;
				}
			}
		}

		public static void Button(Button button, int fontSize = 0, bool withSfx = true)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)button == (Object)null)
			{
				return;
			}
			Graphic targetGraphic = ((Selectable)button).targetGraphic;
			Image val = (Image)(((object)((targetGraphic is Image) ? targetGraphic : null)) ?? ((object)((Component)button).GetComponent<Image>()));
			Sprite val2 = GameAssets.FirstSprite(SpriteNames.Button);
			if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
			{
				val.sprite = val2;
				val.type = (Type)1;
				val.pixelsPerUnitMultiplier = PixelsPerUnit;
				((Graphic)val).color = Color.white;
				((Selectable)button).targetGraphic = (Graphic)(object)val;
			}
			((Selectable)button).colors = GameColors.ButtonColors;
			Sprite val3 = GameAssets.FirstSprite(SpriteNames.ButtonHighlight);
			if ((Object)(object)val3 != (Object)null)
			{
				((Selectable)button).transition = (Transition)2;
				SpriteState spriteState = ((Selectable)button).spriteState;
				((SpriteState)(ref spriteState)).highlightedSprite = val3;
				((SpriteState)(ref spriteState)).pressedSprite = val3;
				((SpriteState)(ref spriteState)).selectedSprite = val3;
				Sprite val4 = GameAssets.FirstSprite(SpriteNames.ButtonDisabled);
				if ((Object)(object)val4 != (Object)null)
				{
					((SpriteState)(ref spriteState)).disabledSprite = val4;
				}
				((Selectable)button).spriteState = spriteState;
			}
			Text[] componentsInChildren = ((Component)button).GetComponentsInChildren<Text>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Text(componentsInChildren[i], TextRole.Label, fontSize);
			}
			TMP_Text[] componentsInChildren2 = ((Component)button).GetComponentsInChildren<TMP_Text>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				Text(componentsInChildren2[i], TextRole.Label, fontSize);
			}
			if (withSfx)
			{
				Sfx(button);
			}
		}

		public static void Sfx(Button button)
		{
			if (!((Object)(object)button == (Object)null) && !((Object)(object)((Component)button).GetComponent<ButtonSfx>() != (Object)null))
			{
				ButtonSfx val = UIRoot.FindSfxTemplate();
				if (!((Object)(object)val == (Object)null))
				{
					ButtonSfx obj = ((Component)button).gameObject.AddComponent<ButtonSfx>();
					obj.m_sfxPrefab = val.m_sfxPrefab;
					obj.m_selectSfxPrefab = val.m_selectSfxPrefab;
				}
			}
		}

		public static void Text(Text text, TextRole role = TextRole.Body, int fontSize = 0, bool outline = true)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)text == (Object)null))
			{
				Font val = ((role == TextRole.Title || role == TextRole.Header) ? (GameAssets.FirstFont(FontNames.NorseBold) ?? GameAssets.FirstFont(FontNames.Bold)) : (GameAssets.FirstFont(FontNames.Body) ?? GameAssets.FirstFont(FontNames.Bold)));
				if ((Object)(object)val != (Object)null)
				{
					text.font = val;
				}
				((Graphic)text).color = ColorFor(role);
				if (fontSize > 0)
				{
					text.fontSize = fontSize;
				}
				if (outline)
				{
					Outline(((Component)text).gameObject);
				}
			}
		}

		public static bool Font(TMP_Text text, TextRole role = TextRole.Body)
		{
			//IL_0048: 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)
			if ((Object)(object)text == (Object)null)
			{
				return false;
			}
			TMP_FontAsset val = ((role == TextRole.Title || role == TextRole.Header) ? VanillaUI.TitleTmpFont : VanillaUI.PrimaryTmpFont);
			val = val ?? GameAssets.FirstTmpFont((role == TextRole.Title) ? FontNames.TmpTitle : FontNames.TmpBody);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			text.fontStyle = (FontStyles)(text.fontStyle & -69);
			if ((Object)(object)val == (Object)(object)text.font)
			{
				return false;
			}
			text.font = val;
			if ((Object)(object)((TMP_Asset)val).material != (Object)null)
			{
				text.fontSharedMaterial = ((TMP_Asset)val).material;
			}
			return true;
		}

		public static bool Font(Text text, TextRole role = TextRole.Body)
		{
			if ((Object)(object)text == (Object)null)
			{
				return false;
			}
			Font val = VanillaUI.PrimaryFont ?? ((role == TextRole.Title || role == TextRole.Header) ? GameAssets.FirstFont(FontNames.NorseBold) : GameAssets.FirstFont(FontNames.Body));
			if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)text.font)
			{
				return false;
			}
			text.font = val;
			return true;
		}

		public static void Text(TMP_Text text, TextRole role = TextRole.Body, int fontSize = 0)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)text == (Object)null))
			{
				Font(text, role);
				((Graphic)text).color = ColorFor(role);
				if (fontSize > 0)
				{
					text.fontSize = fontSize;
				}
			}
		}

		public static Color ColorFor(TextRole role)
		{
			//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)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(role switch
			{
				TextRole.Title => GameColors.Orange, 
				TextRole.Header => GameColors.Yellow, 
				TextRole.Label => GameColors.Beige, 
				TextRole.Disabled => GameColors.Disabled, 
				_ => GameColors.Beige, 
			});
		}

		public static void Outline(GameObject target, Color? color = null)
		{
			//IL_0036: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)target == (Object)null))
			{
				Outline val = target.GetComponent<Outline>();
				if ((Object)(object)val == (Object)null)
				{
					val = target.AddComponent<Outline>();
				}
				((Shadow)val).effectColor = (Color)(((??)color) ?? Color.black);
				((Shadow)val).effectDistance = new Vector2(1f, -1f);
			}
		}

		public static void InputField(InputField field, int fontSize = 0)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)field == (Object)null))
			{
				Image component = ((Component)field).GetComponent<Image>();
				Sprite val = GameAssets.FirstSprite(SpriteNames.Field);
				if ((Object)(object)component != (Object)null && (Object)(object)val != (Object)null)
				{
					component.sprite = val;
					component.type = (Type)1;
					((Graphic)component).color = Color.white;
				}
				if ((Object)(object)field.textComponent != (Object)null)
				{
					Text(field.textComponent, TextRole.Body, fontSize);
				}
				Graphic placeholder = field.placeholder;
				Text val2 = (Text)(object)((placeholder is Text) ? placeholder : null);
				if (val2 != null)
				{
					Text(val2, TextRole.Disabled, fontSize);
				}
			}
		}

		public static void Toggle(Toggle toggle)
		{
			//IL_0090: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)toggle == (Object)null)
			{
				return;
			}
			Graphic targetGraphic = ((Selectable)toggle).targetGraphic;
			Image val = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
			Sprite val2 = GameAssets.FirstSprite(SpriteNames.Checkbox);
			if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
			{
				val.sprite = val2;
				val.type = (Type)0;
				((Graphic)val).color = Color.white;
			}
			Graphic graphic = toggle.graphic;
			Image val3 = (Image)(object)((graphic is Image) ? graphic : null);
			if (val3 != null)
			{
				Sprite val4 = GameAssets.FirstSprite(SpriteNames.CheckboxMarker);
				if ((Object)(object)val4 != (Object)null)
				{
					val3.sprite = val4;
					val3.type = (Type)0;
				}
				((Graphic)val3).color = CheckmarkColour;
			}
			((Selectable)toggle).transition = (Transition)1;
			((Selectable)toggle).colors = CheckboxColours;
			Text[] componentsInChildren = ((Component)toggle).GetComponentsInChildren<Text>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Text(componentsInChildren[i], TextRole.Label);
			}
		}

		public static void Scrollbar(Scrollbar scrollbar)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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_017c: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)scrollbar == (Object)null)
			{
				return;
			}
			Scrollbar scrollbarTemplate = VanillaUI.ScrollbarTemplate;
			if ((Object)(object)scrollbarTemplate == (Object)null)
			{
				ScrollbarByName(scrollbar);
				ApplyVanillaScrollbarColours(scrollbar);
				return;
			}
			Image val = HandleImage(scrollbarTemplate);
			Image val2 = TrackImage(scrollbarTemplate, val);
			Image val3 = HandleImage(scrollbar);
			Image val4 = TrackImage(scrollbar, val3);
			if (!_loggedScrollbar)
			{
				_loggedScrollbar = true;
				UILog.Info("scrollbar copied from " + UIExtensions.PathOf(((Component)scrollbarTemplate).transform) + " (track '" + (((Object)(object)val2 != (Object)null) ? SpriteName(val2) : "none") + "', handle '" + (((Object)(object)val != (Object)null) ? SpriteName(val) : "none") + "')");
			}
			((Selectable)scrollbar).transition = ((Selectable)scrollbarTemplate).transition;
			((Selectable)scrollbar).colors = ((Selectable)scrollbarTemplate).colors;
			if ((Object)(object)val4 != (Object)null)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					CopyImage(val2, val4);
					((Behaviour)val4).enabled = true;
				}
				else
				{
					((Behaviour)val4).enabled = false;
				}
			}
			if ((Object)(object)val3 != (Object)null && (Object)(object)val != (Object)null)
			{
				CopyImage(val, val3);
			}
			((Selectable)scrollbar).colors = ((Selectable)scrollbarTemplate).colors;
			((Selectable)scrollbar).transition = ((Selectable)scrollbarTemplate).transition;
			((Selectable)scrollbar).spriteState = ((Selectable)scrollbarTemplate).spriteState;
			Navigation navigation = default(Navigation);
			((Navigation)(ref navigation)).mode = (Mode)0;
			((Selectable)scrollbar).navigation = navigation;
			if ((Object)(object)((Selectable)scrollbar).targetGraphic != (Object)null)
			{
				CanvasRenderer canvasRenderer = ((Selectable)scrollbar).targetGraphic.canvasRenderer;
				Color color;
				if ((int)((Selectable)scrollbar).transition != 1)
				{
					color = Color.white;
				}
				else
				{
					ColorBlock colors = ((Selectable)scrollbar).colors;
					color = ((ColorBlock)(ref colors)).normalColor;
				}
				canvasRenderer.SetColor(color);
			}
			((Behaviour)scrollbar).enabled = false;
			((Behaviour)scrollbar).enabled = true;
		}

		public static void ApplyVanillaScrollbarColours(Scrollbar scrollbar)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)scrollbar == (Object)null))
			{
				Image val = HandleImage(scrollbar);
				Image val2 = TrackImage(scrollbar, val);
				if ((Object)(object)val2 != (Object)null)
				{
					((Graphic)val2).color = TrackColour;
					((Behaviour)val2).enabled = true;
				}
				if ((Object)(object)val != (Object)null)
				{
					((Graphic)val).color = Color.white;
				}
				((Selectable)scrollbar).transition = (Transition)1;
				((Selectable)scrollbar).colors = HandleColours;
				Navigation navigation = default(Navigation);
				((Navigation)(ref navigation)).mode = (Mode)0;
				((Selectable)scrollbar).navigation = navigation;
				if ((Object)(object)((Selectable)scrollbar).targetGraphic != (Object)null)
				{
					CanvasRenderer canvasRenderer = ((Selectable)scrollbar).targetGraphic.canvasRenderer;
					ColorBlock handleColours = HandleColours;
					canvasRenderer.SetColor(((ColorBlock)(ref handleColours)).normalColor);
				}
				((Behaviour)scrollbar).enabled = false;
				((Behaviour)scrollbar).enabled = true;
			}
		}

		private static string SpriteName(Image image)
		{
			if (!((Object)(object)image.sprite != (Object)null))
			{
				return "no sprite";
			}
			return ((Object)image.sprite).name;
		}

		private static Image HandleImage(Scrollbar scrollbar)
		{
			if ((Object)(object)scrollbar.handleRect != (Object)null)
			{
				Image component = ((Component)scrollbar.handleRect).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					return component;
				}
			}
			Graphic targetGraphic = ((Selectable)scrollbar).targetGraphic;
			return (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
		}

		private static Image TrackImage(Scrollbar scrollbar, Image handle)
		{
			Image component = ((Component)scrollbar).GetComponent<Image>();
			if ((Object)(object)component != (Object)null && (Object)(object)component != (Object)(object)handle)
			{
				return component;
			}
			Image[] componentsInChildren = ((Component)scrollbar).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)handle) && (!((Object)(object)handle != (Object)null) || !((Component)val).transform.IsChildOf(((Component)handle).transform)) && (!((Object)(object)scrollbar.handleRect != (Object)null) || !((Component)val).transform.IsChildOf((Transform)(object)scrollbar.handleRect)))
				{
					return val;
				}
			}
			return null;
		}

		private static void ScrollbarByName(Scrollbar scrollbar)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			Image val = HandleImage(scrollbar);
			Image val2 = TrackImage(scrollbar, val);
			if ((Object)(object)val2 != (Object)null && VanillaUI.TryGetSprite(SpriteNames.ScrollTrack[0], out var sprite))
			{
				val2.sprite = sprite;
				val2.type = (Type)1;
				((Graphic)val2).color = new Color(0f, 0f, 0f, 0.5f);
			}
			if ((Object)(object)val != (Object)null && VanillaUI.TryGetSprite(SpriteNames.ScrollHandle[0], out var sprite2))
			{
				val.sprite = sprite2;
				val.type = (Type)1;
				((Graphic)val).color = GameColors.Muted;
			}
			if (!_loggedScrollbar)
			{
				_loggedScrollbar = true;
				UILog.Warning("no vanilla scrollbar found to copy; left the prefab's own art in place");
			}
		}

		public static void ResetLogs()
		{
			_loggedScrollRect = false;
			_loggedScrollbar = false;
		}

		public static void ScrollRect(ScrollRect scroll, float fallbackSensitivity = 3000f)
		{
			if ((Object)(object)scroll == (Object)null)
			{
				return;
			}
			ScrollRect scrollRectTemplate = VanillaUI.ScrollRectTemplate;
			if ((Object)(object)scrollRectTemplate == (Object)null)
			{
				scroll.scrollSensitivity = fallbackSensitivity;
				Report(scroll, "no template");
				return;
			}
			scroll.scrollSensitivity = scrollRectTemplate.scrollSensitivity;
			scroll.inertia = scrollRectTemplate.inertia;
			scroll.decelerationRate = scrollRectTemplate.decelerationRate;
			scroll.elasticity = scrollRectTemplate.elasticity;
			if (scroll.scrollSensitivity < fallbackSensitivity)
			{
				scroll.scrollSensitivity = fallbackSensitivity;
			}
			Report(scroll, UIExtensions.PathOf(((Component)scrollRectTemplate).transform));
		}

		private static void Report(ScrollRect scroll, string source)
		{
			if (!_loggedScrollRect)
			{
				_loggedScrollRect = true;
				UILog.Info($"scrollrect sensitivity {scroll.scrollSensitivity} (from {source}), " + $"inertia {scroll.inertia}, deceleration {scroll.decelerationRate}");
			}
		}

		private static void CopyImage(Image from, Image to)
		{
			//IL_0021: 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)
			if (!((Object)(object)from == (Object)null) && !((Object)(object)to == (Object)null))
			{
				to.sprite = from.sprite;
				to.type = from.type;
				((Graphic)to).color = ((Graphic)from).color;
				((Graphic)to).material = ((Graphic)from).material;
				to.pixelsPerUnitMultiplier = from.pixelsPerUnitMultiplier;
				to.fillCenter = from.fillCenter;
				to.preserveAspect = from.preserveAspect;
			}
		}

		public static bool GameMaterial(Graphic graphic)
		{
			if ((Object)(object)graphic == (Object)null || graphic is TMP_Text)
			{
				return false;
			}
			Material uiMaterial = VanillaUI.UiMaterial;
			if ((Object)(object)uiMaterial == (Object)null || (Object)(object)graphic.material == (Object)(object)uiMaterial)
			{
				return false;
			}
			graphic.material = uiMaterial;
			return true;
		}

		public static bool Unlit(Graphic graphic)
		{
			if ((Object)(object)graphic == (Object)null || graphic is TMP_Text)
			{
				return false;
			}
			if ((Object)(object)graphic.material == (Object)null || (Object)(object)graphic.material == (Object)(object)Graphic.defaultGraphicMaterial)
			{
				return false;
			}
			graphic.material = null;
			return true;
		}

		public static void Slider(Slider slider)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)slider == (Object)null)
			{
				return;
			}
			Graphic targetGraphic = ((Selectable)slider).targetGraphic;
			Image val = (Image)(object)((targetGraphic is Image) ? targetGraphic : null);
			if (val != null)
			{
				val.sprite = null;
				((Graphic)val).color = Color.white;
			}
			if ((Object)(object)slider.fillRect != (Object)null)
			{
				Image component = ((Component)slider.fillRect).GetComponent<Image>();
				if (component != null)
				{
					component.sprite = null;
					((Graphic)component).color = SliderFillColour;
				}
			}
			if ((Object)(object)slider.handleRect != (Object)null)
			{
				Image component2 = ((Component)slider.handleRect).GetComponent<Image>();
				if (component2 != null)
				{
					Sprite val2 = GameAssets.FirstSprite(SpriteNames.CheckboxMarker);
					if ((Object)(object)val2 != (Object)null)
					{
						component2.sprite = val2;
						component2.type = (Type)0;
					}
					((Graphic)component2).color = SliderHandleColour;
				}
			}
			((Selectable)slider).transition = (Transition)1;
			((Selectable)slider).colors = SliderColours;
			if ((Object)(object)((Selectable)slider).targetGraphic != (Object)null)
			{
				CanvasRenderer canvasRenderer = ((Selectable)slider).targetGraphic.canvasRenderer;
				ColorBlock sliderColours = SliderColours;
				canvasRenderer.SetColor(((ColorBlock)(ref sliderColours)).normalColor);
			}
		}

		static Skin()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_005c: 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_0088: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: 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_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			ColorBlock val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = new Color(52f / 85f, 52f / 85f, 52f / 85f, 1f);
			((ColorBlock)(ref val)).highlightedColor = new Color(49f / 51f, 49f / 51f, 49f / 51f, 1f);
			((ColorBlock)(ref val)).pressedColor = new Color(40f / 51f, 40f / 51f, 40f / 51f, 1f);
			((ColorBlock)(ref val)).selectedColor = Color.white;
			((ColorBlock)(ref val)).disabledColor = new Color(40f / 51f, 40f / 51f, 40f / 51f, 0.5019608f);
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			CheckboxColours = val;
			TrackColour = new Color(0.192f, 0.126f, 0.078f, 1f);
			val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = new Color(63f / 68f, 0.64584446f, 0.34061417f, 1f);
			((ColorBlock)(ref val)).highlightedColor = new Color(1f, 114f / 145f, 0.08823532f, 1f);
			((ColorBlock)(ref val)).pressedColor = new Color(0.83823526f, 0.6471056f, 0.030817453f, 1f);
			((ColorBlock)(ref val)).selectedColor = new Color(1f, 114f / 145f, 0.08823532f, 1f);
			((ColorBlock)(ref val)).disabledColor = new Color(40f / 51f, 40f / 51f, 40f / 51f, 0.5019608f);
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			HandleColours = val;
			SliderFillColour = new Color(0.647f, 0.647f, 0.647f, 1f);
			SliderHandleColour = new Color(1f, 0.641f, 0f, 1f);
			val = default(ColorBlock);
			((ColorBlock)(ref val)).normalColor = new Color(0.271f, 0.271f, 0.271f, 1f);
			((ColorBlock)(ref val)).highlightedColor = new Color(0.957f, 0.957f, 0.957f, 1f);
			((ColorBlock)(ref val)).pressedColor = new Color(0.784f, 0.784f, 0.784f, 1f);
			((ColorBlock)(ref val)).selectedColor = new Color(0.957f, 0.957f, 0.957f, 1f);
			((ColorBlock)(ref val)).disabledColor = new Color(0.784f, 0.784f, 0.784f, 0.502f);
			((ColorBlock)(ref val)).colorMultiplier = 1f;
			((ColorBlock)(ref val)).fadeDuration = 0.1f;
			SliderColours = val;
		}
	}
	internal static class Styler
	{
		public static StyleReport Apply(GameObject root, StyleOptions options = null)
		{
			StyleReport styleReport = new StyleReport();
			if ((Object)(object)root == (Object)null)
			{
				return styleReport;
			}
			options = options ?? StyleOptions.Default;
			VanillaUI.Harvest();
			GameAssets.Index();
			if (options.RebindAssets || options.FixBrokenShaders || options.ApplyGameMaterial)
			{
				Rebind(root, options, styleReport);
			}
			if (options.RebindAssets)
			{
				Scrollbar[] componentsInChildren = root.GetComponentsInChildren<Scrollbar>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Skin.Scrollbar(componentsInChildren[i]);
				}
			}
			if (options.MatchGameScrolling)
			{
				ScrollRect[] componentsInChildren2 = root.GetComponentsInChildren<ScrollRect>(true);
				for (int i = 0; i < componentsInChildren2.Length; i++)
				{
					Skin.ScrollRect(componentsInChildren2[i], options.FallbackScrollSensitivity);
				}
			}
			if (options.StyleByComponent)
			{
				StyleByComponent(root, options, styleReport);
			}
			ApplyRules(root, options, styleReport);
			UILog.Debug($"styled '{((Object)root).name}': {styleReport}");
			if (UILog.Verbose && styleReport.UnresolvedSprites.Count > 0)
			{
				UILog.Debug("no game sprite named: " + string.Join(", ", styleReport.UnresolvedSprites.ToArray()));
			}
			return styleReport;
		}

		public static int Lit(GameObject root, params string[] paths)
		{
			return Set(root, paths, lit: true);
		}

		public static int Unlit(GameObject root, params string[] paths)
		{
			return Set(root, paths, lit: false);
		}

		private static int Set(GameObject root, string[] paths, bool lit)
		{
			if ((Object)(object)root == (Object)null)
			{
				return 0;
			}
			int num = 0;
			foreach (GameObject item in Targets(root, paths))
			{
				Graphic[] components = item.GetComponents<Graphic>();
				foreach (Graphic graphic in components)
				{
					if (lit ? Skin.GameMaterial(graphic) : Skin.Unlit(graphic))
					{
						num++;
					}
				}
			}
			return num;
		}

		private static IEnumerable<GameObject> Targets(GameObject root, string[] paths)
		{
			if (paths == null || paths.Length == 0)
			{
				yield return root;
				yield break;
			}
			foreach (string text in paths)
			{
				GameObject val = UIExtensions.Find(root, text) ?? root.FindDeep(text);
				if ((Object)(object)val == (Object)null)
				{
					UILog.Warning("could not find '" + text + "' under '" + ((Object)root).name + "' to light");
				}
				else
				{
					yield return val;
				}
			}
		}

		public static void ApplyTo(GameObject root, string path, ElementType element, StyleOptions options = null)
		{
			GameObject val = UIExtensions.Find(root, path);
			if ((Object)(object)val == (Object)null)
			{
				UILog.Warning("could not find '" + path + "' under '" + (((Object)(object)root != (Object)null) ? ((Object)root).name : "null") + "'");
			}
			else
			{
				ApplyElement(val, element, options ?? StyleOptions.Default, new StyleReport());
			}
		}

		private static void Rebind(GameObject root, StyleOptions options, StyleReport report)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			Graphic[] componentsInChildren = root.GetComponentsInChildren<Graphic>(true);
			foreach (Graphic val in componentsInChildren)
			{
				if (options.FixBrokenShaders)
				{
					FixMaterial(val, report);
				}
				if (options.ApplyGameMaterial && Skin.GameMaterial(val))
				{
					report.MaterialsApplied++;
				}
				if (!options.RebindAssets)
				{
					continue;
				}
				Image val2 = (Image)(object)((val is Image) ? val : null);
				if (val2 != null)
				{
					RebindSprite(val2, options, report);
					continue;
				}
				Text val3 = (Text)(object)((val is Text) ? val : null);
				if (val3 != null)
				{
					RebindFont(val3, options, report);
					continue;
				}
				TMP_Text val4 = (TMP_Text)(object)((val is TMP_Text) ? val : null);
				if (val4 != null)
				{
					RebindTmpFont(val4, options, report);
				}
			}
			if (!options.RebindAssets)
			{
				return;
			}
			Selectable[] componentsInChildren2 = root.GetComponentsInChildren<Selectable>(true);
			foreach (Selectable val5 in componentsInChildren2)
			{
				SpriteState spriteState = val5.spriteState;
				bool flag = false;
				Sprite sprite = ((SpriteState)(ref spriteState)).highlightedSprite;
				if (RebindSprite(ref sprite, report))
				{
					((SpriteState)(ref spriteState)).highlightedSprite = sprite;
					flag = true;
				}
				Sprite sprite2 = ((SpriteState)(ref spriteState)).pressedSprite;
				if (RebindSprite(ref sprite2, report))
				{
					((SpriteState)(ref spriteState)).pressedSprite = sprite2;
					flag = true;
				}
				Sprite sprite3 = ((SpriteState)(ref spriteState)).selectedSprite;
				if (RebindSprite(ref sprite3, report))
				{
					((SpriteState)(ref spriteState)).selectedSprite = sprite3;
					flag = true;
				}
				Sprite sprite4 = ((SpriteState)(ref spriteState)).disabledSprite;
				if (RebindSprite(ref sprite4, report))
				{
					((SpriteState)(ref spriteState)).disabledSprite = sprite4;
					flag = true;
				}
				if (flag)
				{
					val5.spriteState = spriteState;
				}
			}
		}

		private static void RebindSprite(Image image, StyleOptions options, StyleReport report)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Invalid comparison between Unknown and I4
			Sprite sprite = image.sprite;
			if ((Object)(object)sprite == (Object)null)
			{
				return;
			}
			if (!GameAssets.TryGetSprite(((Object)sprite).name, out var sprite2))
			{
				if (!report.UnresolvedSprites.Contains(((Object)sprite).name))
				{
					report.UnresolvedSprites.Add(((Object)sprite).name);
				}
				return;
			}
			if (options.MatchMenuPixelDensity && (int)image.type == 1)
			{
				image.pixelsPerUnitMultiplier = Skin.PixelsPerUnit;
			}
			if (!((Object)(object)sprite2 == (Object)(object)sprite))
			{
				image.sprite = sprite2;
				report.SpritesRebound++;
			}
		}

		private static bool RebindSprite(ref Sprite sprite, StyleReport report)
		{
			if ((Object)(object)sprite == (Object)null)
			{
				return false;
			}
			if (!GameAssets.TryGetSprite(((Object)sprite).name, out var sprite2) || (Object)(object)sprite2 == (Object)(object)sprite)
			{
				return false;
			}
			sprite = sprite2;
			report.SpritesRebound++;
			return true;
		}

		private static void RebindFont(Text text, StyleOptions options, StyleReport report)
		{
			if ((Object)(object)text.font == (Object)null)
			{
				return;
			}
			Font val = VanillaUI.Font(((Object)text.font).name);
			if ((Object)(object)val == (Object)null)
			{
				if (!report.UnresolvedFonts.Contains(((Object)text.font).name))
				{
					report.UnresolvedFonts.Add(((Object)text.font).name);
				}
				if (options.FallbackToGameFonts && Skin.Font(text, IsTitleFont(((Object)text.font).name) ? TextRole.Title : TextRole.Body))
				{
					report.FontsRebound++;
				}
			}
			else if (!((Object)(object)val == (Object)(object)text.font))
			{
				text.font = val;
				report.FontsRebound++;
			}
		}

		private static void RebindTmpFont(TMP_Text text, StyleOptions options, StyleReport report)
		{
			//IL_00bf: 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)
			if ((Object)(object)text.font == (Object)null)
			{
				return;
			}
			TMP_FontAsset val = VanillaUI.TmpFont(((Object)text.font).name);
			if ((Object)(object)val == (Object)null)
			{
				if (!report.UnresolvedFonts.Contains(((Object)text.font).name))
				{
					report.UnresolvedFonts.Add(((Object)text.font).name);
				}
				if (options.FallbackToGameFonts && Skin.Font(text, IsTitleFont(((Object)text.font).name) ? TextRole.Title : TextRole.Body))
				{
					report.FontsRebound++;
				}
			}
			else if (!((Object)(object)val == (Object)(object)text.font))
			{
				text.font = val;
				if ((Object)(object)((TMP_Asset)val).material != (Object)null)
				{
					text.fontSharedMaterial = ((TMP_Asset)val).material;
				}
				text.fontStyle = (FontStyles)(text.fontStyle & -69);
				report.FontsRebound++;
			}
		}

		private static bool IsTitleFont(string name)
		{
			if (!string.IsNullOrEmpty(name))
			{
				return name.IndexOf("norse", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		private static void FixMaterial(Graphic graphic, StyleReport report)
		{
			Material material = graphic.material;
			if (!((Object)(object)material == (Object)null) && !((Object)(object)material == (Object)(object)Graphic.defaultGraphicMaterial) && (!((Object)(object)material.shader != (Object)null) || !(((Object)material.shader).name != "Hidden/InternalErrorShader")))
			{
				graphic.material = null;
				report.ShadersFixed++;
			}
		}

		private static void StyleByComponent(GameObject root, StyleOptions options, StyleReport report)
		{
			Button[] componentsInChildren = root.GetComponentsInChildren<Button>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Skin.Button(componentsInChildren[i], options.DefaultFontSize, options.AddButtonSfx);
				report.WidgetsStyled++;
			}
			InputField[] componentsInChildren2 = root.GetComponentsInChildren<InputField>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				Skin.InputField(componentsInChildren2[i], options.DefaultFontSize);
				report.WidgetsStyled++;
			}
			Toggle[] componentsInChildren3 = root.GetComponentsInChildren<Toggle>(true);
			for (int i = 0; i < componentsInChildren3.Length; i++)
			{
				Skin.Toggle(componentsInChildren3[i]);
				report.WidgetsStyled++;
			}
			Scrollbar[] componentsInChildren4 = root.GetComponentsInChildren<Scrollbar>(true);
			for (int i = 0; i < componentsInChildren4.Length; i++)
			{
				Skin.Scrollbar(componentsInChildren4[i]);
				report.WidgetsStyled++;
			}
			Slider[] componentsInChildren5 = root.GetComponentsInChildren<Slider>(true);
			for (int i = 0; i < componentsInChildren5.Length; i++)
			{
				Skin.Slider(componentsInChildren5[i]);
				report.WidgetsStyled++;
			}
			Text[] componentsInChildren6 = root.GetComponentsInChildren<Text>(true);
			foreach (Text val in componentsInChildren6)
			{
				if (!((Object)(object)((Component)val).GetComponentInParent<Button>() != (Object)null))
				{
					Skin.Text(val, TextRole.Body, options.DefaultFontSize, options.AddTextOutline);
					report.WidgetsStyled++;
				}
			}
			TMP_Text[] componentsInChildren7 = root.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val2 in componentsInChildren7)
			{
				if (!((Object)(object)((Component)val2).GetComponentInParent<Button>() != (Object)null))
				{
					Skin.Text(val2, TextRole.Body, options.DefaultFontSize);
					report.WidgetsStyled++;
				}
			}
		}

		private static void ApplyRules(GameObject root, StyleOptions options, StyleReport report)
		{
			if (options.Rules.Count == 0)
			{
				return;
			}
			List<Transform> list = new List<Transform>();
			UIExtensions.Collect(root.transform, list);
			foreach (StyleRule rule in options.Rules)
			{
				if (rule == null || rule.Match == null)
				{
					continue;
				}
				foreach (Transform item in list)
				{
					if (!rule.Match(((Component)item).gameObject))
					{
						continue;
					}
					if (rule.Recursive)
					{
						List<Transform> list2 = new List<Transform>();
						UIExtensions.Collect(item, list2);
						foreach (Transform item2 in list2)
						{
							ApplyElement(((Component)item2).gameObject, rule.Element, options, report);
						}
					}
					else
					{
						ApplyElement(((Component)item).gameObject, rule.Element, options, report);
					}
				}
			}
		}

		private static void ApplyElement(GameObject target, ElementType element, StyleOptions options, StyleReport report)
		{
			if (!((Object)(object)target == (Object)null))
			{
				report.WidgetsStyled++;
				switch (element)
				{
				case ElementType.Window:
					Skin.Window(target.GetComponent<Image>());
					break;
				case ElementType.Panel:
					Skin.Panel(target.GetComponent<Image>());
					break;
				case ElementType.Slot:
					Skin.Slot(target.GetComponent<Image>());
					break;
				case ElementType.Button:
					Skin.Button(target.GetComponent<Button>(), options.DefaultFontSize, options.AddButtonSfx);
					break;
				case ElementType.InputField:
					Skin.InputField(target.GetComponent<InputField>(), options.DefaultFontSize);
					break;
				case ElementType.Toggle:
					Skin.Toggle(target.GetComponent<Toggle>());
					break;
				case ElementType.Scrollbar:
					Skin.Scrollbar(target.GetComponent<Scrollbar>());
					break;
				case ElementType.Slider:
					Skin.Slider(target.GetComponent<Slider>());
					break;
				default:
					ApplyTextRole(target, element, options);
					break;
				case ElementType.Ignore:
					break;
				}
			}
		}

		private static void ApplyTextRole(GameObject target, ElementType element, StyleOptions options)
		{
			TextRole role = element switch
			{
				ElementType.Title => TextRole.Title, 
				ElementType.Header => TextRole.Header, 
				ElementType.Label => TextRole.Label, 
				_ => TextRole.Body, 
			};
			Text component = target.GetComponent<Text>();
			if ((Object)(object)component != (Object)null)
			{
				Skin.Text(component, role, options.DefaultFontSize, options.AddTextOutline);
			}
			TMP_Text component2 = target.GetComponent<TMP_Text>();
			if ((Object)(object)component2 != (Object)null)
			{
				Skin.Text(component2, role, options.DefaultFontSize);
			}
		}
	}
	internal enum ElementType
	{
		Ignore,
		Window,
		Panel,
		Slot,
		Button,
		Text,
		Title,
		Header,
		Label,
		InputField,
		Toggle,
		Scrollbar,
		Slider
	}
	internal class StyleRule
	{
		public Func<GameObject, bool> Match;

		public ElementType Element;

		public bool Recursive;

		public static StyleRule Named(string pattern, ElementType element, bool recursive = false)
		{
			Regex regex = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
			return new StyleRule
			{
				Match = (GameObject go) => (Object)(object)go != (Object)null && regex.IsMatch(((Object)go).name),
				Element = element,
				Recursive = recursive
			};
		}

		public static StyleRule Path(string path, ElementType element, bool recursive = false)
		{
			return new StyleRule
			{
				Match = (GameObject go) => (Object)(object)go != (Object)null && UIExtensions.PathOf(go.transform).EndsWith(path, StringComparison.OrdinalIgnoreCase),
				Element = element,
				Recursive = recursive
			};
		}

		public static StyleRule Where(Func<GameObject, bool> predicate, ElementType element, bool recursive = false)
		{
			return new StyleRule
			{
				Match = predicate,
				Element = element,
				Recursive = recursive
			};
		}
	}
	internal class StyleOptions
	{
		public bool RebindAssets = true;

		public bool FixBrokenShaders = true;

		public bool ApplyGameMaterial;

		public bool MatchMenuPixelDensity = true;

		public bool MatchGameScrolling = true;

		public float FallbackScrollSensitivity = 40f;

		public bool FallbackToGameFonts = true;

		public bool StyleByComponent = true;

		public bool AddButtonSfx = true;

		public bool AddTextOutline = true;

		public int DefaultFontSize;

		public readonly List<StyleRule> Rules = new List<StyleRule>();

		public static StyleOptions Default => new StyleOptions();

		public static StyleOptions RebindOnly => new StyleOptions
		{
			StyleByComponent = false,
			AddButtonSfx = false,
			AddTextOutline = false
		};

		public StyleOptions Rule(StyleRule rule)
		{
			if (rule != null)
			{
				Rules.Add(rule);
			}
			return this;
		}

		public StyleOptions Named(string pattern, ElementType element, bool recursive = false)
		{
			return Rule(StyleRule.Named(pattern, element, recursive));
		}

		public StyleOptions Path(string path, ElementType element, bool recursive = false)
		{
			return Rule(StyleRule.Path(path, element, recursive));
		}
	}
	internal class StyleReport
	{
		public int SpritesRebound;

		public int FontsRebound;

		public int WidgetsStyled;

		public int ShadersFixed;

		public int MaterialsApplied;

		public readonly List<string> UnresolvedSprites = new List<string>();

		public readonly List<string> UnresolvedFonts = new List<string>();

		public override string ToString()
		{
			return $"rebound {SpritesRebound} sprites / {FontsRebound} fonts, styled {WidgetsStyled} widgets, " + $"lit {MaterialsApplied} graphics, fixed {ShadersFixed} materials" + ((UnresolvedSprites.Count > 0) ? $", {UnresolvedSprites.Count} sprites had no game match" : string.Empty);
		}
	}
	internal class UIWindow : MonoBehaviour
	{
		public bool BlocksInput = true;

		public bool ClosesOnEscape = true;

		public bool FitToScreen = true;

		private bool _blocking;

		private Vector2 _fittedFor;

		public bool IsOpen => ((Component)this).gameObject.activeSelf;

		public event Action Opened;

		public event Action Closed;

		public static UIWindow Attach(GameObject root, string dragHandlePath = null, string closeButtonPath = null)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			UIWindow uIWindow = root.GetComponent<UIWindow>() ?? root.AddComponent<UIWindow>();
			GameObject val = (string.IsNullOrEmpty(dragHandlePath) ? root : UIExtensions.Find(root, dragHandlePath));
			if ((Object)(object)val != (Object)null)
			{
				Transform transform = root.transform;
				DragHandle.Attach(val, (RectTransform)(object)((transform is RectTransform) ? transform : null));
			}
			if (!string.IsNullOrEmpty(closeButtonPath))
			{
				Button val2 = root.Get<Button>(closeButtonPath);
				if ((Object)(object)val2 != (Object)null)
				{
					((UnityEventBase)val2.onClick).RemoveAllListeners();
					((UnityEvent)val2.onClick).AddListener(new UnityAction(uIWindow.Hide));
				}
			}
			return uIWindow;
		}

		public void Show()
		{
			((Component)this).gameObject.SetActive(true);
			((Component)this).transform.SetAsLastSibling();
		}

		public void Hide()
		{
			((Component)this).gameObject.SetActive(false);
		}

		public void Toggle()
		{
			if (IsOpen)
			{
				Hide();
			}
			else
			{
				Show();
			}
		}

		private void OnEnable()
		{
			if (BlocksInput && !_blocking)
			{
				_blocking = true;
				InputBlocker.Block(state: true);
			}
			FitNow(force: true);
			this.Opened?.Invoke();
		}

		private void OnDisable()
		{
			if (_blocking)
			{
				_blocking = false;
				InputBlocker.Block(state: false);
			}
			this.Closed?.Invoke();
		}

		private void Update()
		{
			if (ClosesOnEscape && Input.GetKeyDown((KeyCode)27))
			{
				Hide();
			}
			if (FitToScreen)
			{
				FitNow();
			}
		}

		public void FitNow(bool force = false)
		{
			//IL_002f: 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_001f: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			if (!FitToScreen)
			{
				return;
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor((float)Screen.width, (float)Screen.height);
			if (!force && val == _fittedFor)
			{
				return;
			}
			_fittedFor = val;
			bool flag = false;
			foreach (Transform item in ((Component)this).transform)
			{
				Transform val2 = item;
				if (((Component)val2).gameObject.activeInHierarchy)
				{
					RectTransform val3 = (RectTransform)(object)((val2 is RectTransform) ? val2 : null);
					if (val3 != null && UILayout.TryVisibleRect(((Component)val2).gameObject, out var _))
					{
						UILayout.Fit(val3);
						flag = true;
					}
				}
			}
			if (!flag)
			{
				Transform transform = ((Component)this).transform;
				RectTransform val4 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (val4 != null)
				{
					UILayout.Fit(val4);
				}
			}
		}
	}
	internal class DragHandle : MonoBehaviour, IBeginDragHandler, IEventSystemHandler, IDragHandler
	{
		public RectTransform Target;

		private Vector2 _grabOffset;

		public static DragHandle Attach(GameObject handle, RectTransform target)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)handle == (Object)null || (Object)(object)target == (Object)null)
			{
				return null;
			}
			if ((Object)(object)handle.GetComponent<Graphic>() == (Object)null)
			{
				((Graphic)handle.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0f);
			}
			DragHandle obj = handle.GetComponent<DragHandle>() ?? handle.AddComponent<DragHandle>();
			obj.Target = target;
			return obj;
		}

		public void OnBeginDrag(PointerEventData eventData)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Target == (Object)null))
			{
				Transform parent = ((Transform)Target).parent;
				Vector2 val = default(Vector2);
				RectTransformUtility.ScreenPointToLocalPointInRectangle((RectTransform)(object)((parent is RectTransform) ? parent : null), eventData.position, eventData.pressEventCamera, ref val);
				_grabOffset = Target.anchoredPosition - val;
			}
		}

		public void OnDrag(PointerEventData eventData)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			if (!((Object)(object)Target == (Object)null) && RectTransformUtility.ScreenPointToLocalPointInRectangle((RectTransform)/*isinst with value type is only supported in some contexts*/, eventData.position, eventData.pressEventCamera, ref val))
			{
				Target.anchoredPosition = val + _grabOffset;
			}
		}
	}
	internal static class InputBlocker
	{
		private class BlockScope : IDisposable
		{
			private bool _disposed;

			public BlockScope()
			{
				Block(state: true);
			}

			public void Dispose()
			{
				if (!_disposed)
				{
					_disposed = true;
					Block(state: false);
				}
			}
		}

		private static int _blocks;

		private static bool _restorePending;

		public static bool IsBlocked => _blocks > 0;

		public static void Block(bool state)
		{
			_blocks = Mathf.Max(0, _blocks + (state ? 1 : (-1)));
			if (_blocks == 0)
			{
				_restorePending = true;
			}
		}

		public static void Reset()
		{
			_blocks = 0;
			_restorePending = true;
		}

		public static IDisposable Scope()
		{
			return new BlockScope();
		}

		internal static void Tick()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			if (IsBlocked)
			{
				if ((int)Cursor.lockState != 0)
				{
					Cursor.lockState = (CursorLockMode)0;
				}
				if (!Cursor.visible)
				{
					Cursor.visible = true;
				}
				GameCamera instance = GameCamera.instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.m_mouseCapture = false;
				}
			}
			else if (_restorePending)
			{
				_restorePending = false;
				GameCamera instance2 = GameCamera.instance;
				if ((Object)(object)instance2 != (Object)null)
				{
					instance2.m_mouseCapture = true;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "TakeInput")]
		[HarmonyPostfix]
		private static void PlayerTakeInputPostfix(ref bool __result)
		{
			if (IsBlocked)
			{
				__result = false;
			}
		}

		[HarmonyPatch(typeof(PlayerController), "TakeInput", new Type[] { typeof(bool) })]
		[HarmonyPostfix]
		private static void PlayerControllerTakeInputPostfix(ref bool __result)
		{
			if (IsBlocked)
			{
				__result = false;
			}
		}

		[HarmonyPatch(typeof(TextInput), "IsVisible")]
		[HarmonyPostfix]
		private static void TextInputIsVisiblePostfix(ref bool __result)
		{
			if (IsBlocked)
			{
				__result = true;
			}
		}
	}
	internal static class UILayout
	{
		public class Overlap
		{
			public Transform Target;

			public string Path;

			public Rect Rect;

			public float ShiftUp;

			public float ShiftDown;

			public float ShiftLeft;

			public float ShiftRight;

			public float Smallest => Mathf.Min(Mathf.Min(ShiftUp, ShiftDown), Mathf.Min(ShiftLeft, ShiftRight));
		}

		public static Rect ScreenRect(RectTransform rect)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rect == (Object)null)
			{
				return default(Rect);
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			rect.GetWorldCorners(array);
			Canvas componentInParent = ((Component)rect).GetComponentInParent<Canvas>();
			Camera obj = (((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode != 0) ? componentInParent.worldCamera : null);
			Vector2 val = RectTransformUtility.WorldToScreenPoint(obj, array[0]);
			Vector2 val2 = RectTransformUtility.WorldToScreenPoint(obj, array[2]);
			return Rect.MinMaxRect(Mathf.Min(val.x, val2.x), Mathf.Min(val.y, val2.y), Mathf.Max(val.x, val2.x), Mathf.Max(val.y, val2.y));
		}

		public static bool TryVisibleRect(GameObject target, out Rect result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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)
			result = default(Rect);
			if ((Object)(object)target == (Object)null)
			{
				return false;
			}
			bool flag = false;
			Graphic[] componentsInChildren = target.GetComponentsInChildren<Graphic>(false);
			foreach (Graphic graphic in componentsInChildren)
			{
				if (IsVisible(graphic) && ClippedRect(graphic, out var result2))
				{
					result = (flag ? Union(result, result2) : result2);
					flag = true;
				}
			}
			return flag;
		}

		private static bool ClippedRect(Graphic graphic, out Rect result)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_0072: 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)
			result = ScreenRect(graphic.rectTransform);
			if (((Rect)(ref result)).width <= 0f || ((Rect)(ref result)).height <= 0f)
			{
				return false;
			}
			Transform parent = ((Component)graphic).transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				RectMask2D component = ((Component)parent).GetComponent<RectMask2D>();
				if (!((Object)(object)component == (Object)null) && ((Behaviour)component).enabled && ((Component)component).gameObject.activeInHierarchy)
				{
					result = Intersect(result, ScreenRect(component.rectTransform));
					if (((Rect)(ref result)).width <= 0f || ((Rect)(ref result)).height <= 0f)
					{
						return false;
					}
				}
				parent = parent.parent;
			}
			return true;
		}

		private static Rect Intersect(Rect a, Rect b)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			return Rect.MinMaxRect(Mathf.Max(((Rect)(ref a)).xMin, ((Rect)(ref b)).xMin), Mathf.Max(((Rect)(ref a)).yMin, ((Rect)(ref b)).yMin), Mathf.Min(((Rect)(ref a)).xMax, ((Rect)(ref b)).xMax), Mathf.Min(((Rect)(ref a)).yMax, ((Rect)(ref b)).yMax));
		}

		private static bool IsVisible(Graphic graphic)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)graphic == (Object)null || !((Behaviour)graphic).isActiveAndEnabled)
			{
				return false;
			}
			if (graphic.color.a <= 0.05f)
			{
				return false;
			}
			if ((Object)(object)graphic.canvasRenderer != (Object)null && graphic.canvasRenderer.GetAlpha() <= 0.05f)
			{
				return false;
			}
			return true;
		}

		private static Rect Union(Rect a, Rect b)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			return Rect.MinMaxRect(Mathf.Min(((Rect)(ref a)).xMin, ((Rect)(ref b)).xMin), Mathf.Min(((Rect)(ref a)).yMin, ((Rect)(ref b)).yMin), Mathf.Max(((Rect)(ref a)).xMax, ((Rect)(ref b)).xMax), Mathf.Max(((Rect)(ref a)).yMax, ((Rect)(ref b)).yMax));
		}

		private static Rect PaintedRect(RectTransform panel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			Rect val = ScreenRect(panel);
			if (!TryVisibleRect(((Component)panel).gameObject, out var result))
			{
				return val;
			}
			return Union(result, val);
		}

		public static List<Overlap> Overlaps(Rect mine, Transform ignoreSubtree = null, float minimumArea = 400f)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			List<Overlap> list = new List<Overlap>();
			if (((Rect)(ref mine)).width <= 0f || ((Rect)(ref mine)).height <= 0f)
			{
				return list;
			}
			float num = 1f;
			if ((Object)(object)UIRoot.Front != (Object)null)
			{
				Canvas componentInParent = ((Component)UIRoot.Front).GetComponentInParent<Canvas>();
				if ((Object)(object)componentInParent != (Object)null && componentInParent.scaleFactor > 0f)
				{
					num = componentInParent.scaleFactor;
				}
			}
			foreach (Graphic item in VanillaGraphics())
			{
				if (IsVisible(item) && (!((Object)(object)ignoreSubtree != (Object)null) || !((Component)item).transform.IsChildOf(ignoreSubtree)))
				{
					Rect val = ScreenRect(item.rectTransform);
					if (!(((Rect)(ref val)).width * ((Rect)(ref val)).height < minimumArea) && (!(((Rect)(ref val)).width >= (float)Screen.width * 0.98f) || !(((Rect)(ref val)).height >= (float)Screen.height * 0.98f)) && ((Rect)(ref mine)).Overlaps(val))
					{
						list.Add(new Overlap
						{
							Target = ((Component)item).transform,
							Path = UIExtensions.PathOf(((Component)item).transform),
							Rect = val,
							ShiftUp = (((Rect)(ref val)).yMax - ((Rect)(ref mine)).yMin) / num,
							ShiftDown = (((Rect)(ref mine)).yMax - ((Rect)(ref val)).yMin) / num,
							ShiftLeft = (((Rect)(ref mine)).xMax - ((Rect)(ref val)).xMin) / num,
							ShiftRight = (((Rect)(ref val)).xMax - ((Rect)(ref mine)).xMin) / num
						});
					}
				}
			}
			Collapse(list);
			list.Sort((Overlap a, Overlap b) => b.ShiftUp.CompareTo(a.ShiftUp));
			return list;
		}

		private static void Collapse(List<Overlap> overlaps)
		{
			for (int num = overlaps.Count - 1; num >= 0; num--)
			{
				for (int i = 0; i < overlaps.Count; i++)
				{
					if (num != i && !((Object)(object)overlaps[i].Target == (Object)null) && !((Object)(object)overlaps[num].Target == (Object)null) && overlaps[num].Target.IsChildOf(overlaps[i].Target))
					{
						overlaps.RemoveAt(num);
						break;
					}
				}
			}
		}

		private static IEnumerable<Graphic> VanillaGraphics()
		{
			foreach (GameObject item in VanillaUI.RootObjects())
			{
				if (!((Object)(object)item == (Object)null))
				{
					Graphic[] componentsInChildren = item.GetComponentsInChildren<Graphic>(false);
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						yield return componentsInChildren[i];
					}
				}
			}
		}

		private static float ScaleFactor(RectTransform rect)
		{
			Canvas val = (((Object)(object)rect != (Object)null) ? ((Component)rect).GetComponentInParent<Canvas>() : null);
			if (!((Object)(object)val != (Object)null) || !(val.scaleFactor > 0f))
			{
				return 1f;
			}
			return val.scaleFactor;
		}

		private static RectTransform CanvasRect(RectTransform rect)
		{
			Canvas val = (((Object)(object)rect != (Object)null) ? ((Component)rect).GetComponentInParent<Canvas>() : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Transform transform = ((Component)(((Object)(object)val.rootCanvas != (Object)null) ? val.rootCanvas : val)).transform;
			return (RectTransform)(object)((transform is RectTransform) ? transform : null);
		}

		public static bool ClampToCanvas(RectTransform panel, float margin = 8f)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)panel == (Object)null)
			{
				return false;
			}
			RectTransform val = CanvasRect(panel);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			float num = ScaleFactor(panel);
			Rect val2 = ScreenRect(val);
			if (((Rect)(ref val2)).height <= 0f)
			{
				return false;
			}
			bool result = false;
			Rect val3 = PaintedRect(panel);
			float num2 = ((Rect)(ref val2)).height - margin * 2f * num;
			if (((Rect)(ref val3)).height > num2 && Mathf.Approximately(panel.anchorMin.y, panel.anchorMax.y))
			{
				float num3 = (((Rect)(ref val3)).height - num2) / num;
				panel.sizeDelta = new Vector2(panel.sizeDelta.x, Mathf.Max(64f, panel.sizeDelta.y - num3));
				result = true;
				val3 = PaintedRect(panel);
			}
			float num4 = 0f;
			float num5 = 0f;
			if (((Rect)(ref val3)).xMin < ((Rect)(ref val2)).xMin + margin * num)
			{
				num4 = ((Rect)(ref val2)).xMin + margin * num - ((Rect)(ref val3)).xMin;
			}
			else if (((Rect)(ref val3)).xMax > ((Rect)(ref val2)).xMax - margin * num)
			{
				num4 = ((Rect)(ref val2)).xMax - margin * num - ((Rect)(ref val3)).xMax;
			}
			if (((Rect)(ref val3)).yMin < ((Rect)(ref val2)).yMin + margin * num)
			{
				num5 = ((Rect)(ref val2)).yMin + margin * num - ((Rect)(ref val3)).yMin;
			}
			else if (((Rect)(ref val3)).yMax > ((Rect)(ref val2)).yMax - margin * num)
			{
				num5 = ((Rect)(ref val2)).yMax - margin * num - ((Rect)(ref val3)).yMax;
			}
			if (Mathf.Abs(num4) < 0.5f && Mathf.Abs(num5) < 0.5f)
			{
				return result;
			}
			panel.anchoredPosition += new Vector2(num4, num5) / num;
			return true;
		}

		public static float NudgeClear(RectTransform panel, float maxShift = 200f)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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)
			if ((Object)(object)panel == (Object)null)
			{
				return 0f;
			}
			if (!TryVisibleRect(((Component)panel).gameObject, out var result))
			{
				return 0f;
			}
			float num = 0f;
			foreach (Overlap item in Overlaps(result, (Transform)(object)panel))
			{
				num = Mathf.Max(num, item.ShiftUp);
			}
			if (num <= 0.5f || num > maxShift)
			{
				return 0f;
			}
			panel.anchoredPosition += new Vector2(0f, num);
			return num;
		}

		public static void Fit(RectTransform panel, float margin = 8f, float maxNudge = 200f)
		{
			if (!((Object)(object)panel == (Object)null))
			{
				ClampToCanvas(panel, margin);
				NudgeClear(panel, maxNudge);
				ClampToCanvas(panel, margin);
			}
		}

		public static float FitToContent(RectTransform panel, ScrollRect scroll, float minHeight = 120f)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_009b: 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_0081: 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_00cc: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)panel == (Object)null || (Object)(object)scroll == (Object)null || (Object)(object)scroll.content == (Object)null || (Object)(object)scroll.viewport == (Object)null)
			{
				return 0f;
			}
			LayoutRebuilder.ForceRebuildLayoutImmediate(scroll.content);
			Rect rect = panel.rect;
			float height = ((Rect)(ref rect)).height;
			rect = scroll.viewport.rect;
			float num = height - ((Rect)(ref rect)).height;
			float num2 = LayoutUtility.GetPreferredHeight(scroll.content);
			if (num2 <= 0f)
			{
				rect = scroll.content.rect;
				num2 = ((Rect)(ref rect)).height;
			}
			float num3 = Mathf.Max(minHeight, num2 + num);
			rect = panel.rect;
			if (Mathf.Abs(num3 - ((Rect)(ref rect)).height) < 1f)
			{
				rect = panel.rect;
				return ((Rect)(ref rect)).height;
			}
			panel.sizeDelta = new Vector2(panel.sizeDelta.x, num3);
			return num3;
		}

		public static string Report(GameObject window, int maxPerPanel = 8)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0071: 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)
			if ((Object)(object)window == (Object)null)
			{
				return "no window";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine(((Object)window).name + ":");
			bool flag = false;
			foreach (Transform item in window.transform)
			{
				Transform val = item;
				if (((Component)val).gameObject.activeInHierarchy && TryVisibleRect(((Component)val).gameObject, out var result))
				{
					flag = true;
					ReportPanel(stringBuilder, ((Object)val).name, result, window.transform, maxPerPanel);
				}
			}
			if (!flag && TryVisibleRect(window, out var result2))
			{
				ReportPanel(stringBuilder, ((Object)window).name, result2, window.transform, maxPerPanel);
			}
			return stringBuilder.ToString();
		}

		private static void ReportPanel(StringBuilder text, string name, Rect rect, Transform ignore, int max)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			text.AppendLine($"  {name}: x {((Rect)(ref rect)).xMin:0}..{((Rect)(ref rect)).xMax:0}, y {((Rect)(ref rect)).yMin:0}..{((Rect)(ref rect)).yMax:0}");
			List<Overlap> list = Overlaps(rect, ignore);
			if (list.Count == 0)
			{
				text.AppendLine("    clear of vanilla UI");
				return;
			}
			float num = 0f;
			int num2 = 0;
			foreach (Overlap item in list)
			{
				num = Mathf.Max(num, item.ShiftUp);
				if (num2++ < max)
				{
					text.AppendLine("    over " + item.Path);
					text.AppendLine($"      up {item.ShiftUp:0} | down {item.ShiftDown:0} | " + $"left {item.ShiftLeft:0} | right {item.ShiftRight:0}");
				}
			}
			if (num2 > max)
			{
				text.AppendLine($"    ...and {num2 - max} more");
			}
			text.AppendLine($"    move up {num:0} to clear everything (add to this panel's anchoredPosition.y)");
		}
	}
	internal static class UIExtensions
	{
		public static GameObject Find(GameObject root, string path)
		{
			if ((Object)(object)root == (Object)null || string.IsNullOrEmpty(path))
			{
				return null;
			}
			if (path.IndexOf('/') >= 0)
			{
				Transform val = root.transform.Find(path);
				if ((Object)(object)val != (Object)null)
				{
					return ((Component)val).gameObject;
				}
				string[] array = path.Split(new char[1] { '/' });
				return root.transform.FindDeep(array[^1]);
			}
			return root.transform.FindDeep(path);
		}

		public static GameObject FindDeep(this Transform root, string name)
		{
			if ((Object)(object)root == (Object)null || string.IsNullOrEmpty(name))
			{
				return null;
			}
			if (string.Equals(((Object)root).name, name, StringComparison.OrdinalIgnoreCase))
			{
				return ((Component)root).gameObject;
			}
			for (int i = 0; i < root.childCount; i++)
			{
				GameObject val = root.GetChild(i).FindDeep(name);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		public static GameObject FindDeep(this GameObject root, string name)
		{
			if (!((Object)(object)root != (Object)null))
			{
				return null;
			}
			return root.transform.FindDeep(name);
		}

		public static string PathOf(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return string.Empty;
			}
			string text = ((Object)transform).name;
			Transform parent = transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}

		public static void Collect(Transform root, List<Transform> into)
		{
			if (!((Object)(object)root == (Object)null) && into != null)
			{
				into.Add(root);
				for (int i = 0; i < root.childCount; i++)
				{
					Collect(root.GetChild(i), into);
				}
			}
		}

		public static T Get<T>(this GameObject root, string path) where T : Component
		{
			GameObject val = Find(root, path);
			if (!((Object)(object)val != (Object)null))
			{
				return default(T);
			}
			return val.GetComponent<T>();
		}

		public static GameObject SetText(this GameObject root, string path, string value)
		{
			GameObject val = Find(root, path);
			if ((Object)(object)val == (Object)null)
			{
				return root;
			}
			Text component = val.GetComponent<Text>();
			if ((Object)(object)component != (Object)null)
			{
				component.text = value;
			}
			TMP_Text component2 = val.GetComponent<TMP_Text>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.text = value;
			}
			return root;
		}

		public static GameObject SetSprite(this GameObject root, string path, Sprite sprite)
		{
			Image val = root.Get<Image>(path);
			if ((Object)(object)val != (Object)null)
			{
				val.sprite = sprite;
				((Behaviour)val).enabled = (Object)(object)sprite != (Object)null;
			}
			return root;
		}

		public static GameObject OnClick(this GameObject root, string path, Action action)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			Button val = root.Get<Button>(path);
			if ((Object)(object)val != (Object)null && action != null)
			{
				((UnityEventBase)val.onClick).RemoveAllListeners();
				((UnityEvent)val.onClick).AddListener((UnityAction)delegate
				{
					action();
				});
			}
			return root;
		}

		public static GameObject CloneTemplate(GameObject template, Transform parent = null, bool active = true)
		{
			if ((Object)(object)template == (Object)null)
			{
				return null;
			}
			GameObject obj = Object.Instantiate<GameObject>(template, ((Object)(object)parent != (Object)null) ? parent : template.transform.parent, false);
			((Object)obj).name = ((Object)template).name + "_clone";
			obj.SetActive(active);
			return obj;
		}

		public static StyleReport Style(this GameObject root, StyleOptions options = null)
		{
			return Styler.Apply(root, options);
		}
	}
	internal static class UILog
	{
		public static string Prefix = "[UIManager]";

		public static bool Verbose;

		private static ManualLogSource _source;

		public static void Use(ManualLogSource source)
		{
			_source = source;
		}

		public static void Debug(string message)
		{
			if (Verbose)
			{
				if (_source != null)
				{
					_source.LogDebug((object)(Prefix + " " + message));
				}
				else
				{
					Debug.Log((object)(Prefix + " " + message));
				}
			}
		}

		public static void Info(string message)
		{
			if (_source != null)
			{
				_source.LogInfo((object)(Prefix + " " + message));
			}
			else
			{
				Debug.Log((object)(Prefix + " " + message));
			}
		}

		public static void Warning(string message)
		{
			if (_source != null)
			{
				_source.LogWarning((object)(Prefix + " " + message));
			}
			else
			{
				Debug.LogWarning((object)(Prefix + " " + message));
			}
		}

		public static void Error(string message)
		{
			if (_source != null)
			{
				_source.LogError((object)(Prefix + " " + message));
			}
			else
			{
				Debug.LogError((object)(Prefix + " " + message));
			}
		}

		public static void Error(string message, Exception e)
		{
			Error(message + "\n" + e);
		}
	}
	internal enum UIPanel
	{
		Front,
		Back,
		PixelFix,
		IngameGui,
		Hud,
		Inventory,
		Crafting,
		Chat,
		Menu,
		TopLeftMessage,
		MainMenu,
		CustomFront
	}
	internal static class UIPanels
	{
		private sealed class Pending
		{
			public UIPanel Panel;

			public Action<Transform> Action;

			public string Owner;
		}

		private static readonly List<Pending> Waiting = new List<Pending>();

		private const string FrontName = "UIManager.CustomFront";

		public static event Action<Hud> HudReady;

		public static event Action<InventoryGui> InventoryReady;

		public static event Action<FejdStartup> MainMenuReady;

		public static Transform Get(UIPanel panel)
		{
			if (!TryGet(panel, out var transform))
			{
				return null;
			}
			return transform;
		}

		public static bool TryGet(UIPanel panel, out Transform transform)
		{
			transform = Resolve(panel);
			return (Object)(object)transform != (Object)null;
		}

		public static void When(UIPanel panel, Action<Transform> action)
		{
			if (action != null)
			{
				string owner = new StackFrame(1).GetMethod()?.DeclaringType?.Name ?? "unknown";
				if (TryGet(panel, out var transform))
				{
					Invoke(action, transform, owner);
					return;
				}
				Waiting.Add(new Pending
				{
					Panel = panel,
					Action = action,
					Owner = owner
				});
			}
		}

		public static GameObject Attach(GameObject prefab, UIPanel panel, bool style = true, StyleOptions options = null)
		{
			if (!TryGet(panel, out var transform))
			{
				UILog.Error(string.Format("panel '{0}' is not up yet - use UIPanels.When before attaching '{1}'", panel, ((Object)(object)prefab != (Object)null) ? ((Object)prefab).name : "null"));
				return null;
			}
			return UIRoot.Instantiate(prefab, transform, style, options);
		}

		public static Transform Find(string path)
		{
			if (string.IsNullOrEmpty(path))
			{
				return null;
			}
			Transform val = Resolve(UIPanel.IngameGui);
			if ((Object)(object)val != (Object)null)
			{
				Transform val2 = val.Find(path);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			GameObject val3 = GameObject.Find(path);
			if (!((Object)(object)val3 != (Object)null))
			{
				return null;
			}
			return val3.transform;
		}

		private static Transform Resolve(UIPanel panel)
		{
			switch (panel)
			{
			case UIPanel.Front:
				return UIRoot.Front;
			case UIPanel.Back:
				return UIRoot.Back;
			case UIPanel.PixelFix:
				return PixelFix();
			case UIPanel.IngameGui:
				return IngameGui();
			case UIPanel.Hud:
				if (!((Object)(object)Hud.instance != (Object)null) || !((Object)(object)Hud.instance.m_rootObject != (Object)null))
				{
					return null;
				}
				return Hud.instance.m_rootObject.transform;
			case UIPanel.Inventory:
				if (!((Object)(object)InventoryGui.instance != (Object)null))
				{
					return Find("Inventory_screen");
				}
				return ((Component)InventoryGui.instance).transform;
			case UIPanel.Crafting:
				return Find("Inventory_screen/root/Crafting");
			case UIPanel.Chat:
				if (!((Object)(object)Chat.instance != (Object)null))
				{
					return Find("Chat");
				}
				return ((Component)Chat.instance).transform;
			case UIPanel.Menu:
				if (!((Object)(object)Menu.instance != (Object)null))
				{
					return Find("Menu");
				}
				return ((Component)Menu.instance).transform;
			case UIPanel.TopLeftMessage:
				return Find("TopLeftMessage");
			case UIPanel.MainMenu:
				return MainMenuRoot();
			case UIPanel.CustomFront:
				return CustomFront();
			default:
				return null;
			}
		}

		private static Transform PixelFix()
		{
			GameObject val = GameObject.Find("_GameMain/LoadingGUI");
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return val.transform.Find("PixelFix");
		}

		private static Transform IngameGui()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			Transform val = PixelFix();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			foreach (Transform item in val)
			{
				Transform val2 = item;
				if (((Object)val2).name.StartsWith("IngameGui", StringComparison.Ordinal))
				{
					return val2;
				}
			}
			return null;
		}

		private static Transform CustomFront()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			GameObject val = GameObject.Find("_GameMain/LoadingGUI");
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Transform val2 = val.transform.Find("UIManager.CustomFront");
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
			RectTransform val3 = (RectTransform)new GameObject("UIManager.CustomFront", new Type[2]
			{
				typeof(RectTransform),
				typeof(GuiPixelFix)
			})
			{
				layer = UIRoot.UILayer
			}.transform;
			((Transform)val3).SetParent(val.transform, false);
			((Transform)val3).SetAsLastSibling();
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = Vector2.one;
			val3.offsetMin = Vector2.zero;
			val3.offsetMax = Vector2.zero;
			((Transform)val3).localScale = Vector3.one;
			val3.anchoredPosition3D = Vector3.zero;
			UILog.Info("created UIManager.CustomFront under " + UIExtensions.PathOf(val.transform));
			return (Transform)val3;
		}

		private static Transform MainMenuRoot()
		{
			GameObject val = GameObject.Find("GuiRoot/GUI");
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return val.transform;
		}

		private static void Invoke(Action<Transform> action, Transform target, string owner)
		{
			try
			{
				action(target);
			}
			catch (Exception e)
			{
				UILog.Error("a UIPanels.When handler from " + owner + " threw", e);
			}
		}

		internal static void Tick()
		{
			for (int num = Waiting.Count - 1; num >= 0; num--)
			{
				Pending pending = Waiting[num];
				if (TryGet(pending.Panel, out var transform))
				{
					Waiting.RemoveAt(num);
					Invoke(pending.Action, transform, pending.Owner);
				}
			}
		}

		[HarmonyPatch(typeof(Hud), "Awake")]
		[HarmonyPostfix]
		private static void HudAwakePostfix(Hud __instance)
		{
			Raise(UIPanels.HudReady, __instance, "HudReady");
		}

		[HarmonyPatch(typeof(InventoryGui), "Awake")]
		[HarmonyPostfix]
		private static void InventoryAwakePostfix(InventoryGui __instance)
		{
			Raise(UIPanels.InventoryReady, __instance, "InventoryReady");
		}

		[HarmonyPatch(typeof(FejdStartup), "SetupGui")]
		[HarmonyPostfix]
		private static void MainMenuPostfix(FejdStartup __instance)
		{
			Raise(UIPanels.MainMenuReady, __instance, "MainMenuReady");
		}

		private static void Raise<T>(Action<T> handlers, T argument, string name)
		{
			if (handlers == null)
			{
				return;
			}
			try
			{
				handlers(argument);
			}
			catch (Exception e)
			{
				UILog.Error("a UIPanels." + name + " handler threw", e);
			}
		}
	}
	internal static class UIFactory
	{
		private static Resources Resources => default(Resources);

		public static GameObject Panel(string name, Transform parent, Vector2 size, bool window = true)
		{
			//IL_002e: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_004c: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			Attach(val, parent, size);
			Image component = val.GetComponent<Image>();
			if (window)
			{
				Skin.Window(component);
				return val;
			}
			Skin.Panel(component);
			return val;
		}

		public static Text Text(string name, Transform parent, string content, TextRole role = TextRole.Body, int fontSize = 0, TextAnchor alignment = (TextAnchor)0)
		{
			//IL_002e: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text)
			});
			val.transform.SetParent(parent, false);
			Text component = val.GetComponent<Text>();
			component.text = content;
			component.alignment = alignment;
			component.supportRichText = true;
			Skin.Text(component, role, fontSize);
			return component;
		}

		public static TextMeshProUGUI TmpText(string name, Transform parent, string content, TextRole role = TextRole.Body, int fontSize = 0, TextAlignmentOptions alignment = (TextAlignmentOptions)257)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj).text = content;
			((TMP_Text)obj).alignment = alignment;
			Skin.Text((TMP_Text)(object)obj, role, fontSize);
			return obj;
		}

		public static Button Button(string name, Transform parent, string label, Vector2 size, UnityAction onClick = null, int fontSize = 0)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = DefaultControls.CreateButton(Resources);
			((Object)obj).name = name;
			Attach(obj, parent, size);
			Button component = obj.GetComponent<Button>();
			Text componentInChildren = obj.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = label;
			}
			Skin.Button(component, fontSize);
			if (onClick != null)
			{
				((UnityEvent)component.onClick).AddListener(onClick);
			}
			return component;
		}

		public static InputField InputField(string name, Transform parent, Vector2 size, string placeholder = "", UnityAction<string> onChanged = null, int fontSize = 0)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = DefaultControls.CreateInputField(Resources);
			((Object)obj).name = name;
			Attach(obj, parent, size);
			InputField component = obj.GetComponent<InputField>();
			Graphic placeholder2 = component.placeholder;
			Text val = (Text)(object)((placeholder2 is Text) ? placeholder2 : null);
			if (val != null)
			{
				val.text = placeholder;
			}
			Skin.InputField(component, fontSize);
			if (onChanged != null)
			{
				((UnityEvent<string>)(object)component.onValueChanged).AddListener(onChanged);
			}
			return component;
		}

		public static Toggle Toggle(string name, Transform parent, string label, bool value = false, UnityAction<bool> onChanged = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = DefaultControls.CreateToggle(Resources);
			((Object)obj).name = name;
			obj.transform.SetParent(parent, false);
			Toggle component = obj.GetComponent<Toggle>();
			component.isOn = value;
			Text componentInChildren = obj.GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = label;
				Skin.Text(componentInChildren);
			}
			Skin.Toggle(component);
			if (onChanged != null)
			{
				((UnityEvent<bool>)(object)component.onValueChanged).AddListener(onChanged);
			}
			return component;
		}

		public static Dropdown Dropdown(string name, Transform parent, Vector2 size, IEnumerable<string> options = null, UnityAction<int> onChanged = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = DefaultControls.CreateDropdown(Resources);
			((Object)val).name = name;
			Attach(val, parent, size);
			Dropdown component = val.GetComponent<Dropdown>();
			if (options != null)
			{
				component.ClearOptions();
				component.AddOptions(options.ToList());
			}
			Text[] componentsInChildren = val.GetComponentsInChildren<Text>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Skin.Text(componentsInChildren[i]);
			}
			Image componentInChildren = val.GetComponentInChildren<Image>();
			if (componentInChildren != null)
			{
				Skin.Panel(componentInChildren);
			}
			Scrollbar componentInChildren2 = val.GetComponentInChildren<Scrollbar>(true);
			if (componentInChildren2 != null)
			{
				Skin.Scrollbar(componentInChildren2);
			}
			if (onChanged != null)
			{
				((UnityEvent<int>)(object)component.onValueChanged).AddListener(onChanged);
			}
			return component;
		}

		public static Slider Slider(string name, Transform parent, Vector2 size, float min = 0f, float max = 1f, float value = 0f, UnityAction<float> onChanged = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = DefaultControls.CreateSlider(Resources);
			((Object)obj).name = name;
			Attach(obj, parent, size);
			Slider component = obj.GetComponent<Slider>();
			component.minValue = min;
			component.maxValue = max;
			component.value = Mathf.Clamp(value, min, max);
			Skin.Slider(component);
			if (onChanged != null)
			{
				((UnityEvent<float>)(object)component.onValueChanged).AddListener(onChanged);
			}
			return component;
		}

		public static ScrollRect ScrollView(string name, Transform parent, Vector2 size, out RectTransform content, bool vertical = true, bool horizontal = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = DefaultControls.CreateScrollView(Resources);
			((Object)obj).name = name;
			Attach(obj, parent, size);
			ScrollRect component = obj.GetComponent<ScrollRect>();
			component.vertical = vertical;
			component.horizontal = horizontal;
			content = component.content;
			if ((Object)(object)content != (Object)null)
			{
				content.anchorMin = new Vector2(0f, 1f);
				content.anchorMax = new Vector2(1f, 1f);
				content.pivot = new Vector2(0.5f, 1f);
				((Component)content).gameObject.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
				VerticalLayoutGroup obj2 = ((Component)content).gameObject.AddComponent<VerticalLayoutGroup>();
				((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = false;
				((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
			}
			if ((Object)(object)component.viewport != (Object)null)
			{
				Image component2 = ((Component)component.viewport).GetComponent<Image>();
				if (component2 != null)
				{
					((Graphic)component2).color = Color.white;
					((Graphic)component2).raycastTarget = true;
				}
				Mask component3 = ((Component)component.viewport).GetComponent<Mask>();
				if (component3 != null)
				{
					component3.showMaskGraphic = false;
				}
			}
			Image component4 = obj.GetComponent<Image>();
			if (component4 != null)
			{
				((Behaviour)component4).enabled = false;
			}
			Skin.ScrollRect(component);
			if ((Object)(object)component.verticalScrollbar != (Object)null)
			{
				Skin.Scrollbar(component.verticalScrollbar);
			}
			if ((Object)(object)component.horizontalScrollbar != (Object)null)
			{
				Skin.Scrollbar(component.horizontalScrollbar);
			}
			return component;
		}

		private static void Attach(GameObject go, Transform parent, Vector2 size)
		{
			//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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			go.transform.SetParent(parent, false);
			RectTransform val = (RectTransform)go.transform;
			((Transform)val).localScale = Vector3.one;
			val.sizeDelta = size;
		}
	}
	internal static class UIEvents
	{
		public static void OnHover(GameObject target, Action enter, Action exit = null)
		{
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			if (enter != null)
			{
				Add(target, (EventTriggerType)0, delegate
				{
					enter();
				});
			}
			if (exit != null)
			{
				Add(target, (EventTriggerType)1, delegate
				{
					exit();
				});
			}
		}

		public static void OnClick(GameObject target, InputButton button, Action action)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null || action == null)
			{
				return;
			}
			Add(target, (EventTriggerType)4, delegate(BaseEventData data)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				PointerEventData val = (PointerEventData)(object)((data is PointerEventData) ? data : null);
				if (val != null && val.button == button)
				{
					action();
				}
			});
		}

		public static void OnLeftClick(GameObject target, Action action)
		{
			OnClick(target, (InputButton)0, action);
		}

		public static void OnRightClick(GameObject target, Action action)
		{
			OnClick(target, (InputButton)1, action);
		}

		public static void ClearEvents(GameObject target)
		{
			if (!((Object)(object)target == (Object)null))
			{
				EventTrigger component = target.GetComponent<EventTrigger>();
				if ((Object)(object)component != (Object)null)
				{
					component.triggers.Clear();
				}
			}
		}

		public static void Add(GameObject target, EventTriggerType type, UnityAction<BaseEventData> action)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			if (!((Object)(object)target == (Object)null) && action != null)
			{
				EventTrigger val = target.GetComponent<EventTrigger>();
				if ((Object)(object)val == (Object)null)
				{
					val = target.AddComponent<EventTrigger>();
				}
				Entry val2 = new Entry
				{
					eventID = type
				};
				((UnityEvent<BaseEventData>)(object)val2.callback).AddListener(action);
				val.triggers.Add(val2);
			}
		}
	}
	internal static class UITooltips
	{
		public const float ShowDelay = 0.5f;

		private static GameObject _prefab;

		private static bool _warned;

		public static GameObject Prefab
		{
			get
			{
				if ((Object)(object)_prefab != (Object)null)
				{
					return _prefab;
				}
				UITooltip[] array = Resources.FindObjectsOfTypeAll<UITooltip>();
				foreach (UITooltip val in array)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.m_tooltipPrefab == (Object)null))
					{
						_prefab = val.m_tooltipPrefab;
						break;
					}
				}
				if ((Object)(object)_prefab == (Object)null && !_warned)
				{
					_warned = true;
					UILog.Warning("no vanilla tooltip found to copy; tooltips will not appear");
				}
				return _prefab;
			}
		}

		public static bool Available => (Object)(object)Prefab != (Object)null;

		public static void Set(GameObject target, string topic, string text, RectTransform bounds = null)
		{
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			UITooltipHost uITooltipHost = target.GetComponent<UITooltipHost>();
			if ((Object)(object)uITooltipHost == (Object)null)
			{
				if (string.IsNullOrEmpty(topic) && string.IsNullOrEmpty(text))
				{
					return;
				}
				uITooltipHost = target.AddComponent<UITooltipHost>();
			}
			uITooltipHost.Topic = topic ?? string.Empty;
			uITooltipHost.Text = text ?? string.Empty;
			if ((Object)(object)bounds != (Object)null)
			{
				uITooltipHost.Bounds = bounds;
			}
			uITooltipHost.Refresh();
		}

		public static void Clear(GameObject target)
		{
			Set(target, string.Empty, string.Empty);
		}

		public static void HideNow()
		{
			UITooltipHost.HideShared();
		}

		internal static GameObject Spawn(Canvas canvas)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			GameObject prefab = Prefab;
			if ((Object)(object)prefab == (Object)null || (Object)(object)canvas == (Object)null)
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(prefab, ((Component)canvas).transform);
			((Object)val).name = "UIManager.Tooltip";
			val.SetActive(true);
			val.transform.SetAsLastSibling();
			Graphic[] componentsInChildren = val.GetComponentsInChildren<Graphic>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].raycastTarget = false;
			}
			Transform transform = val.transform;
			RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val2 != null)
			{
				((Transform)val2).localScale = Vector3.one;
			}
			return val;
		}
	}
	internal class UITooltipHost : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		public string Topic = "";

		public string Text = "";

		public RectTransform Bounds;

		public float Gap = 10f;

		private static UITooltipHost _current;

		private static GameObject _shared;

		private float _timer;

		private Canvas _canvas;

		public void OnPointerEnter(PointerEventData eventData)
		{
			if (!string.IsNullOrEmpty(Topic) || !string.IsNullOrEmpty(Text))
			{
				_current = this;
				_timer = 0f;
				if ((Object)(object)_shared != (Object)null)
				{
					Write();
				}
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			if ((Object)(object)_current == (Object)(object)this)
			{
				HideShared();
			}
		}

		private void OnDisable()
		{
			if ((Object)(object)_current == (Object)(object)this)
			{
				HideShared();
			}
		}

		public void Refresh()
		{
			if ((Object)(object)_current == (Object)(object)this && (Object)(object)_shared != (Object)null)
			{
				Write();
				Place();
			}
		}

		internal static void HideShared()
		{
			_current = null;
			if ((Object)(object)_shared != (Object)null)
			{
				Object.Destroy((Object)(object)_shared);
			}
			_shared = null;
		}

		private void LateUpdate()
		{
			if ((Object)(object)_current != (Object)(object)this)
			{
				return;
			}
			if ((Object)(object)_canvas == (Object)null)
			{
				_canvas = ((Component)this).GetComponentInParent<Canvas>();
			}
			if ((Object)(object)_canvas == (Object)null || (Object)(object)_shared != (Object)null)
			{
				return;
			}
			_timer += Time.unscaledDeltaTime;
			if (!(_timer < 0.5f))
			{
				_shared = UITooltips.Spawn(_canvas);
				if (!((Object)(object)_shared == (Object)null))
				{
					Write();
					Place();
				}
			}
		}

		private void Write()
		{
			if ((Object)(object)_shared == (Object)null)
			{
				return;
			}
			Transform val = Utils.FindChild(_shared.transform, "Text", (IterativeSearchType)0);
			if ((Object)(object)val != (Object)null)
			{
				TMP_Text component = ((Component)val).GetComponent<TMP_Text>();
				if ((Object)(object)component != (Object)null)
				{
					component.text = Text;
				}
			}
			Transform val2 = Utils.FindChild(_shared.transform, "Topic", (IterativeSearchType)0);
			if ((Object)(object)val2 != (Object)null)
			{
				TMP_Text component2 = ((Component)val2).GetComponent<TMP_Text>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.text = Topic;
				}
			}
			RectTransform val3 = Panel();
			if ((Object)(object)val3 != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(val3);
			}
		}

		private RectTransform Panel()
		{
			if ((Object)(object)_shared == (Object)null)
			{
				return null;
			}
			Transform transform = _shared.transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			RectTransform val2 = (RectTransform)((((Transform)val).childCount > 0) ? /*isinst with value type is only supported in some contexts*/: null);
			if (!((Object)(object)val2 != (Object)null))
			{
				return val;
			}
			return val2;
		}

		private void Place()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_00a0: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)(((Object)(object)_shared != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
			Transform transform = ((Component)this).transform;
			RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			RectTransform val3 = Panel();
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
			{
				return;
			}
			Rect rect = val3.rect;
			float width = ((Rect)(ref rect)).width;
			rect = val2.rect;
			float num = ((Rect)(ref rect)).width * 0.5f + Gap;
			rect = val2.rect;
			((Transform)val).position = ((Transform)val2).TransformPoint(new Vector3(num, ((Rect)(ref rect)).height * 0.5f, 0f));
			if (!((Object)(object)Bounds == (Object)null))
			{
				if (Overflows(val3, out var _))
				{
					float num2 = 0f - (num + width);
					rect = val2.rect;
					((Transform)val).position = ((Transform)val2).TransformPoint(new Vector3(num2, ((Rect)(ref rect)).height * 0.5f, 0f));
				}
				if (Overflows(val3, out var shift2))
				{
					((Transform)val).position = ((Transform)val).position + ((Transform)Bounds).TransformVector(new Vector3(shift2.x, shift2.y, 0f));
				}
			}
		}

		private bool Overflows(RectTransform panel, out Vector2 shift)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			shift = Vector2.zero;
			if ((Object)(object)Bounds == (Object)null)
			{
				return false;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			panel.GetWorldCorners(array);
			Vector2 val = Vector2.op_Implicit(((Transform)Bounds).InverseTransformPoint(array[0]));
			Vector2 val2 = Vector2.op_Implicit(((Transform)Bounds).InverseTransformPoint(array[2]));
			Rect rect = Bounds.rect;
			if (val2.x > ((Rect)(ref rect)).xMax)
			{
				shift.x = ((Rect)(ref rect)).xMax - val2.x;
			}
			if (val.x + shift.x < ((Rect)(ref rect)).xMin)
			{
				shift.x = ((Rect)(ref rect)).xMin - val.x;
			}
			if (val.y < ((Rect)(ref rect)).yMin)
			{
				shift.y = ((Rect)(ref rect)).yMin - val.y;
			}
			if (val2.y + shift.y > ((Rect)(ref rect)).yMax)
			{
				shift.y = ((Rect)(ref rect)).yMax - val2.y;
			}
			return shift != Vector2.zero;
		}
	}
	internal class UIPool<T> where T : class
	{
		private readonly Transform _parent;

		private readonly List<GameObject> _objects;

		private readonly List<T> _views;

		private int _cursor;

		public int Count => _cursor;

		public IReadOnlyList<T> Views => _views;

		public UIPool(GameObject template, Transform parent, Func<GameObject, T> bind)
		{
			<template>P = template;
			<bind>P = bind;
			_parent = (((Object)(object)parent != (Object)null) ? parent : (((Object)(object)<template>P != (Object)null) ? <template>P.transform.parent : null));
			_objects = new List<GameObject>();
			_views = new List<T>();
			base..ctor();
		}

		public GameObject ObjectAt(int index)
		{
			if (index < 0 || index >= _objects.Count)
			{
				return null;
			}
			return _objects[index];
		}

		public T ViewAt(int index)
		{
			if (index < 0 || index >= _views.Count)
			{
				return null;
			}
			return _views[index];
		}

		public void Begin()
		{
			_cursor = 0;
		}

		public T Take()
		{
			GameObject clone;
			return Take(out clone);
		}

		public T Take(out GameObject clone)
		{
			clone = null;
			if ((Object)(object)<template>P == (Object)null)
			{
				return null;
			}
			if (_cursor < _objects.Count)
			{
				clone = _objects[_cursor];
				if ((Object)(object)clone == (Object)null)
				{
					clone = Grow(_cursor);
					if ((Object)(object)clone == (Object)null)
					{
						return null;
					}
				}
				if (!clone.activeSelf)
				{
					clone.SetActive(true);
				}
				return _views[_cursor++];
			}
			clone = Grow(-1);
			if ((Object)(object)clone == (Object)null)
			{
				return null;
			}
			return _views[_cursor++];
		}

		public void End()
		{
			for (int i = _cursor; i < _objects.Count; i++)
			{
				GameObject val = _objects[i];
				if ((Object)(object)val != (Object)null && val.activeSelf)
				{
					val.SetActive(false);
				}
			}
		}

		public void Clear()
		{
			foreach (GameObject @object in _objects)
			{
				if ((Object)(object)@object != (Object)null)
				{
					Object.Destroy((Object)(object)@object);
				}
			}
			_objects.Clear();
			_views.Clear();
			_cursor = 0;
		}

		private GameObject Grow(int replaceAt)
		{
			GameObject val = UIExtensions.CloneTemplate(<template>P, _parent);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			T val2 = ((<bind>P != null) ? <bind>P(val) : (val as T));
			if (replaceAt >= 0)
			{
				_objects[replaceAt] = val;
				_views[replaceAt] = val2;
			}
			else
			{
				_objects.Add(val);
				_views.Add(val2);
			}
			return val;
		}
	}
	internal class UIPool : UIPool<GameObject>
	{
		public UIPool(GameObject template, Transform parent = null)
			: base(template, parent, (Func<GameObject, GameObject>)((GameObject clone) => clone))
		{
		}
	}
	internal class UITabs
	{
		private class Tab
		{
			public GameObject Root;

			public Image Selected;

			public Image Hover;

			public Action Chosen;

			public bool Enabled = true;
		}

		private readonly List<Tab> _tabs = new List<Tab>();

		public Color SelectedColor = GameColors.Yellow;

		public Color HoverColor = new Color(1f, 0.889f, 0f, 0.45f);

		public int Index { get; private set; } = -1;

		public int Count => _tabs.Count;

		public event Action<int> Changed;

		public UITabs Add(GameObject tab, Action chosen, Image selected = null, Image hover = null, bool enabled = true)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Expected O, but got Unknown
			if ((Object)(object)tab == (Object)null)
			{
				return this;
			}
			Tab entry = new Tab
			{
				Root = tab,
				Selected = selected,
				Hover = hover,
				Chosen = chosen,
				Enabled = enabled
			};
			_tabs.Add(entry);
			int index = _tabs.Count - 1;
			if ((Object)(object)entry.Selected != (Object)null)
			{
				Skin.Highlight(entry.Selected, SelectedColor);
				((Behaviour)entry.Selected).enabled = false;
			}
			if ((Object)(object)entry.Hover != (Object)null)
			{
				Skin.Highlight(entry.Hover, HoverColor);
				((Behaviour)entry.Hover).enabled = false;
				UIEvents.OnHover(tab, delegate
				{
					if (entry.Enabled)
					{
						((Behaviour)entry.Hover).enabled = true;
					}
				}, delegate
				{
					((Behaviour)entry.Hover).enabled = false;
				});
			}
			Button component = tab.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((Selectable)component).interactable = enabled;
				((UnityEventBase)component.onClick).RemoveAllListeners();
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					Select(index);
				});
				Skin.Sfx(component);
			}
			else
			{
				UIEvents.OnLeftClick(tab, delegate
				{
					Select(index);
				});
			}
			return this;
		}

		public void SetEnabled(int index, bool enabled)
		{
			if (index >= 0 && index < _tabs.Count)
			{
				Tab tab = _tabs[index];
				tab.Enabled = enabled;
				Button val = (((Object)(object)tab.Root != (Object)null) ? tab.Root.GetComponent<Button>() : null);
				if ((Object)(object)val != (Object)null)
				{
					((Selectable)val).interactable = enabled;
				}
				if (!enabled && (Object)(object)tab.Hover != (Object)null)
				{
					((Behaviour)tab.Hover).enabled = false;
				}
			}
		}

		public void SelectSilent(int index)
		{
			if (index >= 0 && index < _tabs.Count && _tabs[index].Enabled)
			{
				Index = index;
				Paint();
			}
		}

		public void Select(int index)
		{
			if (index >= 0 && index < _tabs.Count && _tabs[index].Enabled && index != Index)
			{
				Index = index;
				Paint();
				_tabs[index].Chosen?.Invoke();
				this.Changed?.Invoke(index);
			}
		}

		public void SelectFirstEnabled()
		{
			for (int i = 0; i < _tabs.Count; i++)
			{
				if (_tabs[i].Enabled)
				{
					Select(i);
					break;
				}
			}
		}

		public void Clear()
		{
			_tabs.Clear();
			Index = -1;
		}

		private void Paint()
		{
			for (int i = 0; i < _tabs.Count; i++)
			{
				Image selected = _tabs[i].Selected;
				if ((Object)(object)selected != (Object)null)
				{
					((Behaviour)selected).enabled = i == Index;
				}
			}
		}
	}
}