using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using BepInEx;
using BepInEx.Logging;
using FistVR;
using H3MP;
using H3MP.Networking;
using H3MP.Scripts;
using H3VC.AudioPipelines;
using H3VC.Converter;
using H3VC.Data;
using H3VC.H3MPWrapper;
using H3VC.Network;
using H3VC.NetworkImplement.Mute;
using H3VC.Networks;
using H3VC.Networks.NetworkImplement;
using H3VC.Netwroks;
using H3VC.Presenter;
using H3VC.Servers;
using H3VC.Speakers;
using H3VC.Test;
using H3VC.VC;
using H3VC.VCUsers;
using H3VC.View;
using H3VC.VoiceRecoders;
using H3VC.VoiceRecoders.MicImpement;
using H3VC.src.View;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using NAudio.Wave;
using UniRx;
using UniRx.Diagnostics;
using UniRx.InternalUtil;
using UniRx.Operators;
using UniRx.Triggers;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;
using UnityOpus;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("CatalpaBow")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Add 3d audio voicechat to H3MP")]
[assembly: AssemblyFileVersion("0.1.1.0")]
[assembly: AssemblyInformationalVersion("0.1.1+c594efcbeda7c2038853a7f8a2dd3abb034aa0ef")]
[assembly: AssemblyProduct("CatalpaBow.H3VC")]
[assembly: AssemblyTitle("H3VC")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string id = null, string name = null, string version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string id = null, string name = null, string version = null)
		{
		}
	}
}
namespace H3VC
{
	[BepInPlugin("CatalpaBow.H3VC", "H3VC", "0.1.1")]
	[BepInProcess("h3vr.exe")]
	public class Mod : BaseUnityPlugin
	{
		internal AudioTest audioTest;

		internal static ManualLogSource Logger { get; private set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			VCMain.Intialize();
			ViewMain.Intialize();
			PresenterMain.Intialize(VCMain.recoder);
		}

		private void Update()
		{
		}
	}
	public static class TestPacket
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static GenericCustomPacketReceivedDelegate <0>__PacketReceived;
		}

		public static void Intialize()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__PacketReceived;
			if (obj == null)
			{
				GenericCustomPacketReceivedDelegate val = PacketReceived;
				<>O.<0>__PacketReceived = val;
				obj = (object)val;
			}
			Mod.GenericCustomPacketReceived += (GenericCustomPacketReceivedDelegate)obj;
		}

		public static void PacketReceived(int clientID, string ID, Packet packet)
		{
			if (!(ID != "TestPacket"))
			{
				string text = packet.ReadString(true);
				Mod.Logger.LogMessage((object)text);
			}
		}

		public static void Send()
		{
			//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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			Packet val = new Packet(-1);
			val.Write("TestPacket");
			val.Write("HelloWorldYoYo");
			ClientSend.SendTCPData(val, false);
		}

		public static void Test()
		{
		}
	}
	public class H3VRRaycaster : BaseRaycaster
	{
		public override Camera eventCamera
		{
			get
			{
				throw new NotImplementedException();
			}
		}

		public override void Raycast(PointerEventData eventData, List<RaycastResult> resultAppendList)
		{
			throw new NotImplementedException();
		}
	}
}
namespace H3VC.View
{
	public static class AssetBundleLoader
	{
		private static AssetBundle bundle;

		public static AssetBundle Load()
		{
			if ((Object)(object)bundle != (Object)null)
			{
				return bundle;
			}
			bundle = AssetBundle.LoadFromFile(Directory.GetParent(Assembly.GetExecutingAssembly().Location).FullName + "\\miccfgview");
			return bundle;
		}
	}
	public class H3VCWristMenuSection : FVRWristMenuSection
	{
		public override void Enable()
		{
		}

		private void Awake()
		{
			//IL_001b: 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)
			Image obj = ((Component)this).gameObject.AddComponent<Image>();
			((Graphic)obj).rectTransform.sizeDelta = new Vector2(500f, 350f);
			((Graphic)obj).color = new Color(0.1f, 0.1f, 0.1f, 1f);
		}
	}
	public class VoiceRcoderWristMenuPatch : MonoBehaviour
	{
		[HarmonyPatch(typeof(FVRWristMenu2), "Update")]
		[HarmonyPrefix]
		private static void PrefixUpdate()
		{
		}

		[HarmonyPatch(typeof(FVRWristMenu2), "Awake")]
		[HarmonyPrefix]
		private static void PrefixAwake(FVRWristMenu2 __instance)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_007f: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Section_H3VC", new Type[1] { typeof(RectTransform) });
			GameObject val2 = Object.Instantiate<GameObject>(AssetBundleLoader.Load().LoadAsset<GameObject>("MicSettings"));
			val2.transform.parent = val.transform;
			VoiceRecoderView.SingleInstance.Value = val2.GetComponent<VoiceRecoderView>();
			val.transform.SetParent(__instance.MenuGO.transform);
			val.transform.localPosition = new Vector3(0f, 300f, 0f);
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(350f, 350f);
			FVRWristMenuSection val3 = (FVRWristMenuSection)(object)val.AddComponent<H3VCWristMenuSection>();
			val3.ButtonText = "H3VC";
			__instance.Sections.Add(val3);
			val.SetActive(false);
		}
	}
	public class VoiceRecoderView : MonoBehaviour
	{
		public static ReactiveProperty<VoiceRecoderView> SingleInstance = new ReactiveProperty<VoiceRecoderView>();

		public UniRx.IObservable<Unit> OnViewDestroied;

		public UniRx.IObservable<bool> OnMuteChanged;

		public UniRx.IObservable<Unit> OnPreviousDevice;

		public UniRx.IObservable<Unit> OnNextDevice;

		public UniRx.IObservable<Unit> OnPreviousSoundMode;

		public UniRx.IObservable<Unit> OnNextSoundMode;

		public UniRx.IObservable<Unit> OnInceraseVolume;

		public UniRx.IObservable<Unit> OnDecreaseVolume;

		[SerializeField]
		private Toggle muteToggle;

		[SerializeField]
		private Text soundModeName;

		[SerializeField]
		private Button soundModePrevious;

		[SerializeField]
		private Button soundModeNext;

		[SerializeField]
		private Text deviceNameText;

		[SerializeField]
		private Button devicePrevious;

		[SerializeField]
		private Button deviceNext;

		[SerializeField]
		private GameObject levelMeter;

		[SerializeField]
		private Text volumeNum;

		[SerializeField]
		private Button decreaseVolume;

		[SerializeField]
		private Button increaseVolume;

		public void OnDestroy()
		{
			Mod.Logger.LogInfo((object)"Destroied!");
		}

		public void Awake()
		{
			OnMuteChanged = muteToggle.OnValueChangedAsObservable();
			OnPreviousDevice = devicePrevious.OnClickAsObservable();
			OnNextDevice = deviceNext.OnClickAsObservable();
			OnPreviousSoundMode = soundModePrevious.OnClickAsObservable();
			OnNextSoundMode = soundModeNext.OnClickAsObservable();
			OnDecreaseVolume = decreaseVolume.OnClickAsObservable();
			OnInceraseVolume = increaseVolume.OnClickAsObservable();
			SingleInstance.Value = this;
		}

		public void ChangeSoundMode(string modeName)
		{
			soundModeName.text = modeName;
		}

		public void ChangeDeviceName(string deviceName)
		{
			deviceNameText.text = deviceName;
		}

		public void ChangeVolumeNum(int val)
		{
			volumeNum.text = val.ToString();
		}

		public void SetVoiceLevel(float val)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			levelMeter.transform.localScale = new Vector3(val, 1f, 1f);
		}
	}
}
namespace H3VC.View.FVRComponent
{
	public class FVRDropdown : FVRPointable
	{
		private Dropdown dropdown;

		public void Awake()
		{
			//IL_001f: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)this).GetComponent<RectTransform>();
			dropdown = ((Component)this).GetComponent<Dropdown>();
			((Component)this).gameObject.AddComponent<BoxCollider>().size = new Vector3(component.sizeDelta.x, component.sizeDelta.y, 0f);
		}

		public override void OnPoint(FVRViveHand hand)
		{
			((FVRPointable)this).OnPoint(hand);
			if (hand.Input.TriggerDown && (Object)(object)dropdown != (Object)null)
			{
				dropdown.Show();
			}
		}
	}
	public class FVRToggle : FVRPointable
	{
		private Toggle toggle;

		public void Awake()
		{
			//IL_001f: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)this).GetComponent<RectTransform>();
			toggle = ((Component)this).GetComponent<Toggle>();
			((Component)this).gameObject.AddComponent<BoxCollider>().size = new Vector3(component.sizeDelta.x, component.sizeDelta.y, 0f);
		}

		public override void OnPoint(FVRViveHand hand)
		{
			((FVRPointable)this).OnPoint(hand);
			if (hand.Input.TriggerDown && (Object)(object)toggle != (Object)null)
			{
				toggle.isOn = !toggle.isOn;
			}
		}
	}
}
namespace H3VC.VoiceRecoders
{
	public abstract class BaseMicrophone : IMutipleDevice
	{
		public abstract UniRx.IObservable<float[]> OnAudioReady { get; }

		public BaseMicrophone()
		{
		}

		public abstract void StartRecoding();

		public abstract IEnumerable<MicDeviceInfo> ShowDevices();

		public abstract MicDeviceInfo ChangeDevice(int deviceNumber);

		public abstract int DeviceCount();
	}
	public interface IMutipleDevice
	{
		IEnumerable<MicDeviceInfo> ShowDevices();

		MicDeviceInfo ChangeDevice(int deviceID);

		int DeviceCount();
	}
	public class MicDeviceInfo
	{
		public readonly int deviceID;

		public string name { get; private set; }

		public MicDeviceInfo(int _deviceID, string _name)
		{
			deviceID = _deviceID;
			name = _name;
		}
	}
	public class VoiceLevelMeter
	{
		private VoiceRecoder recoder;

		private ReactiveProperty<float> _crntVoiceLevel;

		private List<float> averageBuf;

		[SerializeField]
		private float dB_Min = -80f;

		[SerializeField]
		private float dB_Max = -0f;

		public IReadOnlyReactiveProperty<float> VoiceLevel => _crntVoiceLevel;

		public VoiceLevelMeter(VoiceRecoder _recoder)
		{
			averageBuf = new List<float>();
			recoder = _recoder;
			_crntVoiceLevel = new ReactiveProperty<float>();
			Intialize();
		}

		private void Intialize()
		{
			(from samples in recoder.OnAudioReady.ThrottleFirst(TimeSpan.FromMilliseconds(16.0))
				select samples.Value.pcmBuffer.Average()).Select(ToDecibel).Select(Normalization).Subscribe(delegate(float level)
			{
				_crntVoiceLevel.Value = level;
			});
		}

		private float Normalization(float dB)
		{
			float num = dB;
			if (num > dB_Max)
			{
				num = dB_Max;
			}
			else if (num < dB_Min)
			{
				num = dB_Min;
			}
			return 1f + num / (dB_Max - dB_Min);
		}

		private float ToDecibel(float sampleAverage)
		{
			return 20f * Mathf.Log10(sampleAverage);
		}
	}
	public class VoiceRecoder : IAudioInput
	{
		public int id = -1;

		private BaseMicrophone mic;

		private VoiceLevelMeter levelMeter;

		public ReactiveProperty<float> volume;

		public ReactiveProperty<bool> isMute;

		public ReactiveProperty<SoundMode> soundMode;

		public ReactiveProperty<MicDeviceInfo> crntDevice;

		public IReadOnlyReactiveProperty<float> VoiceLevel => levelMeter.VoiceLevel;

		public UniRx.IObservable<KeyValuePair<int, PCMSegment>> OnAudioReady => from samples in mic.OnAudioReady
			select samples.Select((float sample) => sample * volume.Value * 2f).ToArray() into sgmnt
			select new PCMSegment(sgmnt, sgmnt.Length) into pcmData
			select new KeyValuePair<int, PCMSegment>(id, pcmData);

		public UniRx.IObservable<KeyValuePair<int, bool>> OnMuteChanged => isMute.Select((bool isMute) => new KeyValuePair<int, bool>(id, isMute));

		public UniRx.IObservable<KeyValuePair<int, SoundMode>> OnSoundModeChanged => soundMode.Select((SoundMode mode) => new KeyValuePair<int, SoundMode>(id, mode));

		public VoiceRecoder(BaseMicrophone _mic)
		{
			mic = _mic;
			volume = new ReactiveProperty<float>();
			volume.Value = 0.5f;
			crntDevice = new ReactiveProperty<MicDeviceInfo>();
			crntDevice.Value = mic.ShowDevices().First();
			isMute = new ReactiveProperty<bool>();
			soundMode = new ReactiveProperty<SoundMode>();
			StartRecoding();
			levelMeter = new VoiceLevelMeter(this);
		}

		public void DecreaseVolume()
		{
			ChangeVolume(volume.Value - 0.1f);
		}

		public void IncreaseVolume()
		{
			ChangeVolume(volume.Value + 0.1f);
		}

		private void ChangeVolume(float val)
		{
			if (val < 0f)
			{
				val = 0f;
			}
			if ((double)val > 2.0)
			{
				val = 2f;
			}
			volume.Value = val;
		}

		private void StartRecoding()
		{
			mic.StartRecoding();
		}

		public IEnumerable<MicDeviceInfo> ShowDevices()
		{
			return mic.ShowDevices();
		}

		public void ChangeDevice(int deviceID)
		{
			mic.ChangeDevice(deviceID);
		}

		public void NextDevice()
		{
			int num = crntDevice.Value.deviceID + 1;
			if (num >= mic.DeviceCount())
			{
				num = 0;
			}
			crntDevice.Value = mic.ChangeDevice(num);
		}

		public void PreviousDevice()
		{
			int num = crntDevice.Value.deviceID - 1;
			if (num < 0)
			{
				num = mic.DeviceCount() - 1;
			}
			crntDevice.Value = mic.ChangeDevice(num);
		}

		public void NextSoundMode()
		{
			int length = Enum.GetValues(typeof(SoundMode)).Length;
			if ((int)(soundMode.Value + 1) >= length)
			{
				soundMode.Value = SoundMode.positional;
			}
			else
			{
				soundMode.Value++;
			}
		}

		public void PreviousSoundMode()
		{
			int length = Enum.GetValues(typeof(SoundMode)).Length;
			if (soundMode.Value - 1 < SoundMode.positional)
			{
				soundMode.Value = (SoundMode)(length - 1);
			}
			else
			{
				soundMode.Value--;
			}
		}
	}
}
namespace H3VC.VoiceRecoders.MicImplement
{
	[Obsolete("", true)]
	public class UnityVoiceMic
	{
	}
}
namespace H3VC.VoiceRecoders.MicImpement
{
	public class NAudioMic : BaseMicrophone
	{
		private Subject<float[]> OnAudioReadySubject;

		private float[] floatSamples;

		private WaveInEvent waveIn;

		public override UniRx.IObservable<float[]> OnAudioReady => OnAudioReadySubject;

		public NAudioMic()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			OnAudioReadySubject = new Subject<float[]>();
			floatSamples = new float[4096];
			int deviceNumber = 0;
			waveIn = new WaveInEvent();
			waveIn.DeviceNumber = deviceNumber;
			waveIn.WaveFormat = new WaveFormat(48000, 1);
			waveIn.BufferMilliseconds = 10;
			waveIn.DataAvailable += DataAvailableHandler;
		}

		private void DataAvailableHandler(object sender, WaveInEventArgs e)
		{
			try
			{
				int recodedPartLength = Bit16ToNormizedFloat(ref floatSamples, e);
				float[] value = CutRecodedSamples(recodedPartLength);
				OnAudioReadySubject.OnNext(value);
			}
			catch (Exception ex)
			{
				Mod.Logger.LogError((object)ex);
			}
		}

		private int Bit16ToNormizedFloat(ref float[] floatSamples, WaveInEventArgs e)
		{
			int num = 0;
			for (num = 0; num < e.BytesRecorded; num += 2)
			{
				float num2 = (float)(short)((e.Buffer[num + 1] << 8) | e.Buffer[num]) / 32768f;
				floatSamples[num / 2] = num2;
			}
			return num / 2;
		}

		private float[] CutRecodedSamples(int recodedPartLength)
		{
			float[] array = new float[recodedPartLength];
			Array.Copy(floatSamples, array, recodedPartLength);
			return array;
		}

		public override void StartRecoding()
		{
			waveIn.StartRecording();
		}

		public override MicDeviceInfo ChangeDevice(int newDeviceNumber)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			waveIn.StopRecording();
			waveIn.Dispose();
			waveIn = new WaveInEvent();
			waveIn.DeviceNumber = newDeviceNumber;
			waveIn.WaveFormat = new WaveFormat(48000, 1);
			waveIn.BufferMilliseconds = 10;
			waveIn.DataAvailable += DataAvailableHandler;
			waveIn.StartRecording();
			WaveInCapabilities capabilities = WaveIn.GetCapabilities(newDeviceNumber);
			return new MicDeviceInfo(newDeviceNumber, ((WaveInCapabilities)(ref capabilities)).ProductName);
		}

		public override IEnumerable<MicDeviceInfo> ShowDevices()
		{
			for (int i = 0; i < WaveIn.DeviceCount; i++)
			{
				int deviceID = i;
				WaveInCapabilities capabilities = WaveIn.GetCapabilities(i);
				yield return new MicDeviceInfo(deviceID, ((WaveInCapabilities)(ref capabilities)).ProductName);
			}
		}

		public override int DeviceCount()
		{
			return WaveIn.DeviceCount;
		}
	}
}
namespace H3VC.VCUsers
{
	public class VCUserList
	{
		private ReactiveCollection<int> _crntUsers;

		public IReadOnlyReactiveCollection<int> crntUserIDs => _crntUsers;

		public UniRx.IObservable<int> OnJoined => from evnt in crntUserIDs.ObserveAdd()
			select evnt.Value;

		public UniRx.IObservable<int> OnLeaved => from evnt in crntUserIDs.ObserveRemove()
			select evnt.Value;

		public VCUserList()
		{
			ReactiveCollection<int> reactiveCollection = new ReactiveCollection<int>();
			foreach (int key in GameManager.players.Keys)
			{
				reactiveCollection.Add(key);
			}
			_crntUsers = reactiveCollection;
			(from plMngr in Observable.FromEvent<OnPlayerAddedDelegate, PlayerManager>((Action<PlayerManager> h) => new OnPlayerAddedDelegate(h.Invoke), delegate(OnPlayerAddedDelegate h)
				{
					GameManager.OnPlayerAdded += h;
				}, delegate(OnPlayerAddedDelegate h)
				{
					GameManager.OnPlayerAdded -= h;
				})
				select plMngr.ID).Subscribe(_crntUsers.Add);
			(from plMngr in Observable.FromEvent<OnPlayerRemovedDelegate, PlayerManager>((Action<PlayerManager> h) => new OnPlayerRemovedDelegate(h.Invoke), delegate(OnPlayerRemovedDelegate h)
				{
					Mod.OnPlayerRemoved += h;
				}, delegate(OnPlayerRemovedDelegate h)
				{
					Mod.OnPlayerRemoved -= h;
				})
				select plMngr.ID).Subscribe(delegate(int id)
			{
				_crntUsers.Remove(id);
			});
			OnJoined.Subscribe(delegate(int id)
			{
				Mod.Logger.LogInfo((object)("VCUser:" + id + "is joined!"));
			});
			OnLeaved.Subscribe(delegate(int id)
			{
				Mod.Logger.LogInfo((object)("VCUser:" + id + "is leaved!"));
			});
		}
	}
}
namespace H3VC.VC
{
	public static class VCMain
	{
		public static AudioPipeline audioPipeline;

		public static VoiceRecoder recoder;

		public static PlayerAudioSpeakers speakers;

		public static VCUserList userList;

		public static AudioRelayServer server;

		public static void Intialize()
		{
			userList = new VCUserList();
			recoder = new VoiceRecoder(new NAudioMic());
			speakers = new PlayerAudioSpeakers(userList);
			NetworkAudioListener inOthers = new NetworkAudioListener();
			NetworkAudioStreamer outSelf = new NetworkAudioStreamer();
			audioPipeline = new AudioPipeline(recoder, outSelf, inOthers, speakers);
			server = new AudioRelayServer();
		}
	}
}
namespace H3VC.Speakers
{
	public class PlayerAudioSpeaker
	{
		public readonly int id;

		private SoundMode soundMode;

		private bool isMute;

		private UnitySpeaker voicePlayer;

		public PlayerAudioSpeaker(UnitySpeaker pl, int _id)
		{
			id = _id;
			voicePlayer = pl;
			soundMode = H3VC.Data.SoundMode.positional;
			voicePlayer.SetPositional(isPositional: false);
		}

		public void Mute(bool isMute)
		{
			voicePlayer.DontPlaySound(isMute);
			this.isMute = isMute;
		}

		public void SoundMode(SoundMode mode)
		{
			ManualLogSource logger = Mod.Logger;
			int num = id;
			logger.LogInfo((object)("UserID:" + num + " is SoundModeChanged"));
			soundMode = mode;
			if (mode == H3VC.Data.SoundMode.positional)
			{
				voicePlayer.SetPositional(isPositional: true);
			}
			else
			{
				voicePlayer.SetPositional(isPositional: false);
			}
		}

		public void Play(PCMSegment sgmnt)
		{
			voicePlayer.Play(sgmnt);
			if (isMute)
			{
				Mute(isMute: true);
				return;
			}
			string text = Players.CurrentScene(id);
			string text2 = Players.CurrentScene(Players.IDSelf());
			bool flag = text == text2;
			if ((soundMode == H3VC.Data.SoundMode.localScene || soundMode == H3VC.Data.SoundMode.positional) && !flag)
			{
				voicePlayer.DontPlaySound(isMute: true);
			}
			else
			{
				voicePlayer.DontPlaySound(isMute: false);
			}
		}
	}
	public class PlayerAudioSpeakers : IAudioOutput
	{
		public List<PlayerAudioSpeaker> speakerList;

		private readonly VCUserList userList;

		public PlayerAudioSpeakers(VCUserList _userList)
		{
			userList = _userList;
			speakerList = userList.crntUserIDs.Select(VoiceSpeakerBuilder.Build).ToList();
			(from spkr in userList.OnJoined.Select(VoiceSpeakerBuilder.Build)
				where spkr != null
				select spkr).Subscribe(speakerList.Add);
			userList.OnLeaved.Subscribe(delegate(int id)
			{
				speakerList.RemoveAll((PlayerAudioSpeaker spkr) => spkr.id == id);
			});
		}

		public void StreamAudio(int id, PCMSegment sgmnt)
		{
			speakerList.Find((PlayerAudioSpeaker spkr) => spkr.id == id)?.Play(sgmnt);
		}

		public void Mute(int id, bool isMute)
		{
			speakerList.Find((PlayerAudioSpeaker spkr) => spkr.id == id)?.Mute(isMute);
		}

		public void SoundMode(int id, SoundMode mode)
		{
			speakerList.Find((PlayerAudioSpeaker spkr) => spkr.id == id)?.SoundMode(mode);
		}
	}
	[RequireComponent(typeof(AudioSource))]
	public class UnitySpeaker : MonoBehaviour
	{
		private const NumChannels channels = NumChannels.Mono;

		private const SamplingFrequency frequency = SamplingFrequency.Frequency_48000;

		private const int audioClipLength = 48000;

		private const int delaySamplesLength = 3840;

		private float[] samplesBuf;

		private int previousTimeSamples;

		private int previousDistance;

		private int previousHead;

		public AudioSource source { get; private set; }

		public int head { get; private set; }

		private void Awake()
		{
			Intialize(1);
		}

		public void Intialize(int channels)
		{
			source = ((Component)this).GetComponent<AudioSource>();
			source.spatialBlend = 1f;
			source.clip = AudioClip.Create("Voice", 48000, channels, 48000, false);
			source.loop = true;
		}

		public void DontPlaySound(bool isMute)
		{
			if (isMute)
			{
				source.volume = 0f;
			}
			else
			{
				source.volume = 1f;
			}
		}

		private void OnDisable()
		{
			source.Stop();
		}

		public void Play(PCMSegment sgmnt)
		{
			Play(sgmnt.pcmBuffer, sgmnt.pcmLength);
		}

		public void Play(float[] samples, int samplesLength)
		{
			if (samplesBuf == null || samplesBuf.Length != samplesLength + 2)
			{
				samplesBuf = new float[samplesLength + 2];
				Mod.Logger.LogInfo((object)("samplesBufSize is changed:" + samplesLength + 2));
			}
			Array.Copy(samples, 0, samplesBuf, 1, samplesLength);
			samplesBuf[0] = samplesBuf[1];
			samplesBuf[samplesBuf.Length - 1] = samplesBuf[samplesBuf.Length - 2];
			source.clip.SetData(samplesBuf, head);
			head += samplesBuf.Length;
			head %= source.clip.samples;
			if (!source.isPlaying && head > 3840)
			{
				Mod.Logger.LogInfo((object)"Played");
				source.Play();
			}
			int num = 0;
			num = ((source.timeSamples <= head) ? (head - source.timeSamples) : (head + source.clip.samples - source.timeSamples));
			if (num > 5760)
			{
				int num2 = head - 3840;
				source.timeSamples = ((num2 < 0) ? (source.clip.samples + num2) : num2);
			}
			Log();
		}

		public void SetInScene()
		{
			source.spatialBlend = 0f;
		}

		public void SetPositional(bool isPositional)
		{
			if (isPositional)
			{
				source.spatialBlend = 1f;
			}
			else
			{
				source.spatialBlend = 0f;
			}
		}

		public void Log()
		{
			_ = source.isPlaying;
		}
	}
	public static class VoiceSpeakerBuilder
	{
		public static PlayerAudioSpeaker Build(int id)
		{
			if (!GameManager.players.TryGetValue(id, out var value))
			{
				return null;
			}
			return new PlayerAudioSpeaker(((Component)value.head).gameObject.AddComponent<UnitySpeaker>(), id);
		}
	}
}
namespace H3VC.Servers
{
	public class AudioRelayServer
	{
		private static AudioRelayServer _instance;

		private VoiceReceiver receiver;

		private IDisposable serverDisposer;

		public static AudioRelayServer Insntance => _instance ?? (_instance = new AudioRelayServer());

		public AudioRelayServer()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			receiver = VoiceReceiver.Instance;
			Mod.OnConnection += new OnConnectionDelegate(Start);
			Server.OnServerClose += new OnServerCloseDelegate(Stop);
		}

		public void Start()
		{
			if (ThreadManager.host)
			{
				Mod.Logger.LogInfo((object)"H3VC ServerStart");
				serverDisposer = receiver.OnVoiceReceived.Subscribe(delegate(UniRx.Tuple<int, OpusSegment> data)
				{
					VoiceSender.ServerSend(data.Item1, data.Item2);
				});
			}
		}

		public void Stop()
		{
			Mod.Logger.LogInfo((object)"H3VC ServerClose");
			serverDisposer.Dispose();
		}
	}
}
namespace H3VC.Netwroks
{
	public enum TransportProtocol
	{
		TCP,
		UDP
	}
}
namespace H3VC.Network
{
	public class VoiceReceiver : IDisposable
	{
		private static VoiceReceiver _instance;

		public static string packetName = "H3VC_VoiceData";

		private Subject<UniRx.Tuple<int, OpusSegment>> voiceReceivedStream;

		public static VoiceReceiver Instance => _instance ?? (_instance = new VoiceReceiver());

		public UniRx.IObservable<UniRx.Tuple<int, OpusSegment>> OnVoiceReceived => voiceReceivedStream;

		public VoiceReceiver()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			voiceReceivedStream = new Subject<UniRx.Tuple<int, OpusSegment>>();
			Mod.GenericCustomPacketReceived += new GenericCustomPacketReceivedDelegate(PacketHandler);
		}

		private void PacketHandler(int clientID, string name, Packet pkt)
		{
			if (!(name != packetName))
			{
				int num = pkt.ReadInt(true);
				byte[] data = pkt.ReadBytes(num, true);
				int length = pkt.ReadInt(true);
				voiceReceivedStream.OnNext(UniRx.Tuple.Create(clientID, new OpusSegment(data, length)));
			}
		}

		public void Dispose()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Mod.GenericCustomPacketReceived -= new GenericCustomPacketReceivedDelegate(PacketHandler);
		}
	}
	internal static class VoiceSender
	{
		public const string packetID = "H3VC_VoiceData";

		public static void ClientSend(OpusSegment sgmnt)
		{
			ClientSend.SendUDPData(sgmnt.ToPacket(-1, "H3VC_VoiceData"), false);
		}

		public static void ServerSend(int sender, OpusSegment sgmnt)
		{
			Packet val = sgmnt.ToPacket(-1, "H3VC_VoiceData");
			val.WriteLength();
			foreach (ServerClient value in Server.clients.Values)
			{
				if (value.ID == sender)
				{
					break;
				}
				value.udp.SendData(val);
			}
		}

		public static void SendFromClient(OpusSegment sgmnt)
		{
			if (ThreadManager.host)
			{
				ServerSend(0, sgmnt);
			}
			else
			{
				ClientSend(sgmnt);
			}
		}
	}
}
namespace H3VC.NetworkImplement.Mute
{
	public static class MuteEvent
	{
		public static MuteSender sender;

		public static MuteReceiver receiver;

		static MuteEvent()
		{
			TransportProtocol prtcl = TransportProtocol.TCP;
			sender = new MuteSender("H3VC_Mute", prtcl);
			receiver = new MuteReceiver("H3VC_Mute");
		}
	}
	public static class SoundModeEvent
	{
		public static SoundModeSender sender;

		public static SoundModeReceiver receiver;

		static SoundModeEvent()
		{
			TransportProtocol prtcl = TransportProtocol.TCP;
			sender = new SoundModeSender("H3VC_SoundMode", prtcl);
			receiver = new SoundModeReceiver("H3VC_SoundMode");
		}
	}
}
namespace H3VC.Networks
{
	public class NetworkAudioListener : IAudioInput
	{
		private VoiceDecoder decoder;

		public UniRx.IObservable<KeyValuePair<int, PCMSegment>> OnAudioReady => VoiceReceiver.Instance.OnVoiceReceived.Select(delegate(UniRx.Tuple<int, OpusSegment> audioData)
		{
			PCMSegment value = decoder.Decode(audioData.Item2);
			return new KeyValuePair<int, PCMSegment>(audioData.Item1, value);
		});

		public UniRx.IObservable<KeyValuePair<int, bool>> OnMuteChanged => MuteEvent.receiver.OnReceivedWithSenderID;

		public UniRx.IObservable<KeyValuePair<int, SoundMode>> OnSoundModeChanged => SoundModeEvent.receiver.OnReceivedWithSenderID;

		public NetworkAudioListener()
		{
			decoder = new VoiceDecoder();
		}
	}
	public class NetworkAudioStreamer : IAudioOutput
	{
		private VoiceEncoder encoder;

		public NetworkAudioStreamer()
		{
			encoder = new VoiceEncoder();
		}

		public void Mute(int id, bool isMute)
		{
			MuteEvent.sender.SendFromClient(isMute);
		}

		public void SoundMode(int id, SoundMode mode)
		{
			SoundModeEvent.sender.SendFromClient(mode);
		}

		public void StreamAudio(int id, PCMSegment sgmnt)
		{
			foreach (OpusSegment item in encoder.Encode(sgmnt.pcmBuffer))
			{
				VoiceSender.SendFromClient(item);
			}
		}
	}
}
namespace H3VC.Networks.NetworkImplement
{
	public class MuteReceiver : ReceiverBase<bool>
	{
		public MuteReceiver(string id)
			: base(id)
		{
		}

		public override bool Unpacket(CustomPacketReceivedEventData data)
		{
			return data.packet.ReadBool(true);
		}
	}
	public class MuteSender : SenderBase<bool>
	{
		public MuteSender(string id, TransportProtocol prtcl)
			: base(id, prtcl)
		{
		}

		public override void WritePacketData(ref Packet pkt, bool data)
		{
			pkt.Write(data);
		}
	}
	public abstract class ReceiverBase<ReceiveT>
	{
		public string packetID;

		public UniRx.IObservable<ReceiveT> OnReceived;

		public UniRx.IObservable<KeyValuePair<int, ReceiveT>> OnReceivedWithSenderID;

		public UniRx.IObservable<CustomPacketReceivedEventData> OnReceivedRaw;

		public ReceiverBase(string packetID)
		{
			ReceiverBase<ReceiveT> receiverBase = this;
			this.packetID = packetID;
			OnReceivedRaw = H3MPNetworkEvents.OnCustomPacketRecevied.Where((CustomPacketReceivedEventData evntData) => evntData.id == packetID);
			OnReceived = OnReceivedRaw.Select(Unpacket);
			OnReceivedWithSenderID = OnReceivedRaw.Select((CustomPacketReceivedEventData data) => new KeyValuePair<int, ReceiveT>(data.clientID, receiverBase.Unpacket(data)));
		}

		public abstract ReceiveT Unpacket(CustomPacketReceivedEventData data);
	}
	public abstract class SenderBase<SendT>
	{
		protected string packetID;

		protected TransportProtocol prtcl;

		protected SenderBase(string pktID, TransportProtocol prtcl)
		{
			packetID = pktID;
			this.prtcl = prtcl;
		}

		private void ClientSend(SendT data)
		{
			ClientSend.SendUDPData(ToPacket(data), false);
		}

		public void ServerSend(SendT data)
		{
			Packet pkt = ToPacket(data);
			ServerRelaySend(0, pkt);
		}

		public void ServerRelaySend(int sender, Packet pkt)
		{
			pkt.WriteLength();
			if (prtcl == TransportProtocol.TCP)
			{
				foreach (ServerClient value in Server.clients.Values)
				{
					if (value.ID == sender)
					{
						break;
					}
					value.udp.SendData(pkt);
				}
				return;
			}
			foreach (ServerClient value2 in Server.clients.Values)
			{
				if (value2.ID == sender)
				{
					break;
				}
				value2.tcp.SendData(pkt);
			}
		}

		public Packet ToPacket(SendT data)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			Packet pkt = new Packet(-1);
			pkt.Write(packetID);
			WritePacketData(ref pkt, data);
			return pkt;
		}

		public abstract void WritePacketData(ref Packet pkt, SendT data);

		public void SendFromClient(SendT data)
		{
			if (ThreadManager.host)
			{
				ServerSend(data);
			}
			else
			{
				ClientSend(data);
			}
		}
	}
	public class SoundModeReceiver : ReceiverBase<SoundMode>
	{
		public SoundModeReceiver(string id)
			: base(id)
		{
		}

		public override SoundMode Unpacket(CustomPacketReceivedEventData data)
		{
			return (SoundMode)data.packet.ReadInt(true);
		}
	}
	public class SoundModeSender : SenderBase<SoundMode>
	{
		public SoundModeSender(string id, TransportProtocol prtcl)
			: base(id, prtcl)
		{
		}

		public override void WritePacketData(ref Packet pkt, SoundMode data)
		{
			pkt.Write((int)data);
		}
	}
}
namespace H3VC.src.View
{
	public static class ViewMain
	{
		public static void Intialize()
		{
			Harmony.CreateAndPatchAll(typeof(VoiceRcoderWristMenuPatch), (string)null);
		}
	}
}
namespace H3VC.src.VC.Logger
{
	public class UnitySpeakerAnalizer
	{
		private UnitySpeaker spkr;

		private int speakrCrntPosDelay;

		private int headPos => spkr.head;

		private int crntPos => spkr.source.timeSamples;
	}
}
namespace H3VC.H3MPWrapper
{
	public static class H3MPNetworkEvents
	{
		public static UniRx.IObservable<CustomPacketReceivedEventData> OnCustomPacketRecevied = Observable.FromEvent<GenericCustomPacketReceivedDelegate, CustomPacketReceivedEventData>((Action<CustomPacketReceivedEventData> h) => (GenericCustomPacketReceivedDelegate)delegate(int cID, string id, Packet pkt)
		{
			h(new CustomPacketReceivedEventData(cID, id, pkt));
		}, delegate(GenericCustomPacketReceivedDelegate h)
		{
			Mod.GenericCustomPacketReceived += h;
		}, delegate(GenericCustomPacketReceivedDelegate h)
		{
			Mod.GenericCustomPacketReceived -= h;
		});
	}
	public class CustomPacketReceivedEventData
	{
		public int clientID;

		public string id;

		public Packet packet;

		public CustomPacketReceivedEventData(int clientID, string id, Packet pkt)
		{
			this.clientID = clientID;
			this.id = id;
			packet = pkt;
		}
	}
	public static class Players
	{
		public static string CurrentScene(int id)
		{
			if (id == IDSelf())
			{
				return GameManager.scene;
			}
			if (GameManager.players.TryGetValue(id, out var value))
			{
				return value.scene;
			}
			return "";
		}

		public static int IDSelf()
		{
			return GameManager.ID;
		}
	}
}
namespace H3VC.AudioPipelines
{
	public class AudioPipeline
	{
		private IAudioInput selfIn;

		private IAudioOutput selfOut;

		private IAudioInput otherIn;

		private IAudioOutput otherOut;

		public AudioPipeline(IAudioInput _inSelf, IAudioOutput _outSelf, IAudioInput _inOthers, IAudioOutput _outOthers)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			selfIn = _inSelf;
			selfOut = _outSelf;
			otherIn = _inOthers;
			otherOut = _outOthers;
			Mod.OnConnection += new OnConnectionDelegate(StartStream);
		}

		public void StartStream()
		{
			selfIn.OnAudioReady.Subscribe(delegate(KeyValuePair<int, PCMSegment> audioData)
			{
				selfOut.StreamAudio(audioData.Key, audioData.Value);
			});
			selfIn.OnMuteChanged.Subscribe(delegate(KeyValuePair<int, bool> isMute)
			{
				selfOut.Mute(isMute.Key, isMute.Value);
			});
			selfIn.OnSoundModeChanged.Subscribe(delegate(KeyValuePair<int, SoundMode> mode)
			{
				selfOut.SoundMode(mode.Key, mode.Value);
			});
			otherIn.OnAudioReady.Subscribe(delegate(KeyValuePair<int, PCMSegment> audioData)
			{
				otherOut.StreamAudio(audioData.Key, audioData.Value);
			});
			otherIn.OnMuteChanged.Subscribe(delegate(KeyValuePair<int, bool> isMute)
			{
				otherOut.Mute(isMute.Key, isMute.Value);
			});
			otherIn.OnSoundModeChanged.Subscribe(delegate(KeyValuePair<int, SoundMode> mode)
			{
				otherOut.SoundMode(mode.Key, mode.Value);
			});
		}
	}
	public interface IAudioInput
	{
		UniRx.IObservable<KeyValuePair<int, PCMSegment>> OnAudioReady { get; }

		UniRx.IObservable<KeyValuePair<int, bool>> OnMuteChanged { get; }

		UniRx.IObservable<KeyValuePair<int, SoundMode>> OnSoundModeChanged { get; }
	}
	public interface IAudioOutput
	{
		void StreamAudio(int id, PCMSegment sgmnt);

		void Mute(int id, bool isMute);

		void SoundMode(int id, SoundMode mode);
	}
}
namespace H3VC.Data
{
	public class OpusSegment
	{
		public readonly byte[] data;

		public readonly int dataLength;

		public readonly int length;

		public OpusSegment(byte[] _data, int _length)
		{
			data = _data;
			dataLength = _data.GetLength(0);
			length = _length;
		}

		public Packet ToPacket(int id, string name)
		{
			//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_000d: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			Packet val = new Packet(id);
			val.Write(name);
			val.Write(dataLength);
			val.Write(data);
			val.Write(length);
			return val;
		}
	}
	public class PCMSegment
	{
		public readonly float[] pcmBuffer;

		public readonly int pcmLength;

		public PCMSegment(float[] _pcmBuffer, int _pcmLength)
		{
			pcmBuffer = _pcmBuffer;
			pcmLength = _pcmLength;
		}
	}
	public enum SoundMode
	{
		positional,
		localScene,
		globalScene
	}
}
namespace H3VC.Converter
{
	public class VoiceDecoder
	{
		private const NumChannels channels = NumChannels.Mono;

		private Decoder decoder;

		private readonly float[] pcmBuffer = new float[5760];

		public VoiceDecoder()
		{
			decoder = new Decoder(SamplingFrequency.Frequency_48000, NumChannels.Mono);
		}

		private void OnDisable()
		{
			decoder.Dispose();
			decoder = null;
		}

		public PCMSegment Decode(OpusSegment segment)
		{
			int pcmLength = decoder.Decode(segment.data, segment.length, pcmBuffer);
			return new PCMSegment(pcmBuffer, pcmLength);
		}
	}
	public class VoiceEncoder
	{
		private const int bitrate = 96000;

		private const int frameSize = 120;

		private const int outputBufferSize = 480;

		private Encoder encoder;

		private Queue<float> pcmQueue = new Queue<float>();

		private readonly float[] frameBuffer = new float[120];

		private readonly byte[] outputBuffer = new byte[480];

		public VoiceEncoder()
		{
			encoder = new Encoder(SamplingFrequency.Frequency_48000, NumChannels.Mono, OpusApplication.Audio)
			{
				Bitrate = 96000,
				Complexity = 10,
				Signal = OpusSignal.Music
			};
		}

		private void Disable()
		{
			encoder.Dispose();
			encoder = null;
			pcmQueue.Clear();
		}

		public IEnumerable<OpusSegment> Encode(float[] data)
		{
			foreach (float item in data)
			{
				pcmQueue.Enqueue(item);
			}
			while (pcmQueue.Count > 120)
			{
				for (int j = 0; j < 120; j++)
				{
					frameBuffer[j] = pcmQueue.Dequeue();
				}
				int length = encoder.Encode(frameBuffer, outputBuffer);
				yield return new OpusSegment(outputBuffer, length);
			}
		}
	}
}
namespace H3VC.Test
{
	public class AssetBundleLoadTest
	{
		public static void Test()
		{
			if ((Object)(object)AssetBundleLoader.Load().LoadAsset<GameObject>("MicSetting") == (Object)null)
			{
				Mod.Logger.LogError((object)"asset is null");
			}
			else
			{
				Mod.Logger.LogInfo((object)"Load is sucsessed!");
			}
		}
	}
	internal class TestMain
	{
	}
	internal class AudioTest
	{
		private VoiceRecoder recoder;

		private UnitySpeaker spkr;

		public AudioTest(VoiceRecoder recoder)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			this.recoder = recoder;
			spkr = new GameObject().AddComponent<UnitySpeaker>();
			spkr.SetPositional(isPositional: false);
			Mod.Logger.LogInfo((object)AudioSettings.outputSampleRate);
			recoder.OnAudioReady.Subscribe(delegate(KeyValuePair<int, PCMSegment> data)
			{
				spkr.Play(data.Value);
			});
		}
	}
	public class SpeakerTests
	{
		private PlayerAudioSpeakers spkrs;

		public SpeakerTests(PlayerAudioSpeakers _spkrs)
		{
			spkrs = _spkrs;
		}

		public bool UserCountTests()
		{
			return spkrs.speakerList.Count == GameManager.players.Count;
		}
	}
	public static class Tester
	{
		public static void Assert(bool isSucsess)
		{
			if (isSucsess)
			{
				Mod.Logger.LogInfo((object)"Test is Sucsesed:");
			}
			else
			{
				Mod.Logger.LogError((object)"Test is Failed");
			}
		}

		public static void UserListTest()
		{
			Mod.Logger.LogDebug((object)("-----------" + MethodBase.GetCurrentMethod().Name + "-----------"));
			Mod.Logger.LogDebug((object)("UserListCount:" + VCMain.userList.crntUserIDs.Count));
			Mod.Logger.LogDebug((object)("H3MPPlayersCount:" + GameManager.players.Count));
			Assert(VCMain.userList.crntUserIDs.Count == GameManager.players.Count);
		}

		public static void Spkr_CountTest()
		{
			Mod.Logger.LogDebug((object)("-----------" + MethodBase.GetCurrentMethod().Name + "-----------"));
			Mod.Logger.LogDebug((object)("spkeakerListCount:" + VCMain.speakers.speakerList.Count));
			Mod.Logger.LogDebug((object)("UserListCount:" + VCMain.userList.crntUserIDs.Count));
			Assert(VCMain.speakers.speakerList.Count == GameManager.players.Count);
		}
	}
}
namespace H3VC.Presenter
{
	public static class PresenterMain
	{
		public static VoiceRecoderPresenter presenter;

		public static void Intialize(VoiceRecoder model)
		{
			VoiceRecoderView.SingleInstance.Where((VoiceRecoderView instance) => instance != null).Subscribe(delegate(VoiceRecoderView view)
			{
				if (presenter == null)
				{
					presenter = new VoiceRecoderPresenter(model, view);
				}
				else
				{
					presenter.ResetView(view);
				}
			});
		}
	}
	public class VoiceRecoderPresenter
	{
		private VoiceRecoder model;

		private VoiceRecoderView view;

		public VoiceRecoderPresenter(VoiceRecoder model, VoiceRecoderView view)
		{
			this.model = model;
			this.view = view;
			Intialize();
		}

		public void Intialize()
		{
			view.OnMuteChanged.Subscribe(delegate(bool isMute)
			{
				model.isMute.Value = isMute;
			}).AddTo((Component)(object)view);
			view.OnNextSoundMode.Subscribe(delegate
			{
				model.NextSoundMode();
			}).AddTo((Component)(object)view);
			view.OnPreviousSoundMode.Subscribe(delegate
			{
				model.PreviousSoundMode();
			}).AddTo((Component)(object)view);
			view.OnNextDevice.Subscribe(delegate
			{
				model.NextDevice();
			}).AddTo((Component)(object)view);
			view.OnPreviousDevice.Subscribe(delegate
			{
				model.PreviousDevice();
			}).AddTo((Component)(object)view);
			view.OnDecreaseVolume.Subscribe(delegate
			{
				model.DecreaseVolume();
			});
			view.OnInceraseVolume.Subscribe(delegate
			{
				model.IncreaseVolume();
			});
			model.soundMode.Subscribe(delegate(SoundMode mode)
			{
				view.ChangeSoundMode(mode.ToString());
			}).AddTo((Component)(object)view);
			model.crntDevice.Subscribe(delegate(MicDeviceInfo info)
			{
				view.ChangeDeviceName(info.name);
			}).AddTo((Component)(object)view);
			model.VoiceLevel.Subscribe(delegate(float level)
			{
				view.SetVoiceLevel(level);
			}).AddTo((Component)(object)view);
			model.volume.Select((float val) => (int)(Math.Round(val * 10f) * 10.0)).Subscribe(delegate(int percent)
			{
				view.ChangeVolumeNum(percent);
			});
		}

		public void ResetView(VoiceRecoderView view)
		{
			this.view = view;
			Intialize();
		}
	}
}
namespace UnityOpus
{
	public class Decoder : IDisposable
	{
		public const int maximumPacketDuration = 5760;

		private IntPtr decoder;

		private readonly NumChannels channels;

		private readonly float[] softclipMem;

		private bool disposedValue;

		public Decoder(SamplingFrequency samplingFrequency, NumChannels channels)
		{
			this.channels = channels;
			decoder = Library.OpusDecoderCreate(samplingFrequency, channels, out var error);
			if (error != 0)
			{
				Debug.LogError((object)("[UnityOpus] Failed to create Decoder. Error code is " + error));
				decoder = IntPtr.Zero;
			}
			softclipMem = new float[(int)channels];
		}

		public int Decode(byte[] data, int dataLength, float[] pcm, int decodeFec = 0)
		{
			if (decoder == IntPtr.Zero)
			{
				return 0;
			}
			int num = Library.OpusDecodeFloat(decoder, data, dataLength, pcm, pcm.Length / (int)channels, decodeFec);
			Library.OpusPcmSoftClip(pcm, num / (int)channels, channels, softclipMem);
			return num;
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!disposedValue && !(decoder == IntPtr.Zero))
			{
				Library.OpusDecoderDestroy(decoder);
				decoder = IntPtr.Zero;
				disposedValue = true;
			}
		}

		~Decoder()
		{
			Dispose(disposing: false);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	public class Encoder : IDisposable
	{
		private int bitrate;

		private int complexity;

		private OpusSignal signal;

		private IntPtr encoder;

		private NumChannels channels;

		private bool disposedValue;

		public int Bitrate
		{
			get
			{
				return bitrate;
			}
			set
			{
				Library.OpusEncoderSetBitrate(encoder, value);
				bitrate = value;
			}
		}

		public int Complexity
		{
			get
			{
				return complexity;
			}
			set
			{
				Library.OpusEncoderSetComplexity(encoder, value);
				complexity = value;
			}
		}

		public OpusSignal Signal
		{
			get
			{
				return signal;
			}
			set
			{
				Library.OpusEncoderSetSignal(encoder, value);
				signal = value;
			}
		}

		public Encoder(SamplingFrequency samplingFrequency, NumChannels channels, OpusApplication application)
		{
			this.channels = channels;
			encoder = Library.OpusEncoderCreate(samplingFrequency, channels, application, out var error);
			if (error != 0)
			{
				Debug.LogError((object)("[UnityOpus] Failed to init encoder. Error code: " + error));
				encoder = IntPtr.Zero;
			}
		}

		public int Encode(float[] pcm, byte[] output)
		{
			if (encoder == IntPtr.Zero)
			{
				return 0;
			}
			return Library.OpusEncodeFloat(encoder, pcm, pcm.Length / (int)channels, output, output.Length);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!disposedValue && !(encoder == IntPtr.Zero))
			{
				Library.OpusEncoderDestroy(encoder);
				encoder = IntPtr.Zero;
				disposedValue = true;
			}
		}

		~Encoder()
		{
			Dispose(disposing: false);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	public enum SamplingFrequency
	{
		Frequency_8000 = 8000,
		Frequency_12000 = 12000,
		Frequency_16000 = 16000,
		Frequency_24000 = 24000,
		Frequency_48000 = 48000
	}
	public enum NumChannels
	{
		Mono = 1,
		Stereo
	}
	public enum OpusApplication
	{
		VoIP = 2048,
		Audio = 2049,
		RestrictedLowDelay = 2051
	}
	public enum OpusSignal
	{
		Auto = -1000,
		Voice = 3001,
		Music = 3002
	}
	public enum ErrorCode
	{
		OK = 0,
		BadArg = -1,
		BufferTooSmall = -2,
		InternalError = -3,
		InvalidPacket = -4,
		Unimplemented = -5,
		InvalidState = -6,
		AllocFail = -7
	}
	public static class Library
	{
		public delegate IntPtr OpusEncoderCreateDelegate(SamplingFrequency samplingFrequency, NumChannels channels, OpusApplication application, out ErrorCode error);

		public delegate int OpusEncodeDelegate(IntPtr encoder, short[] pcm, int frameSize, byte[] data, int maxDataBytes);

		public delegate int OpusEncodeFloatDelegate(IntPtr encoder, float[] pcm, int frameSize, byte[] data, int maxDataBytes);

		public delegate int OpusEncoderDestroyDelegate(IntPtr encoder);

		public delegate int OpusEncoderSetBitrateDelegate(IntPtr encoder, int bitrate);

		public delegate int OpusEncoderSetComplexityDelegate(IntPtr encoder, int complexity);

		public delegate int OpusEncoderSetSignalDelegate(IntPtr encoder, OpusSignal signal);

		public delegate IntPtr OpusDecoderCreateDelegate(SamplingFrequency samplingFrequency, NumChannels channels, out ErrorCode error);

		public delegate int OpusDecodeDelegate(IntPtr decoder, byte[] data, int len, short[] pcm, int frameSize, int decodeFec);

		public delegate int OpusDecodeFloatDelegate(IntPtr decoder, byte[] data, int len, float[] pcm, int frameSize, int decodeFec);

		public delegate void OpusDecoderDestroyDelegate(IntPtr decoder);

		public delegate void OpusPcmSoftClipDelegate(float[] pcm, int frameSize, NumChannels channels, float[] softclipMem);

		public const int maximumPacketDuration = 5760;

		private static IntPtr dllHandle;

		public static readonly OpusEncoderCreateDelegate OpusEncoderCreate;

		public static readonly OpusEncodeDelegate OpusEncode;

		public static OpusEncodeFloatDelegate OpusEncodeFloat;

		public static OpusEncoderDestroyDelegate OpusEncoderDestroy;

		public static OpusEncoderSetBitrateDelegate OpusEncoderSetBitrate;

		public static OpusEncoderSetComplexityDelegate OpusEncoderSetComplexity;

		public static OpusEncoderSetSignalDelegate OpusEncoderSetSignal;

		public static OpusDecoderCreateDelegate OpusDecoderCreate;

		public static OpusDecodeDelegate OpusDecode;

		public static OpusDecodeFloatDelegate OpusDecodeFloat;

		public static OpusDecoderDestroyDelegate OpusDecoderDestroy;

		public static OpusPcmSoftClipDelegate OpusPcmSoftClip;

		static Library()
		{
			dllHandle = LoadLibrary(Directory.GetParent(Assembly.GetExecutingAssembly().Location).FullName + "\\UnityOpus.dll");
			_ = dllHandle == IntPtr.Zero;
			OpusEncoderCreate = GetFunctionPointer<OpusEncoderCreateDelegate>("OpusEncoderCreate");
			OpusEncode = GetFunctionPointer<OpusEncodeDelegate>("OpusEncode");
			OpusEncodeFloat = GetFunctionPointer<OpusEncodeFloatDelegate>("OpusEncodeFloat");
			OpusEncoderDestroy = GetFunctionPointer<OpusEncoderDestroyDelegate>("OpusEncodeFloat");
			OpusEncoderSetBitrate = GetFunctionPointer<OpusEncoderSetBitrateDelegate>("OpusEncoderSetBitrate");
			OpusEncoderSetComplexity = GetFunctionPointer<OpusEncoderSetComplexityDelegate>("OpusEncoderSetComplexity");
			OpusEncoderSetSignal = GetFunctionPointer<OpusEncoderSetSignalDelegate>("OpusEncoderSetSignal");
			OpusDecoderCreate = GetFunctionPointer<OpusDecoderCreateDelegate>("OpusDecoderCreate");
			OpusDecode = GetFunctionPointer<OpusDecodeDelegate>("OpusDecode");
			OpusDecodeFloat = GetFunctionPointer<OpusDecodeFloatDelegate>("OpusDecodeFloat");
			OpusDecoderDestroy = GetFunctionPointer<OpusDecoderDestroyDelegate>("OpusDecoderDestroy");
			OpusPcmSoftClip = GetFunctionPointer<OpusPcmSoftClipDelegate>("OpusPcmSoftClip");
			AppDomain.CurrentDomain.ProcessExit += ProcessExitHandler;
			AppDomain.CurrentDomain.UnhandledException += ProcessExitHandler;
		}

		private static T GetFunctionPointer<T>(string functionName) where T : Delegate
		{
			return (T)Marshal.GetDelegateForFunctionPointer(GetProcAddress(dllHandle, functionName), typeof(T));
		}

		private static void ProcessExitHandler(object sender, EventArgs e)
		{
			FreeLibrary(dllHandle);
		}

		[DllImport("kernel32", CharSet = CharSet.Unicode, SetLastError = true)]
		internal static extern IntPtr LoadLibrary(string lpFileName);

		[DllImport("kernel32", SetLastError = true)]
		internal static extern bool FreeLibrary(IntPtr hModule);

		[DllImport("kernel32", CharSet = CharSet.Ansi, SetLastError = true)]
		internal static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);
	}
}
namespace UniRx
{
	public static class WebRequestExtensions
	{
		private static IObservable<TResult> AbortableDeferredAsyncRequest<TResult>(Func<AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, TResult> end, WebRequest request)
		{
			return Observable.Create(delegate(IObserver<TResult> observer)
			{
				int isCompleted = -1;
				IDisposable subscription = Observable.FromAsyncPattern(begin, delegate(IAsyncResult ar)
				{
					try
					{
						Interlocked.Increment(ref isCompleted);
						return end(ar);
					}
					catch (WebException ex)
					{
						if (ex.Status != WebExceptionStatus.RequestCanceled)
						{
							throw;
						}
						return default(TResult);
					}
				})().Subscribe(observer);
				return Disposable.Create(delegate
				{
					if (Interlocked.Increment(ref isCompleted) == 0)
					{
						subscription.Dispose();
						request.Abort();
					}
				});
			});
		}

		public static IObservable<WebResponse> GetResponseAsObservable(this WebRequest request)
		{
			return AbortableDeferredAsyncRequest(request.BeginGetResponse, request.EndGetResponse, request);
		}

		public static IObservable<HttpWebResponse> GetResponseAsObservable(this HttpWebRequest request)
		{
			return AbortableDeferredAsyncRequest(request.BeginGetResponse, (IAsyncResult ar) => (HttpWebResponse)request.EndGetResponse(ar), request);
		}

		public static IObservable<Stream> GetRequestStreamAsObservable(this WebRequest request)
		{
			return AbortableDeferredAsyncRequest(request.BeginGetRequestStream, request.EndGetRequestStream, request);
		}
	}
	public sealed class BooleanDisposable : IDisposable, ICancelable
	{
		public bool IsDisposed { get; private set; }

		public BooleanDisposable()
		{
		}

		internal BooleanDisposable(bool isDisposed)
		{
			IsDisposed = isDisposed;
		}

		public void Dispose()
		{
			if (!IsDisposed)
			{
				IsDisposed = true;
			}
		}
	}
	public sealed class CompositeDisposable : ICollection<IDisposable>, IEnumerable<IDisposable>, IEnumerable, IDisposable, ICancelable
	{
		private readonly object _gate = new object();

		private bool _disposed;

		private List<IDisposable> _disposables;

		private int _count;

		private const int SHRINK_THRESHOLD = 64;

		public int Count => _count;

		public bool IsReadOnly => false;

		public bool IsDisposed => _disposed;

		public CompositeDisposable()
		{
			_disposables = new List<IDisposable>();
		}

		public CompositeDisposable(int capacity)
		{
			if (capacity < 0)
			{
				throw new ArgumentOutOfRangeException("capacity");
			}
			_disposables = new List<IDisposable>(capacity);
		}

		public CompositeDisposable(params IDisposable[] disposables)
		{
			if (disposables == null)
			{
				throw new ArgumentNullException("disposables");
			}
			_disposables = new List<IDisposable>(disposables);
			_count = _disposables.Count;
		}

		public CompositeDisposable(IEnumerable<IDisposable> disposables)
		{
			if (disposables == null)
			{
				throw new ArgumentNullException("disposables");
			}
			_disposables = new List<IDisposable>(disposables);
			_count = _disposables.Count;
		}

		public void Add(IDisposable item)
		{
			if (item == null)
			{
				throw new ArgumentNullException("item");
			}
			bool flag = false;
			lock (_gate)
			{
				flag = _disposed;
				if (!_disposed)
				{
					_disposables.Add(item);
					_count++;
				}
			}
			if (flag)
			{
				item.Dispose();
			}
		}

		public bool Remove(IDisposable item)
		{
			if (item == null)
			{
				throw new ArgumentNullException("item");
			}
			bool flag = false;
			lock (_gate)
			{
				if (!_disposed)
				{
					int num = _disposables.IndexOf(item);
					if (num >= 0)
					{
						flag = true;
						_disposables[num] = null;
						_count--;
						if (_disposables.Capacity > 64 && _count < _disposables.Capacity / 2)
						{
							List<IDisposable> disposables = _disposables;
							_disposables = new List<IDisposable>(_disposables.Capacity / 2);
							foreach (IDisposable item2 in disposables)
							{
								if (item2 != null)
								{
									_disposables.Add(item2);
								}
							}
						}
					}
				}
			}
			if (flag)
			{
				item.Dispose();
			}
			return flag;
		}

		public void Dispose()
		{
			IDisposable[] array = null;
			lock (_gate)
			{
				if (!_disposed)
				{
					_disposed = true;
					array = _disposables.ToArray();
					_disposables.Clear();
					_count = 0;
				}
			}
			if (array != null)
			{
				IDisposable[] array2 = array;
				for (int i = 0; i < array2.Length; i++)
				{
					array2[i]?.Dispose();
				}
			}
		}

		public void Clear()
		{
			IDisposable[] array = null;
			lock (_gate)
			{
				array = _disposables.ToArray();
				_disposables.Clear();
				_count = 0;
			}
			IDisposable[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				array2[i]?.Dispose();
			}
		}

		public bool Contains(IDisposable item)
		{
			if (item == null)
			{
				throw new ArgumentNullException("item");
			}
			lock (_gate)
			{
				return _disposables.Contains(item);
			}
		}

		public void CopyTo(IDisposable[] array, int arrayIndex)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (arrayIndex < 0 || arrayIndex >= array.Length)
			{
				throw new ArgumentOutOfRangeException("arrayIndex");
			}
			lock (_gate)
			{
				List<IDisposable> list = new List<IDisposable>();
				foreach (IDisposable item in list)
				{
					if (item != null)
					{
						list.Add(item);
					}
				}
				Array.Copy(list.ToArray(), 0, array, arrayIndex, array.Length - arrayIndex);
			}
		}

		public IEnumerator<IDisposable> GetEnumerator()
		{
			List<IDisposable> list = new List<IDisposable>();
			lock (_gate)
			{
				foreach (IDisposable disposable in _disposables)
				{
					if (disposable != null)
					{
						list.Add(disposable);
					}
				}
			}
			return list.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public sealed class DictionaryDisposable<TKey, TValue> : IDisposable, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable where TValue : IDisposable
	{
		private bool isDisposed;

		private readonly Dictionary<TKey, TValue> inner;

		public TValue this[TKey key]
		{
			get
			{
				lock (inner)
				{
					return inner[key];
				}
			}
			set
			{
				lock (inner)
				{
					if (isDisposed)
					{
						value.Dispose();
					}
					if (TryGetValue(key, out var value2))
					{
						value2.Dispose();
						inner[key] = value;
					}
					else
					{
						inner[key] = value;
					}
				}
			}
		}

		public int Count
		{
			get
			{
				lock (inner)
				{
					return inner.Count;
				}
			}
		}

		public Dictionary<TKey, TValue>.KeyCollection Keys
		{
			get
			{
				throw new NotSupportedException("please use .Select(x => x.Key).ToArray()");
			}
		}

		public Dictionary<TKey, TValue>.ValueCollection Values
		{
			get
			{
				throw new NotSupportedException("please use .Select(x => x.Value).ToArray()");
			}
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => ((ICollection<KeyValuePair<TKey, TValue>>)inner).IsReadOnly;

		ICollection<TKey> IDictionary<TKey, TValue>.Keys
		{
			get
			{
				lock (inner)
				{
					return new List<TKey>(inner.Keys);
				}
			}
		}

		ICollection<TValue> IDictionary<TKey, TValue>.Values
		{
			get
			{
				lock (inner)
				{
					return new List<TValue>(inner.Values);
				}
			}
		}

		public DictionaryDisposable()
		{
			inner = new Dictionary<TKey, TValue>();
		}

		public DictionaryDisposable(IEqualityComparer<TKey> comparer)
		{
			inner = new Dictionary<TKey, TValue>(comparer);
		}

		public void Add(TKey key, TValue value)
		{
			lock (inner)
			{
				if (isDisposed)
				{
					value.Dispose();
				}
				else
				{
					inner.Add(key, value);
				}
			}
		}

		public void Clear()
		{
			lock (inner)
			{
				foreach (KeyValuePair<TKey, TValue> item in inner)
				{
					item.Value.Dispose();
				}
				inner.Clear();
			}
		}

		public bool Remove(TKey key)
		{
			lock (inner)
			{
				if (inner.TryGetValue(key, out var value))
				{
					bool num = inner.Remove(key);
					if (num)
					{
						value.Dispose();
					}
					return num;
				}
				return false;
			}
		}

		public bool ContainsKey(TKey key)
		{
			lock (inner)
			{
				return inner.ContainsKey(key);
			}
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			lock (inner)
			{
				return inner.TryGetValue(key, out value);
			}
		}

		public Dictionary<TKey, TValue>.Enumerator GetEnumerator()
		{
			lock (inner)
			{
				return new Dictionary<TKey, TValue>(inner).GetEnumerator();
			}
		}

		public void GetObjectData(SerializationInfo info, StreamingContext context)
		{
			lock (inner)
			{
				((ISerializable)inner).GetObjectData(info, context);
			}
		}

		public void OnDeserialization(object sender)
		{
			lock (inner)
			{
				((IDeserializationCallback)inner).OnDeserialization(sender);
			}
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
		{
			Add(item.Key, item.Value);
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
		{
			lock (inner)
			{
				return ((ICollection<KeyValuePair<TKey, TValue>>)inner).Contains(item);
			}
		}

		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			lock (inner)
			{
				((ICollection<KeyValuePair<TKey, TValue>>)inner).CopyTo(array, arrayIndex);
			}
		}

		IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
		{
			lock (inner)
			{
				return new List<KeyValuePair<TKey, TValue>>(inner).GetEnumerator();
			}
		}

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

		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
		{
			throw new NotSupportedException();
		}

		public void Dispose()
		{
			lock (inner)
			{
				if (isDisposed)
				{
					return;
				}
				isDisposed = true;
				foreach (KeyValuePair<TKey, TValue> item in inner)
				{
					item.Value.Dispose();
				}
				inner.Clear();
			}
		}
	}
	public static class Disposable
	{
		private class EmptyDisposable : IDisposable
		{
			public static EmptyDisposable Singleton = new EmptyDisposable();

			private EmptyDisposable()
			{
			}

			public void Dispose()
			{
			}
		}

		private class AnonymousDisposable : IDisposable
		{
			private bool isDisposed;

			private readonly Action dispose;

			public AnonymousDisposable(Action dispose)
			{
				this.dispose = dispose;
			}

			public void Dispose()
			{
				if (!isDisposed)
				{
					isDisposed = true;
					dispose();
				}
			}
		}

		private class AnonymousDisposable<T> : IDisposable
		{
			private bool isDisposed;

			private readonly T state;

			private readonly Action<T> dispose;

			public AnonymousDisposable(T state, Action<T> dispose)
			{
				this.state = state;
				this.dispose = dispose;
			}

			public void Dispose()
			{
				if (!isDisposed)
				{
					isDisposed = true;
					dispose(state);
				}
			}
		}

		public static readonly IDisposable Empty = EmptyDisposable.Singleton;

		public static IDisposable Create(Action disposeAction)
		{
			return new AnonymousDisposable(disposeAction);
		}

		public static IDisposable CreateWithState<TState>(TState state, Action<TState> disposeAction)
		{
			return new AnonymousDisposable<TState>(state, disposeAction);
		}
	}
	public static class DisposableExtensions
	{
		public static T AddTo<T>(this T disposable, ICollection<IDisposable> container) where T : IDisposable
		{
			if (disposable == null)
			{
				throw new ArgumentNullException("disposable");
			}
			if (container == null)
			{
				throw new ArgumentNullException("container");
			}
			container.Add(disposable);
			return disposable;
		}

		public static T AddTo<T>(this T disposable, GameObject gameObject) where T : IDisposable
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				disposable.Dispose();
				return disposable;
			}
			ObservableDestroyTrigger observableDestroyTrigger = gameObject.GetComponent<ObservableDestroyTrigger>();
			if ((Object)(object)observableDestroyTrigger == (Object)null)
			{
				observableDestroyTrigger = gameObject.AddComponent<ObservableDestroyTrigger>();
			}
			if (!observableDestroyTrigger.IsActivated && !observableDestroyTrigger.IsMonitoredActivate && !((Component)observableDestroyTrigger).gameObject.activeInHierarchy)
			{
				observableDestroyTrigger.IsMonitoredActivate = true;
				MainThreadDispatcher.StartEndOfFrameMicroCoroutine(MonitorTriggerHealth(observableDestroyTrigger, gameObject));
			}
			observableDestroyTrigger.AddDisposableOnDestroy(disposable);
			return disposable;
		}

		private static IEnumerator MonitorTriggerHealth(ObservableDestroyTrigger trigger, GameObject targetGameObject)
		{
			do
			{
				yield return null;
				if (trigger.IsActivated)
				{
					yield break;
				}
			}
			while (!((Object)(object)targetGameObject == (Object)null));
			trigger.ForceRaiseOnDestroy();
		}

		public static T AddTo<T>(this T disposable, Component gameObjectComponent) where T : IDisposable
		{
			if ((Object)(object)gameObjectComponent == (Object)null)
			{
				disposable.Dispose();
				return disposable;
			}
			return disposable.AddTo(gameObjectComponent.gameObject);
		}

		public static T AddTo<T>(this T disposable, ICollection<IDisposable> container, GameObject gameObject) where T : IDisposable
		{
			return disposable.AddTo(container).AddTo(gameObject);
		}

		public static T AddTo<T>(this T disposable, ICollection<IDisposable> container, Component gameObjectComponent) where T : IDisposable
		{
			return disposable.AddTo(container).AddTo(gameObjectComponent);
		}
	}
	public interface ICancelable : IDisposable
	{
		bool IsDisposed { get; }
	}
	public sealed class MultipleAssignmentDisposable : IDisposable, ICancelable
	{
		private static readonly BooleanDisposable True = new BooleanDisposable(isDisposed: true);

		private object gate = new object();

		private IDisposable current;

		public bool IsDisposed
		{
			get
			{
				lock (gate)
				{
					return current == True;
				}
			}
		}

		public IDisposable Disposable
		{
			get
			{
				lock (gate)
				{
					return (current == True) ? UniRx.Disposable.Empty : current;
				}
			}
			set
			{
				bool flag = false;
				lock (gate)
				{
					flag = current == True;
					if (!flag)
					{
						current = value;
					}
				}
				if (flag)
				{
					value?.Dispose();
				}
			}
		}

		public void Dispose()
		{
			IDisposable disposable = null;
			lock (gate)
			{
				if (current != True)
				{
					disposable = current;
					current = True;
				}
			}
			disposable?.Dispose();
		}
	}
	public sealed class RefCountDisposable : ICancelable, IDisposable
	{
		private sealed class InnerDisposable : IDisposable
		{
			private RefCountDisposable _parent;

			private object parentLock = new object();

			public InnerDisposable(RefCountDisposable parent)
			{
				_parent = parent;
			}

			public void Dispose()
			{
				RefCountDisposable parent;
				lock (parentLock)
				{
					parent = _parent;
					_parent = null;
				}
				parent?.Release();
			}
		}

		private readonly object _gate = new object();

		private IDisposable _disposable;

		private bool _isPrimaryDisposed;

		private int _count;

		public bool IsDisposed => _disposable == null;

		public RefCountDisposable(IDisposable disposable)
		{
			if (disposable == null)
			{
				throw new ArgumentNullException("disposable");
			}
			_disposable = disposable;
			_isPrimaryDisposed = false;
			_count = 0;
		}

		public IDisposable GetDisposable()
		{
			lock (_gate)
			{
				if (_disposable == null)
				{
					return Disposable.Empty;
				}
				_count++;
				return new InnerDisposable(this);
			}
		}

		public void Dispose()
		{
			IDisposable disposable = null;
			lock (_gate)
			{
				if (_disposable != null && !_isPrimaryDisposed)
				{
					_isPrimaryDisposed = true;
					if (_count == 0)
					{
						disposable = _disposable;
						_disposable = null;
					}
				}
			}
			disposable?.Dispose();
		}

		private void Release()
		{
			IDisposable disposable = null;
			lock (_gate)
			{
				if (_disposable != null)
				{
					_count--;
					if (_isPrimaryDisposed && _count == 0)
					{
						disposable = _disposable;
						_disposable = null;
					}
				}
			}
			disposable?.Dispose();
		}
	}
	public static class Observable
	{
		private class ConnectableObservable<T> : IConnectableObservable<T>, IObservable<T>
		{
			private class Connection : IDisposable
			{
				private readonly ConnectableObservable<T> parent;

				private IDisposable subscription;

				public Connection(ConnectableObservable<T> parent, IDisposable subscription)
				{
					this.parent = parent;
					this.subscription = subscription;
				}

				public void Dispose()
				{
					lock (parent.gate)
					{
						if (subscription != null)
						{
							subscription.Dispose();
							subscription = null;
							parent.connection = null;
						}
					}
				}
			}

			private readonly IObservable<T> source;

			private readonly ISubject<T> subject;

			private readonly object gate = new object();

			private Connection connection;

			public ConnectableObservable(IObservable<T> source, ISubject<T> subject)
			{
				this.source = source.AsObservable();
				this.subject = subject;
			}

			public IDisposable Connect()
			{
				lock (gate)
				{
					if (connection == null)
					{
						IDisposable subscription = source.Subscribe(subject);
						connection = new Connection(this, subscription);
					}
					return connection;
				}
			}

			public IDisposable Subscribe(IObserver<T> observer)
			{
				return subject.Subscribe(observer);
			}
		}

		private class EveryAfterUpdateInvoker : IEnumerator
		{
			private long count = -1L;

			private readonly IObserver<long> observer;

			private readonly CancellationToken cancellationToken;

			public object Current => null;

			public EveryAfterUpdateInvoker(IObserver<long> observer, CancellationToken cancellationToken)
			{
				this.observer = observer;
				this.cancellationToken = cancellationToken;
			}

			public bool MoveNext()
			{
				if (!cancellationToken.IsCancellationRequested)
				{
					if (count != -1)
					{
						observer.OnNext(count++);
					}
					else
					{
						count++;
					}
					return true;
				}
				return false;
			}

			public void Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly TimeSpan InfiniteTimeSpan = new TimeSpan(0, 0, 0, 0, -1);

		private static readonly HashSet<Type> YieldInstructionTypes = new HashSet<Type>
		{
			typeof(WWW),
			typeof(WaitForEndOfFrame),
			typeof(WaitForFixedUpdate),
			typeof(WaitForSeconds),
			typeof(AsyncOperation),
			typeof(Coroutine)
		};

		private static IObservable<T> AddRef<T>(IObservable<T> xs, RefCountDisposable r)
		{
			return Create((IObserver<T> observer) => new CompositeDisposable(r.GetDisposable(), xs.Subscribe(observer)));
		}

		public static IObservable<TSource> Scan<TSource>(this IObservable<TSource> source, Func<TSource, TSource, TSource> accumulator)
		{
			return new ScanObservable<TSource>(source, accumulator);
		}

		public static IObservable<TAccumulate> Scan<TSource, TAccumulate>(this IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator)
		{
			return new ScanObservable<TSource, TAccumulate>(source, seed, accumulator);
		}

		public static IObservable<TSource> Aggregate<TSource>(this IObservable<TSource> source, Func<TSource, TSource, TSource> accumulator)
		{
			return new AggregateObservable<TSource>(source, accumulator);
		}

		public static IObservable<TAccumulate> Aggregate<TSource, TAccumulate>(this IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator)
		{
			return new AggregateObservable<TSource, TAccumulate>(source, seed, accumulator);
		}

		public static IObservable<TResult> Aggregate<TSource, TAccumulate, TResult>(this IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, Func<TAccumulate, TResult> resultSelector)
		{
			return new AggregateObservable<TSource, TAccumulate, TResult>(source, seed, accumulator, resultSelector);
		}

		public static IConnectableObservable<T> Multicast<T>(this IObservable<T> source, ISubject<T> subject)
		{
			return new ConnectableObservable<T>(source, subject);
		}

		public static IConnectableObservable<T> Publish<T>(this IObservable<T> source)
		{
			return source.Multicast(new Subject<T>());
		}

		public static IConnectableObservable<T> Publish<T>(this IObservable<T> source, T initialValue)
		{
			return source.Multicast(new BehaviorSubject<T>(initialValue));
		}

		public static IConnectableObservable<T> PublishLast<T>(this IObservable<T> source)
		{
			return source.Multicast(new AsyncSubject<T>());
		}

		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source)
		{
			return source.Multicast(new ReplaySubject<T>());
		}

		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source, IScheduler scheduler)
		{
			return source.Multicast(new ReplaySubject<T>(scheduler));
		}

		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source, int bufferSize)
		{
			return source.Multicast(new ReplaySubject<T>(bufferSize));
		}

		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source, int bufferSize, IScheduler scheduler)
		{
			return source.Multicast(new ReplaySubject<T>(bufferSize, scheduler));
		}

		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source, TimeSpan window)
		{
			return source.Multicast(new ReplaySubject<T>(window));
		}

		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source, TimeSpan window, IScheduler scheduler)
		{
			return source.Multicast(new ReplaySubject<T>(window, scheduler));
		}

		public static IConnectableObservable<T> Replay<T>(this IObservable<T> source, int bufferSize, TimeSpan window, IScheduler scheduler)
		{
			return source.Multicast(new ReplaySubject<T>(bufferSize, window, scheduler));
		}

		public static IObservable<T> RefCount<T>(this IConnectableObservable<T> source)
		{
			return new RefCountObservable<T>(source);
		}

		public static IObservable<T> Share<T>(this IObservable<T> source)
		{
			return source.Publish().RefCount();
		}

		public static T Wait<T>(this IObservable<T> source)
		{
			return new Wait<T>(source, InfiniteTimeSpan).Run();
		}

		public static T Wait<T>(this IObservable<T> source, TimeSpan timeout)
		{
			return new Wait<T>(source, timeout).Run();
		}

		private static IEnumerable<IObservable<T>> CombineSources<T>(IObservable<T> first, IObservable<T>[] seconds)
		{
			yield return first;
			for (int i = 0; i < seconds.Length; i++)
			{
				yield return seconds[i];
			}
		}

		public static IObservable<TSource> Concat<TSource>(params IObservable<TSource>[] sources)
		{
			if (sources == null)
			{
				throw new ArgumentNullException("sources");
			}
			return new ConcatObservable<TSource>(sources);
		}

		public static IObservable<TSource> Concat<TSource>(this IEnumerable<IObservable<TSource>> sources)
		{
			if (sources == null)
			{
				throw new ArgumentNullException("sources");
			}
			return new ConcatObservable<TSource>(sources);
		}

		public static IObservable<TSource> Concat<TSource>(this IObservable<IObservable<TSource>> sources)
		{
			return sources.Merge(1);
		}

		public static IObservable<TSource> Concat<TSource>(this IObservable<TSource> first, params IObservable<TSource>[] seconds)
		{
			if (first == null)
			{
				throw new ArgumentNullException("first");
			}
			if (seconds == null)
			{
				throw new ArgumentNullException("seconds");
			}
			if (first is ConcatObservable<TSource> concatObservable)
			{
				return concatObservable.Combine(seconds);
			}
			return CombineSources(first, seconds).Concat();
		}

		public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources)
		{
			return sources.Merge(Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources, IScheduler scheduler)
		{
			return new MergeObservable<TSource>(sources.ToObservable(scheduler), scheduler == Scheduler.CurrentThread);
		}

		public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources, int maxConcurrent)
		{
			return sources.Merge(maxConcurrent, Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		public static IObservable<TSource> Merge<TSource>(this IEnumerable<IObservable<TSource>> sources, int maxConcurrent, IScheduler scheduler)
		{
			return new MergeObservable<TSource>(sources.ToObservable(scheduler), maxConcurrent, scheduler == Scheduler.CurrentThread);
		}

		public static IObservable<TSource> Merge<TSource>(params IObservable<TSource>[] sources)
		{
			return Merge(Scheduler.DefaultSchedulers.ConstantTimeOperations, sources);
		}

		public static IObservable<TSource> Merge<TSource>(IScheduler scheduler, params IObservable<TSource>[] sources)
		{
			return new MergeObservable<TSource>(sources.ToObservable(scheduler), scheduler == Scheduler.CurrentThread);
		}

		public static IObservable<T> Merge<T>(this IObservable<T> first, params IObservable<T>[] seconds)
		{
			return CombineSources(first, seconds).Merge();
		}

		public static IObservable<T> Merge<T>(this IObservable<T> first, IObservable<T> second, IScheduler scheduler)
		{
			return Merge<T>(scheduler, first, second);
		}

		public static IObservable<T> Merge<T>(this IObservable<IObservable<T>> sources)
		{
			return new MergeObservable<T>(sources, isRequiredSubscribeOnCurrentThread: false);
		}

		public static IObservable<T> Merge<T>(this IObservable<IObservable<T>> sources, int maxConcurrent)
		{
			return new MergeObservable<T>(sources, maxConcurrent, isRequiredSubscribeOnCurrentThread: false);
		}

		public static IObservable<TResult> Zip<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)
		{
			return new ZipObservable<TLeft, TRight, TResult>(left, right, selector);
		}

		public static IObservable<IList<T>> Zip<T>(this IEnumerable<IObservable<T>> sources)
		{
			return Zip(sources.ToArray());
		}

		public static IObservable<IList<T>> Zip<T>(params IObservable<T>[] sources)
		{
			return new ZipObservable<T>(sources);
		}

		public static IObservable<TR> Zip<T1, T2, T3, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, ZipFunc<T1, T2, T3, TR> resultSelector)
		{
			return new ZipObservable<T1, T2, T3, TR>(source1, source2, source3, resultSelector);
		}

		public static IObservable<TR> Zip<T1, T2, T3, T4, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, ZipFunc<T1, T2, T3, T4, TR> resultSelector)
		{
			return new ZipObservable<T1, T2, T3, T4, TR>(source1, source2, source3, source4, resultSelector);
		}

		public static IObservable<TR> Zip<T1, T2, T3, T4, T5, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, ZipFunc<T1, T2, T3, T4, T5, TR> resultSelector)
		{
			return new ZipObservable<T1, T2, T3, T4, T5, TR>(source1, source2, source3, source4, source5, resultSelector);
		}

		public static IObservable<TR> Zip<T1, T2, T3, T4, T5, T6, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, ZipFunc<T1, T2, T3, T4, T5, T6, TR> resultSelector)
		{
			return new ZipObservable<T1, T2, T3, T4, T5, T6, TR>(source1, source2, source3, source4, source5, source6, resultSelector);
		}

		public static IObservable<TR> Zip<T1, T2, T3, T4, T5, T6, T7, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, ZipFunc<T1, T2, T3, T4, T5, T6, T7, TR> resultSelector)
		{
			return new ZipObservable<T1, T2, T3, T4, T5, T6, T7, TR>(source1, source2, source3, source4, source5, source6, source7, resultSelector);
		}

		public static IObservable<TResult> CombineLatest<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)
		{
			return new CombineLatestObservable<TLeft, TRight, TResult>(left, right, selector);
		}

		public static IObservable<IList<T>> CombineLatest<T>(this IEnumerable<IObservable<T>> sources)
		{
			return CombineLatest(sources.ToArray());
		}

		public static IObservable<IList<TSource>> CombineLatest<TSource>(params IObservable<TSource>[] sources)
		{
			return new CombineLatestObservable<TSource>(sources);
		}

		public static IObservable<TR> CombineLatest<T1, T2, T3, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, CombineLatestFunc<T1, T2, T3, TR> resultSelector)
		{
			return new CombineLatestObservable<T1, T2, T3, TR>(source1, source2, source3, resultSelector);
		}

		public static IObservable<TR> CombineLatest<T1, T2, T3, T4, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, CombineLatestFunc<T1, T2, T3, T4, TR> resultSelector)
		{
			return new CombineLatestObservable<T1, T2, T3, T4, TR>(source1, source2, source3, source4, resultSelector);
		}

		public static IObservable<TR> CombineLatest<T1, T2, T3, T4, T5, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, CombineLatestFunc<T1, T2, T3, T4, T5, TR> resultSelector)
		{
			return new CombineLatestObservable<T1, T2, T3, T4, T5, TR>(source1, source2, source3, source4, source5, resultSelector);
		}

		public static IObservable<TR> CombineLatest<T1, T2, T3, T4, T5, T6, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, CombineLatestFunc<T1, T2, T3, T4, T5, T6, TR> resultSelector)
		{
			return new CombineLatestObservable<T1, T2, T3, T4, T5, T6, TR>(source1, source2, source3, source4, source5, source6, resultSelector);
		}

		public static IObservable<TR> CombineLatest<T1, T2, T3, T4, T5, T6, T7, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, CombineLatestFunc<T1, T2, T3, T4, T5, T6, T7, TR> resultSelector)
		{
			return new CombineLatestObservable<T1, T2, T3, T4, T5, T6, T7, TR>(source1, source2, source3, source4, source5, source6, source7, resultSelector);
		}

		public static IObservable<TResult> ZipLatest<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)
		{
			return new ZipLatestObservable<TLeft, TRight, TResult>(left, right, selector);
		}

		public static IObservable<IList<T>> ZipLatest<T>(this IEnumerable<IObservable<T>> sources)
		{
			return ZipLatest(sources.ToArray());
		}

		public static IObservable<IList<TSource>> ZipLatest<TSource>(params IObservable<TSource>[] sources)
		{
			return new ZipLatestObservable<TSource>(sources);
		}

		public static IObservable<TR> ZipLatest<T1, T2, T3, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, ZipLatestFunc<T1, T2, T3, TR> resultSelector)
		{
			return new ZipLatestObservable<T1, T2, T3, TR>(source1, source2, source3, resultSelector);
		}

		public static IObservable<TR> ZipLatest<T1, T2, T3, T4, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, ZipLatestFunc<T1, T2, T3, T4, TR> resultSelector)
		{
			return new ZipLatestObservable<T1, T2, T3, T4, TR>(source1, source2, source3, source4, resultSelector);
		}

		public static IObservable<TR> ZipLatest<T1, T2, T3, T4, T5, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, ZipLatestFunc<T1, T2, T3, T4, T5, TR> resultSelector)
		{
			return new ZipLatestObservable<T1, T2, T3, T4, T5, TR>(source1, source2, source3, source4, source5, resultSelector);
		}

		public static IObservable<TR> ZipLatest<T1, T2, T3, T4, T5, T6, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, ZipLatestFunc<T1, T2, T3, T4, T5, T6, TR> resultSelector)
		{
			return new ZipLatestObservable<T1, T2, T3, T4, T5, T6, TR>(source1, source2, source3, source4, source5, source6, resultSelector);
		}

		public static IObservable<TR> ZipLatest<T1, T2, T3, T4, T5, T6, T7, TR>(this IObservable<T1> source1, IObservable<T2> source2, IObservable<T3> source3, IObservable<T4> source4, IObservable<T5> source5, IObservable<T6> source6, IObservable<T7> source7, ZipLatestFunc<T1, T2, T3, T4, T5, T6, T7, TR> resultSelector)
		{
			return new ZipLatestObservable<T1, T2, T3, T4, T5, T6, T7, TR>(source1, source2, source3, source4, source5, source6, source7, resultSelector);
		}

		public static IObservable<T> Switch<T>(this IObservable<IObservable<T>> sources)
		{
			return new SwitchObservable<T>(sources);
		}

		public static IObservable<TResult> WithLatestFrom<TLeft, TRight, TResult>(this IObservable<TLeft> left, IObservable<TRight> right, Func<TLeft, TRight, TResult> selector)
		{
			return new WithLatestFromObservable<TLeft, TRight, TResult>(left, right, selector);
		}

		public static IObservable<T[]> WhenAll<T>(params IObservable<T>[] sources)
		{
			if (sources.Length == 0)
			{
				return Return(new T[0]);
			}
			return new WhenAllObservable<T>(sources);
		}

		public static IObservable<Unit> WhenAll(params IObservable<Unit>[] sources)
		{
			if (sources.Length == 0)
			{
				return ReturnUnit();
			}
			return new WhenAllObservable(sources);
		}

		public static IObservable<T[]> WhenAll<T>(this IEnumerable<IObservable<T>> sources)
		{
			if (sources is IObservable<T>[] sources2)
			{
				return WhenAll(sources2);
			}
			return new WhenAllObservable<T>(sources);
		}

		public static IObservable<Unit> WhenAll(this IEnumerable<IObservable<Unit>> sources)
		{
			if (sources is IObservable<Unit>[] sources2)
			{
				return WhenAll(sources2);
			}
			return new WhenAllObservable(sources);
		}

		public static IObservable<T> StartWith<T>(this IObservable<T> source, T value)
		{
			return new StartWithObservable<T>(source, value);
		}

		public static IObservable<T> StartWith<T>(this IObservable<T> source, Func<T> valueFactory)
		{
			return new StartWithObservable<T>(source, valueFactory);
		}

		public static IObservable<T> StartWith<T>(this IObservable<T> source, params T[] values)
		{
			return source.StartWith(Scheduler.DefaultSchedulers.ConstantTimeOperations, values);
		}

		public static IObservable<T> StartWith<T>(this IObservable<T> source, IEnumerable<T> values)
		{
			return source.StartWith(Scheduler.DefaultSchedulers.ConstantTimeOperations, values);
		}

		public static IObservable<T> StartWith<T>(this IObservable<T> source, IScheduler scheduler, T value)
		{
			return Return(value, scheduler).Concat(source);
		}

		public static IObservable<T> StartWith<T>(this IObservable<T> source, IScheduler scheduler, IEnumerable<T> values)
		{
			T[] array = values as T[];
			if (array == null)
			{
				array = values.ToArray();
			}
			return source.StartWith(scheduler, array);
		}

		public static IObservable<T> StartWith<T>(this IObservable<T> source, IScheduler scheduler, params T[] values)
		{
			return values.ToObservable(scheduler).Concat(source);
		}

		public static IObservable<T> Synchronize<T>(this IObservable<T> source)
		{
			return new SynchronizeObservable<T>(source, new object());
		}

		public static IObservable<T> Synchronize<T>(this IObservable<T> source, object gate)
		{
			return new SynchronizeObservable<T>(source, gate);
		}

		public static IObservable<T> ObserveOn<T>(this IObservable<T> source, IScheduler scheduler)
		{
			return new ObserveOnObservable<T>(source, scheduler);
		}

		public static IObservable<T> SubscribeOn<T>(this IObservable<T> source, IScheduler scheduler)
		{
			return new SubscribeOnObservable<T>(source, scheduler);
		}

		public static IObservable<T> DelaySubscription<T>(this IObservable<T> source, TimeSpan dueTime)
		{
			return new DelaySubscriptionObservable<T>(source, dueTime, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		public static IObservable<T> DelaySubscription<T>(this IObservable<T> source, TimeSpan dueTime, IScheduler scheduler)
		{
			return new DelaySubscriptionObservable<T>(source, dueTime, scheduler);
		}

		public static IObservable<T> DelaySubscription<T>(this IObservable<T> source, DateTimeOffset dueTime)
		{
			return new DelaySubscriptionObservable<T>(source, dueTime, Scheduler.DefaultSchedulers.TimeBasedOperations);
		}

		public static IObservable<T> DelaySubscription<T>(this IObservable<T> source, DateTimeOffset dueTime, IScheduler scheduler)
		{
			return new DelaySubscriptionObservable<T>(source, dueTime, scheduler);
		}

		public static IObservable<T> Amb<T>(params IObservable<T>[] sources)
		{
			return Amb((IEnumerable<IObservable<T>>)sources);
		}

		public static IObservable<T> Amb<T>(IEnumerable<IObservable<T>> sources)
		{
			IObservable<T> observable = Never<T>();
			foreach (IObservable<T> source in sources)
			{
				observable = observable.Amb(source);
			}
			return observable;
		}

		public static IObservable<T> Amb<T>(this IObservable<T> source, IObservable<T> second)
		{
			return new AmbObservable<T>(source, second);
		}

		public static IObservable<T> AsObservable<T>(this IObservable<T> source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (source is AsObservableObservable<T>)
			{
				return source;
			}
			return new AsObservableObservable<T>(source);
		}

		public static IObservable<T> ToObservable<T>(this IEnumerable<T> source)
		{
			return source.ToObservable(Scheduler.DefaultSchedulers.Iteration);
		}

		public static IObservable<T> ToObservable<T>(this IEnumerable<T> source, IScheduler scheduler)
		{
			return new ToObservableObservable<T>(source, scheduler);
		}

		public static IObservable<TResult> Cast<TSource, TResult>(this IObservable<TSource> source)
		{
			return new CastObservable<TSource, TResult>(source);
		}

		public static IObservable<TResult> Cast<TSource, TResult>(this IObservable<TSource> source, TResult witness)
		{
			return new CastObservable<TSource, TResult>(source);
		}

		public static IObservable<TResult> OfType<TSource, TResult>(this IObservable<TSource> source)
		{
			return new OfTypeObservable<TSource, TResult>(source);
		}

		public static IObservable<TResult> OfType<TSource, TResult>(this IObservable<TSource> source, TResult witness)
		{
			return new OfTypeObservable<TSource, TResult>(source);
		}

		public static IObservable<Unit> AsUnitObservable<T>(this IObservable<T> source)
		{
			return new AsUnitObservableObservable<T>(source);
		}

		public static IObservable<Unit> AsSingleUnitObservable<T>(this IObservable<T> source)
		{
			return new AsSingleUnitObservableObservable<T>(source);
		}

		public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe)
		{
			if (subscribe == null)
			{
				throw new ArgumentNullException("subscribe");
			}
			return new CreateObservable<T>(subscribe);
		}

		public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
		{
			if (subscribe == null)
			{
				throw new ArgumentNullException("subscribe");
			}
			return new CreateObservable<T>(subscribe, isRequiredSubscribeOnCurrentThread);
		}

		public static IObservable<T> CreateWithState<T, TState>(TState state, Func<TState, IObserver<T>, IDisposable> subscribe)
		{
			if (subscribe == null)
			{
				throw new ArgumentNullException("subscribe");
			}
			return new CreateObservable<T, TState>(state, subscribe);
		}

		public static IObservable<T> CreateWithState<T, TState>(TState state, Func<TState, IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
		{
			if (subscribe == null)
			{
				throw new ArgumentNullException("subscribe");
			}
			return new CreateObservable<T, TState>(state, subscribe, isRequiredSubscribeOnCurrentThread);
		}

		public static IObservable<T> CreateSafe<T>(Func<IObserver<T>, IDisposable> subscribe)
		{
			if (subscribe == null)
			{
				throw new ArgumentNullException("subscribe");
			}
			return new CreateSafeObservable<T>(subscribe);
		}

		public static IObservable<T> CreateSafe<T>(Func<IObserver<T>, IDisposable> subscribe, bool isRequiredSubscribeOnCurrentThread)
		{
			if (subscribe == null)
			{
				throw new ArgumentNullException("subscribe");
			}
			return new CreateSafeObservable<T>(subscribe, isRequiredSubscribeOnCurrentThread);
		}

		public static IObservable<T> Empty<T>()
		{
			return Empty<T>(Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		public static IObservable<T> Empty<T>(IScheduler scheduler)
		{
			if (scheduler == Scheduler.Immediate)
			{
				return ImmutableEmptyObservable<T>.Instance;
			}
			return new EmptyObservable<T>(scheduler);
		}

		public static IObservable<T> Empty<T>(T witness)
		{
			return Empty<T>(Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		public static IObservable<T> Empty<T>(IScheduler scheduler, T witness)
		{
			return Empty<T>(scheduler);
		}

		public static IObservable<T> Never<T>()
		{
			return ImmutableNeverObservable<T>.Instance;
		}

		public static IObservable<T> Never<T>(T witness)
		{
			return ImmutableNeverObservable<T>.Instance;
		}

		public static IObservable<T> Return<T>(T value)
		{
			return Return(value, Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		public static IObservable<T> Return<T>(T value, IScheduler scheduler)
		{
			if (scheduler == Scheduler.Immediate)
			{
				return new ImmediateReturnObservable<T>(value);
			}
			return new ReturnObservable<T>(value, scheduler);
		}

		public static IObservable<Unit> Return(Unit value)
		{
			return ImmutableReturnUnitObservable.Instance;
		}

		public static IObservable<bool> Return(bool value)
		{
			if (!value)
			{
				return ImmutableReturnFalseObservable.Instance;
			}
			return ImmutableReturnTrueObservable.Instance;
		}

		public static IObservable<Unit> ReturnUnit()
		{
			return ImmutableReturnUnitObservable.Instance;
		}

		public static IObservable<T> Throw<T>(Exception error)
		{
			return Throw<T>(error, Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		public static IObservable<T> Throw<T>(Exception error, T witness)
		{
			return Throw<T>(error, Scheduler.DefaultSchedulers.ConstantTimeOperations);
		}

		public static IObservable<T> Throw<T>(Exception error, IScheduler scheduler)
		{
			return new ThrowObservable<T>(error, scheduler);
		}

		public static IObservable<T> Throw<T>(Exception error, IScheduler scheduler, T witness)
		{
			return Throw<T>(error, scheduler);
		}

		public static IObservable<int> Range(int start, int count)
		{
			return Range(start, count, Scheduler.DefaultSchedulers.Iteration);
		}

		public static IObservable<int> Range(int start, int count, IScheduler scheduler)
		{
			return new RangeObservable(start, count, scheduler);
		}

		public static IObservable<T> Repeat<T>(T value)
		{
			return Repeat(value, Scheduler.DefaultSchedulers.Iteration);
		}

		public static IObservable<T> Repeat<T>(T value, IScheduler scheduler)
		{
			if (scheduler == null)
			{
				throw new ArgumentNullException("scheduler");
			}
			return new RepeatObservable<T>(value, null, scheduler);
		}

		public static IObservable<T> Repeat<T>(T value, int repeatCount)
		{
			return Repeat(value, repeatCount, Scheduler.DefaultSchedulers.Iteration);
		}

		public static IObservable<T> Repeat<T>(T value, int repeatCount, IScheduler scheduler)
		{
			if (repeatCount < 0)
			{
				throw new ArgumentOutOfRangeException("repeatCount");
			}
			if (scheduler == null)
			{
				throw new ArgumentNullException("scheduler");
			}
			return new RepeatObservable<T>(value, repeatCount, scheduler);
		}

		public static IObservable<T> Repeat<T>(this IObservable<T> source)
		{
			return RepeatInfinite(source).Concat();
		}

		private static IEnumerable<IObservable<T>> RepeatInfinite<T>(IObservable<T> source)
		{
			while (true)
			{
				yield return source;
			}
		}

		public static IObservable<T> RepeatSafe<T>(this IObservable<T> source)
		{
			return new RepeatSafeObservable<T>(RepeatInfinite(source), source.IsRequiredSubscribeOnCurrentThread());
		}

		public static IObservable<T> Defer<T>(Func<IObservable<T>> observableFactory)
		{
			return new DeferObservable<T>(observableFactory);
		}

		public static IObservable<T> Start<T>(Func<T> function)
		{
			return new StartObservable<T>(function, null, Scheduler.DefaultSchedulers.AsyncConversions);
		}

		public static IObservable<T> Start<T>(Func<T> function, TimeSpan timeSpan)
		{
			return new StartObservable<T>(function, timeSpan, Scheduler.DefaultSchedulers.AsyncConversions);
		}

		public static IObservable<T> Start<T>(Func<T> function, IScheduler scheduler)
		{
			return new StartObservable<T>(function, null, scheduler);
		}

		public static IObservable<T> Start<T>(Func<T> function, TimeSpan timeSpan, IScheduler scheduler)
		{
			return new StartObservable<T>(function, timeSpan, scheduler);
		}

		public static IObservable<Unit> Start(Action action)
		{
			return new StartObservable<Unit>(action, null, Scheduler.DefaultSchedulers.AsyncConversions);
		}

		public static IObservable<Unit> Start(Action action, TimeSpan timeSpan)
		{
			return new StartObservable<Unit>(action, timeSpan, Scheduler.DefaultSchedulers.AsyncConversions);
		}

		public static IObservable<Unit> Start(Action action, IScheduler scheduler)
		{
			return new StartObservable<Unit>(action, null, scheduler);
		}

		public static IObservable<Unit> Start(Action action, TimeSpan timeSpan, IScheduler scheduler)
		{
			return new StartObservable<Unit>(action, timeSpan, scheduler);
		}

		public static Func<IObservable<T>> ToAsync<T>(Func<T> function)
		{
			return ToAsync(function, Scheduler.DefaultSchedulers.AsyncConversions);
		}

		public static Func<IObservable<T>> ToAsync<T>(Func<T> function, IScheduler scheduler)
		{
			return delegate
			{
				AsyncSubject<T> subject = new AsyncSubject<T>();
				scheduler.Schedule(delegate
				{
					T val = default(T);
					try
					{
						val = function();
					}
					catch (Exception error)
					{
						subject.OnError(error);
						return;
					}
					subject.OnNext(val);
					subject.OnCompleted();
				});
				return subject.AsObservable();
			};
		}

		public static Func<IObservable<Unit>> ToAsync(Action action)
		{
			return ToAsync(action, Scheduler.DefaultSchedulers.AsyncConversions);
		}

		public static Func<IObservable<Unit>> ToAsync(Action action, IScheduler scheduler)
		{
			return delegate
			{
				AsyncSubject<Unit> subject = new AsyncSubject<Unit>();
				scheduler.Schedule(delegate
				{
					try
					{
						action();
					}
					catch (Exception error)
					{
						subject.OnError(error);
						return;
					}
					subject.OnNext(Unit.Default);
					subject.OnCompleted();
				});
				return subject.AsObservable();
			};
		}

		public static IObservable<TR> Select<T, TR>(this IObservable<T> source, Func<T, TR> selector)
		{
			if (source is WhereObservable<T> whereObservable)
			{
				return whereObservable.CombineSelector(selector);
			}
			return new SelectObservable<T, TR>(source, selector);
		}

		public static IObservable<TR> Select<T, TR>(this IObservable<T> source, Func<T, int, TR> selector)
		{
			return new SelectObservable<T, TR>(source, selector);
		}

		public static IObservable<T> Where<T>(this IObservable<T> source, Func<T, bool> predicate)
		{
			if (source is WhereObservable<T> whereObservable)
			{
				return whereObservable.CombinePredicate(predicate);
			}
			if (source is ISelect<T> select)
			{
				return select.CombinePredicate(predicate);
			}
			return new WhereObservable<T>(sou