using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Reptile;
using Reptile.Phone;
using TagLib;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.6.1", FrameworkDisplayName = ".NET Framework 4.6.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("BombRushRadio")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Allows adding custom music tracks to Bomb Rush Cyberfunk.")]
[assembly: AssemblyFileVersion("1.6.1.0")]
[assembly: AssemblyInformationalVersion("1.6.1")]
[assembly: AssemblyProduct("BombRushRadio")]
[assembly: AssemblyTitle("BombRushRadio")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.6.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]
	[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 BombRushRadio
{
	public class Helpers
	{
		public static string[] GetMetadata(string filePath, bool oldMethod)
		{
			string text = string.Empty;
			string text2;
			if (!oldMethod)
			{
				try
				{
					File val = File.Create(filePath);
					text2 = val.Tag.Title;
					for (int i = 0; i < val.Tag.Performers.Length; i++)
					{
						text = ((i != val.Tag.Performers.Length - 1) ? (text + val.Tag.Performers[i] + ", ") : (text + val.Tag.Performers[i]));
					}
				}
				catch (Exception)
				{
					return GetMetadata(filePath, oldMethod: true);
				}
				if (string.IsNullOrEmpty(text2))
				{
					return GetMetadata(filePath, oldMethod: true);
				}
			}
			else
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
				if (!fileNameWithoutExtension.Contains("-"))
				{
					text2 = fileNameWithoutExtension;
				}
				else
				{
					text = fileNameWithoutExtension.Split(new char[1] { '-' }).First();
					text2 = fileNameWithoutExtension.Substring(text.Length + 1);
				}
			}
			if (!string.IsNullOrEmpty(text))
			{
				text = text.Trim();
			}
			return new string[2]
			{
				text,
				text2.Trim()
			};
		}

		public static string FormatMetadata(string[] metadata, string type)
		{
			if (string.IsNullOrEmpty(metadata[0]))
			{
				return metadata[1];
			}
			if (1 == 0)
			{
			}
			string result = ((!(type == "by")) ? (metadata[0] + " - " + metadata[1]) : (metadata[1] + " by " + metadata[0]));
			if (1 == 0)
			{
			}
			return result;
		}
	}
	[HarmonyPatch(typeof(BaseModule), "UnloadMainMenuScene")]
	public class UnloadMainMenuScenePatch
	{
		private static void Prefix()
		{
			BombRushRadio.InMainMenu = false;
		}
	}
	[HarmonyPatch(typeof(BaseModule), "LoadMainMenuScene")]
	public class LoadMainMenuScenePatch
	{
		private static void Prefix()
		{
			BombRushRadio.InMainMenu = true;
		}
	}
	[HarmonyPatch(typeof(AppMusicPlayer), "OnAppInit")]
	public class AppMusicPlayer_Patches
	{
		public static AppMusicPlayer Instance;

		private static void Postfix(AppMusicPlayer __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			Instance = __instance;
			if ((Object)(object)MusicPlayer_Patches_RefreshMusicQueueForStage.CurrentChapter != (Object)null)
			{
				MusicPlayer_Patches_RefreshMusicQueueForStage.Refresh((MusicPlayer)__instance.GameMusicPlayer, MusicPlayer_Patches_RefreshMusicQueueForStage.CurrentChapter, MusicPlayer_Patches_RefreshMusicQueueForStage.CurrentStage);
			}
		}
	}
	[HarmonyPatch(typeof(AppMusicPlayer), "OnAppDisable")]
	public class AppMusicPlayerDisable_Patches
	{
		private static void Prefix(AppMusicPlayer __instance)
		{
			AppMusicPlayer_Patches.Instance = null;
		}
	}
	[HarmonyPatch(typeof(AppHomeScreen), "AwakeAnimation")]
	public class AppMusicPlayerRefresh_Patches
	{
		private static void Prefix(AppHomeScreen __instance)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)MusicPlayer_Patches_RefreshMusicQueueForStage.CurrentChapter != (Object)null)
			{
				MusicPlayer_Patches_RefreshMusicQueueForStage.Refresh(BombRushRadio.MInstance, MusicPlayer_Patches_RefreshMusicQueueForStage.CurrentChapter, MusicPlayer_Patches_RefreshMusicQueueForStage.CurrentStage);
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class MusicPlayer_Patches
	{
		private static void Postfix(MusicPlayer __instance, AudioSource audioSource, MusicTrackQueue musicTrackQueue)
		{
			BombRushRadio.MInstance = __instance;
		}
	}
	[HarmonyPatch(typeof(MusicPlayer), "RefreshMusicQueueForStage")]
	public class MusicPlayer_Patches_RefreshMusicQueueForStage
	{
		public static ChapterMusic CurrentChapter;

		public static Stage CurrentStage;

		public static void Refresh(MusicPlayer __instance, ChapterMusic chapterMusic, Stage stage)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			__instance.musicTrackQueue.ClearTracks();
			ObjectiveInfo currentObjectiveInfo = Story.GetCurrentObjectiveInfo();
			if ((int)stage == 5)
			{
				MusicTrack musicTrackByID = Core.Instance.AudioManager.MusicLibraryPlayer.GetMusicTrackByID((MusicTrackID)6);
				__instance.AddMusicTrack(musicTrackByID);
				Debug.Log((object)("[BRR] [BASE-GAME] Added " + musicTrackByID.Title + " to the total list."));
			}
			else
			{
				MusicTrack chapterMusic2 = chapterMusic.GetChapterMusic(currentObjectiveInfo.chapter);
				__instance.AddMusicTrack(chapterMusic2);
				Debug.Log((object)("[BRR] [BASE-GAME] Added " + chapterMusic2.Title + " to the total list."));
			}
			AUnlockable[] unlockables = ((App)WorldHandler.instance.GetCurrentPlayer().phone.GetAppInstance<AppMusicPlayer>()).Unlockables;
			foreach (AUnlockable obj in unlockables)
			{
				MusicTrack val = (MusicTrack)(object)((obj is MusicTrack) ? obj : null);
				if (Core.Instance.Platform.User.GetUnlockableSaveDataFor((AUnlockable)(object)val).IsUnlocked)
				{
					val.isRepeatable = false;
					__instance.AddMusicTrack(val);
					Debug.Log((object)("[BRR] [BASE-GAME] Added " + val.Title + " to the total list."));
				}
			}
			foreach (MusicTrack track in BombRushRadio.Audios)
			{
				if (!((Object)(object)__instance.musicTrackQueue.currentMusicTracks.Find((MusicTrack m) => m.Title == track.Title && m.Artist == track.Artist) != (Object)null))
				{
					__instance.musicTrackQueue.currentMusicTracks.Add(track);
					Debug.Log((object)("[BRR] [CUSTOM] Added " + track.Title + " to the total list."));
				}
			}
			Debug.Log((object)"[BRR] Finished checking for songs to add...");
			if ((Object)(object)AppMusicPlayer_Patches.Instance != (Object)null)
			{
				Debug.Log((object)"[BRR] Refreshing songs on the app...");
				AppMusicPlayer_Patches.Instance.RefreshList();
			}
		}

		private static void Prefix(MusicPlayer __instance, ChapterMusic chapterMusic, MusicTrack trackToPlay, Stage stage)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			CurrentChapter = chapterMusic;
			CurrentStage = stage;
			Refresh(__instance, chapterMusic, stage);
			__instance.musicTrackQueue.UpdateMusicQueueForStage(trackToPlay);
		}
	}
	[HarmonyPatch(typeof(MusicTrackQueue), "HasMusicTrack")]
	public class MusicTrackQueue_Patches
	{
		private static bool Prefix(MusicTrack musicTrack)
		{
			if (Object.op_Implicit((Object)(object)BombRushRadio.Audios.Find((MusicTrack m) => musicTrack.Artist == m.Artist && musicTrack.Title == m.Title)))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(MusicTrackQueue), "SelectNextTrack")]
	public class MusicTrackQueue_Patches_SelectNextTrack
	{
		private static bool Prefix(MusicTrackQueue __instance)
		{
			Debug.Log((object)("[BRR] Finding next track. Amount: " + __instance.AmountOfTracks));
			return true;
		}
	}
	[HarmonyPatch(typeof(MusicTrackQueue), "EvaluateNextTrack")]
	public class MusicTrackQueue_Patches_EvaluateNextTrack
	{
		private static bool Prefix(MusicTrackQueue __instance, int nextTrackIndex)
		{
			Debug.Log((object)"[BRR] Next Track!");
			MusicTrack val = __instance.currentMusicTracks[nextTrackIndex];
			__instance.currentTrackIndex = nextTrackIndex;
			__instance.BufferTrackAtIndex(nextTrackIndex);
			Debug.Log((object)("[BRR] Playing track: " + val.Title + " by " + val.Artist + " (id: " + nextTrackIndex + ")"));
			return false;
		}
	}
	[HarmonyPatch(typeof(MusicPlayer), "HandleNoMusicPlayerDataFound")]
	public class MusicPlayer_Patches_NoMusicFound
	{
		private static void Prefix(MusicPlayer __instance)
		{
			Debug.Log((object)"[BRR] Music not found... skipping to next track.");
		}
	}
	[HarmonyPatch(typeof(MusicPlayer), "PlayFrom")]
	public class MusicPlayer_Patches_PlayFrom
	{
		private static void Prefix(MusicPlayer __instance)
		{
			__instance.ForcePaused();
		}
	}
	[HarmonyPatch(typeof(MusicPlayerBuffer), "BufferMusicTrack")]
	public class MusicPlayerBuffer_BufferMusicTrack_Patches
	{
		private static bool Prefix(MusicPlayerBuffer __instance, MusicTrack musicTrackToLoad)
		{
			if ((Object)(object)musicTrackToLoad == (Object)null || (Object)(object)musicTrackToLoad.AudioClip == (Object)null)
			{
				return false;
			}
			MusicPlayerData val = __instance.FindMusicPlayerDataByMusicTrack(musicTrackToLoad);
			if (val == null)
			{
				val = __instance.CreateNewMusicPlayerDataObject(musicTrackToLoad);
			}
			__instance.BufferMusicPlayerData(val);
			return false;
		}
	}
	[HarmonyPatch(typeof(MusicPlayerBuffer), "UnloadMusicPlayerData")]
	public class MusicPlayerBuffer_Patches
	{
		private static bool Prefix(MusicPlayerData musicPlayerData)
		{
			MusicTrack val = BombRushRadio.Audios.Find((MusicTrack m) => musicPlayerData.Artist == m.Artist && musicPlayerData.Title == m.Title);
			if ((Object)(object)val != (Object)null)
			{
				return false;
			}
			return true;
		}
	}
	[BepInPlugin("BombRushRadio", "BombRushRadio", "1.6.1")]
	public class BombRushRadio : BaseUnityPlugin
	{
		public static ConfigEntry<bool> StreamAudio;

		public static ConfigEntry<KeyCode> ReloadKey;

		public static MusicPlayer MInstance;

		public static List<MusicTrack> Audios = new List<MusicTrack>();

		public int ShouldBeDone;

		public int Done;

		private static readonly List<string> Loaded = new List<string>();

		public static bool InMainMenu = false;

		public static bool Loading;

		private readonly string _songFolder = Path.Combine(Application.streamingAssetsPath, "Mods", "BombRushRadio", "Songs");

		private readonly string _cachePath = Path.Combine(Paths.CachePath, "BombRushRadio");

		public void SanitizeSongs()
		{
			if ((Object)(object)Core.Instance == (Object)null || Core.Instance.audioManager == null || Core.Instance.audioManager.musicPlayer == null)
			{
				return;
			}
			List<MusicTrack> list = new List<MusicTrack>();
			int num = 0;
			foreach (MusicTrack tr in Audios)
			{
				if (MInstance.musicTrackQueue.currentMusicTracks.Contains(tr))
				{
					MInstance.musicTrackQueue.currentMusicTracks.Remove(tr);
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)("[BRR] Adding " + tr.Title));
				}
				if (Loaded.FirstOrDefault((string l) => l == Helpers.FormatMetadata(new string[2] { tr.Artist, tr.Title }, "dash")) == null)
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)("[BRR] Removing " + tr.Title));
					list.Add(tr);
				}
				MInstance.musicTrackQueue.currentMusicTracks.Insert(1 + num, tr);
				num++;
			}
			foreach (MusicTrack item in list)
			{
				Audios.Remove(item);
				item.AudioClip.UnloadAudioData();
			}
		}

		public IEnumerator LoadAudioFile(string filePath, AudioType type)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			string[] metadata = Helpers.GetMetadata(filePath, oldMethod: false);
			string songName = Helpers.FormatMetadata(metadata, "dash");
			filePath = UnityWebRequest.EscapeURL(filePath);
			UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip("file:///" + filePath, type);
			try
			{
				yield return www.SendWebRequest();
				if ((int)www.result == 2)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)www.error);
					yield break;
				}
				Done++;
				MusicTrack musicTrack = ScriptableObject.CreateInstance<MusicTrack>();
				musicTrack.AudioClip = null;
				musicTrack.Artist = metadata[0];
				musicTrack.Title = metadata[1];
				musicTrack.isRepeatable = false;
				DownloadHandlerAudioClip downloadHandler = (DownloadHandlerAudioClip)www.downloadHandler;
				if (StreamAudio.Value)
				{
					downloadHandler.streamAudio = true;
				}
				AudioClip myClip = downloadHandler.audioClip;
				((Object)myClip).name = filePath;
				musicTrack.AudioClip = myClip;
				Audios.Add(musicTrack);
				((BaseUnityPlugin)this).Logger.LogInfo((object)string.Format("[BRR] Loaded {0} ({1}/{2})", Helpers.FormatMetadata(metadata, "by"), Done, ShouldBeDone));
				Loaded.Add(songName);
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}

		public IEnumerator LoadFile(string f)
		{
			string extension = Path.GetExtension(f).ToLowerInvariant().Substring(1);
			string text = extension;
			if ((text == "cache" || text == "tag") ? true : false)
			{
				File.Delete(f);
				yield return null;
			}
			string[] metadata = Helpers.GetMetadata(f, oldMethod: false);
			if (Object.op_Implicit((Object)(object)Audios.Find((MusicTrack m) => m.Artist == metadata[0] && m.Title == metadata[1])))
			{
				string songName = Helpers.FormatMetadata(metadata, "dash");
				Loaded.Add(songName);
				((BaseUnityPlugin)this).Logger.LogInfo((object)("[BRR] " + songName + " is already loaded, skipping."));
			}
			else
			{
				if (1 == 0)
				{
				}
				AudioType val = (AudioType)(extension switch
				{
					"aif" => 2, 
					"aiff" => 2, 
					"it" => 10, 
					"mod" => 12, 
					"mp2" => 13, 
					"mp3" => 13, 
					"ogg" => 14, 
					"s3m" => 17, 
					"wav" => 20, 
					"xm" => 21, 
					"flac" => 0, 
					_ => 0, 
				});
				if (1 == 0)
				{
				}
				AudioType type = val;
				ShouldBeDone++;
				((MonoBehaviour)this).StartCoroutine(LoadAudioFile(f, type));
			}
			yield return null;
		}

		public IEnumerator SearchDirectories(string path = "")
		{
			string p = ((path.Length == 0) ? _songFolder : path);
			string[] directories = Directory.GetDirectories(p);
			foreach (string f in directories)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)("[BRR] Searching directory " + f));
				((MonoBehaviour)this).StartCoroutine(SearchDirectories(f));
			}
			string[] files = Directory.GetFiles(p);
			foreach (string f2 in files)
			{
				((MonoBehaviour)this).StartCoroutine(LoadFile(f2));
			}
			yield return null;
		}

		public IEnumerator ReloadSongs()
		{
			Loaded.Clear();
			Loading = true;
			if (Audios.Count > 0 && Core.Instance.audioManager.musicPlayer.IsPlaying && MInstance != null)
			{
				Core.Instance.audioManager.musicPlayer.ForcePaused();
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[BRR] Loading songs...");
			ShouldBeDone = 0;
			Done = 0;
			yield return ((MonoBehaviour)this).StartCoroutine(SearchDirectories());
			((BaseUnityPlugin)this).Logger.LogInfo((object)("[BRR] TOTAL SONGS LOADED: " + Audios.Count));
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[BRR] Bomb Rush Radio has been loaded!");
			Loading = false;
			Audios.Sort((MusicTrack t, MusicTrack t2) => string.Compare(((Object)t.AudioClip).name, ((Object)t2.AudioClip).name, StringComparison.OrdinalIgnoreCase));
			SanitizeSongs();
		}

		private void Awake()
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			if (!Directory.Exists(_songFolder))
			{
				Directory.CreateDirectory(_songFolder);
			}
			if (Directory.Exists(_cachePath))
			{
				Directory.Delete(_cachePath, recursive: true);
			}
			StreamAudio = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "Stream Audio", true, "Whether to stream audio from disk or load at runtime (Streaming is faster but more CPU intensive)");
			ReloadKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Settings", "Reload Key", (KeyCode)282, "Keybind used for reloading songs.");
			((MonoBehaviour)this).StartCoroutine(ReloadSongs());
			Harmony val = new Harmony("kade.bombrushradio");
			val.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[BRR] Patched...");
			Core.OnUpdate += (OnUpdateHandler)delegate
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				if (Input.GetKeyDown(ReloadKey.Value) && !InMainMenu)
				{
					((MonoBehaviour)this).StartCoroutine(ReloadSongs());
				}
			};
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "BombRushRadio";

		public const string PLUGIN_NAME = "BombRushRadio";

		public const string PLUGIN_VERSION = "1.6.1";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}

using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization;
using System.Configuration.Assemblies;
using System.Data;
using System.Data.Common;
using System.Data.SqlTypes;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Diagnostics.SymbolStore;
using System.Diagnostics.Tracing;
using System.Drawing;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.IO.IsolatedStorage;
using System.IO.MemoryMappedFiles;
using System.IO.Pipes;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Net.Cache;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Mail;
using System.Net.Mime;
using System.Net.NetworkInformation;
using System.Net.Security;
using System.Net.Sockets;
using System.Net.WebSockets;
using System.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Authentication;
using System.Security.Authentication.ExtendedProtection;
using System.Security.Claims;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Security.Permissions;
using System.Security.Principal;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;
using System.Transactions;
using System.Web;
using System.Windows.Input;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Resolvers;
using System.Xml.Schema;
using System.Xml.Serialization;
using System.Xml.XPath;
using System.Xml.Xsl;
using Microsoft.Win32.SafeHandles;

[assembly: AssemblyTitle("netstandard")]
[assembly: AssemblyDescription("netstandard")]
[assembly: AssemblyDefaultAlias("netstandard")]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyProduct("Microsoft® .NET Framework")]
[assembly: AssemblyCopyright("© Microsoft Corporation.  All rights reserved.")]
[assembly: AssemblyMetadata(".NETFrameworkAssembly", "")]
[assembly: AssemblyFileVersion("4.6.26011.1")]
[assembly: AssemblyInformationalVersion("4.6.26011.1")]
[assembly: AssemblyVersion("2.0.0.0")]
[assembly: TypeForwardedTo(typeof(CriticalHandleMinusOneIsInvalid))]
[assembly: TypeForwardedTo(typeof(CriticalHandleZeroOrMinusOneIsInvalid))]
[assembly: TypeForwardedTo(typeof(SafeFileHandle))]
[assembly: TypeForwardedTo(typeof(SafeHandleMinusOneIsInvalid))]
[assembly: TypeForwardedTo(typeof(SafeHandleZeroOrMinusOneIsInvalid))]
[assembly: TypeForwardedTo(typeof(SafeMemoryMappedFileHandle))]
[assembly: TypeForwardedTo(typeof(SafeMemoryMappedViewHandle))]
[assembly: TypeForwardedTo(typeof(SafePipeHandle))]
[assembly: TypeForwardedTo(typeof(SafeProcessHandle))]
[assembly: TypeForwardedTo(typeof(SafeWaitHandle))]
[assembly: TypeForwardedTo(typeof(SafeX509ChainHandle))]
[assembly: TypeForwardedTo(typeof(AccessViolationException))]
[assembly: TypeForwardedTo(typeof(Action))]
[assembly: TypeForwardedTo(typeof(Action<>))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, >))]
[assembly: TypeForwardedTo(typeof(Action<, , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Activator))]
[assembly: TypeForwardedTo(typeof(AggregateException))]
[assembly: TypeForwardedTo(typeof(AppContext))]
[assembly: TypeForwardedTo(typeof(AppDomain))]
[assembly: TypeForwardedTo(typeof(AppDomainUnloadedException))]
[assembly: TypeForwardedTo(typeof(ApplicationException))]
[assembly: TypeForwardedTo(typeof(ApplicationId))]
[assembly: TypeForwardedTo(typeof(ArgumentException))]
[assembly: TypeForwardedTo(typeof(ArgumentNullException))]
[assembly: TypeForwardedTo(typeof(ArgumentOutOfRangeException))]
[assembly: TypeForwardedTo(typeof(ArithmeticException))]
[assembly: TypeForwardedTo(typeof(Array))]
[assembly: TypeForwardedTo(typeof(ArraySegment<>))]
[assembly: TypeForwardedTo(typeof(ArrayTypeMismatchException))]
[assembly: TypeForwardedTo(typeof(AssemblyLoadEventArgs))]
[assembly: TypeForwardedTo(typeof(AssemblyLoadEventHandler))]
[assembly: TypeForwardedTo(typeof(AsyncCallback))]
[assembly: TypeForwardedTo(typeof(Attribute))]
[assembly: TypeForwardedTo(typeof(AttributeTargets))]
[assembly: TypeForwardedTo(typeof(AttributeUsageAttribute))]
[assembly: TypeForwardedTo(typeof(BadImageFormatException))]
[assembly: TypeForwardedTo(typeof(Base64FormattingOptions))]
[assembly: TypeForwardedTo(typeof(BitConverter))]
[assembly: TypeForwardedTo(typeof(bool))]
[assembly: TypeForwardedTo(typeof(Buffer))]
[assembly: TypeForwardedTo(typeof(byte))]
[assembly: TypeForwardedTo(typeof(CannotUnloadAppDomainException))]
[assembly: TypeForwardedTo(typeof(char))]
[assembly: TypeForwardedTo(typeof(CharEnumerator))]
[assembly: TypeForwardedTo(typeof(CLSCompliantAttribute))]
[assembly: TypeForwardedTo(typeof(GeneratedCodeAttribute))]
[assembly: TypeForwardedTo(typeof(IndentedTextWriter))]
[assembly: TypeForwardedTo(typeof(ArrayList))]
[assembly: TypeForwardedTo(typeof(BitArray))]
[assembly: TypeForwardedTo(typeof(CaseInsensitiveComparer))]
[assembly: TypeForwardedTo(typeof(CaseInsensitiveHashCodeProvider))]
[assembly: TypeForwardedTo(typeof(CollectionBase))]
[assembly: TypeForwardedTo(typeof(Comparer))]
[assembly: TypeForwardedTo(typeof(BlockingCollection<>))]
[assembly: TypeForwardedTo(typeof(ConcurrentBag<>))]
[assembly: TypeForwardedTo(typeof(ConcurrentDictionary<, >))]
[assembly: TypeForwardedTo(typeof(ConcurrentQueue<>))]
[assembly: TypeForwardedTo(typeof(ConcurrentStack<>))]
[assembly: TypeForwardedTo(typeof(EnumerablePartitionerOptions))]
[assembly: TypeForwardedTo(typeof(IProducerConsumerCollection<>))]
[assembly: TypeForwardedTo(typeof(OrderablePartitioner<>))]
[assembly: TypeForwardedTo(typeof(Partitioner))]
[assembly: TypeForwardedTo(typeof(Partitioner<>))]
[assembly: TypeForwardedTo(typeof(DictionaryBase))]
[assembly: TypeForwardedTo(typeof(DictionaryEntry))]
[assembly: TypeForwardedTo(typeof(Comparer<>))]
[assembly: TypeForwardedTo(typeof(Dictionary<, >))]
[assembly: TypeForwardedTo(typeof(EqualityComparer<>))]
[assembly: TypeForwardedTo(typeof(HashSet<>))]
[assembly: TypeForwardedTo(typeof(ICollection<>))]
[assembly: TypeForwardedTo(typeof(IComparer<>))]
[assembly: TypeForwardedTo(typeof(IDictionary<, >))]
[assembly: TypeForwardedTo(typeof(IEnumerable<>))]
[assembly: TypeForwardedTo(typeof(IEnumerator<>))]
[assembly: TypeForwardedTo(typeof(IEqualityComparer<>))]
[assembly: TypeForwardedTo(typeof(IList<>))]
[assembly: TypeForwardedTo(typeof(IReadOnlyCollection<>))]
[assembly: TypeForwardedTo(typeof(IReadOnlyDictionary<, >))]
[assembly: TypeForwardedTo(typeof(IReadOnlyList<>))]
[assembly: TypeForwardedTo(typeof(ISet<>))]
[assembly: TypeForwardedTo(typeof(KeyNotFoundException))]
[assembly: TypeForwardedTo(typeof(KeyValuePair<, >))]
[assembly: TypeForwardedTo(typeof(LinkedListNode<>))]
[assembly: TypeForwardedTo(typeof(LinkedList<>))]
[assembly: TypeForwardedTo(typeof(List<>))]
[assembly: TypeForwardedTo(typeof(Queue<>))]
[assembly: TypeForwardedTo(typeof(SortedDictionary<, >))]
[assembly: TypeForwardedTo(typeof(SortedList<, >))]
[assembly: TypeForwardedTo(typeof(SortedSet<>))]
[assembly: TypeForwardedTo(typeof(Stack<>))]
[assembly: TypeForwardedTo(typeof(Hashtable))]
[assembly: TypeForwardedTo(typeof(ICollection))]
[assembly: TypeForwardedTo(typeof(IComparer))]
[assembly: TypeForwardedTo(typeof(IDictionary))]
[assembly: TypeForwardedTo(typeof(IDictionaryEnumerator))]
[assembly: TypeForwardedTo(typeof(IEnumerable))]
[assembly: TypeForwardedTo(typeof(IEnumerator))]
[assembly: TypeForwardedTo(typeof(IEqualityComparer))]
[assembly: TypeForwardedTo(typeof(IHashCodeProvider))]
[assembly: TypeForwardedTo(typeof(IList))]
[assembly: TypeForwardedTo(typeof(IStructuralComparable))]
[assembly: TypeForwardedTo(typeof(IStructuralEquatable))]
[assembly: TypeForwardedTo(typeof(Collection<>))]
[assembly: TypeForwardedTo(typeof(KeyedCollection<, >))]
[assembly: TypeForwardedTo(typeof(ObservableCollection<>))]
[assembly: TypeForwardedTo(typeof(ReadOnlyCollection<>))]
[assembly: TypeForwardedTo(typeof(ReadOnlyDictionary<, >))]
[assembly: TypeForwardedTo(typeof(ReadOnlyObservableCollection<>))]
[assembly: TypeForwardedTo(typeof(Queue))]
[assembly: TypeForwardedTo(typeof(ReadOnlyCollectionBase))]
[assembly: TypeForwardedTo(typeof(SortedList))]
[assembly: TypeForwardedTo(typeof(BitVector32))]
[assembly: TypeForwardedTo(typeof(CollectionsUtil))]
[assembly: TypeForwardedTo(typeof(HybridDictionary))]
[assembly: TypeForwardedTo(typeof(INotifyCollectionChanged))]
[assembly: TypeForwardedTo(typeof(IOrderedDictionary))]
[assembly: TypeForwardedTo(typeof(ListDictionary))]
[assembly: TypeForwardedTo(typeof(NameObjectCollectionBase))]
[assembly: TypeForwardedTo(typeof(NameValueCollection))]
[assembly: TypeForwardedTo(typeof(NotifyCollectionChangedAction))]
[assembly: TypeForwardedTo(typeof(NotifyCollectionChangedEventArgs))]
[assembly: TypeForwardedTo(typeof(NotifyCollectionChangedEventHandler))]
[assembly: TypeForwardedTo(typeof(OrderedDictionary))]
[assembly: TypeForwardedTo(typeof(StringCollection))]
[assembly: TypeForwardedTo(typeof(StringDictionary))]
[assembly: TypeForwardedTo(typeof(StringEnumerator))]
[assembly: TypeForwardedTo(typeof(Stack))]
[assembly: TypeForwardedTo(typeof(StructuralComparisons))]
[assembly: TypeForwardedTo(typeof(Comparison<>))]
[assembly: TypeForwardedTo(typeof(AddingNewEventArgs))]
[assembly: TypeForwardedTo(typeof(AddingNewEventHandler))]
[assembly: TypeForwardedTo(typeof(AmbientValueAttribute))]
[assembly: TypeForwardedTo(typeof(ArrayConverter))]
[assembly: TypeForwardedTo(typeof(AsyncCompletedEventArgs))]
[assembly: TypeForwardedTo(typeof(AsyncCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(AsyncOperation))]
[assembly: TypeForwardedTo(typeof(AsyncOperationManager))]
[assembly: TypeForwardedTo(typeof(AttributeCollection))]
[assembly: TypeForwardedTo(typeof(AttributeProviderAttribute))]
[assembly: TypeForwardedTo(typeof(BackgroundWorker))]
[assembly: TypeForwardedTo(typeof(BaseNumberConverter))]
[assembly: TypeForwardedTo(typeof(BindableAttribute))]
[assembly: TypeForwardedTo(typeof(BindableSupport))]
[assembly: TypeForwardedTo(typeof(BindingDirection))]
[assembly: TypeForwardedTo(typeof(BindingList<>))]
[assembly: TypeForwardedTo(typeof(BooleanConverter))]
[assembly: TypeForwardedTo(typeof(BrowsableAttribute))]
[assembly: TypeForwardedTo(typeof(ByteConverter))]
[assembly: TypeForwardedTo(typeof(CancelEventArgs))]
[assembly: TypeForwardedTo(typeof(CancelEventHandler))]
[assembly: TypeForwardedTo(typeof(CategoryAttribute))]
[assembly: TypeForwardedTo(typeof(CharConverter))]
[assembly: TypeForwardedTo(typeof(CollectionChangeAction))]
[assembly: TypeForwardedTo(typeof(CollectionChangeEventArgs))]
[assembly: TypeForwardedTo(typeof(CollectionChangeEventHandler))]
[assembly: TypeForwardedTo(typeof(CollectionConverter))]
[assembly: TypeForwardedTo(typeof(ComplexBindingPropertiesAttribute))]
[assembly: TypeForwardedTo(typeof(Component))]
[assembly: TypeForwardedTo(typeof(ComponentCollection))]
[assembly: TypeForwardedTo(typeof(ComponentConverter))]
[assembly: TypeForwardedTo(typeof(ComponentEditor))]
[assembly: TypeForwardedTo(typeof(ComponentResourceManager))]
[assembly: TypeForwardedTo(typeof(Container))]
[assembly: TypeForwardedTo(typeof(ContainerFilterService))]
[assembly: TypeForwardedTo(typeof(CultureInfoConverter))]
[assembly: TypeForwardedTo(typeof(CustomTypeDescriptor))]
[assembly: TypeForwardedTo(typeof(DataErrorsChangedEventArgs))]
[assembly: TypeForwardedTo(typeof(DataObjectAttribute))]
[assembly: TypeForwardedTo(typeof(DataObjectFieldAttribute))]
[assembly: TypeForwardedTo(typeof(DataObjectMethodAttribute))]
[assembly: TypeForwardedTo(typeof(DataObjectMethodType))]
[assembly: TypeForwardedTo(typeof(DateTimeConverter))]
[assembly: TypeForwardedTo(typeof(DateTimeOffsetConverter))]
[assembly: TypeForwardedTo(typeof(DecimalConverter))]
[assembly: TypeForwardedTo(typeof(DefaultBindingPropertyAttribute))]
[assembly: TypeForwardedTo(typeof(DefaultEventAttribute))]
[assembly: TypeForwardedTo(typeof(DefaultPropertyAttribute))]
[assembly: TypeForwardedTo(typeof(DefaultValueAttribute))]
[assembly: TypeForwardedTo(typeof(DescriptionAttribute))]
[assembly: TypeForwardedTo(typeof(ActiveDesignerEventArgs))]
[assembly: TypeForwardedTo(typeof(ActiveDesignerEventHandler))]
[assembly: TypeForwardedTo(typeof(CheckoutException))]
[assembly: TypeForwardedTo(typeof(CommandID))]
[assembly: TypeForwardedTo(typeof(ComponentChangedEventArgs))]
[assembly: TypeForwardedTo(typeof(ComponentChangedEventHandler))]
[assembly: TypeForwardedTo(typeof(ComponentChangingEventArgs))]
[assembly: TypeForwardedTo(typeof(ComponentChangingEventHandler))]
[assembly: TypeForwardedTo(typeof(ComponentEventArgs))]
[assembly: TypeForwardedTo(typeof(ComponentEventHandler))]
[assembly: TypeForwardedTo(typeof(ComponentRenameEventArgs))]
[assembly: TypeForwardedTo(typeof(ComponentRenameEventHandler))]
[assembly: TypeForwardedTo(typeof(DesignerCollection))]
[assembly: TypeForwardedTo(typeof(DesignerEventArgs))]
[assembly: TypeForwardedTo(typeof(DesignerEventHandler))]
[assembly: TypeForwardedTo(typeof(DesignerOptionService))]
[assembly: TypeForwardedTo(typeof(DesignerTransaction))]
[assembly: TypeForwardedTo(typeof(DesignerTransactionCloseEventArgs))]
[assembly: TypeForwardedTo(typeof(DesignerTransactionCloseEventHandler))]
[assembly: TypeForwardedTo(typeof(DesignerVerb))]
[assembly: TypeForwardedTo(typeof(DesignerVerbCollection))]
[assembly: TypeForwardedTo(typeof(DesigntimeLicenseContext))]
[assembly: TypeForwardedTo(typeof(DesigntimeLicenseContextSerializer))]
[assembly: TypeForwardedTo(typeof(HelpContextType))]
[assembly: TypeForwardedTo(typeof(HelpKeywordAttribute))]
[assembly: TypeForwardedTo(typeof(HelpKeywordType))]
[assembly: TypeForwardedTo(typeof(IComponentChangeService))]
[assembly: TypeForwardedTo(typeof(IComponentDiscoveryService))]
[assembly: TypeForwardedTo(typeof(IComponentInitializer))]
[assembly: TypeForwardedTo(typeof(IDesigner))]
[assembly: TypeForwardedTo(typeof(IDesignerEventService))]
[assembly: TypeForwardedTo(typeof(IDesignerFilter))]
[assembly: TypeForwardedTo(typeof(IDesignerHost))]
[assembly: TypeForwardedTo(typeof(IDesignerHostTransactionState))]
[assembly: TypeForwardedTo(typeof(IDesignerOptionService))]
[assembly: TypeForwardedTo(typeof(IDictionaryService))]
[assembly: TypeForwardedTo(typeof(IEventBindingService))]
[assembly: TypeForwardedTo(typeof(IExtenderListService))]
[assembly: TypeForwardedTo(typeof(IExtenderProviderService))]
[assembly: TypeForwardedTo(typeof(IHelpService))]
[assembly: TypeForwardedTo(typeof(IInheritanceService))]
[assembly: TypeForwardedTo(typeof(IMenuCommandService))]
[assembly: TypeForwardedTo(typeof(IReferenceService))]
[assembly: TypeForwardedTo(typeof(IResourceService))]
[assembly: TypeForwardedTo(typeof(IRootDesigner))]
[assembly: TypeForwardedTo(typeof(ISelectionService))]
[assembly: TypeForwardedTo(typeof(IServiceContainer))]
[assembly: TypeForwardedTo(typeof(ITreeDesigner))]
[assembly: TypeForwardedTo(typeof(ITypeDescriptorFilterService))]
[assembly: TypeForwardedTo(typeof(ITypeDiscoveryService))]
[assembly: TypeForwardedTo(typeof(ITypeResolutionService))]
[assembly: TypeForwardedTo(typeof(MenuCommand))]
[assembly: TypeForwardedTo(typeof(SelectionTypes))]
[assembly: TypeForwardedTo(typeof(ComponentSerializationService))]
[assembly: TypeForwardedTo(typeof(ContextStack))]
[assembly: TypeForwardedTo(typeof(DefaultSerializationProviderAttribute))]
[assembly: TypeForwardedTo(typeof(DesignerLoader))]
[assembly: TypeForwardedTo(typeof(DesignerSerializerAttribute))]
[assembly: TypeForwardedTo(typeof(IDesignerLoaderHost))]
[assembly: TypeForwardedTo(typeof(IDesignerLoaderHost2))]
[assembly: TypeForwardedTo(typeof(IDesignerLoaderService))]
[assembly: TypeForwardedTo(typeof(IDesignerSerializationManager))]
[assembly: TypeForwardedTo(typeof(IDesignerSerializationProvider))]
[assembly: TypeForwardedTo(typeof(IDesignerSerializationService))]
[assembly: TypeForwardedTo(typeof(INameCreationService))]
[assembly: TypeForwardedTo(typeof(InstanceDescriptor))]
[assembly: TypeForwardedTo(typeof(MemberRelationship))]
[assembly: TypeForwardedTo(typeof(MemberRelationshipService))]
[assembly: TypeForwardedTo(typeof(ResolveNameEventArgs))]
[assembly: TypeForwardedTo(typeof(ResolveNameEventHandler))]
[assembly: TypeForwardedTo(typeof(RootDesignerSerializerAttribute))]
[assembly: TypeForwardedTo(typeof(SerializationStore))]
[assembly: TypeForwardedTo(typeof(ServiceContainer))]
[assembly: TypeForwardedTo(typeof(ServiceCreatorCallback))]
[assembly: TypeForwardedTo(typeof(StandardCommands))]
[assembly: TypeForwardedTo(typeof(StandardToolWindows))]
[assembly: TypeForwardedTo(typeof(TypeDescriptionProviderService))]
[assembly: TypeForwardedTo(typeof(ViewTechnology))]
[assembly: TypeForwardedTo(typeof(DesignerAttribute))]
[assembly: TypeForwardedTo(typeof(DesignerCategoryAttribute))]
[assembly: TypeForwardedTo(typeof(DesignerSerializationVisibility))]
[assembly: TypeForwardedTo(typeof(DesignerSerializationVisibilityAttribute))]
[assembly: TypeForwardedTo(typeof(DesignOnlyAttribute))]
[assembly: TypeForwardedTo(typeof(DesignTimeVisibleAttribute))]
[assembly: TypeForwardedTo(typeof(DisplayNameAttribute))]
[assembly: TypeForwardedTo(typeof(DoubleConverter))]
[assembly: TypeForwardedTo(typeof(DoWorkEventArgs))]
[assembly: TypeForwardedTo(typeof(DoWorkEventHandler))]
[assembly: TypeForwardedTo(typeof(EditorAttribute))]
[assembly: TypeForwardedTo(typeof(EditorBrowsableAttribute))]
[assembly: TypeForwardedTo(typeof(EditorBrowsableState))]
[assembly: TypeForwardedTo(typeof(EnumConverter))]
[assembly: TypeForwardedTo(typeof(EventDescriptor))]
[assembly: TypeForwardedTo(typeof(EventDescriptorCollection))]
[assembly: TypeForwardedTo(typeof(EventHandlerList))]
[assembly: TypeForwardedTo(typeof(ExpandableObjectConverter))]
[assembly: TypeForwardedTo(typeof(ExtenderProvidedPropertyAttribute))]
[assembly: TypeForwardedTo(typeof(GuidConverter))]
[assembly: TypeForwardedTo(typeof(HandledEventArgs))]
[assembly: TypeForwardedTo(typeof(HandledEventHandler))]
[assembly: TypeForwardedTo(typeof(IBindingList))]
[assembly: TypeForwardedTo(typeof(IBindingListView))]
[assembly: TypeForwardedTo(typeof(ICancelAddNew))]
[assembly: TypeForwardedTo(typeof(IChangeTracking))]
[assembly: TypeForwardedTo(typeof(IComNativeDescriptorHandler))]
[assembly: TypeForwardedTo(typeof(IComponent))]
[assembly: TypeForwardedTo(typeof(IContainer))]
[assembly: TypeForwardedTo(typeof(ICustomTypeDescriptor))]
[assembly: TypeForwardedTo(typeof(IDataErrorInfo))]
[assembly: TypeForwardedTo(typeof(IEditableObject))]
[assembly: TypeForwardedTo(typeof(IExtenderProvider))]
[assembly: TypeForwardedTo(typeof(IIntellisenseBuilder))]
[assembly: TypeForwardedTo(typeof(IListSource))]
[assembly: TypeForwardedTo(typeof(ImmutableObjectAttribute))]
[assembly: TypeForwardedTo(typeof(INestedContainer))]
[assembly: TypeForwardedTo(typeof(INestedSite))]
[assembly: TypeForwardedTo(typeof(InheritanceAttribute))]
[assembly: TypeForwardedTo(typeof(InheritanceLevel))]
[assembly: TypeForwardedTo(typeof(InitializationEventAttribute))]
[assembly: TypeForwardedTo(typeof(INotifyDataErrorInfo))]
[assembly: TypeForwardedTo(typeof(INotifyPropertyChanged))]
[assembly: TypeForwardedTo(typeof(INotifyPropertyChanging))]
[assembly: TypeForwardedTo(typeof(InstallerTypeAttribute))]
[assembly: TypeForwardedTo(typeof(InstanceCreationEditor))]
[assembly: TypeForwardedTo(typeof(Int16Converter))]
[assembly: TypeForwardedTo(typeof(Int32Converter))]
[assembly: TypeForwardedTo(typeof(Int64Converter))]
[assembly: TypeForwardedTo(typeof(InvalidAsynchronousStateException))]
[assembly: TypeForwardedTo(typeof(InvalidEnumArgumentException))]
[assembly: TypeForwardedTo(typeof(IRaiseItemChangedEvents))]
[assembly: TypeForwardedTo(typeof(IRevertibleChangeTracking))]
[assembly: TypeForwardedTo(typeof(ISite))]
[assembly: TypeForwardedTo(typeof(ISupportInitialize))]
[assembly: TypeForwardedTo(typeof(ISupportInitializeNotification))]
[assembly: TypeForwardedTo(typeof(ISynchronizeInvoke))]
[assembly: TypeForwardedTo(typeof(ITypeDescriptorContext))]
[assembly: TypeForwardedTo(typeof(ITypedList))]
[assembly: TypeForwardedTo(typeof(License))]
[assembly: TypeForwardedTo(typeof(LicenseContext))]
[assembly: TypeForwardedTo(typeof(LicenseException))]
[assembly: TypeForwardedTo(typeof(LicenseManager))]
[assembly: TypeForwardedTo(typeof(LicenseProvider))]
[assembly: TypeForwardedTo(typeof(LicenseProviderAttribute))]
[assembly: TypeForwardedTo(typeof(LicenseUsageMode))]
[assembly: TypeForwardedTo(typeof(LicFileLicenseProvider))]
[assembly: TypeForwardedTo(typeof(ListBindableAttribute))]
[assembly: TypeForwardedTo(typeof(ListChangedEventArgs))]
[assembly: TypeForwardedTo(typeof(ListChangedEventHandler))]
[assembly: TypeForwardedTo(typeof(ListChangedType))]
[assembly: TypeForwardedTo(typeof(ListSortDescription))]
[assembly: TypeForwardedTo(typeof(ListSortDescriptionCollection))]
[assembly: TypeForwardedTo(typeof(ListSortDirection))]
[assembly: TypeForwardedTo(typeof(LocalizableAttribute))]
[assembly: TypeForwardedTo(typeof(LookupBindingPropertiesAttribute))]
[assembly: TypeForwardedTo(typeof(MarshalByValueComponent))]
[assembly: TypeForwardedTo(typeof(MaskedTextProvider))]
[assembly: TypeForwardedTo(typeof(MaskedTextResultHint))]
[assembly: TypeForwardedTo(typeof(MemberDescriptor))]
[assembly: TypeForwardedTo(typeof(MergablePropertyAttribute))]
[assembly: TypeForwardedTo(typeof(MultilineStringConverter))]
[assembly: TypeForwardedTo(typeof(NestedContainer))]
[assembly: TypeForwardedTo(typeof(NotifyParentPropertyAttribute))]
[assembly: TypeForwardedTo(typeof(NullableConverter))]
[assembly: TypeForwardedTo(typeof(ParenthesizePropertyNameAttribute))]
[assembly: TypeForwardedTo(typeof(PasswordPropertyTextAttribute))]
[assembly: TypeForwardedTo(typeof(ProgressChangedEventArgs))]
[assembly: TypeForwardedTo(typeof(ProgressChangedEventHandler))]
[assembly: TypeForwardedTo(typeof(PropertyChangedEventArgs))]
[assembly: TypeForwardedTo(typeof(PropertyChangedEventHandler))]
[assembly: TypeForwardedTo(typeof(PropertyChangingEventArgs))]
[assembly: TypeForwardedTo(typeof(PropertyChangingEventHandler))]
[assembly: TypeForwardedTo(typeof(PropertyDescriptor))]
[assembly: TypeForwardedTo(typeof(PropertyDescriptorCollection))]
[assembly: TypeForwardedTo(typeof(PropertyTabAttribute))]
[assembly: TypeForwardedTo(typeof(PropertyTabScope))]
[assembly: TypeForwardedTo(typeof(ProvidePropertyAttribute))]
[assembly: TypeForwardedTo(typeof(ReadOnlyAttribute))]
[assembly: TypeForwardedTo(typeof(RecommendedAsConfigurableAttribute))]
[assembly: TypeForwardedTo(typeof(ReferenceConverter))]
[assembly: TypeForwardedTo(typeof(RefreshEventArgs))]
[assembly: TypeForwardedTo(typeof(RefreshEventHandler))]
[assembly: TypeForwardedTo(typeof(RefreshProperties))]
[assembly: TypeForwardedTo(typeof(RefreshPropertiesAttribute))]
[assembly: TypeForwardedTo(typeof(RunInstallerAttribute))]
[assembly: TypeForwardedTo(typeof(RunWorkerCompletedEventArgs))]
[assembly: TypeForwardedTo(typeof(RunWorkerCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(SByteConverter))]
[assembly: TypeForwardedTo(typeof(SettingsBindableAttribute))]
[assembly: TypeForwardedTo(typeof(SingleConverter))]
[assembly: TypeForwardedTo(typeof(StringConverter))]
[assembly: TypeForwardedTo(typeof(SyntaxCheck))]
[assembly: TypeForwardedTo(typeof(TimeSpanConverter))]
[assembly: TypeForwardedTo(typeof(ToolboxItemAttribute))]
[assembly: TypeForwardedTo(typeof(ToolboxItemFilterAttribute))]
[assembly: TypeForwardedTo(typeof(ToolboxItemFilterType))]
[assembly: TypeForwardedTo(typeof(TypeConverter))]
[assembly: TypeForwardedTo(typeof(TypeConverterAttribute))]
[assembly: TypeForwardedTo(typeof(TypeDescriptionProvider))]
[assembly: TypeForwardedTo(typeof(TypeDescriptionProviderAttribute))]
[assembly: TypeForwardedTo(typeof(TypeDescriptor))]
[assembly: TypeForwardedTo(typeof(TypeListConverter))]
[assembly: TypeForwardedTo(typeof(UInt16Converter))]
[assembly: TypeForwardedTo(typeof(UInt32Converter))]
[assembly: TypeForwardedTo(typeof(UInt64Converter))]
[assembly: TypeForwardedTo(typeof(WarningException))]
[assembly: TypeForwardedTo(typeof(Win32Exception))]
[assembly: TypeForwardedTo(typeof(AssemblyHashAlgorithm))]
[assembly: TypeForwardedTo(typeof(AssemblyVersionCompatibility))]
[assembly: TypeForwardedTo(typeof(Console))]
[assembly: TypeForwardedTo(typeof(ConsoleCancelEventArgs))]
[assembly: TypeForwardedTo(typeof(ConsoleCancelEventHandler))]
[assembly: TypeForwardedTo(typeof(ConsoleColor))]
[assembly: TypeForwardedTo(typeof(ConsoleKey))]
[assembly: TypeForwardedTo(typeof(ConsoleKeyInfo))]
[assembly: TypeForwardedTo(typeof(ConsoleModifiers))]
[assembly: TypeForwardedTo(typeof(ConsoleSpecialKey))]
[assembly: TypeForwardedTo(typeof(ContextBoundObject))]
[assembly: TypeForwardedTo(typeof(ContextMarshalException))]
[assembly: TypeForwardedTo(typeof(ContextStaticAttribute))]
[assembly: TypeForwardedTo(typeof(Convert))]
[assembly: TypeForwardedTo(typeof(Converter<, >))]
[assembly: TypeForwardedTo(typeof(AcceptRejectRule))]
[assembly: TypeForwardedTo(typeof(CommandBehavior))]
[assembly: TypeForwardedTo(typeof(CommandType))]
[assembly: TypeForwardedTo(typeof(CatalogLocation))]
[assembly: TypeForwardedTo(typeof(DataAdapter))]
[assembly: TypeForwardedTo(typeof(DataColumnMapping))]
[assembly: TypeForwardedTo(typeof(DataColumnMappingCollection))]
[assembly: TypeForwardedTo(typeof(DataTableMapping))]
[assembly: TypeForwardedTo(typeof(DataTableMappingCollection))]
[assembly: TypeForwardedTo(typeof(DbColumn))]
[assembly: TypeForwardedTo(typeof(DbCommand))]
[assembly: TypeForwardedTo(typeof(DbCommandBuilder))]
[assembly: TypeForwardedTo(typeof(DbConnection))]
[assembly: TypeForwardedTo(typeof(DbConnectionStringBuilder))]
[assembly: TypeForwardedTo(typeof(DbDataAdapter))]
[assembly: TypeForwardedTo(typeof(DbDataReader))]
[assembly: TypeForwardedTo(typeof(DbDataReaderExtensions))]
[assembly: TypeForwardedTo(typeof(DbDataRecord))]
[assembly: TypeForwardedTo(typeof(DbDataSourceEnumerator))]
[assembly: TypeForwardedTo(typeof(DbEnumerator))]
[assembly: TypeForwardedTo(typeof(DbException))]
[assembly: TypeForwardedTo(typeof(DbMetaDataCollectionNames))]
[assembly: TypeForwardedTo(typeof(DbMetaDataColumnNames))]
[assembly: TypeForwardedTo(typeof(DbParameter))]
[assembly: TypeForwardedTo(typeof(DbParameterCollection))]
[assembly: TypeForwardedTo(typeof(DbProviderFactory))]
[assembly: TypeForwardedTo(typeof(DbProviderSpecificTypePropertyAttribute))]
[assembly: TypeForwardedTo(typeof(DbTransaction))]
[assembly: TypeForwardedTo(typeof(GroupByBehavior))]
[assembly: TypeForwardedTo(typeof(IDbColumnSchemaGenerator))]
[assembly: TypeForwardedTo(typeof(IdentifierCase))]
[assembly: TypeForwardedTo(typeof(RowUpdatedEventArgs))]
[assembly: TypeForwardedTo(typeof(RowUpdatingEventArgs))]
[assembly: TypeForwardedTo(typeof(SchemaTableColumn))]
[assembly: TypeForwardedTo(typeof(SchemaTableOptionalColumn))]
[assembly: TypeForwardedTo(typeof(SupportedJoinOperators))]
[assembly: TypeForwardedTo(typeof(ConflictOption))]
[assembly: TypeForwardedTo(typeof(ConnectionState))]
[assembly: TypeForwardedTo(typeof(Constraint))]
[assembly: TypeForwardedTo(typeof(ConstraintCollection))]
[assembly: TypeForwardedTo(typeof(ConstraintException))]
[assembly: TypeForwardedTo(typeof(DataColumn))]
[assembly: TypeForwardedTo(typeof(DataColumnChangeEventArgs))]
[assembly: TypeForwardedTo(typeof(DataColumnChangeEventHandler))]
[assembly: TypeForwardedTo(typeof(DataColumnCollection))]
[assembly: TypeForwardedTo(typeof(DataException))]
[assembly: TypeForwardedTo(typeof(DataRelation))]
[assembly: TypeForwardedTo(typeof(DataRelationCollection))]
[assembly: TypeForwardedTo(typeof(DataRow))]
[assembly: TypeForwardedTo(typeof(DataRowAction))]
[assembly: TypeForwardedTo(typeof(DataRowBuilder))]
[assembly: TypeForwardedTo(typeof(DataRowChangeEventArgs))]
[assembly: TypeForwardedTo(typeof(DataRowChangeEventHandler))]
[assembly: TypeForwardedTo(typeof(DataRowCollection))]
[assembly: TypeForwardedTo(typeof(DataRowState))]
[assembly: TypeForwardedTo(typeof(DataRowVersion))]
[assembly: TypeForwardedTo(typeof(DataRowView))]
[assembly: TypeForwardedTo(typeof(DataSet))]
[assembly: TypeForwardedTo(typeof(DataSetDateTime))]
[assembly: TypeForwardedTo(typeof(DataSysDescriptionAttribute))]
[assembly: TypeForwardedTo(typeof(DataTable))]
[assembly: TypeForwardedTo(typeof(DataTableClearEventArgs))]
[assembly: TypeForwardedTo(typeof(DataTableClearEventHandler))]
[assembly: TypeForwardedTo(typeof(DataTableCollection))]
[assembly: TypeForwardedTo(typeof(DataTableNewRowEventArgs))]
[assembly: TypeForwardedTo(typeof(DataTableNewRowEventHandler))]
[assembly: TypeForwardedTo(typeof(DataTableReader))]
[assembly: TypeForwardedTo(typeof(DataView))]
[assembly: TypeForwardedTo(typeof(DataViewManager))]
[assembly: TypeForwardedTo(typeof(DataViewRowState))]
[assembly: TypeForwardedTo(typeof(DataViewSetting))]
[assembly: TypeForwardedTo(typeof(DataViewSettingCollection))]
[assembly: TypeForwardedTo(typeof(DBConcurrencyException))]
[assembly: TypeForwardedTo(typeof(DbType))]
[assembly: TypeForwardedTo(typeof(DeletedRowInaccessibleException))]
[assembly: TypeForwardedTo(typeof(DuplicateNameException))]
[assembly: TypeForwardedTo(typeof(EvaluateException))]
[assembly: TypeForwardedTo(typeof(FillErrorEventArgs))]
[assembly: TypeForwardedTo(typeof(FillErrorEventHandler))]
[assembly: TypeForwardedTo(typeof(ForeignKeyConstraint))]
[assembly: TypeForwardedTo(typeof(IColumnMapping))]
[assembly: TypeForwardedTo(typeof(IColumnMappingCollection))]
[assembly: TypeForwardedTo(typeof(IDataAdapter))]
[assembly: TypeForwardedTo(typeof(IDataParameter))]
[assembly: TypeForwardedTo(typeof(IDataParameterCollection))]
[assembly: TypeForwardedTo(typeof(IDataReader))]
[assembly: TypeForwardedTo(typeof(IDataRecord))]
[assembly: TypeForwardedTo(typeof(IDbCommand))]
[assembly: TypeForwardedTo(typeof(IDbConnection))]
[assembly: TypeForwardedTo(typeof(IDbDataAdapter))]
[assembly: TypeForwardedTo(typeof(IDbDataParameter))]
[assembly: TypeForwardedTo(typeof(IDbTransaction))]
[assembly: TypeForwardedTo(typeof(InRowChangingEventException))]
[assembly: TypeForwardedTo(typeof(InternalDataCollectionBase))]
[assembly: TypeForwardedTo(typeof(InvalidConstraintException))]
[assembly: TypeForwardedTo(typeof(InvalidExpressionException))]
[assembly: TypeForwardedTo(typeof(System.Data.IsolationLevel))]
[assembly: TypeForwardedTo(typeof(ITableMapping))]
[assembly: TypeForwardedTo(typeof(ITableMappingCollection))]
[assembly: TypeForwardedTo(typeof(KeyRestrictionBehavior))]
[assembly: TypeForwardedTo(typeof(LoadOption))]
[assembly: TypeForwardedTo(typeof(MappingType))]
[assembly: TypeForwardedTo(typeof(MergeFailedEventArgs))]
[assembly: TypeForwardedTo(typeof(MergeFailedEventHandler))]
[assembly: TypeForwardedTo(typeof(MissingMappingAction))]
[assembly: TypeForwardedTo(typeof(MissingPrimaryKeyException))]
[assembly: TypeForwardedTo(typeof(MissingSchemaAction))]
[assembly: TypeForwardedTo(typeof(NoNullAllowedException))]
[assembly: TypeForwardedTo(typeof(ParameterDirection))]
[assembly: TypeForwardedTo(typeof(PropertyCollection))]
[assembly: TypeForwardedTo(typeof(ReadOnlyException))]
[assembly: TypeForwardedTo(typeof(RowNotInTableException))]
[assembly: TypeForwardedTo(typeof(Rule))]
[assembly: TypeForwardedTo(typeof(SchemaSerializationMode))]
[assembly: TypeForwardedTo(typeof(SchemaType))]
[assembly: TypeForwardedTo(typeof(SerializationFormat))]
[assembly: TypeForwardedTo(typeof(SqlDbType))]
[assembly: TypeForwardedTo(typeof(INullable))]
[assembly: TypeForwardedTo(typeof(SqlAlreadyFilledException))]
[assembly: TypeForwardedTo(typeof(SqlBinary))]
[assembly: TypeForwardedTo(typeof(SqlBoolean))]
[assembly: TypeForwardedTo(typeof(SqlByte))]
[assembly: TypeForwardedTo(typeof(SqlBytes))]
[assembly: TypeForwardedTo(typeof(SqlChars))]
[assembly: TypeForwardedTo(typeof(SqlCompareOptions))]
[assembly: TypeForwardedTo(typeof(SqlDateTime))]
[assembly: TypeForwardedTo(typeof(SqlDecimal))]
[assembly: TypeForwardedTo(typeof(SqlDouble))]
[assembly: TypeForwardedTo(typeof(SqlGuid))]
[assembly: TypeForwardedTo(typeof(SqlInt16))]
[assembly: TypeForwardedTo(typeof(SqlInt32))]
[assembly: TypeForwardedTo(typeof(SqlInt64))]
[assembly: TypeForwardedTo(typeof(SqlMoney))]
[assembly: TypeForwardedTo(typeof(SqlNotFilledException))]
[assembly: TypeForwardedTo(typeof(SqlNullValueException))]
[assembly: TypeForwardedTo(typeof(SqlSingle))]
[assembly: TypeForwardedTo(typeof(SqlString))]
[assembly: TypeForwardedTo(typeof(SqlTruncateException))]
[assembly: TypeForwardedTo(typeof(SqlTypeException))]
[assembly: TypeForwardedTo(typeof(SqlXml))]
[assembly: TypeForwardedTo(typeof(StorageState))]
[assembly: TypeForwardedTo(typeof(StateChangeEventArgs))]
[assembly: TypeForwardedTo(typeof(StateChangeEventHandler))]
[assembly: TypeForwardedTo(typeof(StatementCompletedEventArgs))]
[assembly: TypeForwardedTo(typeof(StatementCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(StatementType))]
[assembly: TypeForwardedTo(typeof(StrongTypingException))]
[assembly: TypeForwardedTo(typeof(SyntaxErrorException))]
[assembly: TypeForwardedTo(typeof(UniqueConstraint))]
[assembly: TypeForwardedTo(typeof(UpdateRowSource))]
[assembly: TypeForwardedTo(typeof(UpdateStatus))]
[assembly: TypeForwardedTo(typeof(VersionNotFoundException))]
[assembly: TypeForwardedTo(typeof(XmlReadMode))]
[assembly: TypeForwardedTo(typeof(XmlWriteMode))]
[assembly: TypeForwardedTo(typeof(DataMisalignedException))]
[assembly: TypeForwardedTo(typeof(DateTime))]
[assembly: TypeForwardedTo(typeof(DateTimeKind))]
[assembly: TypeForwardedTo(typeof(DateTimeOffset))]
[assembly: TypeForwardedTo(typeof(DayOfWeek))]
[assembly: TypeForwardedTo(typeof(DBNull))]
[assembly: TypeForwardedTo(typeof(decimal))]
[assembly: TypeForwardedTo(typeof(Delegate))]
[assembly: TypeForwardedTo(typeof(BooleanSwitch))]
[assembly: TypeForwardedTo(typeof(ExcludeFromCodeCoverageAttribute))]
[assembly: TypeForwardedTo(typeof(SuppressMessageAttribute))]
[assembly: TypeForwardedTo(typeof(ConditionalAttribute))]
[assembly: TypeForwardedTo(typeof(Contract))]
[assembly: TypeForwardedTo(typeof(ContractAbbreviatorAttribute))]
[assembly: TypeForwardedTo(typeof(ContractArgumentValidatorAttribute))]
[assembly: TypeForwardedTo(typeof(ContractClassAttribute))]
[assembly: TypeForwardedTo(typeof(ContractClassForAttribute))]
[assembly: TypeForwardedTo(typeof(ContractFailedEventArgs))]
[assembly: TypeForwardedTo(typeof(ContractFailureKind))]
[assembly: TypeForwardedTo(typeof(ContractInvariantMethodAttribute))]
[assembly: TypeForwardedTo(typeof(ContractOptionAttribute))]
[assembly: TypeForwardedTo(typeof(ContractPublicPropertyNameAttribute))]
[assembly: TypeForwardedTo(typeof(ContractReferenceAssemblyAttribute))]
[assembly: TypeForwardedTo(typeof(ContractRuntimeIgnoredAttribute))]
[assembly: TypeForwardedTo(typeof(ContractVerificationAttribute))]
[assembly: TypeForwardedTo(typeof(PureAttribute))]
[assembly: TypeForwardedTo(typeof(CorrelationManager))]
[assembly: TypeForwardedTo(typeof(DataReceivedEventArgs))]
[assembly: TypeForwardedTo(typeof(DataReceivedEventHandler))]
[assembly: TypeForwardedTo(typeof(Debug))]
[assembly: TypeForwardedTo(typeof(DebuggableAttribute))]
[assembly: TypeForwardedTo(typeof(Debugger))]
[assembly: TypeForwardedTo(typeof(DebuggerBrowsableAttribute))]
[assembly: TypeForwardedTo(typeof(DebuggerBrowsableState))]
[assembly: TypeForwardedTo(typeof(DebuggerDisplayAttribute))]
[assembly: TypeForwardedTo(typeof(DebuggerHiddenAttribute))]
[assembly: TypeForwardedTo(typeof(DebuggerNonUserCodeAttribute))]
[assembly: TypeForwardedTo(typeof(DebuggerStepperBoundaryAttribute))]
[assembly: TypeForwardedTo(typeof(DebuggerStepThroughAttribute))]
[assembly: TypeForwardedTo(typeof(DebuggerTypeProxyAttribute))]
[assembly: TypeForwardedTo(typeof(DebuggerVisualizerAttribute))]
[assembly: TypeForwardedTo(typeof(DefaultTraceListener))]
[assembly: TypeForwardedTo(typeof(DelimitedListTraceListener))]
[assembly: TypeForwardedTo(typeof(EventTypeFilter))]
[assembly: TypeForwardedTo(typeof(FileVersionInfo))]
[assembly: TypeForwardedTo(typeof(MonitoringDescriptionAttribute))]
[assembly: TypeForwardedTo(typeof(Process))]
[assembly: TypeForwardedTo(typeof(ProcessModule))]
[assembly: TypeForwardedTo(typeof(ProcessModuleCollection))]
[assembly: TypeForwardedTo(typeof(ProcessPriorityClass))]
[assembly: TypeForwardedTo(typeof(ProcessStartInfo))]
[assembly: TypeForwardedTo(typeof(ProcessThread))]
[assembly: TypeForwardedTo(typeof(ProcessThreadCollection))]
[assembly: TypeForwardedTo(typeof(ProcessWindowStyle))]
[assembly: TypeForwardedTo(typeof(SourceFilter))]
[assembly: TypeForwardedTo(typeof(SourceLevels))]
[assembly: TypeForwardedTo(typeof(SourceSwitch))]
[assembly: TypeForwardedTo(typeof(StackFrame))]
[assembly: TypeForwardedTo(typeof(StackFrameExtensions))]
[assembly: TypeForwardedTo(typeof(StackTrace))]
[assembly: TypeForwardedTo(typeof(Stopwatch))]
[assembly: TypeForwardedTo(typeof(Switch))]
[assembly: TypeForwardedTo(typeof(SwitchAttribute))]
[assembly: TypeForwardedTo(typeof(SwitchLevelAttribute))]
[assembly: TypeForwardedTo(typeof(ISymbolBinder))]
[assembly: TypeForwardedTo(typeof(ISymbolBinder1))]
[assembly: TypeForwardedTo(typeof(ISymbolDocument))]
[assembly: TypeForwardedTo(typeof(ISymbolDocumentWriter))]
[assembly: TypeForwardedTo(typeof(ISymbolMethod))]
[assembly: TypeForwardedTo(typeof(ISymbolNamespace))]
[assembly: TypeForwardedTo(typeof(ISymbolReader))]
[assembly: TypeForwardedTo(typeof(ISymbolScope))]
[assembly: TypeForwardedTo(typeof(ISymbolVariable))]
[assembly: TypeForwardedTo(typeof(ISymbolWriter))]
[assembly: TypeForwardedTo(typeof(SymAddressKind))]
[assembly: TypeForwardedTo(typeof(SymbolToken))]
[assembly: TypeForwardedTo(typeof(SymDocumentType))]
[assembly: TypeForwardedTo(typeof(SymLanguageType))]
[assembly: TypeForwardedTo(typeof(SymLanguageVendor))]
[assembly: TypeForwardedTo(typeof(TextWriterTraceListener))]
[assembly: TypeForwardedTo(typeof(ThreadPriorityLevel))]
[assembly: TypeForwardedTo(typeof(System.Diagnostics.ThreadState))]
[assembly: TypeForwardedTo(typeof(ThreadWaitReason))]
[assembly: TypeForwardedTo(typeof(Trace))]
[assembly: TypeForwardedTo(typeof(TraceEventCache))]
[assembly: TypeForwardedTo(typeof(TraceEventType))]
[assembly: TypeForwardedTo(typeof(TraceFilter))]
[assembly: TypeForwardedTo(typeof(TraceLevel))]
[assembly: TypeForwardedTo(typeof(TraceListener))]
[assembly: TypeForwardedTo(typeof(TraceListenerCollection))]
[assembly: TypeForwardedTo(typeof(TraceOptions))]
[assembly: TypeForwardedTo(typeof(TraceSource))]
[assembly: TypeForwardedTo(typeof(TraceSwitch))]
[assembly: TypeForwardedTo(typeof(EventActivityOptions))]
[assembly: TypeForwardedTo(typeof(EventAttribute))]
[assembly: TypeForwardedTo(typeof(EventChannel))]
[assembly: TypeForwardedTo(typeof(EventCommand))]
[assembly: TypeForwardedTo(typeof(EventCommandEventArgs))]
[assembly: TypeForwardedTo(typeof(EventCounter))]
[assembly: TypeForwardedTo(typeof(EventDataAttribute))]
[assembly: TypeForwardedTo(typeof(EventFieldAttribute))]
[assembly: TypeForwardedTo(typeof(EventFieldFormat))]
[assembly: TypeForwardedTo(typeof(EventFieldTags))]
[assembly: TypeForwardedTo(typeof(EventIgnoreAttribute))]
[assembly: TypeForwardedTo(typeof(EventKeywords))]
[assembly: TypeForwardedTo(typeof(EventLevel))]
[assembly: TypeForwardedTo(typeof(EventListener))]
[assembly: TypeForwardedTo(typeof(EventManifestOptions))]
[assembly: TypeForwardedTo(typeof(EventOpcode))]
[assembly: TypeForwardedTo(typeof(EventSource))]
[assembly: TypeForwardedTo(typeof(EventSourceAttribute))]
[assembly: TypeForwardedTo(typeof(EventSourceException))]
[assembly: TypeForwardedTo(typeof(EventSourceOptions))]
[assembly: TypeForwardedTo(typeof(EventSourceSettings))]
[assembly: TypeForwardedTo(typeof(EventTags))]
[assembly: TypeForwardedTo(typeof(EventTask))]
[assembly: TypeForwardedTo(typeof(EventWrittenEventArgs))]
[assembly: TypeForwardedTo(typeof(NonEventAttribute))]
[assembly: TypeForwardedTo(typeof(DivideByZeroException))]
[assembly: TypeForwardedTo(typeof(DllNotFoundException))]
[assembly: TypeForwardedTo(typeof(double))]
[assembly: TypeForwardedTo(typeof(Color))]
[assembly: TypeForwardedTo(typeof(Point))]
[assembly: TypeForwardedTo(typeof(PointF))]
[assembly: TypeForwardedTo(typeof(Rectangle))]
[assembly: TypeForwardedTo(typeof(RectangleF))]
[assembly: TypeForwardedTo(typeof(Size))]
[assembly: TypeForwardedTo(typeof(SizeF))]
[assembly: TypeForwardedTo(typeof(DuplicateWaitObjectException))]
[assembly: TypeForwardedTo(typeof(BinaryOperationBinder))]
[assembly: TypeForwardedTo(typeof(BindingRestrictions))]
[assembly: TypeForwardedTo(typeof(CallInfo))]
[assembly: TypeForwardedTo(typeof(ConvertBinder))]
[assembly: TypeForwardedTo(typeof(CreateInstanceBinder))]
[assembly: TypeForwardedTo(typeof(DeleteIndexBinder))]
[assembly: TypeForwardedTo(typeof(DeleteMemberBinder))]
[assembly: TypeForwardedTo(typeof(DynamicMetaObject))]
[assembly: TypeForwardedTo(typeof(DynamicMetaObjectBinder))]
[assembly: TypeForwardedTo(typeof(DynamicObject))]
[assembly: TypeForwardedTo(typeof(ExpandoObject))]
[assembly: TypeForwardedTo(typeof(GetIndexBinder))]
[assembly: TypeForwardedTo(typeof(GetMemberBinder))]
[assembly: TypeForwardedTo(typeof(IDynamicMetaObjectProvider))]
[assembly: TypeForwardedTo(typeof(IInvokeOnGetBinder))]
[assembly: TypeForwardedTo(typeof(InvokeBinder))]
[assembly: TypeForwardedTo(typeof(InvokeMemberBinder))]
[assembly: TypeForwardedTo(typeof(SetIndexBinder))]
[assembly: TypeForwardedTo(typeof(SetMemberBinder))]
[assembly: TypeForwardedTo(typeof(UnaryOperationBinder))]
[assembly: TypeForwardedTo(typeof(EntryPointNotFoundException))]
[assembly: TypeForwardedTo(typeof(Enum))]
[assembly: TypeForwardedTo(typeof(Environment))]
[assembly: TypeForwardedTo(typeof(EnvironmentVariableTarget))]
[assembly: TypeForwardedTo(typeof(EventArgs))]
[assembly: TypeForwardedTo(typeof(EventHandler))]
[assembly: TypeForwardedTo(typeof(EventHandler<>))]
[assembly: TypeForwardedTo(typeof(Exception))]
[assembly: TypeForwardedTo(typeof(ExecutionEngineException))]
[assembly: TypeForwardedTo(typeof(FieldAccessException))]
[assembly: TypeForwardedTo(typeof(FileStyleUriParser))]
[assembly: TypeForwardedTo(typeof(FlagsAttribute))]
[assembly: TypeForwardedTo(typeof(FormatException))]
[assembly: TypeForwardedTo(typeof(FormattableString))]
[assembly: TypeForwardedTo(typeof(FtpStyleUriParser))]
[assembly: TypeForwardedTo(typeof(Func<>))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, >))]
[assembly: TypeForwardedTo(typeof(Func<, , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(GC))]
[assembly: TypeForwardedTo(typeof(GCCollectionMode))]
[assembly: TypeForwardedTo(typeof(GCNotificationStatus))]
[assembly: TypeForwardedTo(typeof(GenericUriParser))]
[assembly: TypeForwardedTo(typeof(GenericUriParserOptions))]
[assembly: TypeForwardedTo(typeof(Calendar))]
[assembly: TypeForwardedTo(typeof(CalendarAlgorithmType))]
[assembly: TypeForwardedTo(typeof(CalendarWeekRule))]
[assembly: TypeForwardedTo(typeof(CharUnicodeInfo))]
[assembly: TypeForwardedTo(typeof(ChineseLunisolarCalendar))]
[assembly: TypeForwardedTo(typeof(CompareInfo))]
[assembly: TypeForwardedTo(typeof(CompareOptions))]
[assembly: TypeForwardedTo(typeof(CultureInfo))]
[assembly: TypeForwardedTo(typeof(CultureNotFoundException))]
[assembly: TypeForwardedTo(typeof(CultureTypes))]
[assembly: TypeForwardedTo(typeof(DateTimeFormatInfo))]
[assembly: TypeForwardedTo(typeof(DateTimeStyles))]
[assembly: TypeForwardedTo(typeof(DaylightTime))]
[assembly: TypeForwardedTo(typeof(DigitShapes))]
[assembly: TypeForwardedTo(typeof(EastAsianLunisolarCalendar))]
[assembly: TypeForwardedTo(typeof(GlobalizationExtensions))]
[assembly: TypeForwardedTo(typeof(GregorianCalendar))]
[assembly: TypeForwardedTo(typeof(GregorianCalendarTypes))]
[assembly: TypeForwardedTo(typeof(HebrewCalendar))]
[assembly: TypeForwardedTo(typeof(HijriCalendar))]
[assembly: TypeForwardedTo(typeof(IdnMapping))]
[assembly: TypeForwardedTo(typeof(JapaneseCalendar))]
[assembly: TypeForwardedTo(typeof(JapaneseLunisolarCalendar))]
[assembly: TypeForwardedTo(typeof(JulianCalendar))]
[assembly: TypeForwardedTo(typeof(KoreanCalendar))]
[assembly: TypeForwardedTo(typeof(KoreanLunisolarCalendar))]
[assembly: TypeForwardedTo(typeof(NumberFormatInfo))]
[assembly: TypeForwardedTo(typeof(NumberStyles))]
[assembly: TypeForwardedTo(typeof(PersianCalendar))]
[assembly: TypeForwardedTo(typeof(RegionInfo))]
[assembly: TypeForwardedTo(typeof(SortKey))]
[assembly: TypeForwardedTo(typeof(SortVersion))]
[assembly: TypeForwardedTo(typeof(StringInfo))]
[assembly: TypeForwardedTo(typeof(TaiwanCalendar))]
[assembly: TypeForwardedTo(typeof(TaiwanLunisolarCalendar))]
[assembly: TypeForwardedTo(typeof(TextElementEnumerator))]
[assembly: TypeForwardedTo(typeof(TextInfo))]
[assembly: TypeForwardedTo(typeof(ThaiBuddhistCalendar))]
[assembly: TypeForwardedTo(typeof(TimeSpanStyles))]
[assembly: TypeForwardedTo(typeof(UmAlQuraCalendar))]
[assembly: TypeForwardedTo(typeof(UnicodeCategory))]
[assembly: TypeForwardedTo(typeof(GopherStyleUriParser))]
[assembly: TypeForwardedTo(typeof(Guid))]
[assembly: TypeForwardedTo(typeof(HttpStyleUriParser))]
[assembly: TypeForwardedTo(typeof(IAsyncResult))]
[assembly: TypeForwardedTo(typeof(ICloneable))]
[assembly: TypeForwardedTo(typeof(IComparable))]
[assembly: TypeForwardedTo(typeof(IComparable<>))]
[assembly: TypeForwardedTo(typeof(IConvertible))]
[assembly: TypeForwardedTo(typeof(ICustomFormatter))]
[assembly: TypeForwardedTo(typeof(IDisposable))]
[assembly: TypeForwardedTo(typeof(IEquatable<>))]
[assembly: TypeForwardedTo(typeof(IFormatProvider))]
[assembly: TypeForwardedTo(typeof(IFormattable))]
[assembly: TypeForwardedTo(typeof(IndexOutOfRangeException))]
[assembly: TypeForwardedTo(typeof(InsufficientExecutionStackException))]
[assembly: TypeForwardedTo(typeof(InsufficientMemoryException))]
[assembly: TypeForwardedTo(typeof(short))]
[assembly: TypeForwardedTo(typeof(int))]
[assembly: TypeForwardedTo(typeof(long))]
[assembly: TypeForwardedTo(typeof(IntPtr))]
[assembly: TypeForwardedTo(typeof(InvalidCastException))]
[assembly: TypeForwardedTo(typeof(InvalidOperationException))]
[assembly: TypeForwardedTo(typeof(InvalidProgramException))]
[assembly: TypeForwardedTo(typeof(InvalidTimeZoneException))]
[assembly: TypeForwardedTo(typeof(BinaryReader))]
[assembly: TypeForwardedTo(typeof(BinaryWriter))]
[assembly: TypeForwardedTo(typeof(BufferedStream))]
[assembly: TypeForwardedTo(typeof(CompressionLevel))]
[assembly: TypeForwardedTo(typeof(CompressionMode))]
[assembly: TypeForwardedTo(typeof(DeflateStream))]
[assembly: TypeForwardedTo(typeof(GZipStream))]
[assembly: TypeForwardedTo(typeof(ZipArchive))]
[assembly: TypeForwardedTo(typeof(ZipArchiveEntry))]
[assembly: TypeForwardedTo(typeof(ZipArchiveMode))]
[assembly: TypeForwardedTo(typeof(ZipFile))]
[assembly: TypeForwardedTo(typeof(ZipFileExtensions))]
[assembly: TypeForwardedTo(typeof(Directory))]
[assembly: TypeForwardedTo(typeof(DirectoryInfo))]
[assembly: TypeForwardedTo(typeof(DirectoryNotFoundException))]
[assembly: TypeForwardedTo(typeof(DriveInfo))]
[assembly: TypeForwardedTo(typeof(DriveNotFoundException))]
[assembly: TypeForwardedTo(typeof(DriveType))]
[assembly: TypeForwardedTo(typeof(EndOfStreamException))]
[assembly: TypeForwardedTo(typeof(ErrorEventArgs))]
[assembly: TypeForwardedTo(typeof(ErrorEventHandler))]
[assembly: TypeForwardedTo(typeof(File))]
[assembly: TypeForwardedTo(typeof(FileAccess))]
[assembly: TypeForwardedTo(typeof(FileAttributes))]
[assembly: TypeForwardedTo(typeof(FileInfo))]
[assembly: TypeForwardedTo(typeof(FileLoadException))]
[assembly: TypeForwardedTo(typeof(FileMode))]
[assembly: TypeForwardedTo(typeof(FileNotFoundException))]
[assembly: TypeForwardedTo(typeof(FileOptions))]
[assembly: TypeForwardedTo(typeof(FileShare))]
[assembly: TypeForwardedTo(typeof(FileStream))]
[assembly: TypeForwardedTo(typeof(FileSystemEventArgs))]
[assembly: TypeForwardedTo(typeof(FileSystemEventHandler))]
[assembly: TypeForwardedTo(typeof(FileSystemInfo))]
[assembly: TypeForwardedTo(typeof(FileSystemWatcher))]
[assembly: TypeForwardedTo(typeof(HandleInheritability))]
[assembly: TypeForwardedTo(typeof(InternalBufferOverflowException))]
[assembly: TypeForwardedTo(typeof(InvalidDataException))]
[assembly: TypeForwardedTo(typeof(IOException))]
[assembly: TypeForwardedTo(typeof(INormalizeForIsolatedStorage))]
[assembly: TypeForwardedTo(typeof(IsolatedStorage))]
[assembly: TypeForwardedTo(typeof(IsolatedStorageException))]
[assembly: TypeForwardedTo(typeof(IsolatedStorageFile))]
[assembly: TypeForwardedTo(typeof(IsolatedStorageFileStream))]
[assembly: TypeForwardedTo(typeof(IsolatedStorageScope))]
[assembly: TypeForwardedTo(typeof(MemoryMappedFile))]
[assembly: TypeForwardedTo(typeof(MemoryMappedFileAccess))]
[assembly: TypeForwardedTo(typeof(MemoryMappedFileOptions))]
[assembly: TypeForwardedTo(typeof(MemoryMappedFileRights))]
[assembly: TypeForwardedTo(typeof(MemoryMappedViewAccessor))]
[assembly: TypeForwardedTo(typeof(MemoryMappedViewStream))]
[assembly: TypeForwardedTo(typeof(MemoryStream))]
[assembly: TypeForwardedTo(typeof(NotifyFilters))]
[assembly: TypeForwardedTo(typeof(Path))]
[assembly: TypeForwardedTo(typeof(PathTooLongException))]
[assembly: TypeForwardedTo(typeof(AnonymousPipeClientStream))]
[assembly: TypeForwardedTo(typeof(AnonymousPipeServerStream))]
[assembly: TypeForwardedTo(typeof(NamedPipeClientStream))]
[assembly: TypeForwardedTo(typeof(NamedPipeServerStream))]
[assembly: TypeForwardedTo(typeof(PipeDirection))]
[assembly: TypeForwardedTo(typeof(PipeOptions))]
[assembly: TypeForwardedTo(typeof(PipeStream))]
[assembly: TypeForwardedTo(typeof(PipeStreamImpersonationWorker))]
[assembly: TypeForwardedTo(typeof(PipeTransmissionMode))]
[assembly: TypeForwardedTo(typeof(RenamedEventArgs))]
[assembly: TypeForwardedTo(typeof(RenamedEventHandler))]
[assembly: TypeForwardedTo(typeof(SearchOption))]
[assembly: TypeForwardedTo(typeof(SeekOrigin))]
[assembly: TypeForwardedTo(typeof(Stream))]
[assembly: TypeForwardedTo(typeof(StreamReader))]
[assembly: TypeForwardedTo(typeof(StreamWriter))]
[assembly: TypeForwardedTo(typeof(StringReader))]
[assembly: TypeForwardedTo(typeof(StringWriter))]
[assembly: TypeForwardedTo(typeof(TextReader))]
[assembly: TypeForwardedTo(typeof(TextWriter))]
[assembly: TypeForwardedTo(typeof(UnmanagedMemoryAccessor))]
[assembly: TypeForwardedTo(typeof(UnmanagedMemoryStream))]
[assembly: TypeForwardedTo(typeof(WaitForChangedResult))]
[assembly: TypeForwardedTo(typeof(WatcherChangeTypes))]
[assembly: TypeForwardedTo(typeof(IObservable<>))]
[assembly: TypeForwardedTo(typeof(IObserver<>))]
[assembly: TypeForwardedTo(typeof(IProgress<>))]
[assembly: TypeForwardedTo(typeof(IServiceProvider))]
[assembly: TypeForwardedTo(typeof(Lazy<>))]
[assembly: TypeForwardedTo(typeof(Lazy<, >))]
[assembly: TypeForwardedTo(typeof(LdapStyleUriParser))]
[assembly: TypeForwardedTo(typeof(Enumerable))]
[assembly: TypeForwardedTo(typeof(EnumerableExecutor))]
[assembly: TypeForwardedTo(typeof(EnumerableExecutor<>))]
[assembly: TypeForwardedTo(typeof(EnumerableQuery))]
[assembly: TypeForwardedTo(typeof(EnumerableQuery<>))]
[assembly: TypeForwardedTo(typeof(BinaryExpression))]
[assembly: TypeForwardedTo(typeof(BlockExpression))]
[assembly: TypeForwardedTo(typeof(CatchBlock))]
[assembly: TypeForwardedTo(typeof(ConditionalExpression))]
[assembly: TypeForwardedTo(typeof(ConstantExpression))]
[assembly: TypeForwardedTo(typeof(DebugInfoExpression))]
[assembly: TypeForwardedTo(typeof(DefaultExpression))]
[assembly: TypeForwardedTo(typeof(DynamicExpression))]
[assembly: TypeForwardedTo(typeof(DynamicExpressionVisitor))]
[assembly: TypeForwardedTo(typeof(ElementInit))]
[assembly: TypeForwardedTo(typeof(Expression))]
[assembly: TypeForwardedTo(typeof(ExpressionType))]
[assembly: TypeForwardedTo(typeof(ExpressionVisitor))]
[assembly: TypeForwardedTo(typeof(Expression<>))]
[assembly: TypeForwardedTo(typeof(GotoExpression))]
[assembly: TypeForwardedTo(typeof(GotoExpressionKind))]
[assembly: TypeForwardedTo(typeof(IArgumentProvider))]
[assembly: TypeForwardedTo(typeof(IDynamicExpression))]
[assembly: TypeForwardedTo(typeof(IndexExpression))]
[assembly: TypeForwardedTo(typeof(InvocationExpression))]
[assembly: TypeForwardedTo(typeof(LabelExpression))]
[assembly: TypeForwardedTo(typeof(LabelTarget))]
[assembly: TypeForwardedTo(typeof(LambdaExpression))]
[assembly: TypeForwardedTo(typeof(ListInitExpression))]
[assembly: TypeForwardedTo(typeof(LoopExpression))]
[assembly: TypeForwardedTo(typeof(MemberAssignment))]
[assembly: TypeForwardedTo(typeof(MemberBinding))]
[assembly: TypeForwardedTo(typeof(MemberBindingType))]
[assembly: TypeForwardedTo(typeof(MemberExpression))]
[assembly: TypeForwardedTo(typeof(MemberInitExpression))]
[assembly: TypeForwardedTo(typeof(MemberListBinding))]
[assembly: TypeForwardedTo(typeof(MemberMemberBinding))]
[assembly: TypeForwardedTo(typeof(MethodCallExpression))]
[assembly: TypeForwardedTo(typeof(NewArrayExpression))]
[assembly: TypeForwardedTo(typeof(NewExpression))]
[assembly: TypeForwardedTo(typeof(ParameterExpression))]
[assembly: TypeForwardedTo(typeof(RuntimeVariablesExpression))]
[assembly: TypeForwardedTo(typeof(SwitchCase))]
[assembly: TypeForwardedTo(typeof(SwitchExpression))]
[assembly: TypeForwardedTo(typeof(SymbolDocumentInfo))]
[assembly: TypeForwardedTo(typeof(TryExpression))]
[assembly: TypeForwardedTo(typeof(TypeBinaryExpression))]
[assembly: TypeForwardedTo(typeof(UnaryExpression))]
[assembly: TypeForwardedTo(typeof(IGrouping<, >))]
[assembly: TypeForwardedTo(typeof(ILookup<, >))]
[assembly: TypeForwardedTo(typeof(IOrderedEnumerable<>))]
[assembly: TypeForwardedTo(typeof(IOrderedQueryable))]
[assembly: TypeForwardedTo(typeof(IOrderedQueryable<>))]
[assembly: TypeForwardedTo(typeof(IQueryable))]
[assembly: TypeForwardedTo(typeof(IQueryable<>))]
[assembly: TypeForwardedTo(typeof(IQueryProvider))]
[assembly: TypeForwardedTo(typeof(Lookup<, >))]
[assembly: TypeForwardedTo(typeof(OrderedParallelQuery<>))]
[assembly: TypeForwardedTo(typeof(ParallelEnumerable))]
[assembly: TypeForwardedTo(typeof(ParallelExecutionMode))]
[assembly: TypeForwardedTo(typeof(ParallelMergeOptions))]
[assembly: TypeForwardedTo(typeof(ParallelQuery))]
[assembly: TypeForwardedTo(typeof(ParallelQuery<>))]
[assembly: TypeForwardedTo(typeof(Queryable))]
[assembly: TypeForwardedTo(typeof(LoaderOptimization))]
[assembly: TypeForwardedTo(typeof(LoaderOptimizationAttribute))]
[assembly: TypeForwardedTo(typeof(LocalDataStoreSlot))]
[assembly: TypeForwardedTo(typeof(MarshalByRefObject))]
[assembly: TypeForwardedTo(typeof(Math))]
[assembly: TypeForwardedTo(typeof(MemberAccessException))]
[assembly: TypeForwardedTo(typeof(MethodAccessException))]
[assembly: TypeForwardedTo(typeof(MidpointRounding))]
[assembly: TypeForwardedTo(typeof(MissingFieldException))]
[assembly: TypeForwardedTo(typeof(MissingMemberException))]
[assembly: TypeForwardedTo(typeof(MissingMethodException))]
[assembly: TypeForwardedTo(typeof(ModuleHandle))]
[assembly: TypeForwardedTo(typeof(MTAThreadAttribute))]
[assembly: TypeForwardedTo(typeof(MulticastDelegate))]
[assembly: TypeForwardedTo(typeof(MulticastNotSupportedException))]
[assembly: TypeForwardedTo(typeof(AuthenticationManager))]
[assembly: TypeForwardedTo(typeof(AuthenticationSchemes))]
[assembly: TypeForwardedTo(typeof(AuthenticationSchemeSelector))]
[assembly: TypeForwardedTo(typeof(Authorization))]
[assembly: TypeForwardedTo(typeof(BindIPEndPoint))]
[assembly: TypeForwardedTo(typeof(HttpCacheAgeControl))]
[assembly: TypeForwardedTo(typeof(HttpRequestCacheLevel))]
[assembly: TypeForwardedTo(typeof(HttpRequestCachePolicy))]
[assembly: TypeForwardedTo(typeof(RequestCacheLevel))]
[assembly: TypeForwardedTo(typeof(RequestCachePolicy))]
[assembly: TypeForwardedTo(typeof(Cookie))]
[assembly: TypeForwardedTo(typeof(CookieCollection))]
[assembly: TypeForwardedTo(typeof(CookieContainer))]
[assembly: TypeForwardedTo(typeof(CookieException))]
[assembly: TypeForwardedTo(typeof(CredentialCache))]
[assembly: TypeForwardedTo(typeof(DecompressionMethods))]
[assembly: TypeForwardedTo(typeof(Dns))]
[assembly: TypeForwardedTo(typeof(DnsEndPoint))]
[assembly: TypeForwardedTo(typeof(DownloadDataCompletedEventArgs))]
[assembly: TypeForwardedTo(typeof(DownloadDataCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(DownloadProgressChangedEventArgs))]
[assembly: TypeForwardedTo(typeof(DownloadProgressChangedEventHandler))]
[assembly: TypeForwardedTo(typeof(DownloadStringCompletedEventArgs))]
[assembly: TypeForwardedTo(typeof(DownloadStringCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(EndPoint))]
[assembly: TypeForwardedTo(typeof(FileWebRequest))]
[assembly: TypeForwardedTo(typeof(FileWebResponse))]
[assembly: TypeForwardedTo(typeof(FtpStatusCode))]
[assembly: TypeForwardedTo(typeof(FtpWebRequest))]
[assembly: TypeForwardedTo(typeof(FtpWebResponse))]
[assembly: TypeForwardedTo(typeof(GlobalProxySelection))]
[assembly: TypeForwardedTo(typeof(ByteArrayContent))]
[assembly: TypeForwardedTo(typeof(ClientCertificateOption))]
[assembly: TypeForwardedTo(typeof(DelegatingHandler))]
[assembly: TypeForwardedTo(typeof(FormUrlEncodedContent))]
[assembly: TypeForwardedTo(typeof(AuthenticationHeaderValue))]
[assembly: TypeForwardedTo(typeof(CacheControlHeaderValue))]
[assembly: TypeForwardedTo(typeof(ContentDispositionHeaderValue))]
[assembly: TypeForwardedTo(typeof(ContentRangeHeaderValue))]
[assembly: TypeForwardedTo(typeof(EntityTagHeaderValue))]
[assembly: TypeForwardedTo(typeof(HttpContentHeaders))]
[assembly: TypeForwardedTo(typeof(HttpHeaders))]
[assembly: TypeForwardedTo(typeof(HttpHeaderValueCollection<>))]
[assembly: TypeForwardedTo(typeof(HttpRequestHeaders))]
[assembly: TypeForwardedTo(typeof(HttpResponseHeaders))]
[assembly: TypeForwardedTo(typeof(MediaTypeHeaderValue))]
[assembly: TypeForwardedTo(typeof(MediaTypeWithQualityHeaderValue))]
[assembly: TypeForwardedTo(typeof(NameValueHeaderValue))]
[assembly: TypeForwardedTo(typeof(NameValueWithParametersHeaderValue))]
[assembly: TypeForwardedTo(typeof(ProductHeaderValue))]
[assembly: TypeForwardedTo(typeof(ProductInfoHeaderValue))]
[assembly: TypeForwardedTo(typeof(RangeConditionHeaderValue))]
[assembly: TypeForwardedTo(typeof(RangeHeaderValue))]
[assembly: TypeForwardedTo(typeof(RangeItemHeaderValue))]
[assembly: TypeForwardedTo(typeof(RetryConditionHeaderValue))]
[assembly: TypeForwardedTo(typeof(StringWithQualityHeaderValue))]
[assembly: TypeForwardedTo(typeof(TransferCodingHeaderValue))]
[assembly: TypeForwardedTo(typeof(TransferCodingWithQualityHeaderValue))]
[assembly: TypeForwardedTo(typeof(ViaHeaderValue))]
[assembly: TypeForwardedTo(typeof(WarningHeaderValue))]
[assembly: TypeForwardedTo(typeof(HttpClient))]
[assembly: TypeForwardedTo(typeof(HttpClientHandler))]
[assembly: TypeForwardedTo(typeof(HttpCompletionOption))]
[assembly: TypeForwardedTo(typeof(HttpContent))]
[assembly: TypeForwardedTo(typeof(HttpMessageHandler))]
[assembly: TypeForwardedTo(typeof(HttpMessageInvoker))]
[assembly: TypeForwardedTo(typeof(HttpMethod))]
[assembly: TypeForwardedTo(typeof(HttpRequestException))]
[assembly: TypeForwardedTo(typeof(HttpRequestMessage))]
[assembly: TypeForwardedTo(typeof(HttpResponseMessage))]
[assembly: TypeForwardedTo(typeof(MessageProcessingHandler))]
[assembly: TypeForwardedTo(typeof(MultipartContent))]
[assembly: TypeForwardedTo(typeof(MultipartFormDataContent))]
[assembly: TypeForwardedTo(typeof(StreamContent))]
[assembly: TypeForwardedTo(typeof(StringContent))]
[assembly: TypeForwardedTo(typeof(HttpContinueDelegate))]
[assembly: TypeForwardedTo(typeof(HttpListener))]
[assembly: TypeForwardedTo(typeof(HttpListenerBasicIdentity))]
[assembly: TypeForwardedTo(typeof(HttpListenerContext))]
[assembly: TypeForwardedTo(typeof(HttpListenerException))]
[assembly: TypeForwardedTo(typeof(HttpListenerPrefixCollection))]
[assembly: TypeForwardedTo(typeof(HttpListenerRequest))]
[assembly: TypeForwardedTo(typeof(HttpListenerResponse))]
[assembly: TypeForwardedTo(typeof(HttpListenerTimeoutManager))]
[assembly: TypeForwardedTo(typeof(HttpRequestHeader))]
[assembly: TypeForwardedTo(typeof(HttpResponseHeader))]
[assembly: TypeForwardedTo(typeof(HttpStatusCode))]
[assembly: TypeForwardedTo(typeof(HttpVersion))]
[assembly: TypeForwardedTo(typeof(HttpWebRequest))]
[assembly: TypeForwardedTo(typeof(HttpWebResponse))]
[assembly: TypeForwardedTo(typeof(IAuthenticationModule))]
[assembly: TypeForwardedTo(typeof(ICredentialPolicy))]
[assembly: TypeForwardedTo(typeof(ICredentials))]
[assembly: TypeForwardedTo(typeof(ICredentialsByHost))]
[assembly: TypeForwardedTo(typeof(IPAddress))]
[assembly: TypeForwardedTo(typeof(IPEndPoint))]
[assembly: TypeForwardedTo(typeof(IPHostEntry))]
[assembly: TypeForwardedTo(typeof(IWebProxy))]
[assembly: TypeForwardedTo(typeof(IWebProxyScript))]
[assembly: TypeForwardedTo(typeof(IWebRequestCreate))]
[assembly: TypeForwardedTo(typeof(AlternateView))]
[assembly: TypeForwardedTo(typeof(AlternateViewCollection))]
[assembly: TypeForwardedTo(typeof(Attachment))]
[assembly: TypeForwardedTo(typeof(AttachmentBase))]
[assembly: TypeForwardedTo(typeof(AttachmentCollection))]
[assembly: TypeForwardedTo(typeof(DeliveryNotificationOptions))]
[assembly: TypeForwardedTo(typeof(LinkedResource))]
[assembly: TypeForwardedTo(typeof(LinkedResourceCollection))]
[assembly: TypeForwardedTo(typeof(MailAddress))]
[assembly: TypeForwardedTo(typeof(MailAddressCollection))]
[assembly: TypeForwardedTo(typeof(MailMessage))]
[assembly: TypeForwardedTo(typeof(MailPriority))]
[assembly: TypeForwardedTo(typeof(SendCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(SmtpClient))]
[assembly: TypeForwardedTo(typeof(SmtpDeliveryFormat))]
[assembly: TypeForwardedTo(typeof(SmtpDeliveryMethod))]
[assembly: TypeForwardedTo(typeof(SmtpException))]
[assembly: TypeForwardedTo(typeof(SmtpFailedRecipientException))]
[assembly: TypeForwardedTo(typeof(SmtpFailedRecipientsException))]
[assembly: TypeForwardedTo(typeof(SmtpStatusCode))]
[assembly: TypeForwardedTo(typeof(ContentDisposition))]
[assembly: TypeForwardedTo(typeof(ContentType))]
[assembly: TypeForwardedTo(typeof(DispositionTypeNames))]
[assembly: TypeForwardedTo(typeof(MediaTypeNames))]
[assembly: TypeForwardedTo(typeof(TransferEncoding))]
[assembly: TypeForwardedTo(typeof(NetworkCredential))]
[assembly: TypeForwardedTo(typeof(DuplicateAddressDetectionState))]
[assembly: TypeForwardedTo(typeof(GatewayIPAddressInformation))]
[assembly: TypeForwardedTo(typeof(GatewayIPAddressInformationCollection))]
[assembly: TypeForwardedTo(typeof(IcmpV4Statistics))]
[assembly: TypeForwardedTo(typeof(IcmpV6Statistics))]
[assembly: TypeForwardedTo(typeof(IPAddressCollection))]
[assembly: TypeForwardedTo(typeof(IPAddressInformation))]
[assembly: TypeForwardedTo(typeof(IPAddressInformationCollection))]
[assembly: TypeForwardedTo(typeof(IPGlobalProperties))]
[assembly: TypeForwardedTo(typeof(IPGlobalStatistics))]
[assembly: TypeForwardedTo(typeof(IPInterfaceProperties))]
[assembly: TypeForwardedTo(typeof(IPInterfaceStatistics))]
[assembly: TypeForwardedTo(typeof(IPStatus))]
[assembly: TypeForwardedTo(typeof(IPv4InterfaceProperties))]
[assembly: TypeForwardedTo(typeof(IPv4InterfaceStatistics))]
[assembly: TypeForwardedTo(typeof(IPv6InterfaceProperties))]
[assembly: TypeForwardedTo(typeof(MulticastIPAddressInformation))]
[assembly: TypeForwardedTo(typeof(MulticastIPAddressInformationCollection))]
[assembly: TypeForwardedTo(typeof(NetBiosNodeType))]
[assembly: TypeForwardedTo(typeof(NetworkAddressChangedEventHandler))]
[assembly: TypeForwardedTo(typeof(NetworkAvailabilityChangedEventHandler))]
[assembly: TypeForwardedTo(typeof(NetworkAvailabilityEventArgs))]
[assembly: TypeForwardedTo(typeof(NetworkChange))]
[assembly: TypeForwardedTo(typeof(NetworkInformationException))]
[assembly: TypeForwardedTo(typeof(NetworkInterface))]
[assembly: TypeForwardedTo(typeof(NetworkInterfaceComponent))]
[assembly: TypeForwardedTo(typeof(NetworkInterfaceType))]
[assembly: TypeForwardedTo(typeof(OperationalStatus))]
[assembly: TypeForwardedTo(typeof(PhysicalAddress))]
[assembly: TypeForwardedTo(typeof(Ping))]
[assembly: TypeForwardedTo(typeof(PingCompletedEventArgs))]
[assembly: TypeForwardedTo(typeof(PingCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(PingException))]
[assembly: TypeForwardedTo(typeof(PingOptions))]
[assembly: TypeForwardedTo(typeof(PingReply))]
[assembly: TypeForwardedTo(typeof(PrefixOrigin))]
[assembly: TypeForwardedTo(typeof(ScopeLevel))]
[assembly: TypeForwardedTo(typeof(SuffixOrigin))]
[assembly: TypeForwardedTo(typeof(TcpConnectionInformation))]
[assembly: TypeForwardedTo(typeof(TcpState))]
[assembly: TypeForwardedTo(typeof(TcpStatistics))]
[assembly: TypeForwardedTo(typeof(UdpStatistics))]
[assembly: TypeForwardedTo(typeof(UnicastIPAddressInformation))]
[assembly: TypeForwardedTo(typeof(UnicastIPAddressInformationCollection))]
[assembly: TypeForwardedTo(typeof(OpenReadCompletedEventArgs))]
[assembly: TypeForwardedTo(typeof(OpenReadCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(OpenWriteCompletedEventArgs))]
[assembly: TypeForwardedTo(typeof(OpenWriteCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(ProtocolViolationException))]
[assembly: TypeForwardedTo(typeof(AuthenticatedStream))]
[assembly: TypeForwardedTo(typeof(AuthenticationLevel))]
[assembly: TypeForwardedTo(typeof(EncryptionPolicy))]
[assembly: TypeForwardedTo(typeof(LocalCertificateSelectionCallback))]
[assembly: TypeForwardedTo(typeof(NegotiateStream))]
[assembly: TypeForwardedTo(typeof(ProtectionLevel))]
[assembly: TypeForwardedTo(typeof(RemoteCertificateValidationCallback))]
[assembly: TypeForwardedTo(typeof(SslPolicyErrors))]
[assembly: TypeForwardedTo(typeof(SslStream))]
[assembly: TypeForwardedTo(typeof(SecurityProtocolType))]
[assembly: TypeForwardedTo(typeof(ServicePoint))]
[assembly: TypeForwardedTo(typeof(ServicePointManager))]
[assembly: TypeForwardedTo(typeof(SocketAddress))]
[assembly: TypeForwardedTo(typeof(AddressFamily))]
[assembly: TypeForwardedTo(typeof(IOControlCode))]
[assembly: TypeForwardedTo(typeof(IPPacketInformation))]
[assembly: TypeForwardedTo(typeof(IPProtectionLevel))]
[assembly: TypeForwardedTo(typeof(IPv6MulticastOption))]
[assembly: TypeForwardedTo(typeof(LingerOption))]
[assembly: TypeForwardedTo(typeof(MulticastOption))]
[assembly: TypeForwardedTo(typeof(NetworkStream))]
[assembly: TypeForwardedTo(typeof(ProtocolFamily))]
[assembly: TypeForwardedTo(typeof(ProtocolType))]
[assembly: TypeForwardedTo(typeof(SelectMode))]
[assembly: TypeForwardedTo(typeof(SendPacketsElement))]
[assembly: TypeForwardedTo(typeof(Socket))]
[assembly: TypeForwardedTo(typeof(SocketAsyncEventArgs))]
[assembly: TypeForwardedTo(typeof(SocketAsyncOperation))]
[assembly: TypeForwardedTo(typeof(SocketError))]
[assembly: TypeForwardedTo(typeof(SocketException))]
[assembly: TypeForwardedTo(typeof(SocketFlags))]
[assembly: TypeForwardedTo(typeof(SocketInformation))]
[assembly: TypeForwardedTo(typeof(SocketInformationOptions))]
[assembly: TypeForwardedTo(typeof(SocketOptionLevel))]
[assembly: TypeForwardedTo(typeof(SocketOptionName))]
[assembly: TypeForwardedTo(typeof(SocketReceiveFromResult))]
[assembly: TypeForwardedTo(typeof(SocketReceiveMessageFromResult))]
[assembly: TypeForwardedTo(typeof(SocketShutdown))]
[assembly: TypeForwardedTo(typeof(SocketTaskExtensions))]
[assembly: TypeForwardedTo(typeof(SocketType))]
[assembly: TypeForwardedTo(typeof(TcpClient))]
[assembly: TypeForwardedTo(typeof(TcpListener))]
[assembly: TypeForwardedTo(typeof(TransmitFileOptions))]
[assembly: TypeForwardedTo(typeof(UdpClient))]
[assembly: TypeForwardedTo(typeof(UdpReceiveResult))]
[assembly: TypeForwardedTo(typeof(TransportContext))]
[assembly: TypeForwardedTo(typeof(UploadDataCompletedEventArgs))]
[assembly: TypeForwardedTo(typeof(UploadDataCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(UploadFileCompletedEventArgs))]
[assembly: TypeForwardedTo(typeof(UploadFileCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(UploadProgressChangedEventArgs))]
[assembly: TypeForwardedTo(typeof(UploadProgressChangedEventHandler))]
[assembly: TypeForwardedTo(typeof(UploadStringCompletedEventArgs))]
[assembly: TypeForwardedTo(typeof(UploadStringCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(UploadValuesCompletedEventArgs))]
[assembly: TypeForwardedTo(typeof(UploadValuesCompletedEventHandler))]
[assembly: TypeForwardedTo(typeof(WebClient))]
[assembly: TypeForwardedTo(typeof(WebException))]
[assembly: TypeForwardedTo(typeof(WebExceptionStatus))]
[assembly: TypeForwardedTo(typeof(WebHeaderCollection))]
[assembly: TypeForwardedTo(typeof(WebProxy))]
[assembly: TypeForwardedTo(typeof(WebRequest))]
[assembly: TypeForwardedTo(typeof(WebRequestMethods))]
[assembly: TypeForwardedTo(typeof(WebResponse))]
[assembly: TypeForwardedTo(typeof(ClientWebSocket))]
[assembly: TypeForwardedTo(typeof(ClientWebSocketOptions))]
[assembly: TypeForwardedTo(typeof(HttpListenerWebSocketContext))]
[assembly: TypeForwardedTo(typeof(WebSocket))]
[assembly: TypeForwardedTo(typeof(WebSocketCloseStatus))]
[assembly: TypeForwardedTo(typeof(WebSocketContext))]
[assembly: TypeForwardedTo(typeof(WebSocketError))]
[assembly: TypeForwardedTo(typeof(WebSocketException))]
[assembly: TypeForwardedTo(typeof(WebSocketMessageType))]
[assembly: TypeForwardedTo(typeof(WebSocketReceiveResult))]
[assembly: TypeForwardedTo(typeof(WebSocketState))]
[assembly: TypeForwardedTo(typeof(WebUtility))]
[assembly: TypeForwardedTo(typeof(NetPipeStyleUriParser))]
[assembly: TypeForwardedTo(typeof(NetTcpStyleUriParser))]
[assembly: TypeForwardedTo(typeof(NewsStyleUriParser))]
[assembly: TypeForwardedTo(typeof(NonSerializedAttribute))]
[assembly: TypeForwardedTo(typeof(NotFiniteNumberException))]
[assembly: TypeForwardedTo(typeof(NotImplementedException))]
[assembly: TypeForwardedTo(typeof(NotSupportedException))]
[assembly: TypeForwardedTo(typeof(Nullable))]
[assembly: TypeForwardedTo(typeof(Nullable<>))]
[assembly: TypeForwardedTo(typeof(NullReferenceException))]
[assembly: TypeForwardedTo(typeof(BigInteger))]
[assembly: TypeForwardedTo(typeof(Complex))]
[assembly: TypeForwardedTo(typeof(object))]
[assembly: TypeForwardedTo(typeof(ObjectDisposedException))]
[assembly: TypeForwardedTo(typeof(ObsoleteAttribute))]
[assembly: TypeForwardedTo(typeof(OperatingSystem))]
[assembly: TypeForwardedTo(typeof(OperationCanceledException))]
[assembly: TypeForwardedTo(typeof(OutOfMemoryException))]
[assembly: TypeForwardedTo(typeof(OverflowException))]
[assembly: TypeForwardedTo(typeof(ParamArrayAttribute))]
[assembly: TypeForwardedTo(typeof(PlatformID))]
[assembly: TypeForwardedTo(typeof(PlatformNotSupportedException))]
[assembly: TypeForwardedTo(typeof(Predicate<>))]
[assembly: TypeForwardedTo(typeof(Progress<>))]
[assembly: TypeForwardedTo(typeof(Random))]
[assembly: TypeForwardedTo(typeof(RankException))]
[assembly: TypeForwardedTo(typeof(AmbiguousMatchException))]
[assembly: TypeForwardedTo(typeof(Assembly))]
[assembly: TypeForwardedTo(typeof(AssemblyAlgorithmIdAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyCompanyAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyConfigurationAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyContentType))]
[assembly: TypeForwardedTo(typeof(AssemblyCopyrightAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyCultureAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyDefaultAliasAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyDelaySignAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyDescriptionAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyFileVersionAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyFlagsAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyInformationalVersionAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyKeyFileAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyKeyNameAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyMetadataAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyName))]
[assembly: TypeForwardedTo(typeof(AssemblyNameFlags))]
[assembly: TypeForwardedTo(typeof(AssemblyNameProxy))]
[assembly: TypeForwardedTo(typeof(AssemblyProductAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblySignatureKeyAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyTitleAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyTrademarkAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyVersionAttribute))]
[assembly: TypeForwardedTo(typeof(Binder))]
[assembly: TypeForwardedTo(typeof(BindingFlags))]
[assembly: TypeForwardedTo(typeof(CallingConventions))]
[assembly: TypeForwardedTo(typeof(ConstructorInfo))]
[assembly: TypeForwardedTo(typeof(CustomAttributeData))]
[assembly: TypeForwardedTo(typeof(CustomAttributeExtensions))]
[assembly: TypeForwardedTo(typeof(CustomAttributeFormatException))]
[assembly: TypeForwardedTo(typeof(CustomAttributeNamedArgument))]
[assembly: TypeForwardedTo(typeof(CustomAttributeTypedArgument))]
[assembly: TypeForwardedTo(typeof(DefaultMemberAttribute))]
[assembly: TypeForwardedTo(typeof(FlowControl))]
[assembly: TypeForwardedTo(typeof(OpCode))]
[assembly: TypeForwardedTo(typeof(OpCodes))]
[assembly: TypeForwardedTo(typeof(OpCodeType))]
[assembly: TypeForwardedTo(typeof(OperandType))]
[assembly: TypeForwardedTo(typeof(PackingSize))]
[assembly: TypeForwardedTo(typeof(StackBehaviour))]
[assembly: TypeForwardedTo(typeof(EventAttributes))]
[assembly: TypeForwardedTo(typeof(EventInfo))]
[assembly: TypeForwardedTo(typeof(ExceptionHandlingClause))]
[assembly: TypeForwardedTo(typeof(ExceptionHandlingClauseOptions))]
[assembly: TypeForwardedTo(typeof(FieldAttributes))]
[assembly: TypeForwardedTo(typeof(FieldInfo))]
[assembly: TypeForwardedTo(typeof(GenericParameterAttributes))]
[assembly: TypeForwardedTo(typeof(ICustomAttributeProvider))]
[assembly: TypeForwardedTo(typeof(ImageFileMachine))]
[assembly: TypeForwardedTo(typeof(InterfaceMapping))]
[assembly: TypeForwardedTo(typeof(IntrospectionExtensions))]
[assembly: TypeForwardedTo(typeof(InvalidFilterCriteriaException))]
[assembly: TypeForwardedTo(typeof(IReflect))]
[assembly: TypeForwardedTo(typeof(IReflectableType))]
[assembly: TypeForwardedTo(typeof(LocalVariableInfo))]
[assembly: TypeForwardedTo(typeof(ManifestResourceInfo))]
[assembly: TypeForwardedTo(typeof(MemberFilter))]
[assembly: TypeForwardedTo(typeof(MemberInfo))]
[assembly: TypeForwardedTo(typeof(MemberTypes))]
[assembly: TypeForwardedTo(typeof(MethodAttributes))]
[assembly: TypeForwardedTo(typeof(MethodBase))]
[assembly: TypeForwardedTo(typeof(MethodBody))]
[assembly: TypeForwardedTo(typeof(MethodImplAttributes))]
[assembly: TypeForwardedTo(typeof(MethodInfo))]
[assembly: TypeForwardedTo(typeof(Missing))]
[assembly: TypeForwardedTo(typeof(Module))]
[assembly: TypeForwardedTo(typeof(ModuleResolveEventHandler))]
[assembly: TypeForwardedTo(typeof(ObfuscateAssemblyAttribute))]
[assembly: TypeForwardedTo(typeof(ObfuscationAttribute))]
[assembly: TypeForwardedTo(typeof(ParameterAttributes))]
[assembly: TypeForwardedTo(typeof(ParameterInfo))]
[assembly: TypeForwardedTo(typeof(ParameterModifier))]
[assembly: TypeForwardedTo(typeof(Pointer))]
[assembly: TypeForwardedTo(typeof(PortableExecutableKinds))]
[assembly: TypeForwardedTo(typeof(ProcessorArchitecture))]
[assembly: TypeForwardedTo(typeof(PropertyAttributes))]
[assembly: TypeForwardedTo(typeof(PropertyInfo))]
[assembly: TypeForwardedTo(typeof(ReflectionContext))]
[assembly: TypeForwardedTo(typeof(ReflectionTypeLoadException))]
[assembly: TypeForwardedTo(typeof(ResourceAttributes))]
[assembly: TypeForwardedTo(typeof(ResourceLocation))]
[assembly: TypeForwardedTo(typeof(RuntimeReflectionExtensions))]
[assembly: TypeForwardedTo(typeof(StrongNameKeyPair))]
[assembly: TypeForwardedTo(typeof(TargetException))]
[assembly: TypeForwardedTo(typeof(TargetInvocationException))]
[assembly: TypeForwardedTo(typeof(TargetParameterCountException))]
[assembly: TypeForwardedTo(typeof(TypeAttributes))]
[assembly: TypeForwardedTo(typeof(TypeDelegator))]
[assembly: TypeForwardedTo(typeof(TypeFilter))]
[assembly: TypeForwardedTo(typeof(TypeInfo))]
[assembly: TypeForwardedTo(typeof(ResolveEventArgs))]
[assembly: TypeForwardedTo(typeof(ResolveEventHandler))]
[assembly: TypeForwardedTo(typeof(IResourceReader))]
[assembly: TypeForwardedTo(typeof(IResourceWriter))]
[assembly: TypeForwardedTo(typeof(MissingManifestResourceException))]
[assembly: TypeForwardedTo(typeof(MissingSatelliteAssemblyException))]
[assembly: TypeForwardedTo(typeof(NeutralResourcesLanguageAttribute))]
[assembly: TypeForwardedTo(typeof(ResourceManager))]
[assembly: TypeForwardedTo(typeof(ResourceReader))]
[assembly: TypeForwardedTo(typeof(ResourceSet))]
[assembly: TypeForwardedTo(typeof(ResourceWriter))]
[assembly: TypeForwardedTo(typeof(SatelliteContractVersionAttribute))]
[assembly: TypeForwardedTo(typeof(UltimateResourceFallbackLocation))]
[assembly: TypeForwardedTo(typeof(AssemblyTargetedPatchBandAttribute))]
[assembly: TypeForwardedTo(typeof(AccessedThroughPropertyAttribute))]
[assembly: TypeForwardedTo(typeof(AsyncStateMachineAttribute))]
[assembly: TypeForwardedTo(typeof(AsyncTaskMethodBuilder))]
[assembly: TypeForwardedTo(typeof(AsyncTaskMethodBuilder<>))]
[assembly: TypeForwardedTo(typeof(AsyncVoidMethodBuilder))]
[assembly: TypeForwardedTo(typeof(CallConvCdecl))]
[assembly: TypeForwardedTo(typeof(CallConvFastcall))]
[assembly: TypeForwardedTo(typeof(CallConvStdcall))]
[assembly: TypeForwardedTo(typeof(CallConvThiscall))]
[assembly: TypeForwardedTo(typeof(CallerFilePathAttribute))]
[assembly: TypeForwardedTo(typeof(CallerLineNumberAttribute))]
[assembly: TypeForwardedTo(typeof(CallerMemberNameAttribute))]
[assembly: TypeForwardedTo(typeof(CallSite))]
[assembly: TypeForwardedTo(typeof(CallSiteBinder))]
[assembly: TypeForwardedTo(typeof(CallSiteHelpers))]
[assembly: TypeForwardedTo(typeof(CallSite<>))]
[assembly: TypeForwardedTo(typeof(CompilationRelaxations))]
[assembly: TypeForwardedTo(typeof(CompilationRelaxationsAttribute))]
[assembly: TypeForwardedTo(typeof(CompilerGeneratedAttribute))]
[assembly: TypeForwardedTo(typeof(CompilerGlobalScopeAttribute))]
[assembly: TypeForwardedTo(typeof(CompilerMarshalOverride))]
[assembly: TypeForwardedTo(typeof(ConditionalWeakTable<, >))]
[assembly: TypeForwardedTo(typeof(ConfiguredTaskAwaitable))]
[assembly: TypeForwardedTo(typeof(ConfiguredTaskAwaitable<>))]
[assembly: TypeForwardedTo(typeof(ContractHelper))]
[assembly: TypeForwardedTo(typeof(CustomConstantAttribute))]
[assembly: TypeForwardedTo(typeof(DateTimeConstantAttribute))]
[assembly: TypeForwardedTo(typeof(DebugInfoGenerator))]
[assembly: TypeForwardedTo(typeof(DecimalConstantAttribute))]
[assembly: TypeForwardedTo(typeof(DefaultDependencyAttribute))]
[assembly: TypeForwardedTo(typeof(DependencyAttribute))]
[assembly: TypeForwardedTo(typeof(DisablePrivateReflectionAttribute))]
[assembly: TypeForwardedTo(typeof(DiscardableAttribute))]
[assembly: TypeForwardedTo(typeof(DynamicAttribute))]
[assembly: TypeForwardedTo(typeof(ExtensionAttribute))]
[assembly: TypeForwardedTo(typeof(FixedAddressValueTypeAttribute))]
[assembly: TypeForwardedTo(typeof(FixedBufferAttribute))]
[assembly: TypeForwardedTo(typeof(FormattableStringFactory))]
[assembly: TypeForwardedTo(typeof(HasCopySemanticsAttribute))]
[assembly: TypeForwardedTo(typeof(IAsyncStateMachine))]
[assembly: TypeForwardedTo(typeof(ICriticalNotifyCompletion))]
[assembly: TypeForwardedTo(typeof(IndexerNameAttribute))]
[assembly: TypeForwardedTo(typeof(INotifyCompletion))]
[assembly: TypeForwardedTo(typeof(InternalsVisibleToAttribute))]
[assembly: TypeForwardedTo(typeof(IRuntimeVariables))]
[assembly: TypeForwardedTo(typeof(IsBoxed))]
[assembly: TypeForwardedTo(typeof(IsByValue))]
[assembly: TypeForwardedTo(typeof(IsConst))]
[assembly: TypeForwardedTo(typeof(IsCopyConstructed))]
[assembly: TypeForwardedTo(typeof(IsExplicitlyDereferenced))]
[assembly: TypeForwardedTo(typeof(IsImplicitlyDereferenced))]
[assembly: TypeForwardedTo(typeof(IsJitIntrinsic))]
[assembly: TypeForwardedTo(typeof(IsLong))]
[assembly: TypeForwardedTo(typeof(IsPinned))]
[assembly: TypeForwardedTo(typeof(IsSignUnspecifiedByte))]
[assembly: TypeForwardedTo(typeof(IStrongBox))]
[assembly: TypeForwardedTo(typeof(IsUdtReturn))]
[assembly: TypeForwardedTo(typeof(IsVolatile))]
[assembly: TypeForwardedTo(typeof(IteratorStateMachineAttribute))]
[assembly: TypeForwardedTo(typeof(IUnknownConstantAttribute))]
[assembly: TypeForwardedTo(typeof(LoadHint))]
[assembly: TypeForwardedTo(typeof(MethodCodeType))]
[assembly: TypeForwardedTo(typeof(MethodImplAttribute))]
[assembly: TypeForwardedTo(typeof(MethodImplOptions))]
[assembly: TypeForwardedTo(typeof(NativeCppClassAttribute))]
[assembly: TypeForwardedTo(typeof(ReadOnlyCollectionBuilder<>))]
[assembly: TypeForwardedTo(typeof(ReferenceAssemblyAttribute))]
[assembly: TypeForwardedTo(typeof(RequiredAttributeAttribute))]
[assembly: TypeForwardedTo(typeof(RuleCache<>))]
[assembly: TypeForwardedTo(typeof(RuntimeCompatibilityAttribute))]
[assembly: TypeForwardedTo(typeof(RuntimeHelpers))]
[assembly: TypeForwardedTo(typeof(RuntimeWrappedException))]
[assembly: TypeForwardedTo(typeof(ScopelessEnumAttribute))]
[assembly: TypeForwardedTo(typeof(SpecialNameAttribute))]
[assembly: TypeForwardedTo(typeof(StateMachineAttribute))]
[assembly: TypeForwardedTo(typeof(StringFreezingAttribute))]
[assembly: TypeForwardedTo(typeof(StrongBox<>))]
[assembly: TypeForwardedTo(typeof(SuppressIldasmAttribute))]
[assembly: TypeForwardedTo(typeof(TaskAwaiter))]
[assembly: TypeForwardedTo(typeof(TaskAwaiter<>))]
[assembly: TypeForwardedTo(typeof(TupleElementNamesAttribute))]
[assembly: TypeForwardedTo(typeof(TypeForwardedFromAttribute))]
[assembly: TypeForwardedTo(typeof(TypeForwardedToAttribute))]
[assembly: TypeForwardedTo(typeof(UnsafeValueTypeAttribute))]
[assembly: TypeForwardedTo(typeof(YieldAwaitable))]
[assembly: TypeForwardedTo(typeof(Cer))]
[assembly: TypeForwardedTo(typeof(Consistency))]
[assembly: TypeForwardedTo(typeof(CriticalFinalizerObject))]
[assembly: TypeForwardedTo(typeof(PrePrepareMethodAttribute))]
[assembly: TypeForwardedTo(typeof(ReliabilityContractAttribute))]
[assembly: TypeForwardedTo(typeof(ExceptionDispatchInfo))]
[assembly: TypeForwardedTo(typeof(FirstChanceExceptionEventArgs))]
[assembly: TypeForwardedTo(typeof(HandleProcessCorruptedStateExceptionsAttribute))]
[assembly: TypeForwardedTo(typeof(GCLargeObjectHeapCompactionMode))]
[assembly: TypeForwardedTo(typeof(GCLatencyMode))]
[assembly: TypeForwardedTo(typeof(GCSettings))]
[assembly: TypeForwardedTo(typeof(AllowReversePInvokeCallsAttribute))]
[assembly: TypeForwardedTo(typeof(Architecture))]
[assembly: TypeForwardedTo(typeof(ArrayWithOffset))]
[assembly: TypeForwardedTo(typeof(BestFitMappingAttribute))]
[assembly: TypeForwardedTo(typeof(BStrWrapper))]
[assembly: TypeForwardedTo(typeof(CallingConvention))]
[assembly: TypeForwardedTo(typeof(CharSet))]
[assembly: TypeForwardedTo(typeof(ClassInterfaceAttribute))]
[assembly: TypeForwardedTo(typeof(ClassInterfaceType))]
[assembly: TypeForwardedTo(typeof(CoClassAttribute))]
[assembly: TypeForwardedTo(typeof(ComAliasNameAttribute))]
[assembly: TypeForwardedTo(typeof(ComAwareEventInfo))]
[assembly: TypeForwardedTo(typeof(ComCompatibleVersionAttribute))]
[assembly: TypeForwardedTo(typeof(ComConversionLossAttribute))]
[assembly: TypeForwardedTo(typeof(ComDefaultInterfaceAttribute))]
[assembly: TypeForwardedTo(typeof(ComEventInterfaceAttribute))]
[assembly: TypeForwardedTo(typeof(ComEventsHelper))]
[assembly: TypeForwardedTo(typeof(COMException))]
[assembly: TypeForwardedTo(typeof(ComImportAttribute))]
[assembly: TypeForwardedTo(typeof(ComInterfaceType))]
[assembly: TypeForwardedTo(typeof(ComMemberType))]
[assembly: TypeForwardedTo(typeof(ComRegisterFunctionAttribute))]
[assembly: TypeForwardedTo(typeof(ComSourceInterfacesAttribute))]
[assembly: TypeForwardedTo(typeof(ADVF))]
[assembly: TypeForwardedTo(typeof(BINDPTR))]
[assembly: TypeForwardedTo(typeof(BIND_OPTS))]
[assembly: TypeForwardedTo(typeof(CALLCONV))]
[assembly: TypeForwardedTo(typeof(CONNECTDATA))]
[assembly: TypeForwardedTo(typeof(DATADIR))]
[assembly: TypeForwardedTo(typeof(DESCKIND))]
[assembly: TypeForwardedTo(typeof(DISPPARAMS))]
[assembly: TypeForwardedTo(typeof(DVASPECT))]
[assembly: TypeForwardedTo(typeof(ELEMDESC))]
[assembly: TypeForwardedTo(typeof(EXCEPINFO))]
[assembly: TypeForwardedTo(typeof(FILETIME))]
[assembly: TypeForwardedTo(typeof(FORMATETC))]
[assembly: TypeForwardedTo(typeof(FUNCDESC))]
[assembly: TypeForwardedTo(typeof(FUNCFLAGS))]
[assembly: TypeForwardedTo(typeof(FUNCKIND))]
[assembly: TypeForwardedTo(typeof(IAdviseSink))]
[assembly: TypeForwardedTo(typeof(IBindCtx))]
[assembly: TypeForwardedTo(typeof(IConnectionPoint))]
[assembly: TypeForwardedTo(typeof(IConnectionPointContainer))]
[assembly: TypeForwardedTo(typeof(IDataObject))]
[assembly: TypeForwardedTo(typeof(IDLDESC))]
[assembly: TypeForwardedTo(typeof(IDLFLAG))]
[assembly: TypeForwardedTo(typeof(IEnumConnectionPoints))]
[assembly: TypeForwardedTo(typeof(IEnumConnections))]
[assembly: TypeForwardedTo(typeof(IEnumFORMATETC))]
[assembly: TypeForwardedTo(typeof(IEnumMoniker))]
[assembly: TypeForwardedTo(typeof(IEnumSTATDATA))]
[assembly: TypeForwardedTo(typeof(IEnumString))]
[assembly: TypeForwardedTo(typeof(IEnumVARIANT))]
[assembly: TypeForwardedTo(typeof(IMoniker))]
[assembly: TypeForwardedTo(typeof(IMPLTYPEFLAGS))]
[assembly: TypeForwardedTo(typeof(INVOKEKIND))]
[assembly: TypeForwardedTo(typeof(IPersistFile))]
[assembly: TypeForwardedTo(typeof(IRunningObjectTable))]
[assembly: TypeForwardedTo(typeof(IStream))]
[assembly: TypeForwardedTo(typeof(ITypeComp))]
[assembly: TypeForwardedTo(typeof(ITypeInfo))]
[assembly: TypeForwardedTo(typeof(ITypeInfo2))]
[assembly: TypeForwardedTo(typeof(ITypeLib))]
[assembly: TypeForwardedTo(typeof(ITypeLib2))]
[assembly: TypeForwardedTo(typeof(LIBFLAGS))]
[assembly: TypeForwardedTo(typeof(PARAMDESC))]
[assembly: TypeForwardedTo(typeof(PARAMFLAG))]
[assembly: TypeForwardedTo(typeof(STATDATA))]
[assembly: TypeForwardedTo(typeof(STATSTG))]
[assembly: TypeForwardedTo(typeof(STGMEDIUM))]
[assembly: TypeForwardedTo(typeof(SYSKIND))]
[assembly: TypeForwardedTo(typeof(TYMED))]
[assembly: TypeForwardedTo(typeof(TYPEATTR))]
[assembly: TypeForwardedTo(typeof(TYPEDESC))]
[assembly: TypeForwardedTo(typeof(TYPEFLAGS))]
[assembly: TypeForwardedTo(typeof(TYPEKIND))]
[assembly: TypeForwardedTo(typeof(TYPELIBATTR))]
[assembly: TypeForwardedTo(typeof(VARDESC))]
[assembly: TypeForwardedTo(typeof(VARFLAGS))]
[assembly: TypeForwardedTo(typeof(VARKIND))]
[assembly: TypeForwardedTo(typeof(ComUnregisterFunctionAttribute))]
[assembly: TypeForwardedTo(typeof(ComVisibleAttribute))]
[assembly: TypeForwardedTo(typeof(CriticalHandle))]
[assembly: TypeForwardedTo(typeof(CurrencyWrapper))]
[assembly: TypeForwardedTo(typeof(CustomQueryInterfaceMode))]
[assembly: TypeForwardedTo(typeof(CustomQueryInterfaceResult))]
[assembly: TypeForwardedTo(typeof(DefaultCharSetAttribute))]
[assembly: TypeForwardedTo(typeof(DefaultDllImportSearchPathsAttribute))]
[assembly: TypeForwardedTo(typeof(DefaultParameterValueAttribute))]
[assembly: TypeForwardedTo(typeof(DispatchWrapper))]
[assembly: TypeForwardedTo(typeof(DispIdAttribute))]
[assembly: TypeForwardedTo(typeof(DllImportAttribute))]
[assembly: TypeForwardedTo(typeof(DllImportSearchPath))]
[assembly: TypeForwardedTo(typeof(ErrorWrapper))]
[assembly: TypeForwardedTo(typeof(ExternalException))]
[assembly: TypeForwardedTo(typeof(FieldOffsetAttribute))]
[assembly: TypeForwardedTo(typeof(GCHandle))]
[assembly: TypeForwardedTo(typeof(GCHandleType))]
[assembly: TypeForwardedTo(typeof(GuidAttribute))]
[assembly: TypeForwardedTo(typeof(HandleCollector))]
[assembly: TypeForwardedTo(typeof(HandleRef))]
[assembly: TypeForwardedTo(typeof(ICustomAdapter))]
[assembly: TypeForwardedTo(typeof(ICustomFactory))]
[assembly: TypeForwardedTo(typeof(ICustomMarshaler))]
[assembly: TypeForwardedTo(typeof(ICustomQueryInterface))]
[assembly: TypeForwardedTo(typeof(InAttribute))]
[assembly: TypeForwardedTo(typeof(InterfaceTypeAttribute))]
[assembly: TypeForwardedTo(typeof(InvalidComObjectException))]
[assembly: TypeForwardedTo(typeof(InvalidOleVariantTypeException))]
[assembly: TypeForwardedTo(typeof(LayoutKind))]
[assembly: TypeForwardedTo(typeof(LCIDConversionAttribute))]
[assembly: TypeForwardedTo(typeof(Marshal))]
[assembly: TypeForwardedTo(typeof(MarshalAsAttribute))]
[assembly: TypeForwardedTo(typeof(MarshalDirectiveException))]
[assembly: TypeForwardedTo(typeof(OptionalAttribute))]
[assembly: TypeForwardedTo(typeof(OSPlatform))]
[assembly: TypeForwardedTo(typeof(OutAttribute))]
[assembly: TypeForwardedTo(typeof(PreserveSigAttribute))]
[assembly: TypeForwardedTo(typeof(PrimaryInteropAssemblyAttribute))]
[assembly: TypeForwardedTo(typeof(ProgIdAttribute))]
[assembly: TypeForwardedTo(typeof(RuntimeEnvironment))]
[assembly: TypeForwardedTo(typeof(RuntimeInformation))]
[assembly: TypeForwardedTo(typeof(SafeArrayRankMismatchException))]
[assembly: TypeForwardedTo(typeof(SafeArrayTypeMismatchException))]
[assembly: TypeForwardedTo(typeof(SafeBuffer))]
[assembly: TypeForwardedTo(typeof(SafeHandle))]
[assembly: TypeForwardedTo(typeof(SEHException))]
[assembly: TypeForwardedTo(typeof(StructLayoutAttribute))]
[assembly: TypeForwardedTo(typeof(TypeIdentifierAttribute))]
[assembly: TypeForwardedTo(typeof(UnknownWrapper))]
[assembly: TypeForwardedTo(typeof(UnmanagedFunctionPointerAttribute))]
[assembly: TypeForwardedTo(typeof(UnmanagedType))]
[assembly: TypeForwardedTo(typeof(VarEnum))]
[assembly: TypeForwardedTo(typeof(VariantWrapper))]
[assembly: TypeForwardedTo(typeof(MemoryFailPoint))]
[assembly: TypeForwardedTo(typeof(CollectionDataContractAttribute))]
[assembly: TypeForwardedTo(typeof(ContractNamespaceAttribute))]
[assembly: TypeForwardedTo(typeof(DataContractAttribute))]
[assembly: TypeForwardedTo(typeof(DataContractResolver))]
[assembly: TypeForwardedTo(typeof(DataContractSerializer))]
[assembly: TypeForwardedTo(typeof(DataContractSerializerExtensions))]
[assembly: TypeForwardedTo(typeof(DataContractSerializerSettings))]
[assembly: TypeForwardedTo(typeof(DataMemberAttribute))]
[assembly: TypeForwardedTo(typeof(DateTimeFormat))]
[assembly: TypeForwardedTo(typeof(EmitTypeInformation))]
[assembly: TypeForwardedTo(typeof(EnumMemberAttribute))]
[assembly: TypeForwardedTo(typeof(ExportOptions))]
[assembly: TypeForwardedTo(typeof(ExtensionDataObject))]
[assembly: TypeForwardedTo(typeof(Formatter))]
[assembly: TypeForwardedTo(typeof(FormatterConverter))]
[assembly: TypeForwardedTo(typeof(BinaryFormatter))]
[assembly: TypeForwardedTo(typeof(FormatterAssemblyStyle))]
[assembly: TypeForwardedTo(typeof(FormatterTypeStyle))]
[assembly: TypeForwardedTo(typeof(TypeFilterLevel))]
[assembly: TypeForwardedTo(typeof(FormatterServices))]
[assembly: TypeForwardedTo(typeof(IDeserializationCallback))]
[assembly: TypeForwardedTo(typeof(IExtensibleDataObject))]
[assembly: TypeForwardedTo(typeof(IFormatter))]
[assembly: TypeForwardedTo(typeof(IFormatterConverter))]
[assembly: TypeForwardedTo(typeof(IgnoreDataMemberAttribute))]
[assembly: TypeForwardedTo(typeof(InvalidDataContractException))]
[assembly: TypeForwardedTo(typeof(IObjectReference))]
[assembly: TypeForwardedTo(typeof(ISafeSerializationData))]
[assembly: TypeForwardedTo(typeof(ISerializable))]
[assembly: TypeForwardedTo(typeof(ISerializationSurrogate))]
[assembly: TypeForwardedTo(typeof(ISerializationSurrogateProvider))]
[assembly: TypeForwardedTo(typeof(ISurrogateSelector))]
[assembly: TypeForwardedTo(typeof(DataContractJsonSerializer))]
[assembly: TypeForwardedTo(typeof(DataContractJsonSerializerSettings))]
[assembly: TypeForwardedTo(typeof(IXmlJsonReaderInitializer))]
[assembly: TypeForwardedTo(typeof(IXmlJsonWriterInitializer))]
[assembly: TypeForwardedTo(typeof(JsonReaderWriterFactory))]
[assembly: TypeForwardedTo(typeof(KnownTypeAttribute))]
[assembly: TypeForwardedTo(typeof(ObjectIDGenerator))]
[assembly: TypeForwardedTo(typeof(ObjectManager))]
[assembly: TypeForwardedTo(typeof(OnDeserializedAttribute))]
[assembly: TypeForwardedTo(typeof(OnDeserializingAttribute))]
[assembly: TypeForwardedTo(typeof(OnSerializedAttribute))]
[assembly: TypeForwardedTo(typeof(OnSerializingAttribute))]
[assembly: TypeForwardedTo(typeof(OptionalFieldAttribute))]
[assembly: TypeForwardedTo(typeof(SafeSerializationEventArgs))]
[assembly: TypeForwardedTo(typeof(SerializationBinder))]
[assembly: TypeForwardedTo(typeof(SerializationEntry))]
[assembly: TypeForwardedTo(typeof(SerializationException))]
[assembly: TypeForwardedTo(typeof(SerializationInfo))]
[assembly: TypeForwardedTo(typeof(SerializationInfoEnumerator))]
[assembly: TypeForwardedTo(typeof(SerializationObjectManager))]
[assembly: TypeForwardedTo(typeof(StreamingContext))]
[assembly: TypeForwardedTo(typeof(StreamingContextStates))]
[assembly: TypeForwardedTo(typeof(SurrogateSelector))]
[assembly: TypeForwardedTo(typeof(XmlObjectSerializer))]
[assembly: TypeForwardedTo(typeof(XmlSerializableServices))]
[assembly: TypeForwardedTo(typeof(XPathQueryGenerator))]
[assembly: TypeForwardedTo(typeof(XsdDataContractExporter))]
[assembly: TypeForwardedTo(typeof(TargetedPatchingOptOutAttribute))]
[assembly: TypeForwardedTo(typeof(ComponentGuaranteesAttribute))]
[assembly: TypeForwardedTo(typeof(ComponentGuaranteesOptions))]
[assembly: TypeForwardedTo(typeof(FrameworkName))]
[assembly: TypeForwardedTo(typeof(ResourceConsumptionAttribute))]
[assembly: TypeForwardedTo(typeof(ResourceExposureAttribute))]
[assembly: TypeForwardedTo(typeof(ResourceScope))]
[assembly: TypeForwardedTo(typeof(TargetFrameworkAttribute))]
[assembly: TypeForwardedTo(typeof(VersioningHelper))]
[assembly: TypeForwardedTo(typeof(RuntimeArgumentHandle))]
[assembly: TypeForwardedTo(typeof(RuntimeFieldHandle))]
[assembly: TypeForwardedTo(typeof(RuntimeMethodHandle))]
[assembly: TypeForwardedTo(typeof(RuntimeTypeHandle))]
[assembly: TypeForwardedTo(typeof(sbyte))]
[assembly: TypeForwardedTo(typeof(AllowPartiallyTrustedCallersAttribute))]
[assembly: TypeForwardedTo(typeof(AuthenticationException))]
[assembly: TypeForwardedTo(typeof(CipherAlgorithmType))]
[assembly: TypeForwardedTo(typeof(ExchangeAlgorithmType))]
[assembly: TypeForwardedTo(typeof(ChannelBinding))]
[assembly: TypeForwardedTo(typeof(ChannelBindingKind))]
[assembly: TypeForwardedTo(typeof(ExtendedProtectionPolicy))]
[assembly: TypeForwardedTo(typeof(ExtendedProtectionPolicyTypeConverter))]
[assembly: TypeForwardedTo(typeof(PolicyEnforcement))]
[assembly: TypeForwardedTo(typeof(ProtectionScenario))]
[assembly: TypeForwardedTo(typeof(ServiceNameCollection))]
[assembly: TypeForwardedTo(typeof(HashAlgorithmType))]
[assembly: TypeForwardedTo(typeof(InvalidCredentialException))]
[assembly: TypeForwardedTo(typeof(SslProtocols))]
[assembly: TypeForwardedTo(typeof(Claim))]
[assembly: TypeForwardedTo(typeof(ClaimsIdentity))]
[assembly: TypeForwardedTo(typeof(ClaimsPrincipal))]
[assembly: TypeForwardedTo(typeof(ClaimTypes))]
[assembly: TypeForwardedTo(typeof(ClaimValueTypes))]
[assembly: TypeForwardedTo(typeof(Aes))]
[assembly: TypeForwardedTo(typeof(AesCryptoServiceProvider))]
[assembly: TypeForwardedTo(typeof(AesManaged))]
[assembly: TypeForwardedTo(typeof(AsnEncodedData))]
[assembly: TypeForwardedTo(typeof(AsnEncodedDataCollection))]
[assembly: TypeForwardedTo(typeof(AsnEncodedDataEnumerator))]
[assembly: TypeForwardedTo(typeof(AsymmetricAlgorithm))]
[assembly: TypeForwardedTo(typeof(AsymmetricKeyExchangeDeformatter))]
[assembly: TypeForwardedTo(typeof(AsymmetricKeyExchangeFormatter))]
[assembly: TypeForwardedTo(typeof(AsymmetricSignatureDeformatter))]
[assembly: TypeForwardedTo(typeof(AsymmetricSignatureFormatter))]
[assembly: TypeForwardedTo(typeof(CipherMode))]
[assembly: TypeForwardedTo(typeof(CryptoConfig))]
[assembly: TypeForwardedTo(typeof(CryptographicException))]
[assembly: TypeForwardedTo(typeof(CryptographicUnexpectedOperationException))]
[assembly: TypeForwardedTo(typeof(CryptoStream))]
[assembly: TypeForwardedTo(typeof(CryptoStreamMode))]
[assembly: TypeForwardedTo(typeof(CspKeyContainerInfo))]
[assembly: TypeForwardedTo(typeof(CspParameters))]
[assembly: TypeForwardedTo(typeof(CspProviderFlags))]
[assembly: TypeForwardedTo(typeof(DeriveBytes))]
[assembly: TypeForwardedTo(typeof(DES))]
[assembly: TypeForwardedTo(typeof(DESCryptoServiceProvider))]
[assembly: TypeForwardedTo(typeof(DSA))]
[assembly: TypeForwardedTo(typeof(DSACryptoServiceProvider))]
[assembly: TypeForwardedTo(typeof(DSAParameters))]
[assembly: TypeForwardedTo(typeof(DSASignatureDeformatter))]
[assembly: TypeForwardedTo(typeof(DSASignatureFormatter))]
[assembly: TypeForwardedTo(typeof(ECCurve))]
[assembly: TypeForwardedTo(typeof(ECDiffieHellmanPublicKey))]
[assembly: TypeForwardedTo(typeof(ECDsa))]
[assembly: TypeForwardedTo(typeof(ECParameters))]
[assembly: TypeForwardedTo(typeof(ECPoint))]
[assembly: TypeForwardedTo(typeof(FromBase64Transform))]
[assembly: TypeForwardedTo(typeof(FromBase64TransformMode))]
[assembly: TypeForwardedTo(typeof(HashAlgorithm))]
[assembly: TypeForwardedTo(typeof(HashAlgorithmName))]
[assembly: TypeForwardedTo(typeof(HMAC))]
[assembly: TypeForwardedTo(typeof(HMACMD5))]
[assembly: TypeForwardedTo(typeof(HMACSHA1))]
[assembly: TypeForwardedTo(typeof(HMACSHA256))]
[assembly: TypeForwardedTo(typeof(HMACSHA384))]
[assembly: TypeForwardedTo(typeof(HMACSHA512))]
[assembly: TypeForwardedTo(typeof(ICryptoTransform))]
[assembly: TypeForwardedTo(typeof(ICspAsymmetricAlgorithm))]
[assembly: TypeForwardedTo(typeof(IncrementalHash))]
[assembly: TypeForwardedTo(typeof(KeyedHashAlgorithm))]
[assembly: TypeForwardedTo(typeof(KeyNumber))]
[assembly: TypeForwardedTo(typeof(KeySizes))]
[assembly: TypeForwardedTo(typeof(MaskGenerationMethod))]
[assembly: TypeForwardedTo(typeof(MD5))]
[assembly: TypeForwardedTo(typeof(MD5CryptoServiceProvider))]
[assembly: TypeForwardedTo(typeof(Oid))]
[assembly: TypeForwardedTo(typeof(OidCollection))]
[assembly: TypeForwardedTo(typeof(OidEnumerator))]
[assembly: TypeForwardedTo(typeof(OidGroup))]
[assembly: TypeForwardedTo(typeof(PaddingMode))]
[assembly: TypeForwardedTo(typeof(PasswordDeriveBytes))]
[assembly: TypeForwardedTo(typeof(PKCS1MaskGenerationMethod))]
[assembly: TypeForwardedTo(typeof(RandomNumberGenerator))]
[assembly: TypeForwardedTo(typeof(RC2))]
[assembly: TypeForwardedTo(typeof(RC2CryptoServiceProvider))]
[assembly: TypeForwardedTo(typeof(Rfc2898DeriveBytes))]
[assembly: TypeForwardedTo(typeof(Rijndael))]
[assembly: TypeForwardedTo(typeof(RijndaelManaged))]
[assembly: TypeForwardedTo(typeof(RNGCryptoServiceProvider))]
[assembly: TypeForwardedTo(typeof(RSA))]
[assembly: TypeForwardedTo(typeof(RSACryptoServiceProvider))]
[assembly: TypeForwardedTo(typeof(RSAEncryptionPadding))]
[assembly: TypeForwardedTo(typeof(RSAEncryptionPaddingMode))]
[assembly: TypeForwardedTo(typeof(RSAOAEPKeyExchangeDeformatter))]
[assembly: TypeForwardedTo(typeof(RSAOAEPKeyExchangeFormatter))]
[assembly: TypeForwardedTo(typeof(RSAParameters))]
[assembly: TypeForwardedTo(typeof(RSAPKCS1KeyExchangeDeformatter))]
[assembly: TypeForwardedTo(typeof(RSAPKCS1KeyExchangeFormatter))]
[assembly: TypeForwardedTo(typeof(RSAPKCS1SignatureDeformatter))]
[assembly: TypeForwardedTo(typeof(RSAPKCS1SignatureFormatter))]
[assembly: TypeForwardedTo(typeof(RSASignaturePadding))]
[assembly: TypeForwardedTo(typeof(RSASignaturePaddingMode))]
[assembly: TypeForwardedTo(typeof(SHA1))]
[assembly: TypeForwardedTo(typeof(SHA1CryptoServiceProvider))]
[assembly: TypeForwardedTo(typeof(SHA1Managed))]
[assembly: TypeForwardedTo(typeof(SHA256))]
[assembly: TypeForwardedTo(typeof(SHA256CryptoServiceProvider))]
[assembly: TypeForwardedTo(typeof(SHA256Managed))]
[assembly: TypeForwardedTo(typeof(SHA384))]
[assembly: TypeForwardedTo(typeof(SHA384CryptoServiceProvider))]
[assembly: TypeForwardedTo(typeof(SHA384Managed))]
[assembly: TypeForwardedTo(typeof(SHA512))]
[assembly: TypeForwar

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Text;
using System.Xml;
using Microsoft.CodeAnalysis;
using TagLib.Aac;
using TagLib.Aiff;
using TagLib.Ape;
using TagLib.Asf;
using TagLib.Audible;
using TagLib.Dsf;
using TagLib.Flac;
using TagLib.Gif;
using TagLib.IFD;
using TagLib.IFD.Entries;
using TagLib.IFD.Makernotes;
using TagLib.IFD.Tags;
using TagLib.IIM;
using TagLib.Id3v1;
using TagLib.Id3v2;
using TagLib.Image;
using TagLib.Image.NoMetadata;
using TagLib.Jpeg;
using TagLib.Matroska;
using TagLib.Mpeg;
using TagLib.Mpeg4;
using TagLib.MusePack;
using TagLib.NonContainer;
using TagLib.Ogg;
using TagLib.Ogg.Codecs;
using TagLib.Png;
using TagLib.Riff;
using TagLib.Tiff;
using TagLib.Tiff.Arw;
using TagLib.Tiff.Cr2;
using TagLib.Tiff.Dng;
using TagLib.Tiff.Nef;
using TagLib.Tiff.Pef;
using TagLib.Tiff.Rw2;
using TagLib.WavPack;
using TagLib.Xmp;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("Brian Nickel, Gabriel Burt, Stephen Shaw, etc")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2006-2007 Brian Nickel.  Copyright (c) 2009-2020 Other contributors")]
[assembly: AssemblyDescription("A library for for reading and writing metadata in media files, including video, audio, and photo formats.")]
[assembly: AssemblyFileVersion("2.3.0.0")]
[assembly: AssemblyInformationalVersion("2.3.0.0")]
[assembly: AssemblyProduct("TagLib#")]
[assembly: AssemblyTitle("TagLibSharp")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/mono/taglib-sharp")]
[assembly: AssemblyVersion("2.3.0.0")]
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
	{
	}
}
namespace TagLib
{
	public enum StringType
	{
		Latin1,
		UTF16,
		UTF16BE,
		UTF8,
		UTF16LE
	}
	public class ByteVector : IList<byte>, ICollection<byte>, IEnumerable<byte>, IEnumerable, IComparable<ByteVector>
	{
		private static readonly uint[] crc_table = new uint[256]
		{
			0u, 79764919u, 159529838u, 222504665u, 319059676u, 398814059u, 445009330u, 507990021u, 638119352u, 583659535u,
			797628118u, 726387553u, 890018660u, 835552979u, 1015980042u, 944750013u, 1276238704u, 1221641927u, 1167319070u, 1095957929u,
			1595256236u, 1540665371u, 1452775106u, 1381403509u, 1780037320u, 1859660671u, 1671105958u, 1733955601u, 2031960084u, 2111593891u,
			1889500026u, 1952343757u, 2552477408u, 2632100695u, 2443283854u, 2506133561u, 2334638140u, 2414271883u, 2191915858u, 2254759653u,
			3190512472u, 3135915759u, 3081330742u, 3009969537u, 2905550212u, 2850959411u, 2762807018u, 2691435357u, 3560074640u, 3505614887u,
			3719321342u, 3648080713u, 3342211916u, 3287746299u, 3467911202u, 3396681109u, 4063920168u, 4143685023u, 4223187782u, 4286162673u,
			3779000052u, 3858754371u, 3904687514u, 3967668269u, 881225847u, 809987520u, 1023691545u, 969234094u, 662832811u, 591600412u,
			771767749u, 717299826u, 311336399u, 374308984u, 453813921u, 533576470u, 25881363u, 88864420u, 134795389u, 214552010u,
			2023205639u, 2086057648u, 1897238633u, 1976864222u, 1804852699u, 1867694188u, 1645340341u, 1724971778u, 1587496639u, 1516133128u,
			1461550545u, 1406951526u, 1302016099u, 1230646740u, 1142491917u, 1087903418u, 2896545431u, 2825181984u, 2770861561u, 2716262478u,
			3215044683u, 3143675388u, 3055782693u, 3001194130u, 2326604591u, 2389456536u, 2200899649u, 2280525302u, 2578013683u, 2640855108u,
			2418763421u, 2498394922u, 3769900519u, 3832873040u, 3912640137u, 3992402750u, 4088425275u, 4151408268u, 4197601365u, 4277358050u,
			3334271071u, 3263032808u, 3476998961u, 3422541446u, 3585640067u, 3514407732u, 3694837229u, 3640369242u, 1762451694u, 1842216281u,
			1619975040u, 1682949687u, 2047383090u, 2127137669u, 1938468188u, 2001449195u, 1325665622u, 1271206113u, 1183200824u, 1111960463u,
			1543535498u, 1489069629u, 1434599652u, 1363369299u, 622672798u, 568075817u, 748617968u, 677256519u, 907627842u, 853037301u,
			1067152940u, 995781531u, 51762726u, 131386257u, 177728840u, 240578815u, 269590778u, 349224269u, 429104020u, 491947555u,
			4046411278u, 4126034873u, 4172115296u, 4234965207u, 3794477266u, 3874110821u, 3953728444u, 4016571915u, 3609705398u, 3555108353u,
			3735388376u, 3664026991u, 3290680682u, 3236090077u, 3449943556u, 3378572211u, 3174993278u, 3120533705u, 3032266256u, 2961025959u,
			2923101090u, 2868635157u, 2813903052u, 2742672763u, 2604032198u, 2683796849u, 2461293480u, 2524268063u, 2284983834u, 2364738477u,
			2175806836u, 2238787779u, 1569362073u, 1498123566u, 1409854455u, 1355396672u, 1317987909u, 1246755826u, 1192025387u, 1137557660u,
			2072149281u, 2135122070u, 1912620623u, 1992383480u, 1753615357u, 1816598090u, 1627664531u, 1707420964u, 295390185u, 358241886u,
			404320391u, 483945776u, 43990325u, 106832002u, 186451547u, 266083308u, 932423249u, 861060070u, 1041341759u, 986742920u,
			613929101u, 542559546u, 756411363u, 701822548u, 3316196985u, 3244833742u, 3425377559u, 3370778784u, 3601682597u, 3530312978u,
			3744426955u, 3689838204u, 3819031489u, 3881883254u, 3928223919u, 4007849240u, 4037393693u, 4100235434u, 4180117107u, 4259748804u,
			2310601993u, 2373574846u, 2151335527u, 2231098320u, 2596047829u, 2659030626u, 2470359227u, 2550115596u, 2947551409u, 2876312838u,
			2788305887u, 2733848168u, 3165939309u, 3094707162u, 3040238851u, 2985771188u
		};

		private static bool use_broken_latin1;

		private static readonly ReadOnlyByteVector td1 = new ReadOnlyByteVector(1);

		private static readonly ReadOnlyByteVector td2 = new ReadOnlyByteVector(2);

		private static Encoding last_utf16_encoding = Encoding.Unicode;

		private readonly List<byte> data = new List<byte>();

		public byte[] Data => data.ToArray();

		public bool IsEmpty => data.Count == 0;

		public uint Checksum
		{
			get
			{
				uint num = 0u;
				foreach (byte datum in data)
				{
					num = (num << 8) ^ crc_table[((num >> 24) & 0xFF) ^ datum];
				}
				return num;
			}
		}

		public static bool UseBrokenLatin1Behavior
		{
			get
			{
				return use_broken_latin1;
			}
			set
			{
				use_broken_latin1 = value;
			}
		}

		public int Count => data.Count;

		public bool IsSynchronized => false;

		public object SyncRoot => this;

		public virtual bool IsReadOnly => false;

		public virtual bool IsFixedSize => false;

		public byte this[int index]
		{
			get
			{
				return data[index];
			}
			set
			{
				if (IsReadOnly)
				{
					throw new NotSupportedException("Cannot edit readonly objects.");
				}
				data[index] = value;
			}
		}

		public ByteVector()
		{
		}

		public ByteVector(ByteVector vector)
		{
			if (vector != null)
			{
				data.AddRange(vector);
			}
		}

		public ByteVector(params byte[] data)
		{
			if (data != null)
			{
				this.data.AddRange(data);
			}
		}

		public ByteVector(byte[] data, int length)
		{
			if (length > data.Length)
			{
				throw new ArgumentOutOfRangeException("length", "Length exceeds size of data.");
			}
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", "Length is less than zero.");
			}
			if (length == data.Length)
			{
				this.data.AddRange(data);
				return;
			}
			byte[] array = new byte[length];
			Array.Copy(data, 0, array, 0, length);
			this.data.AddRange(array);
		}

		public ByteVector(int size)
			: this(size, 0)
		{
		}

		public ByteVector(int size, byte value)
		{
			if (size < 0)
			{
				throw new ArgumentOutOfRangeException("size", "Size is less than zero.");
			}
			if (size != 0)
			{
				byte[] array = new byte[size];
				for (int i = 0; i < size; i++)
				{
					array[i] = value;
				}
				data.AddRange(array);
			}
		}

		public ByteVector Mid(int startIndex, int length)
		{
			if (startIndex < 0 || startIndex > Count)
			{
				throw new ArgumentOutOfRangeException("startIndex");
			}
			if (length < 0 || startIndex + length > Count)
			{
				throw new ArgumentOutOfRangeException("length");
			}
			if (length == 0)
			{
				return new ByteVector();
			}
			if (startIndex + length > data.Count)
			{
				length = data.Count - startIndex;
			}
			byte[] array = new byte[length];
			data.CopyTo(startIndex, array, 0, length);
			return array;
		}

		public ByteVector Mid(int index)
		{
			return Mid(index, Count - index);
		}

		public int Find(ByteVector pattern, int offset, int byteAlign)
		{
			if (pattern == null)
			{
				throw new ArgumentNullException("pattern");
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", "offset must be at least 0.");
			}
			if (byteAlign < 1)
			{
				throw new ArgumentOutOfRangeException("byteAlign", "byteAlign must be at least 1.");
			}
			if (pattern.Count > Count - offset)
			{
				return -1;
			}
			if (pattern.Count == 1)
			{
				byte b = pattern[0];
				for (int i = offset; i < data.Count; i += byteAlign)
				{
					if (data[i] == b)
					{
						return i;
					}
				}
				return -1;
			}
			int[] array = new int[256];
			for (int j = 0; j < 256; j++)
			{
				array[j] = pattern.Count;
			}
			for (int k = 0; k < pattern.Count - 1; k++)
			{
				array[pattern[k]] = pattern.Count - k - 1;
			}
			for (int l = pattern.Count - 1 + offset; l < data.Count; l += array[data[l]])
			{
				int num = l;
				int num2 = pattern.Count - 1;
				while (num2 >= 0 && data[num] == pattern[num2])
				{
					num--;
					num2--;
				}
				if (-1 == num2 && (num + 1 - offset) % byteAlign == 0)
				{
					return num + 1;
				}
			}
			return -1;
		}

		public int Find(ByteVector pattern, int offset)
		{
			return Find(pattern, offset, 1);
		}

		public int Find(ByteVector pattern)
		{
			return Find(pattern, 0, 1);
		}

		public int RFind(ByteVector pattern, int offset, int byteAlign)
		{
			if (pattern == null)
			{
				throw new ArgumentNullException("pattern");
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset");
			}
			if (pattern.Count == 0 || pattern.Count > Count - offset)
			{
				return -1;
			}
			if (pattern.Count == 1)
			{
				byte b = pattern[0];
				for (int num = Count - offset - 1; num >= 0; num -= byteAlign)
				{
					if (data[num] == b)
					{
						return num;
					}
				}
				return -1;
			}
			int[] array = new int[256];
			for (int i = 0; i < 256; i++)
			{
				array[i] = pattern.Count;
			}
			for (int num2 = pattern.Count - 1; num2 > 0; num2--)
			{
				array[pattern[num2]] = num2;
			}
			for (int num3 = Count - offset - pattern.Count; num3 >= 0; num3 -= array[data[num3]])
			{
				if ((offset - num3) % byteAlign == 0 && ContainsAt(pattern, num3))
				{
					return num3;
				}
			}
			return -1;
		}

		public int RFind(ByteVector pattern, int offset)
		{
			return RFind(pattern, offset, 1);
		}

		public int RFind(ByteVector pattern)
		{
			return RFind(pattern, 0, 1);
		}

		public bool ContainsAt(ByteVector pattern, int offset, int patternOffset, int patternLength)
		{
			if (pattern == null)
			{
				throw new ArgumentNullException("pattern");
			}
			if (pattern.Count < patternLength)
			{
				patternLength = pattern.Count;
			}
			if (patternLength > data.Count || offset >= data.Count || patternOffset >= pattern.Count || patternLength <= 0 || offset < 0)
			{
				return false;
			}
			for (int i = 0; i < patternLength - patternOffset; i++)
			{
				if (data[i + offset] != pattern[i + patternOffset])
				{
					return false;
				}
			}
			return true;
		}

		public bool ContainsAt(ByteVector pattern, int offset, int patternOffset)
		{
			return ContainsAt(pattern, offset, patternOffset, int.MaxValue);
		}

		public bool ContainsAt(ByteVector pattern, int offset)
		{
			return ContainsAt(pattern, offset, 0);
		}

		public bool StartsWith(ByteVector pattern)
		{
			return ContainsAt(pattern, 0);
		}

		public bool EndsWith(ByteVector pattern)
		{
			if (pattern == null)
			{
				throw new ArgumentNullException("pattern");
			}
			return ContainsAt(pattern, data.Count - pattern.Count);
		}

		public int EndsWithPartialMatch(ByteVector pattern)
		{
			if (pattern == null)
			{
				throw new ArgumentNullException("pattern");
			}
			if (pattern.Count > data.Count)
			{
				return -1;
			}
			int num = data.Count - pattern.Count;
			for (int i = 1; i < pattern.Count; i++)
			{
				if (ContainsAt(pattern, num + i, 0, pattern.Count - i))
				{
					return num + i;
				}
			}
			return -1;
		}

		public void Add(ByteVector data)
		{
			if (IsReadOnly)
			{
				throw new NotSupportedException("Cannot edit readonly objects.");
			}
			if (data != null)
			{
				this.data.AddRange(data);
			}
		}

		public void Add(byte[] data)
		{
			if (IsReadOnly)
			{
				throw new NotSupportedException("Cannot edit readonly objects.");
			}
			if (data != null)
			{
				this.data.AddRange(data);
			}
		}

		public void Insert(int index, ByteVector data)
		{
			if (IsReadOnly)
			{
				throw new NotSupportedException("Cannot edit readonly objects.");
			}
			if (data != null)
			{
				this.data.InsertRange(index, data);
			}
		}

		public void Insert(int index, byte[] data)
		{
			if (IsReadOnly)
			{
				throw new NotSupportedException("Cannot edit readonly objects.");
			}
			if (data != null)
			{
				this.data.InsertRange(index, data);
			}
		}

		public ByteVector Resize(int size, byte padding)
		{
			if (IsReadOnly)
			{
				throw new NotSupportedException("Cannot edit readonly objects.");
			}
			if (data.Count > size)
			{
				data.RemoveRange(size, data.Count - size);
			}
			while (data.Count < size)
			{
				data.Add(padding);
			}
			return this;
		}

		public ByteVector Resize(int size)
		{
			return Resize(size, 0);
		}

		public void RemoveRange(int index, int count)
		{
			if (IsReadOnly)
			{
				throw new NotSupportedException("Cannot edit readonly objects.");
			}
			data.RemoveRange(index, count);
		}

		public int ToInt(bool mostSignificantByteFirst)
		{
			int num = 0;
			int num2 = ((Count > 4) ? 3 : (Count - 1));
			for (int i = 0; i <= num2; i++)
			{
				int num3 = (mostSignificantByteFirst ? (num2 - i) : i);
				num |= this[i] << num3 * 8;
			}
			return num;
		}

		public int ToInt()
		{
			return ToInt(mostSignificantByteFirst: true);
		}

		public uint ToUInt(bool mostSignificantByteFirst)
		{
			uint num = 0u;
			int num2 = ((Count > 4) ? 3 : (Count - 1));
			for (int i = 0; i <= num2; i++)
			{
				int num3 = (mostSignificantByteFirst ? (num2 - i) : i);
				num |= (uint)(this[i] << num3 * 8);
			}
			return num;
		}

		public uint ToUInt()
		{
			return ToUInt(mostSignificantByteFirst: true);
		}

		public short ToShort(bool mostSignificantByteFirst)
		{
			short num = 0;
			int num2 = ((Count > 2) ? 1 : (Count - 1));
			for (int i = 0; i <= num2; i++)
			{
				int num3 = (mostSignificantByteFirst ? (num2 - i) : i);
				num |= (short)(this[i] << num3 * 8);
			}
			return num;
		}

		public short ToShort()
		{
			return ToShort(mostSignificantByteFirst: true);
		}

		public ushort ToUShort(bool mostSignificantByteFirst)
		{
			ushort num = 0;
			int num2 = ((Count > 2) ? 1 : (Count - 1));
			for (int i = 0; i <= num2; i++)
			{
				int num3 = (mostSignificantByteFirst ? (num2 - i) : i);
				num |= (ushort)(this[i] << num3 * 8);
			}
			return num;
		}

		public ushort ToUShort()
		{
			return ToUShort(mostSignificantByteFirst: true);
		}

		public long ToLong(bool mostSignificantByteFirst)
		{
			long num = 0L;
			int num2 = ((Count > 8) ? 7 : (Count - 1));
			for (int i = 0; i <= num2; i++)
			{
				int num3 = (mostSignificantByteFirst ? (num2 - i) : i);
				num |= (long)((ulong)this[i] << num3 * 8);
			}
			return num;
		}

		public long ToLong()
		{
			return ToLong(mostSignificantByteFirst: true);
		}

		public ulong ToULong(bool mostSignificantByteFirst)
		{
			ulong num = 0uL;
			int num2 = ((Count > 8) ? 7 : (Count - 1));
			for (int i = 0; i <= num2; i++)
			{
				int num3 = (mostSignificantByteFirst ? (num2 - i) : i);
				num |= (ulong)this[i] << num3 * 8;
			}
			return num;
		}

		public ulong ToULong()
		{
			return ToULong(mostSignificantByteFirst: true);
		}

		public float ToFloat(bool mostSignificantByteFirst)
		{
			byte[] array = (byte[])Data.Clone();
			if (mostSignificantByteFirst)
			{
				Array.Reverse((Array)array);
			}
			return BitConverter.ToSingle(array, 0);
		}

		public float ToFloat()
		{
			return ToFloat(mostSignificantByteFirst: true);
		}

		public double ToDouble(bool mostSignificantByteFirst)
		{
			byte[] array = (byte[])Data.Clone();
			if (mostSignificantByteFirst)
			{
				Array.Reverse((Array)array);
			}
			return BitConverter.ToDouble(array, 0);
		}

		public double ToDouble()
		{
			return ToDouble(mostSignificantByteFirst: true);
		}

		public double ToExtendedPrecision()
		{
			int num = ((this[0] & 0x7F) << 8) | this[1];
			ulong num2 = ((ulong)this[2] << 24) | ((ulong)this[3] << 16) | ((ulong)this[4] << 8) | this[5];
			ulong num3 = ((ulong)this[6] << 24) | ((ulong)this[7] << 16) | ((ulong)this[8] << 8) | this[9];
			double num4;
			if (num == 0 && num2 == 0L && num3 == 0L)
			{
				num4 = 0.0;
			}
			else if (num == 32767)
			{
				num4 = double.PositiveInfinity;
			}
			else
			{
				num -= 16383;
				num4 = (double)num2 * Math.Pow(2.0, num -= 31);
				num4 += (double)num3 * Math.Pow(2.0, num -= 32);
			}
			if ((this[0] & 0x80) == 0)
			{
				return num4;
			}
			return 0.0 - num4;
		}

		public string ToString(StringType type, int offset, int count)
		{
			if (offset < 0 || offset > Count)
			{
				throw new ArgumentOutOfRangeException("offset");
			}
			if (count < 0 || count + offset > Count)
			{
				throw new ArgumentOutOfRangeException("count");
			}
			ByteVector bom = ((type == StringType.UTF16 && data.Count - offset > 1) ? Mid(offset, 2) : null);
			string @string = StringTypeToEncoding(type, bom).GetString(Data, offset, count);
			if (@string.Length != 0 && (@string[0] == '\ufffe' || @string[0] == '\ufeff'))
			{
				return @string.Substring(1);
			}
			return @string;
		}

		[Obsolete("Use ToString(StringType,int,int)")]
		public string ToString(StringType type, int offset)
		{
			return ToString(type, offset, Count - offset);
		}

		public string ToString(StringType type)
		{
			return ToString(type, 0, Count);
		}

		public override string ToString()
		{
			return ToString(StringType.UTF8, 0, Count);
		}

		public string[] ToStrings(StringType type, int offset)
		{
			return ToStrings(type, offset, int.MaxValue);
		}

		public string[] ToStrings(StringType type, int offset, int count)
		{
			int num = 0;
			int num2 = offset;
			List<string> list = new List<string>();
			ByteVector byteVector = TextDelimiter(type);
			int count2 = byteVector.Count;
			while (num < count && num2 < Count)
			{
				int num3 = num2;
				if (num + 1 == count)
				{
					num2 = offset + count;
				}
				else
				{
					num2 = Find(byteVector, num3, count2);
					if (num2 < 0)
					{
						num2 = Count;
					}
				}
				int num4 = num2 - num3;
				if (num4 == 0)
				{
					list.Add(string.Empty);
				}
				else
				{
					string text = ToString(type, num3, num4);
					if (text.Length != 0 && (text[0] == '\ufffe' || text[0] == '\ufeff'))
					{
						text = text.Substring(1);
					}
					list.Add(text);
				}
				num2 += count2;
			}
			return list.ToArray();
		}

		public static bool operator ==(ByteVector first, ByteVector second)
		{
			bool flag = (object)first == null;
			bool flag2 = (object)second == null;
			if (flag && flag2)
			{
				return true;
			}
			if (flag || flag2)
			{
				return false;
			}
			return first.Equals(second);
		}

		public static bool operator !=(ByteVector first, ByteVector second)
		{
			return !(first == second);
		}

		public static bool operator <(ByteVector first, ByteVector second)
		{
			if (first == null)
			{
				throw new ArgumentNullException("first");
			}
			if (second == null)
			{
				throw new ArgumentNullException("second");
			}
			return first.CompareTo(second) < 0;
		}

		public static bool operator <=(ByteVector first, ByteVector second)
		{
			if (first == null)
			{
				throw new ArgumentNullException("first");
			}
			if (second == null)
			{
				throw new ArgumentNullException("second");
			}
			return first.CompareTo(second) <= 0;
		}

		public static bool operator >(ByteVector first, ByteVector second)
		{
			if (first == null)
			{
				throw new ArgumentNullException("first");
			}
			if (second == null)
			{
				throw new ArgumentNullException("second");
			}
			return first.CompareTo(second) > 0;
		}

		public static bool operator >=(ByteVector first, ByteVector second)
		{
			if (first == null)
			{
				throw new ArgumentNullException("first");
			}
			if (second == null)
			{
				throw new ArgumentNullException("second");
			}
			return first.CompareTo(second) >= 0;
		}

		public static ByteVector operator +(ByteVector first, ByteVector second)
		{
			return new ByteVector(first) { second };
		}

		public static implicit operator ByteVector(byte value)
		{
			return new ByteVector(value);
		}

		public static implicit operator ByteVector(byte[] value)
		{
			return new ByteVector(value);
		}

		public static implicit operator ByteVector(string value)
		{
			return FromString(value, StringType.UTF8);
		}

		public static ByteVector FromInt(int value, bool mostSignificantByteFirst)
		{
			ByteVector byteVector = new ByteVector();
			for (int i = 0; i < 4; i++)
			{
				int num = (mostSignificantByteFirst ? (3 - i) : i);
				byteVector.Add((byte)((uint)(value >> num * 8) & 0xFFu));
			}
			return byteVector;
		}

		public static ByteVector FromInt(int value)
		{
			return FromInt(value, mostSignificantByteFirst: true);
		}

		public static ByteVector FromUInt(uint value, bool mostSignificantByteFirst)
		{
			ByteVector byteVector = new ByteVector();
			for (int i = 0; i < 4; i++)
			{
				int num = (mostSignificantByteFirst ? (3 - i) : i);
				byteVector.Add((byte)((value >> num * 8) & 0xFFu));
			}
			return byteVector;
		}

		public static ByteVector FromUInt(uint value)
		{
			return FromUInt(value, mostSignificantByteFirst: true);
		}

		public static ByteVector FromShort(short value, bool mostSignificantByteFirst)
		{
			ByteVector byteVector = new ByteVector();
			for (int i = 0; i < 2; i++)
			{
				int num = (mostSignificantByteFirst ? (1 - i) : i);
				byteVector.Add((byte)((uint)(value >> num * 8) & 0xFFu));
			}
			return byteVector;
		}

		public static ByteVector FromShort(short value)
		{
			return FromShort(value, mostSignificantByteFirst: true);
		}

		public static ByteVector FromUShort(ushort value, bool mostSignificantByteFirst)
		{
			ByteVector byteVector = new ByteVector();
			for (int i = 0; i < 2; i++)
			{
				int num = (mostSignificantByteFirst ? (1 - i) : i);
				byteVector.Add((byte)((uint)(value >> num * 8) & 0xFFu));
			}
			return byteVector;
		}

		public static ByteVector FromUShort(ushort value)
		{
			return FromUShort(value, mostSignificantByteFirst: true);
		}

		public static ByteVector FromLong(long value, bool mostSignificantByteFirst)
		{
			ByteVector byteVector = new ByteVector();
			for (int i = 0; i < 8; i++)
			{
				int num = (mostSignificantByteFirst ? (7 - i) : i);
				byteVector.Add((byte)((value >> num * 8) & 0xFF));
			}
			return byteVector;
		}

		public static ByteVector FromLong(long value)
		{
			return FromLong(value, mostSignificantByteFirst: true);
		}

		public static ByteVector FromULong(ulong value, bool mostSignificantByteFirst)
		{
			ByteVector byteVector = new ByteVector();
			for (int i = 0; i < 8; i++)
			{
				int num = (mostSignificantByteFirst ? (7 - i) : i);
				byteVector.Add((byte)((value >> num * 8) & 0xFF));
			}
			return byteVector;
		}

		public static ByteVector FromULong(ulong value)
		{
			return FromULong(value, mostSignificantByteFirst: true);
		}

		public static ByteVector FromString(string text, StringType type, int length)
		{
			ByteVector byteVector = new ByteVector();
			if (type == StringType.UTF16)
			{
				byteVector.Add(new byte[2] { 255, 254 });
			}
			if (text == null || text.Length == 0)
			{
				return byteVector;
			}
			if (text.Length > length)
			{
				text = text.Substring(0, length);
			}
			byteVector.Add(StringTypeToEncoding(type, byteVector).GetBytes(text));
			return byteVector;
		}

		public static ByteVector FromString(string text, StringType type)
		{
			return FromString(text, type, int.MaxValue);
		}

		public static ByteVector FromString(string text, int length)
		{
			return FromString(text, StringType.UTF8, length);
		}

		[Obsolete("Use FromString(string,StringType)")]
		public static ByteVector FromString(string text)
		{
			return FromString(text, StringType.UTF8);
		}

		public static ByteVector FromPath(string path)
		{
			byte[] firstChunk;
			return FromPath(path, out firstChunk, copyFirstChunk: false);
		}

		internal static ByteVector FromPath(string path, out byte[] firstChunk, bool copyFirstChunk)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			return FromFile(new File.LocalFileAbstraction(path), out firstChunk, copyFirstChunk);
		}

		public static ByteVector FromFile(File.IFileAbstraction abstraction)
		{
			byte[] firstChunk;
			return FromFile(abstraction, out firstChunk, copyFirstChunk: false);
		}

		internal static ByteVector FromFile(File.IFileAbstraction abstraction, out byte[] firstChunk, bool copyFirstChunk)
		{
			if (abstraction == null)
			{
				throw new ArgumentNullException("abstraction");
			}
			Stream readStream = abstraction.ReadStream;
			ByteVector result = FromStream(readStream, out firstChunk, copyFirstChunk);
			abstraction.CloseStream(readStream);
			return result;
		}

		public static ByteVector FromStream(Stream stream)
		{
			byte[] firstChunk;
			return FromStream(stream, out firstChunk, copyFirstChunk: false);
		}

		internal static ByteVector FromStream(Stream stream, out byte[] firstChunk, bool copyFirstChunk)
		{
			ByteVector byteVector = new ByteVector();
			byte[] array = new byte[4096];
			int num = array.Length;
			int num2 = 0;
			bool flag = false;
			firstChunk = null;
			int num3;
			do
			{
				Array.Clear(array, 0, array.Length);
				num3 = stream.Read(array, 0, num);
				byteVector.Add(array);
				num2 += num3;
				if (flag)
				{
					continue;
				}
				if (copyFirstChunk)
				{
					if (firstChunk == null || firstChunk.Length != num)
					{
						firstChunk = new byte[num];
					}
					Array.Copy(array, 0, firstChunk, 0, num3);
				}
				flag = true;
			}
			while ((num2 != stream.Length || stream.Length <= 0) && (num3 >= num || stream.Length > 0));
			if (stream.Length > 0 && byteVector.Count != stream.Length)
			{
				byteVector.Resize((int)stream.Length);
			}
			return byteVector;
		}

		public static ByteVector TextDelimiter(StringType type)
		{
			if (type != StringType.UTF16 && type != StringType.UTF16BE && type != StringType.UTF16LE)
			{
				return td1;
			}
			return td2;
		}

		private static Encoding StringTypeToEncoding(StringType type, ByteVector bom)
		{
			switch (type)
			{
			case StringType.UTF16:
				if (bom == null)
				{
					return last_utf16_encoding;
				}
				if (bom[0] == byte.MaxValue && bom[1] == 254)
				{
					return last_utf16_encoding = Encoding.Unicode;
				}
				if (bom[1] == byte.MaxValue && bom[0] == 254)
				{
					return last_utf16_encoding = Encoding.BigEndianUnicode;
				}
				return last_utf16_encoding;
			case StringType.UTF16BE:
				return Encoding.BigEndianUnicode;
			case StringType.UTF8:
				return Encoding.UTF8;
			case StringType.UTF16LE:
				return Encoding.Unicode;
			default:
				if (use_broken_latin1)
				{
					return Encoding.Default;
				}
				try
				{
					return Encoding.GetEncoding("latin1");
				}
				catch (ArgumentException)
				{
					return Encoding.UTF8;
				}
			}
		}

		public override bool Equals(object other)
		{
			if (!(other is ByteVector))
			{
				return false;
			}
			return Equals((ByteVector)other);
		}

		public bool Equals(ByteVector other)
		{
			return CompareTo(other) == 0;
		}

		public override int GetHashCode()
		{
			return (int)Checksum;
		}

		public int CompareTo(ByteVector other)
		{
			if ((object)other == null)
			{
				throw new ArgumentNullException("other");
			}
			int num = Count - other.Count;
			int num2 = 0;
			while (num == 0 && num2 < Count)
			{
				num = this[num2] - other[num2];
				num2++;
			}
			return num;
		}

		public IEnumerator<byte> GetEnumerator()
		{
			return data.GetEnumerator();
		}

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

		public void Clear()
		{
			if (IsReadOnly)
			{
				throw new NotSupportedException("Cannot edit readonly objects.");
			}
			data.Clear();
		}

		public void Add(byte item)
		{
			if (IsReadOnly)
			{
				throw new NotSupportedException("Cannot edit readonly objects.");
			}
			data.Add(item);
		}

		public bool Remove(byte item)
		{
			if (IsReadOnly)
			{
				throw new NotSupportedException("Cannot edit readonly objects.");
			}
			return data.Remove(item);
		}

		public void CopyTo(byte[] array, int arrayIndex)
		{
			data.CopyTo(array, arrayIndex);
		}

		public bool Contains(byte item)
		{
			return data.Contains(item);
		}

		public void RemoveAt(int index)
		{
			if (IsReadOnly)
			{
				throw new NotSupportedException("Cannot edit readonly objects.");
			}
			data.RemoveAt(index);
		}

		public void Insert(int index, byte item)
		{
			if (IsReadOnly)
			{
				throw new NotSupportedException("Cannot edit readonly objects.");
			}
			data.Insert(index, item);
		}

		public int IndexOf(byte item)
		{
			return data.IndexOf(item);
		}
	}
	[ComVisible(false)]
	public class ByteVectorCollection : ListBase<ByteVector>
	{
		public ByteVectorCollection()
		{
		}

		public ByteVectorCollection(IEnumerable<ByteVector> list)
		{
			if (list != null)
			{
				Add(list);
			}
		}

		public ByteVectorCollection(params ByteVector[] list)
		{
			if (list != null)
			{
				Add(list);
			}
		}

		public override void SortedInsert(ByteVector item, bool unique)
		{
			if (item == null)
			{
				throw new ArgumentNullException("item");
			}
			int i;
			for (i = 0; i < base.Count; i++)
			{
				if (item == base[i] && unique)
				{
					return;
				}
				if (item >= base[i])
				{
					break;
				}
			}
			Insert(i + 1, item);
		}

		public ByteVector ToByteVector(ByteVector separator)
		{
			if (separator == null)
			{
				throw new ArgumentNullException("separator");
			}
			ByteVector byteVector = new ByteVector();
			for (int i = 0; i < base.Count; i++)
			{
				if (i != 0 && separator.Count > 0)
				{
					byteVector.Add(separator);
				}
				byteVector.Add(base[i]);
			}
			return byteVector;
		}

		public static ByteVectorCollection Split(ByteVector vector, ByteVector pattern, int byteAlign, int max)
		{
			if (vector == null)
			{
				throw new ArgumentNullException("vector");
			}
			if (pattern == null)
			{
				throw new ArgumentNullException("pattern");
			}
			if (byteAlign < 1)
			{
				throw new ArgumentOutOfRangeException("byteAlign", "byteAlign must be at least 1.");
			}
			ByteVectorCollection byteVectorCollection = new ByteVectorCollection();
			int num = 0;
			int num2 = vector.Find(pattern, 0, byteAlign);
			while (num2 != -1 && (max < 1 || max > byteVectorCollection.Count + 1))
			{
				byteVectorCollection.Add(vector.Mid(num, num2 - num));
				num = num2 + pattern.Count;
				num2 = vector.Find(pattern, num2 + pattern.Count, byteAlign);
			}
			if (num < vector.Count)
			{
				byteVectorCollection.Add(vector.Mid(num, vector.Count - num));
			}
			return byteVectorCollection;
		}

		public static ByteVectorCollection Split(ByteVector vector, ByteVector pattern, int byteAlign)
		{
			return Split(vector, pattern, byteAlign, 0);
		}

		public static ByteVectorCollection Split(ByteVector vector, ByteVector pattern)
		{
			return Split(vector, pattern, 1);
		}
	}
	public class CombinedTag : Tag
	{
		private readonly List<Tag> tags;

		public virtual Tag[] Tags => tags.ToArray();

		public override TagTypes TagTypes
		{
			get
			{
				TagTypes tagTypes = TagTypes.None;
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tagTypes |= tag.TagTypes;
					}
				}
				return tagTypes;
			}
		}

		public override string Title
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string title = tag.Title;
						if (title != null)
						{
							return title;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Title = value;
					}
				}
			}
		}

		public override string Subtitle
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string subtitle = tag.Subtitle;
						if (subtitle != null)
						{
							return subtitle;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Subtitle = value;
					}
				}
			}
		}

		public override string Description
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string description = tag.Description;
						if (description != null)
						{
							return description;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Description = value;
					}
				}
			}
		}

		public override string[] Performers
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string[] performers = tag.Performers;
						if (performers != null && performers.Length != 0)
						{
							return performers;
						}
					}
				}
				return new string[0];
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Performers = value;
					}
				}
			}
		}

		public override string[] PerformersSort
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string[] performersSort = tag.PerformersSort;
						if (performersSort != null && performersSort.Length != 0)
						{
							return performersSort;
						}
					}
				}
				return new string[0];
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.PerformersSort = value;
					}
				}
			}
		}

		public override string[] PerformersRole
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string[] performersRole = tag.PerformersRole;
						if (performersRole != null && performersRole.Length != 0)
						{
							return performersRole;
						}
					}
				}
				return new string[0];
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.PerformersRole = value;
					}
				}
			}
		}

		public override string[] AlbumArtistsSort
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string[] albumArtistsSort = tag.AlbumArtistsSort;
						if (albumArtistsSort != null && albumArtistsSort.Length != 0)
						{
							return albumArtistsSort;
						}
					}
				}
				return new string[0];
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.AlbumArtistsSort = value;
					}
				}
			}
		}

		public override string[] AlbumArtists
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string[] albumArtists = tag.AlbumArtists;
						if (albumArtists != null && albumArtists.Length != 0)
						{
							return albumArtists;
						}
					}
				}
				return new string[0];
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.AlbumArtists = value;
					}
				}
			}
		}

		public override string[] Composers
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string[] composers = tag.Composers;
						if (composers != null && composers.Length != 0)
						{
							return composers;
						}
					}
				}
				return new string[0];
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Composers = value;
					}
				}
			}
		}

		public override string[] ComposersSort
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string[] composersSort = tag.ComposersSort;
						if (composersSort != null && composersSort.Length != 0)
						{
							return composersSort;
						}
					}
				}
				return new string[0];
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.ComposersSort = value;
					}
				}
			}
		}

		public override string TitleSort
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string titleSort = tag.TitleSort;
						if (titleSort != null && titleSort.Length > 0)
						{
							return titleSort;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.TitleSort = value;
					}
				}
			}
		}

		public override string AlbumSort
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string albumSort = tag.AlbumSort;
						if (albumSort != null && albumSort.Length > 0)
						{
							return albumSort;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.AlbumSort = value;
					}
				}
			}
		}

		public override string Album
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string album = tag.Album;
						if (album != null)
						{
							return album;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Album = value;
					}
				}
			}
		}

		public override string Comment
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string comment = tag.Comment;
						if (comment != null)
						{
							return comment;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Comment = value;
					}
				}
			}
		}

		public override string[] Genres
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string[] genres = tag.Genres;
						if (genres != null && genres.Length != 0)
						{
							return genres;
						}
					}
				}
				return new string[0];
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Genres = value;
					}
				}
			}
		}

		public override uint Year
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						uint year = tag.Year;
						if (year != 0)
						{
							return year;
						}
					}
				}
				return 0u;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Year = value;
					}
				}
			}
		}

		public override uint Track
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						uint track = tag.Track;
						if (track != 0)
						{
							return track;
						}
					}
				}
				return 0u;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Track = value;
					}
				}
			}
		}

		public override uint TrackCount
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						uint trackCount = tag.TrackCount;
						if (trackCount != 0)
						{
							return trackCount;
						}
					}
				}
				return 0u;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.TrackCount = value;
					}
				}
			}
		}

		public override uint Disc
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						uint disc = tag.Disc;
						if (disc != 0)
						{
							return disc;
						}
					}
				}
				return 0u;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Disc = value;
					}
				}
			}
		}

		public override uint DiscCount
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						uint discCount = tag.DiscCount;
						if (discCount != 0)
						{
							return discCount;
						}
					}
				}
				return 0u;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.DiscCount = value;
					}
				}
			}
		}

		public override string Lyrics
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string lyrics = tag.Lyrics;
						if (lyrics != null)
						{
							return lyrics;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Lyrics = value;
					}
				}
			}
		}

		public override string Grouping
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string grouping = tag.Grouping;
						if (grouping != null)
						{
							return grouping;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Grouping = value;
					}
				}
			}
		}

		public override uint BeatsPerMinute
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						uint beatsPerMinute = tag.BeatsPerMinute;
						if (beatsPerMinute != 0)
						{
							return beatsPerMinute;
						}
					}
				}
				return 0u;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.BeatsPerMinute = value;
					}
				}
			}
		}

		public override string Conductor
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string conductor = tag.Conductor;
						if (conductor != null)
						{
							return conductor;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Conductor = value;
					}
				}
			}
		}

		public override string Copyright
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string copyright = tag.Copyright;
						if (copyright != null)
						{
							return copyright;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Copyright = value;
					}
				}
			}
		}

		public override DateTime? DateTagged
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						DateTime? dateTagged = tag.DateTagged;
						if (dateTagged.HasValue)
						{
							return dateTagged;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.DateTagged = value;
					}
				}
			}
		}

		public override string MusicBrainzArtistId
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string musicBrainzArtistId = tag.MusicBrainzArtistId;
						if (musicBrainzArtistId != null)
						{
							return musicBrainzArtistId;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.MusicBrainzArtistId = value;
					}
				}
			}
		}

		public override string MusicBrainzReleaseGroupId
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string musicBrainzReleaseGroupId = tag.MusicBrainzReleaseGroupId;
						if (musicBrainzReleaseGroupId != null)
						{
							return musicBrainzReleaseGroupId;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.MusicBrainzReleaseGroupId = value;
					}
				}
			}
		}

		public override string MusicBrainzReleaseId
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string musicBrainzReleaseId = tag.MusicBrainzReleaseId;
						if (musicBrainzReleaseId != null)
						{
							return musicBrainzReleaseId;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.MusicBrainzReleaseId = value;
					}
				}
			}
		}

		public override string MusicBrainzReleaseArtistId
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string musicBrainzReleaseArtistId = tag.MusicBrainzReleaseArtistId;
						if (musicBrainzReleaseArtistId != null)
						{
							return musicBrainzReleaseArtistId;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.MusicBrainzReleaseArtistId = value;
					}
				}
			}
		}

		public override string MusicBrainzTrackId
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string musicBrainzTrackId = tag.MusicBrainzTrackId;
						if (musicBrainzTrackId != null)
						{
							return musicBrainzTrackId;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.MusicBrainzTrackId = value;
					}
				}
			}
		}

		public override string MusicBrainzDiscId
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string musicBrainzDiscId = tag.MusicBrainzDiscId;
						if (musicBrainzDiscId != null)
						{
							return musicBrainzDiscId;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.MusicBrainzDiscId = value;
					}
				}
			}
		}

		public override string MusicIpId
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string musicIpId = tag.MusicIpId;
						if (musicIpId != null)
						{
							return musicIpId;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.MusicIpId = value;
					}
				}
			}
		}

		public override string AmazonId
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string amazonId = tag.AmazonId;
						if (amazonId != null)
						{
							return amazonId;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.AmazonId = value;
					}
				}
			}
		}

		public override string MusicBrainzReleaseStatus
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string musicBrainzReleaseStatus = tag.MusicBrainzReleaseStatus;
						if (musicBrainzReleaseStatus != null)
						{
							return musicBrainzReleaseStatus;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.MusicBrainzReleaseStatus = value;
					}
				}
			}
		}

		public override string MusicBrainzReleaseType
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string musicBrainzReleaseType = tag.MusicBrainzReleaseType;
						if (musicBrainzReleaseType != null)
						{
							return musicBrainzReleaseType;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.MusicBrainzReleaseType = value;
					}
				}
			}
		}

		public override string MusicBrainzReleaseCountry
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string musicBrainzReleaseCountry = tag.MusicBrainzReleaseCountry;
						if (musicBrainzReleaseCountry != null)
						{
							return musicBrainzReleaseCountry;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.MusicBrainzReleaseCountry = value;
					}
				}
			}
		}

		public override IPicture[] Pictures
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						IPicture[] pictures = tag.Pictures;
						if (pictures != null && pictures.Length != 0)
						{
							return pictures;
						}
					}
				}
				return base.Pictures;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Pictures = value;
					}
				}
			}
		}

		public override double ReplayGainTrackGain
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						double replayGainTrackGain = tag.ReplayGainTrackGain;
						if (!double.IsNaN(replayGainTrackGain))
						{
							return replayGainTrackGain;
						}
					}
				}
				return double.NaN;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.ReplayGainTrackGain = value;
					}
				}
			}
		}

		public override double ReplayGainTrackPeak
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						double replayGainTrackPeak = tag.ReplayGainTrackPeak;
						if (!double.IsNaN(replayGainTrackPeak))
						{
							return replayGainTrackPeak;
						}
					}
				}
				return double.NaN;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.ReplayGainTrackPeak = value;
					}
				}
			}
		}

		public override double ReplayGainAlbumGain
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						double replayGainAlbumGain = tag.ReplayGainAlbumGain;
						if (!double.IsNaN(replayGainAlbumGain))
						{
							return replayGainAlbumGain;
						}
					}
				}
				return double.NaN;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.ReplayGainAlbumGain = value;
					}
				}
			}
		}

		public override double ReplayGainAlbumPeak
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						double replayGainAlbumPeak = tag.ReplayGainAlbumPeak;
						if (!double.IsNaN(replayGainAlbumPeak))
						{
							return replayGainAlbumPeak;
						}
					}
				}
				return double.NaN;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.ReplayGainAlbumPeak = value;
					}
				}
			}
		}

		public override string InitialKey
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string initialKey = tag.InitialKey;
						if (initialKey != null)
						{
							return initialKey;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.InitialKey = value;
					}
				}
			}
		}

		public override string RemixedBy
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string remixedBy = tag.RemixedBy;
						if (remixedBy != null)
						{
							return remixedBy;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.RemixedBy = value;
					}
				}
			}
		}

		public override string Publisher
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string publisher = tag.Publisher;
						if (publisher != null)
						{
							return publisher;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Publisher = value;
					}
				}
			}
		}

		public override string ISRC
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string iSRC = tag.ISRC;
						if (iSRC != null)
						{
							return iSRC;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.ISRC = value;
					}
				}
			}
		}

		public override string Length
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						string length = tag.Length;
						if (length != null)
						{
							return length;
						}
					}
				}
				return null;
			}
			set
			{
				foreach (Tag tag in tags)
				{
					if (tag != null)
					{
						tag.Length = value;
					}
				}
			}
		}

		public override bool IsEmpty
		{
			get
			{
				foreach (Tag tag in tags)
				{
					if (tag.IsEmpty)
					{
						return true;
					}
				}
				return false;
			}
		}

		public CombinedTag()
		{
			tags = new List<Tag>();
		}

		public CombinedTag(params Tag[] tags)
		{
			this.tags = new List<Tag>(tags);
		}

		public void SetTags(params Tag[] tags)
		{
			this.tags.Clear();
			this.tags.AddRange(tags);
		}

		protected void InsertTag(int index, Tag tag)
		{
			tags.Insert(index, tag);
		}

		protected void AddTag(Tag tag)
		{
			tags.Add(tag);
		}

		protected void RemoveTag(Tag tag)
		{
			tags.Remove(tag);
		}

		protected void ClearTags()
		{
			tags.Clear();
		}

		public override void Clear()
		{
			foreach (Tag tag in tags)
			{
				tag.Clear();
			}
		}
	}
	[Serializable]
	public class CorruptFileException : Exception
	{
		public CorruptFileException(string message)
			: base(message)
		{
		}

		public CorruptFileException()
		{
		}

		public CorruptFileException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		protected CorruptFileException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	internal static class Debugger
	{
		public delegate void DebugMessageSentHandler(string message);

		private struct DebugTimeData
		{
			public TimeSpan time;

			public long occurances;

			public DebugTimeData(TimeSpan time, int occurances)
			{
				this.time = time;
				this.occurances = occurances;
			}
		}

		private static readonly string allowed = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`~!@#$%^&*()_+-={}[];:'\",.<>?/\\|";

		private static readonly Dictionary<object, Dictionary<object, DebugTimeData>> debug_times = new Dictionary<object, Dictionary<object, DebugTimeData>>();

		public static event DebugMessageSentHandler DebugMessageSent;

		public static void Debug(string message)
		{
			Debugger.DebugMessageSent?.Invoke(message);
		}

		public static void DumpHex(ByteVector data)
		{
			DumpHex(data.Data);
		}

		public static void DumpHex(byte[] data)
		{
			int num = 16;
			int num2 = data.Length / num + ((data.Length % num != 0) ? 1 : 0);
			for (int i = 0; i < num2; i++)
			{
				for (int j = 0; j < num; j++)
				{
					if (i == num2 - 1 && data.Length % num != 0 && j >= data.Length % num)
					{
						Console.Write("   ");
					}
					else
					{
						Console.Write(" {0:x2}", data[i * num + j]);
					}
				}
				Console.Write(" | ");
				for (int k = 0; k < num; k++)
				{
					if (i == num2 - 1 && data.Length % num != 0 && k >= data.Length % num)
					{
						Console.Write(" ");
					}
					else
					{
						WriteByte2(data[i * num + k]);
					}
				}
				Console.WriteLine();
			}
			Console.WriteLine();
		}

		private static void WriteByte2(byte data)
		{
			string text = allowed;
			foreach (char c in text)
			{
				if (c == data)
				{
					Console.Write(c);
					return;
				}
			}
			Console.Write(".");
		}

		public static void AddDebugTime(object o1, object o2, DateTime start)
		{
			DebugTimeData value = new DebugTimeData(DateTime.Now - start, 1);
			if (debug_times.ContainsKey(o1) && debug_times[o1].ContainsKey(o2))
			{
				value.time += debug_times[o1][o2].time;
				value.occurances += debug_times[o1][o2].occurances;
			}
			if (!debug_times.ContainsKey(o1))
			{
				debug_times.Add(o1, new Dictionary<object, DebugTimeData>());
			}
			if (!debug_times[o1].ContainsKey(o2))
			{
				debug_times[o1].Add(o2, value);
			}
			else
			{
				debug_times[o1][o2] = value;
			}
		}

		public static void DumpDebugTime(object o1)
		{
			Console.WriteLine(o1.ToString());
			if (!debug_times.ContainsKey(o1))
			{
				return;
			}
			foreach (KeyValuePair<object, DebugTimeData> item in debug_times[o1])
			{
				Console.WriteLine("  {0}", item.Key);
				Console.WriteLine("    Objects: {0}", item.Value.time);
				Console.WriteLine("    Total:   {0}", item.Value.occurances);
				Console.WriteLine("    Average: {0}", new TimeSpan(item.Value.time.Ticks / item.Value.occurances));
				Console.WriteLine();
			}
			debug_times.Remove(o1);
		}
	}
	[Flags]
	public enum ReadStyle
	{
		None = 0,
		Average = 2,
		PictureLazy = 4
	}
	public abstract class File : IDisposable
	{
		public enum AccessMode
		{
			Read,
			Write,
			Closed
		}

		public delegate File FileTypeResolver(IFileAbstraction abstraction, string mimetype, ReadStyle style);

		public class LocalFileAbstraction : IFileAbstraction
		{
			private readonly string name;

			public string Name => name;

			public Stream ReadStream => System.IO.File.Open(Name, FileMode.Open, FileAccess.Read, FileShare.Read);

			public Stream WriteStream => System.IO.File.Open(Name, FileMode.Open, FileAccess.ReadWrite);

			public LocalFileAbstraction(string path)
			{
				if (path == null)
				{
					throw new ArgumentNullException("path");
				}
				name = path;
			}

			public void CloseStream(Stream stream)
			{
				if (stream == null)
				{
					throw new ArgumentNullException("stream");
				}
				stream.Close();
			}
		}

		public interface IFileAbstraction
		{
			string Name { get; }

			Stream ReadStream { get; }

			Stream WriteStream { get; }

			void CloseStream(Stream stream);
		}

		private Stream file_stream;

		protected IFileAbstraction file_abstraction;

		private static readonly int buffer_size = 1024;

		private static readonly List<FileTypeResolver> file_type_resolvers = new List<FileTypeResolver>();

		private List<string> corruption_reasons;

		public static uint BufferSize => (uint)buffer_size;

		public abstract Tag Tag { get; }

		public abstract Properties Properties { get; }

		public TagTypes TagTypesOnDisk { get; protected set; }

		public TagTypes TagTypes => Tag?.TagTypes ?? TagTypes.None;

		public string Name => file_abstraction.Name;

		public string MimeType { get; internal set; }

		public long Tell
		{
			get
			{
				if (Mode != AccessMode.Closed)
				{
					return file_stream.Position;
				}
				return 0L;
			}
		}

		public long Length
		{
			get
			{
				if (Mode != AccessMode.Closed)
				{
					return file_stream.Length;
				}
				return 0L;
			}
		}

		public long InvariantStartPosition { get; protected set; } = -1L;


		public long InvariantEndPosition { get; protected set; } = -1L;


		public AccessMode Mode
		{
			get
			{
				if (file_stream == null)
				{
					return AccessMode.Closed;
				}
				if (file_stream.CanWrite)
				{
					return AccessMode.Write;
				}
				return AccessMode.Read;
			}
			set
			{
				if (Mode != value && (Mode != AccessMode.Write || value != 0))
				{
					if (file_stream != null)
					{
						file_abstraction.CloseStream(file_stream);
					}
					file_stream = null;
					switch (value)
					{
					case AccessMode.Read:
						file_stream = file_abstraction.ReadStream;
						break;
					case AccessMode.Write:
						file_stream = file_abstraction.WriteStream;
						break;
					}
					Mode = value;
				}
			}
		}

		public IFileAbstraction FileAbstraction => file_abstraction;

		public virtual bool Writeable => !PossiblyCorrupt;

		public bool PossiblyCorrupt => corruption_reasons != null;

		public IEnumerable<string> CorruptionReasons => corruption_reasons;

		protected File(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			file_abstraction = new LocalFileAbstraction(path);
		}

		protected File(IFileAbstraction abstraction)
		{
			if (abstraction == null)
			{
				throw new ArgumentNullException("abstraction");
			}
			file_abstraction = abstraction;
		}

		internal void MarkAsCorrupt(string reason)
		{
			if (corruption_reasons == null)
			{
				corruption_reasons = new List<string>();
			}
			corruption_reasons.Add(reason);
		}

		public void Dispose()
		{
			Mode = AccessMode.Closed;
		}

		public abstract void Save();

		public abstract void RemoveTags(TagTypes types);

		public abstract Tag GetTag(TagTypes type, bool create);

		public Tag GetTag(TagTypes type)
		{
			return GetTag(type, create: false);
		}

		public ByteVector ReadBlock(int length)
		{
			if (length < 0)
			{
				throw new ArgumentException("Length must be non-negative", "length");
			}
			if (length == 0)
			{
				return new ByteVector();
			}
			Mode = AccessMode.Read;
			byte[] array = new byte[length];
			int num = 0;
			int num2 = 0;
			int num3 = length;
			do
			{
				num = file_stream.Read(array, num2, num3);
				num2 += num;
				num3 -= num;
			}
			while (num3 > 0 && num != 0);
			return new ByteVector(array, num2);
		}

		public void WriteBlock(ByteVector data)
		{
			if (data == null)
			{
				throw new ArgumentNullException("data");
			}
			Mode = AccessMode.Write;
			file_stream.Write(data.Data, 0, data.Count);
		}

		public long Find(ByteVector pattern, long startPosition, ByteVector before)
		{
			if (pattern == null)
			{
				throw new ArgumentNullException("pattern");
			}
			Mode = AccessMode.Read;
			if (pattern.Count > buffer_size)
			{
				return -1L;
			}
			long num = startPosition;
			long position = file_stream.Position;
			try
			{
				file_stream.Position = startPosition;
				ByteVector byteVector = ReadBlock(buffer_size);
				while (byteVector.Count > 0)
				{
					int num2 = byteVector.Find(pattern);
					if (before != null && byteVector.Find(before) < num2)
					{
						return -1L;
					}
					if (num2 >= 0)
					{
						return num + num2;
					}
					num += buffer_size - pattern.Count;
					if (before != null && before.Count > pattern.Count)
					{
						num -= before.Count - pattern.Count;
					}
					file_stream.Position = num;
					byteVector = ReadBlock(buffer_size);
				}
				return -1L;
			}
			finally
			{
				file_stream.Position = position;
			}
		}

		public long Find(ByteVector pattern, long startPosition)
		{
			return Find(pattern, startPosition, null);
		}

		public long Find(ByteVector pattern)
		{
			return Find(pattern, 0L);
		}

		private long RFind(ByteVector pattern, long startPosition, ByteVector after)
		{
			if (pattern == null)
			{
				throw new ArgumentNullException("pattern");
			}
			Mode = AccessMode.Read;
			if (pattern.Count > buffer_size)
			{
				return -1L;
			}
			long position = file_stream.Position;
			long num = Length - startPosition;
			int num2 = buffer_size;
			num2 = (int)Math.Min(num, buffer_size);
			num -= num2;
			file_stream.Position = num;
			ByteVector byteVector = ReadBlock(num2);
			while (byteVector.Count > 0)
			{
				long num3 = byteVector.RFind(pattern);
				if (num3 >= 0)
				{
					file_stream.Position = position;
					return num + num3;
				}
				if (after != null && byteVector.RFind(after) >= 0)
				{
					file_stream.Position = position;
					return -1L;
				}
				num2 = (int)Math.Min(num, buffer_size);
				num -= num2;
				if (num2 + pattern.Count > buffer_size)
				{
					num += pattern.Count;
				}
				file_stream.Position = num;
				byteVector = ReadBlock(num2);
			}
			file_stream.Position = position;
			return -1L;
		}

		public long RFind(ByteVector pattern, long startPosition)
		{
			return RFind(pattern, startPosition, null);
		}

		public long RFind(ByteVector pattern)
		{
			return RFind(pattern, 0L);
		}

		public void Insert(ByteVector data, long start, long replace)
		{
			if (data == null)
			{
				throw new ArgumentNullException("data");
			}
			Insert(data, data.Count, start, replace);
		}

		public void Insert(ByteVector data, long start)
		{
			Insert(data, start, 0L);
		}

		public void Insert(long size, long start)
		{
			Insert(null, size, start, 0L);
		}

		public void RemoveBlock(long start, long length)
		{
			if (length > 0)
			{
				Mode = AccessMode.Write;
				int length2 = buffer_size;
				long num = start + length;
				long num2 = start;
				ByteVector byteVector = (byte)1;
				while (byteVector.Count != 0)
				{
					file_stream.Position = num;
					byteVector = ReadBlock(length2);
					num += byteVector.Count;
					file_stream.Position = num2;
					WriteBlock(byteVector);
					num2 += byteVector.Count;
				}
				Truncate(num2);
			}
		}

		public void Seek(long offset, SeekOrigin origin)
		{
			if (Mode != AccessMode.Closed)
			{
				file_stream.Seek(offset, origin);
			}
		}

		public void Seek(long offset)
		{
			Seek(offset, SeekOrigin.Begin);
		}

		public static File Create(string path)
		{
			return Create(path, null, ReadStyle.Average);
		}

		public static File Create(IFileAbstraction abstraction)
		{
			return Create(abstraction, null, ReadStyle.Average);
		}

		public static File Create(string path, ReadStyle propertiesStyle)
		{
			return Create(path, null, propertiesStyle);
		}

		public static File Create(IFileAbstraction abstraction, ReadStyle propertiesStyle)
		{
			return Create(abstraction, null, propertiesStyle);
		}

		public static File Create(string path, string mimetype, ReadStyle propertiesStyle)
		{
			return Create(new LocalFileAbstraction(path), mimetype, propertiesStyle);
		}

		public static File Create(IFileAbstraction abstraction, string mimetype, ReadStyle propertiesStyle)
		{
			if (mimetype == null)
			{
				string text = string.Empty;
				int num = abstraction.Name.LastIndexOf(".") + 1;
				if (num >= 1 && num < abstraction.Name.Length)
				{
					text = abstraction.Name.Substring(num, abstraction.Name.Length - num);
				}
				mimetype = "taglib/" + text.ToLower(CultureInfo.InvariantCulture);
			}
			foreach (FileTypeResolver file_type_resolver in file_type_resolvers)
			{
				File file = file_type_resolver(abstraction, mimetype, propertiesStyle);
				if (file != null)
				{
					return file;
				}
			}
			if (!FileTypes.AvailableTypes.ContainsKey(mimetype))
			{
				throw new UnsupportedFormatException(string.Format(CultureInfo.InvariantCulture, "{0} ({1})", abstraction.Name, mimetype));
			}
			Type type = FileTypes.AvailableTypes[mimetype];
			try
			{
				File obj = (File)Activator.CreateInstance(type, abstraction, propertiesStyle);
				obj.MimeType = mimetype;
				return obj;
			}
			catch (TargetInvocationException ex)
			{
				PrepareExceptionForRethrow(ex.InnerException);
				throw ex.InnerException;
			}
		}

		public static void AddFileTypeResolver(FileTypeResolver resolver)
		{
			if (resolver != null)
			{
				file_type_resolvers.Insert(0, resolver);
			}
		}

		protected void PreSave()
		{
			if (!Writeable)
			{
				throw new InvalidOperationException("File not writeable.");
			}
			if (PossiblyCorrupt)
			{
				throw new CorruptFileException("Corrupted file cannot be saved.");
			}
			if (Tag?.Pictures == null)
			{
				return;
			}
			IPicture[] pictures = Tag.Pictures;
			for (int i = 0; i < pictures.Length; i++)
			{
				if (pictures[i] is ILazy lazy)
				{
					lazy.Load();
				}
			}
		}

		private void Insert(ByteVector data, long size, long start, long replace)
		{
			Mode = AccessMode.Write;
			if (size == replace)
			{
				if (data != null)
				{
					file_stream.Position = start;
					WriteBlock(data);
				}
				return;
			}
			if (size < replace)
			{
				if (data != null)
				{
					file_stream.Position = start;
					WriteBlock(data);
				}
				RemoveBlock(start + size, replace - size);
				return;
			}
			int num = (int)(size - replace);
			int num2 = num % buffer_size;
			if (num2 != 0)
			{
				num += buffer_size - num2;
			}
			long num3 = start + replace;
			long num4 = start;
			file_stream.Position = num3;
			byte[] data2 = ReadBlock(num).Data;
			num3 += num;
			if (data != null)
			{
				file_stream.Position = num4;
				WriteBlock(data);
			}
			else if (start + size > Length)
			{
				file_stream.SetLength(start + size);
			}
			num4 += size;
			byte[] array = new byte[data2.Length];
			Array.Copy(data2, 0, array, 0, data2.Length);
			while (num != 0)
			{
				file_stream.Position = num3;
				int num5 = file_stream.Read(data2, 0, (num < data2.Length) ? num : data2.Length);
				num3 += num;
				file_stream.Position = num4;
				file_stream.Write(array, 0, (num < array.Length) ? num : array.Length);
				num4 += num;
				Array.Copy(data2, 0, array, 0, num5);
				num = num5;
			}
		}

		protected void Truncate(long length)
		{
			AccessMode mode = Mode;
			Mode = AccessMode.Write;
			file_stream.SetLength(length);
			Mode = mode;
		}

		private static void PrepareExceptionForRethrow(Exception ex)
		{
			StreamingContext context = new StreamingContext(StreamingContextStates.CrossAppDomain);
			ObjectManager objectManager = new ObjectManager(null, context);
			SerializationInfo info = new SerializationInfo(ex.GetType(), new FormatterConverter());
			ex.GetObjectData(info, context);
			objectManager.RegisterObject(ex, 1L, info);
			objectManager.DoFixups();
		}
	}
	public static class FileTypes
	{
		private static Dictionary<string, Type> file_types;

		private static readonly Type[] static_file_types;

		public static IDictionary<string, Type> AvailableTypes => file_types;

		static FileTypes()
		{
			static_file_types = new Type[26]
			{
				typeof(TagLib.Aac.File),
				typeof(TagLib.Aiff.File),
				typeof(TagLib.Ape.File),
				typeof(TagLib.Asf.File),
				typeof(TagLib.Audible.File),
				typeof(TagLib.Dsf.File),
				typeof(TagLib.Flac.File),
				typeof(TagLib.Matroska.File),
				typeof(TagLib.Gif.File),
				typeof(TagLib.Image.NoMetadata.File),
				typeof(TagLib.Jpeg.File),
				typeof(TagLib.Mpeg4.File),
				typeof(AudioFile),
				typeof(TagLib.Mpeg.File),
				typeof(TagLib.MusePack.File),
				typeof(TagLib.Ogg.File),
				typeof(TagLib.Png.File),
				typeof(TagLib.Riff.File),
				typeof(TagLib.Tiff.Arw.File),
				typeof(TagLib.Tiff.Cr2.File),
				typeof(TagLib.Tiff.Dng.File),
				typeof(TagLib.Tiff.File),
				typeof(TagLib.Tiff.Nef.File),
				typeof(TagLib.Tiff.Pef.File),
				typeof(TagLib.Tiff.Rw2.File),
				typeof(TagLib.WavPack.File)
			};
			Init();
		}

		internal static void Init()
		{
			if (file_types == null)
			{
				file_types = new Dictionary<string, Type>();
				Type[] array = static_file_types;
				for (int i = 0; i < array.Length; i++)
				{
					Register(array[i]);
				}
			}
		}

		public static void Register(Type type)
		{
			Attribute[] customAttributes = Attribute.GetCustomAttributes(type, typeof(SupportedMimeType), inherit: false);
			if (customAttributes.Length != 0)
			{
				Attribute[] array = customAttributes;
				for (int i = 0; i < array.Length; i++)
				{
					SupportedMimeType supportedMimeType = (SupportedMimeType)array[i];
					file_types.Add(supportedMimeType.MimeType, type);
				}
			}
		}
	}
	public static class Genres
	{
		private static readonly string[] audio = new string[148]
		{
			"Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge", "Hip-Hop", "Jazz", "Metal",
			"New Age", "Oldies", "Other", "Pop", "R&B", "Rap", "Reggae", "Rock", "Techno", "Industrial",
			"Alternative", "Ska", "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop", "Vocal", "Jazz+Funk",
			"Fusion", "Trance", "Classical", "Instrumental", "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise",
			"Alternative Rock", "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop", "Instrumental Rock", "Ethnic", "Gothic",
			"Darkwave", "Techno-Industrial", "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy", "Cult", "Gangsta",
			"Top 40", "Christian Rap", "Pop/Funk", "Jungle", "Native American", "Cabaret", "New Wave", "Psychedelic", "Rave", "Showtunes",
			"Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz", "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
			"Folk", "Folk/Rock", "National Folk", "Swing", "Fusion", "Bebob", "Latin", "Revival", "Celtic", "Bluegrass",
			"Avantgarde", "Gothic Rock", "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock", "Big Band", "Chorus", "Easy Listening", "Acoustic",
			"Humour", "Speech", "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass", "Primus", "Porn Groove",
			"Satire", "Slow Jam", "Club", "Tango", "Samba", "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
			"Duet", "Punk Rock", "Drum Solo", "A Cappella", "Euro-House", "Dance Hall", "Goa", "Drum & Bass", "Club-House", "Hardcore",
			"Terror", "Indie", "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap", "Heavy Metal", "Black Metal", "Crossover",
			"Contemporary Christian", "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop", "Synthpop"
		};

		private static readonly string[] video = new string[40]
		{
			"Action", "Action/Adventure", "Adult", "Adventure", "Catastrophe", "Child's", "Claymation", "Comedy", "Concert", "Documentary",
			"Drama", "Eastern", "Entertaining", "Erotic", "Extremal Sport", "Fantasy", "Fashion", "Historical", "Horror", "Horror/Mystic",
			"Humor", "Indian", "Informercial", "Melodrama", "Military & War", "Music Video", "Musical", "Mystery", "Nature", "Political Satire",
			"Popular Science", "Psychological Thriller", "Religion", "Science Fiction", "Scifi Action", "Slapstick", "Splatter", "Sports", "Thriller", "Western"
		};

		public static string[] Audio => (string[])audio.Clone();

		public static string[] Video => (string[])video.Clone();

		public static byte AudioToIndex(string name)
		{
			for (byte b = 0; b < audio.Length; b++)
			{
				if (name == audio[b])
				{
					return b;
				}
			}
			return byte.MaxValue;
		}

		public static byte VideoToIndex(string name)
		{
			for (byte b = 0; b < video.Length; b++)
			{
				if (name == video[b])
				{
					return b;
				}
			}
			return byte.MaxValue;
		}

		public static string IndexToAudio(byte index)
		{
			if (index >= audio.Length)
			{
				return null;
			}
			return audio[index];
		}

		public static string IndexToVideo(byte index)
		{
			if (index >= video.Length)
			{
				return null;
			}
			return video[index];
		}

		public static string IndexToAudio(string text)
		{
			return IndexToAudio(StringToByte(text));
		}

		public static string IndexToVideo(string text)
		{
			return IndexToVideo(StringToByte(text));
		}

		private static byte StringToByte(string text)
		{
			int num;
			if (text != null && text.Length > 2 && text[0] == '(' && (num = text.IndexOf(')')) != -1 && byte.TryParse(text.Substring(1, num - 1), out var result))
			{
				return result;
			}
			if (text != null && byte.TryParse(text, out result))
			{
				return result;
			}
			return byte.MaxValue;
		}
	}
	[Flags]
	public enum MediaTypes
	{
		None = 0,
		Audio = 1,
		Video = 2,
		Photo = 4,
		Text = 8
	}
	public interface ICodec
	{
		TimeSpan Duration { get; }

		MediaTypes MediaTypes { get; }

		string Description { get; }
	}
	public interface IAudioCodec : ICodec
	{
		int AudioBitrate { get; }

		int AudioSampleRate { get; }

		int AudioChannels { get; }
	}
	public interface ILosslessAudioCodec
	{
		int BitsPerSample { get; }
	}
	public interface IVideoCodec : ICodec
	{
		int VideoWidth { get; }

		int VideoHeight { get; }
	}
	public interface IPhotoCodec : ICodec
	{
		int PhotoWidth { get; }

		int PhotoHeight { get; }

		int PhotoQuality { get; }
	}
	public interface ILazy
	{
		bool IsLoaded { get; }

		void Load();
	}
	public class ListBase<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable where T : IComparable<T>
	{
		private readonly List<T> data = new List<T>();

		public bool IsEmpty => Count == 0;

		public bool IsReadOnly => false;

		public bool IsFixedSize => false;

		public T this[int index]
		{
			get
			{
				return data[index];
			}
			set
			{
				data[index] = value;
			}
		}

		public int Count => data.Count;

		public bool IsSynchronized => false;

		public object SyncRoot => this;

		public ListBase()
		{
		}

		public ListBase(ListBase<T> list)
		{
			if (list != null)
			{
				Add(list);
			}
		}

		public ListBase(params T[] list)
		{
			if (list != null)
			{
				Add(list);
			}
		}

		public void Add(ListBase<T> list)
		{
			if (list != null)
			{
				data.AddRange(list);
			}
		}

		public void Add(IEnumerable<T> list)
		{
			if (list != null)
			{
				data.AddRange(list);
			}
		}

		public void Add(T[] list)
		{
			if (list != null)
			{
				data.AddRange(list);
			}
		}

		public virtual void SortedInsert(T item, bool unique)
		{
			if (item == null)
			{
				throw new ArgumentNullException("item");
			}
			int i;
			for (i = 0; i < data.Count; i++)
			{
				if (item.CompareTo(data[i]) == 0 && unique)
				{
					return;
				}
				if (item.CompareTo(data[i]) <= 0)
				{
					break;
				}
			}
			Insert(i, item);
		}

		public void SortedInsert(T item)
		{
			if (item == null)
			{
				throw new ArgumentNullException("item");
			}
			SortedInsert(item, unique: false);
		}

		public T[] ToArray()
		{
			return data.ToArray();
		}

		public void Add(T item)
		{
			data.Add(item);
		}

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

		public bool Contains(T item)
		{
			return data.Contains(item);
		}

		public int IndexOf(T item)
		{
			return data.IndexOf(item);
		}

		public void Insert(int index, T item)
		{
			data.Insert(index, item);
		}

		public bool Remove(T item)
		{
			return data.Remove(item);
		}

		public void RemoveAt(int index)
		{
			data.RemoveAt(index);
		}

		public string ToString(string separator)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < Count; i++)
			{
				if (i != 0)
				{
					stringBuilder.Append(separator);
				}
				stringBuilder.Append(this[i]);
			}
			return stringBuilder.ToString();
		}

		public override string ToString()
		{
			return ToString(", ");
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			data.CopyTo(array, arrayIndex);
		}

		public IEnumerator<T> GetEnumerator()
		{
			return data.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return data.GetEnumerator();
		}
	}
	public class TextBox : Box
	{
		private ByteVector data;

		public override ByteVector Data
		{
			get
			{
				return data;
			}
			set
			{
				data = value;
			}
		}

		public TextBox(BoxHeader header, File file, IsoHandlerBox handler)
			: base(header, handler)
		{
			if (file == null)
			{
				throw new ArgumentNullException("file");
			}
			data = LoadData(file);
		}
	}
	public class UrlBox : Box
	{
		private ByteVector data;

		public override ByteVector Data
		{
			get
			{
				return data;
			}
			set
			{
				data = value;
			}
		}

		public UrlBox(BoxHeader header, File file, IsoHandlerBox handler)
			: base(header, handler)
		{
			if (file == null)
			{
				throw new ArgumentNullException("file");
			}
			data = LoadData(file);
		}
	}
	public enum PictureType
	{
		Other = 0,
		FileIcon = 1,
		OtherFileIcon = 2,
		FrontCover = 3,
		BackCover = 4,
		LeafletPage = 5,
		Media = 6,
		LeadArtist = 7,
		Artist = 8,
		Conductor = 9,
		Band = 10,
		Composer = 11,
		Lyricist = 12,
		RecordingLocation = 13,
		DuringRecording = 14,
		DuringPerformance = 15,
		MovieScreenCapture = 16,
		ColoredFish = 17,
		Illustration = 18,
		BandLogo = 19,
		PublisherLogo = 20,
		NotAPicture = 255
	}
	public interface IPicture
	{
		string MimeType { get; set; }

		PictureType Type { get; set; }

		string Filename { get; set; }

		string Description { get; set; }

		ByteVector Data { get; set; }
	}
	public class Picture : IPicture
	{
		private static readonly string[] lutExtensionMime = new string[150]
		{
			"aac", "audio/aac", "abw", "application/x-abiword", "arc", "application/octet-stream", "avi", "video/x-msvideo", "azw", "application/vnd.amazon.ebook",
			"bin", "application/octet-stream", "bmp", "image/bmp", "bmp", "image/x-windows-bmp", "bm", "image/bmp", "bz", "application/x-bzip",
			"bz2", "application/x-bzip2", "csh", "application/x-csh", "css", "text/css", "csv", "text/csv", "doc", "application/msword",
			"eot", "application/vnd.ms-fontobject", "epub", "application/epub+zip", "gif", "image/gif", "htm", "text/html", "html", "text/html",
			"ico", "image/x-icon", "ics", "text/calendar", "jar", "application/java-archive", "jpg", "image/jpeg", "jpeg", "image/jpeg",
			"js", "application/javascript", "json", "application/json", "mid", "audio/midi", "midi", "audio/midi", "mp3", "audio/mpeg",
			"mp1", "audio/mpeg", "mp2", "audio/mpeg", "mpg", "video/mpeg", "mpeg", "video/mpeg", "m4a", "audio/mp4",
			"mp4", "video/mp4", "m4v", "video/mp4", "mpkg", "application/vnd.apple.installer+xml", "odp", "application/vnd.oasis.opendocument.presentation", "ods", "application/vnd.oasis.opendocument.spreadsheet",
			"odt", "application/vnd.oasis.opendocument.text", "oga", "audio/ogg", "ogg", "audio/ogg", "ogx", "application/ogg", "ogv", "video/ogg",
			"otf", "font/otf", "png", "image/png", "pdf", "application/pdf", "ppt", "application/vnd.ms-powerpoint", "rar", "application/x-rar-compressed",
			"rtf", "application/rtf", "sh", "application/x-sh", "svg", "image/svg+xml", "swf", "application/x-shockwave-flash", "tar", "application/x-tar",
			"tif", "image/tiff", "tiff", "image/tiff", "ts", "video/vnd.dlna.mpeg-tts", "ttf", "font/ttf", "vsd", "application/vnd.visio",
			"wav", "audio/x-wav", "weba", "audio/webm", "webm", "video/webm", "webp", "image/webp", "woff", "font/woff",
			"woff2", "font/woff2", "xhtml", "application/xhtml+xml", "xls", "application/vnd.ms", "xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "xml", "application/xml",
			"xul", "application/vnd.mozilla.xul+xml", "zip", "application/zip", "3gp", "video/3gpp", "3g2", "video/3gpp2", "7z", "application/x-7z-compressed"
		};

		public string MimeType { get; set; }

		public PictureType Type { get; set; }

		public string Filename { get; set; }

		public string Description { get; set; }

		public ByteVector Data { get; set; }

		public Picture()
		{
		}

		public Picture(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			Data = ByteVector.FromPath(path);
			Filename = Path.GetFileName(path);
			Description = Filename;
			MimeType = GetMimeFromExtension(Filename);
			Type = (MimeType.StartsWith("image/") ? PictureType.FrontCover : PictureType.NotAPicture);
		}

		public Picture(File.IFileAbstraction abstraction)
		{
			if (abstraction == null)
			{
				throw new ArgumentNullException("abstraction");
			}
			Data = ByteVector.FromFile(abstraction);
			Filename = abstraction.Name;
			Description = abstraction.Name;
			if (!string.IsNullOrEmpty(Filename) && Filename.Contains("."))
			{
				MimeType = GetMimeFromExtension(Filename);
				Type = (MimeType.StartsWith("image/") ? PictureType.FrontCover : PictureType.NotAPicture);
				return;
			}
			string extensionFromData = GetExtensionFromData(Data);
			MimeType = GetMimeFromExtension(extensionFromData);
			if (extensionFromData != null)
			{
				Type = PictureType.FrontCover;
				Filename = (Description = "cover" + extensionFromData);
			}
			else
			{
				Type = PictureType.NotAPicture;
				Filename = "UnknownType";
			}
		}

		public Picture(ByteVector data)
		{
			if (data == null)
			{
				throw new ArgumentNullException("data");
			}
			Data = new ByteVector(data);
			string extensionFromData = GetExtensionFromData(data);
			MimeType = GetMimeFromExtension(extensionFromData);
			if (extensionFromData != null)
			{
				Type = PictureType.FrontCover;
				Filename = (Description = "cover" + extensionFromData);
			}
			else
			{
				Type = PictureType.NotAPicture;
				Filename = "UnknownType";
			}
		}

		public Picture(IPicture picture)
		{
			MimeType = picture.MimeType;
			Type = picture.Type;
			Filename = picture.Filename;
			Description = picture.Description;
			Data = picture.Data;
		}

		[Obsolete("Use Picture(string filename) constructor instead.")]
		public static Picture CreateFromPath(string filename)
		{
			return new Picture(filename);
		}

		[Obsolete("Use Picture(File.IFileAbstraction abstraction) constructor instead.")]
		public static Picture CreateFromFile(File.IFileAbstraction abstraction)
		{
			return new Picture(abstraction);
		}

		public static string GetExtensionFromData(ByteVector data)
		{
			string result = null;
			if (data.Count >= 4)
			{
				if (data[1] == 80 && data[2] == 78 && data[3] == 71)
				{
					result = ".png";
				}
				else if (data[0] == 71 && data[1] == 73 && data[2] == 70)
				{
					result = ".gif";
				}
				else if (data[0] == 66 && data[1] == 77)
				{
					result = ".bmp";
				}
				else if (data[0] == byte.MaxValue && data[1] == 216 && data[data.Count - 2] == byte.MaxValue && data[data.Count - 1] == 217)
				{
					result = ".jpg";
				}
			}
			return result;
		}

		public static string GetExtensionFromMime(string mime)
		{
			string result = null;
			for (int i = 1; i < lutExtensionMime.Length; i += 2)
			{
				if (lutExtensionMime[i] == mime)
				{
					result = lutExtensionMime[i - 1];
					break;
				}
			}
			return result;
		}

		public static string GetMimeFromExtension(string name)
		{
			string result = "application/octet-stream";
			if (string.IsNullOrEmpty(name))
			{
				return result;
			}
			string extension = Path.GetExtension(name);
			extension = ((!string.IsNullOrEmpty(extension)) ? extension.Substring(1) : name);
			extension = extension.ToLower();
			for (int i = 0; i < lutExtensionMime.Length; i += 2)
			{
				if (lutExtensionMime[i] == extension)
				{
					result = lutExtensionMime[i + 1];
					break;
				}
			}
			return result;
		}
	}
	public class PictureLazy : IPicture, ILazy
	{
		private string mime_type;

		private PictureType type;

		private string filename;

		private ByteVector data;

		private File.IFileAbstraction file;

		private readonly long stream_offset;

		private readonly long stream_size = -1L;

		public string MimeType
		{
			get
			{
				if (mime_type == null)
				{
					Load();
				}
				return mime_type;
			}
			set
			{
				mime_type = value;
			}
		}

		public PictureType Type
		{
			get
			{
				if (type == PictureType.Other && mime_type == null)
				{
					Load();
				}
				return type;
			}
			set
			{
				type = value;
			}
		}

		public string Filename
		{
			get
			{
				if (filename == null)
				{
					Load();
				}
				return filename;
			}
			set
			{
				filename = value;
			}
		}

		public string Description { get; set; }

		public ByteVector Data
		{
			get
			{
				if (data == null)
				{
					Load();
				}
				return data;
			}
			set
			{
				data = value;
			}
		}

		public bool IsLoaded => data != null;

		public PictureLazy()
		{
		}

		public PictureLazy(string path)
		{
			if (path == null)
			{
				throw new ArgumentNullException("path");
			}
			file = new File.LocalFileAbstraction(path);
			filename = Path.GetFileName(path);
			Description = filename;
			mime_type = Picture.GetMimeFromExtension(filename);
			type = (mime_type.StartsWith("image/") ? PictureType.FrontCover : PictureType.NotAPicture);
		}

		public PictureLazy(File.IFileAbstraction abstraction, long offset = 0L, long size = -1L)
		{
			if (abstraction == null)
			{
				throw new ArgumentNullException("abstraction");
			}
			file = abstraction;
			stream_offset = offset;
			stream_size = size;
			filename = abstraction.Name;
			Description = abstraction.Name;
			if (!string.IsNullOrEmpty(filename) && filename.Contains("."))
			{
				mime_type = Picture.GetMimeFromExtension(filename);
				type = (mime_type.StartsWith("image/") ? PictureType.FrontCover : PictureType.NotAPicture);
			}
		}

		public PictureLazy(ByteVector data)
		{
			if (data == null)
			{
				throw new ArgumentNullException("data");
			}
			Data = new ByteVector(data);
			string extensionFromData = Picture.GetExtensionFromData(data);
			MimeType = Picture.GetMimeFromExtension(extensionFromData);
			if (extensionFromData != null)
			{
				type = PictureType.FrontCover;
				filename = (Description = "cover" + extensionFromData);
			}
			else
			{
				type = PictureType.NotAPicture;
				filename = "UnknownType";
			}
		}

		public PictureLazy(IPicture picture)
		{
			mime_type = picture.MimeType;
			type = picture.Type;
			filename = picture.Filename;
			Description = picture.Description;
			data = picture.Data;
		}

		public void Load()
		{
			if (data != null)
			{
				return;
			}
			Stream stream = null;
			try
			{
				if (stream_size == 0L)
				{
					data = new ByteVector();
				}
				else if (stream_size > 0)
				{
					stream = file.ReadStream;
					stream.Seek(stream_offset, SeekOrigin.Begin);
					int num = 0;
					int num2 = 0;
					int num3 = (int)stream_size;
					byte[] buffer = new byte[num3];
					do
					{
						num = stream.Read(buffer, num2, num3);
						num2 += num;
						num3 -= num;
					}
					while (num3 > 0 && num != 0);
					data = new ByteVector(buffer, num2);
				}
				else
				{
					stream = file.ReadStream;
					stream.Seek(stream_offset, SeekOrigin.Begin);
					data = ByteVector.FromStream(stream);
				}
			}
			finally
			{
				if (stream != null && file != null)
				{
					file.CloseStream(stream);
				}
				file = null;
			}
			if (mime_type != null)
			{
				return;
			}
			string extensionFromData = Picture.GetExtensionFromData(data);
			MimeType = Picture.GetMimeFromExtension(extensionFromData);
			if (extensionFromData != null)
			{
				type = PictureType.FrontCover;
				if (filename == null)
				{
					string text2 = (Description = "cover" + extensionFromData);
					filename = text2;
				}
			}
			else
			{
				type = PictureType.NotAPicture;
				if (filename == null)
				{
					filename = "UnknownType";
				}
			}
		}
	}
	public class Properties : IAudioCodec, ICodec, IVideoCodec, IPhotoCodec
	{
		private readonly ICodec[] codecs = new ICodec[0];

		private TimeSpan duration = TimeSpan.Zero;

		public IEnumerable<ICodec> Codecs => codecs;

		public TimeSpan Duration
		{
			get
			{
				TimeSpan timeSpan = duration;
				if (timeSpan != TimeSpan.Zero)
				{
					return timeSpan;
				}
				ICodec[] array = codecs;
				foreach (ICodec codec in array)
				{
					if (codec != null && codec.Duration > timeSpan)
					{
						timeSpan = codec.Duration;
					}
				}
				return timeSpan;
			}
		}

		public MediaTypes MediaTypes
		{
			get
			{
				MediaTypes mediaTypes = MediaTypes.None;
				ICodec[] array = codecs;
				foreach (ICodec codec in array)
				{
					if (codec != null)
					{
						mediaTypes |= codec.MediaTypes;
					}
				}
				return mediaTypes;
			}
		}

		public string Description
		{
			get
			{
				StringBuilder stringBuilder = new StringBuilder();
				ICodec[] array = codecs;
				foreach (ICodec codec in array)
				{
					if (codec != null)
					{
						if (stringBuilder.Length != 0)
						{
							stringBuilder.Append("; ");
						}
						stringBuilder.Append(codec.Description);
					}
				}
				return stringBuilder.ToString();
			}
		}

		public int AudioBitrate
		{
			get
			{
				ICodec[] array = codecs;
				foreach (ICodec codec in array)
				{
					if (codec != null && (codec.MediaTypes & MediaTypes.Audio) != 0 && codec is IAudioCodec audioCodec && audioCodec.AudioBitrate != 0)
					{
						return audioCodec.AudioBitrate;
					}
				}
				return 0;
			}
		}

		public int AudioSampleRate
		{
			get
			{
				ICodec[] array = codecs;
				foreach (ICodec codec in array)
				{
					if (codec != null && (codec.MediaTypes & MediaTypes.Audio) != 0 && codec is IAudioCodec audioCodec && audioCodec.AudioSampleRate != 0)
					{
						return audioCodec.AudioSampleRate;
					}
				}
				return 0;
			}
		}

		public int BitsPerSample
		{
			get
			{
				ICodec[] array = codecs;
				foreach (ICodec codec in array)
				{
					if (codec != null && (codec.MediaTypes & MediaTypes.Audio) != 0 && codec is ILosslessAudioCodec losslessAudioCodec && losslessAudioCodec.BitsPerSample != 0)
					{
						return losslessAudioCodec.BitsPerSample;
					}
				}
				return 0;
			}
		}

		public int AudioChannels
		{
			get
			{
				ICodec[] array = codecs;
				foreach (ICodec codec in array)
				{
					if (codec != null && (codec.MediaTypes & MediaTypes.Audio) != 0 && codec is IAudioCodec audioCodec && audioCodec.AudioChannels != 0)
					{
						return audioCodec.AudioChannels;
					}
				}
				return 0;
			}
		}

		public int VideoWidth
		{
			get
			{
				ICodec[] array = codecs;
				foreach (ICodec codec in array)
				{
					if (codec != null && (codec.MediaTypes & MediaTypes.Video) != 0 && codec is IVideoCodec videoCodec && videoCodec.VideoWidth != 0)
					{
						return videoCodec.VideoWidth;
					}
				}
				return 0;
			}
		}

		public int VideoHeight
		{
			get
			{
				ICodec[] array = codecs;
				foreach (ICodec codec in array)
				{
					if (codec != null && (codec.MediaTypes & MediaTypes.Video) != 0 && codec is IVideoCodec videoCodec && videoCodec.VideoHeight != 0)
					{
						return videoCodec.VideoHeight;
					}
				}
				return 0;
			}
		}

		public int PhotoWidth
		{
			get
			{
				ICodec[] array = codecs;
				foreach (ICodec codec in array)
				{
					if (codec != null && (codec.MediaTypes & MediaTypes.Photo) != 0 && codec is IPhotoCodec photoCodec && photoCodec.PhotoWidth != 0)
					{
						return photoCodec.PhotoWidth;
					}
				}
				return 0;
			}
		}

		public int PhotoHeight
		{
			get
			{
				ICodec[] array = codecs;
				foreach (ICodec codec in array)
				{
					if (codec != null && (codec.MediaTypes & MediaTypes.Photo) != 0 && codec is IPhotoCodec photoCodec && photoCodec.PhotoHeight != 0)
					{
						return photoCodec.PhotoHeight;
					}
				}
				return 0;
			}
		}

		public int PhotoQuality
		{
			get
			{
				ICodec[] array = codecs;
				foreach (ICodec codec in array)
				{
					if (codec != null && (codec.MediaTypes & MediaTypes.Photo) != 0 && codec is IPhotoCodec photoCodec && photoCodec.PhotoQuality != 0)
					{
						return photoCodec.PhotoQuality;
					}
				}
				return 0;
			}
		}

		public Properties()
		{
		}

		public Properties(TimeSpan duration, params ICodec[] codecs)
		{
			this.duration = duration;
			if (codecs != null)
			{
				this.codecs = codecs;
			}
		}

		public Properties(TimeSpan duration, IEnumerable<ICodec> codecs)
		{
			this.duration = duration;
			if (codecs != null)
			{
				this.codecs = new List<ICodec>(codecs).ToArray();
			}
		}
	}
	public sealed class ReadOnlyByteVector : ByteVector
	{
		public override bool IsReadOnly => true;

		public override bool IsFixedSize => true;

		public ReadOnlyByteVector()
		{
		}

		public ReadOnlyByteVector(int size, byte value)
			: base(size, value)
		{
		}

		public ReadOnlyByteVector(int size)
			: this(size, 0)
		{
		}

		public ReadOnlyByteVector(ByteVector vector)
			: base(vector)
		{
		}

		public ReadOnlyByteVector(byte[] data, int length)
			: base(data, length)
		{
		}

		public ReadOnlyByteVector(params byte[] data)
			: base(data)
		{
		}

		public static implicit operator ReadOnlyByteVector(byte value)
		{
			return new ReadOnlyByteVector(value);
		}

		public static implicit operator ReadOnlyByteVector(byte[] value)
		{
			return new ReadOnlyByteVector(value);
		}

		public static implicit operator ReadOnlyByteVector(string value)
		{
			return new ReadOnlyByteVector(ByteVector.FromString(value, StringType.UTF8));
		}
	}
	[ComVisible(false)]
	public class StringCollection : ListBase<string>
	{
		public StringCollection()
		{
		}

		public StringCollection(StringCollection values)
		{
			Add(values);
		}

		public StringCollection(params string[] values)
		{
			Add(values);
		}

		public StringCollection(ByteVectorCollection vectorList, StringType type)
		{
			foreach (ByteVector vector in vectorList)
			{
				Add(vector.ToString(type));
			}
		}

		public StringCollection(ByteVectorCollection vectorList)
			: this(vectorList, StringType.UTF8)
		{
		}

		public static StringCollection Split(string value, string pattern)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (pattern == null)
			{
				throw new ArgumentNullException("pattern");
			}
			StringCollection stringCollection = new StringCollection();
			int num = 0;
			int num2 = value.IndexOf(pattern, 0);
			int length = pattern.Length;
			while (num2 != -1)
			{
				stringCollection.Add(value.Substring(num, num2 - num));
				num = num2 + length;
				num2 = value.IndexOf(pattern, num);
			}
			stringCollection.Add(value.Substring(num));
			return stringCollection;
		}
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
	public sealed class SupportedMimeType : Attribute
	{
		private static readonly List<SupportedMimeType> mimetypes;

		public string MimeType { get; private set; }

		public string Extension { get; private set; }

		public static IEnumerable<string> AllMimeTypes
		{
			get
			{
				foreach (SupportedMimeType mimetype in mimetypes)
				{
					yield return mimetype.MimeType;
				}
			}
		}

		public static IEnumerable<string> AllExtensions
		{
			get
			{
				foreach (SupportedMimeType mimetype in mimetypes)
				{
					if (mimetype.Extension != null)
					{
						yield return mimetype.Extension;
					}
				}
			}
		}

		static SupportedMimeType()
		{
			mimetypes = new List<SupportedMimeType>();
			FileTypes.Init();
		}

		public SupportedMimeType(string mimetype)
		{
			MimeType = mimetype;
			mimetypes.Add(this);
		}

		public SupportedMimeType(string mimetype, string extension)
			: this(mimetype)
		{
			Extension = extension;
		}
	}
	[Flags]
	public enum TagTypes : uint
	{
		None = 0u,
		Xiph = 1u,
		Id3v1 = 2u,
		Id3v2 = 4u,
		Ape = 8u,
		Apple = 0x10u,
		Asf = 0x20u,
		RiffInfo = 0x40u,
		MovieId = 0x80u,
		DivX = 0x100u,
		FlacMetadata = 0x200u,
		TiffIFD = 0x400u,
		XMP = 0x800u,
		JpegComment = 0x1000u,
		GifComment = 0x2000u,
		Png = 0x4000u,
		IPTCIIM = 0x8000u,
		AudibleMetadata = 0x10000u,
		Matroska = 0x20000u,
		AllTags = uint.MaxValue
	}
	public abstract class Tag
	{
		public abstract TagTypes TagTypes { get; }

		public virtual string Title
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string TitleSort
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string Subtitle
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string Description
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string[] Performers
		{
			get
			{
				return new string[0];
			}
			set
			{
			}
		}

		public virtual string[] PerformersSort
		{
			get
			{
				return new string[0];
			}
			set
			{
			}
		}

		public virtual string[] PerformersRole
		{
			get
			{
				return new string[0];
			}
			set
			{
			}
		}

		public virtual string[] AlbumArtists
		{
			get
			{
				return new string[0];
			}
			set
			{
			}
		}

		public virtual string[] AlbumArtistsSort
		{
			get
			{
				return new string[0];
			}
			set
			{
			}
		}

		public virtual string[] Composers
		{
			get
			{
				return new string[0];
			}
			set
			{
			}
		}

		public virtual string[] ComposersSort
		{
			get
			{
				return new string[0];
			}
			set
			{
			}
		}

		public virtual string Album
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string AlbumSort
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string Comment
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string[] Genres
		{
			get
			{
				return new string[0];
			}
			set
			{
			}
		}

		public virtual uint Year
		{
			get
			{
				return 0u;
			}
			set
			{
			}
		}

		public virtual uint Track
		{
			get
			{
				return 0u;
			}
			set
			{
			}
		}

		public virtual uint TrackCount
		{
			get
			{
				return 0u;
			}
			set
			{
			}
		}

		public virtual uint Disc
		{
			get
			{
				return 0u;
			}
			set
			{
			}
		}

		public virtual uint DiscCount
		{
			get
			{
				return 0u;
			}
			set
			{
			}
		}

		public virtual string Lyrics
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string Grouping
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual uint BeatsPerMinute
		{
			get
			{
				return 0u;
			}
			set
			{
			}
		}

		public virtual string Conductor
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string Copyright
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual DateTime? DateTagged
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string MusicBrainzArtistId
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string MusicBrainzReleaseGroupId
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string MusicBrainzReleaseId
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string MusicBrainzReleaseArtistId
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string MusicBrainzTrackId
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string MusicBrainzDiscId
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string MusicIpId
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string AmazonId
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string MusicBrainzReleaseStatus
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string MusicBrainzReleaseType
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string MusicBrainzReleaseCountry
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual double ReplayGainTrackGain
		{
			get
			{
				return double.NaN;
			}
			set
			{
			}
		}

		public virtual double ReplayGainTrackPeak
		{
			get
			{
				return double.NaN;
			}
			set
			{
			}
		}

		public virtual double ReplayGainAlbumGain
		{
			get
			{
				return double.NaN;
			}
			set
			{
			}
		}

		public virtual double ReplayGainAlbumPeak
		{
			get
			{
				return double.NaN;
			}
			set
			{
			}
		}

		public virtual string InitialKey
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string RemixedBy
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string Publisher
		{
			get
			{
				return null;
			}