#define TRACE
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Net;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Speech.AudioFormat;
using System.Speech.Internal;
using System.Speech.Internal.GrammarBuilding;
using System.Speech.Internal.ObjectTokens;
using System.Speech.Internal.SapiInterop;
using System.Speech.Internal.SrgsCompiler;
using System.Speech.Internal.SrgsParser;
using System.Speech.Internal.Synthesis;
using System.Speech.Recognition;
using System.Speech.Recognition.SrgsGrammar;
using System.Speech.Synthesis;
using System.Speech.Synthesis.TtsEngine;
using System.Text;
using System.Threading;
using System.Xml;
using System.Xml.XPath;
using Microsoft.CodeAnalysis;
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyDefaultAlias("System.Speech")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: CLSCompliant(true)]
[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.System32 | DllImportSearchPath.AssemblyDirectory)]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("Provides types to perform speech synthesis and speech recognition.\r\n\r\nCommonly Used Types\r\nSystem.Speech.Synthesis.SpeechSynthesizer\r\nSystem.Speech.Recognition.SpeechRecognizer")]
[assembly: AssemblyFileVersion("8.0.23.53103")]
[assembly: AssemblyInformationalVersion("8.0.0+5535e31a712343a63f5d7d796cd874e563e5ac14")]
[assembly: AssemblyProduct("Microsoft® .NET")]
[assembly: AssemblyTitle("System.Speech")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/runtime")]
[assembly: SupportedOSPlatform("Windows")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("8.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NativeIntegerAttribute : Attribute
	{
		public readonly bool[] TransformFlags;

		public NativeIntegerAttribute()
		{
			TransformFlags = new bool[1] { true };
		}

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
internal static class Interop
{
	internal static class Libraries
	{
		internal const string Activeds = "activeds.dll";

		internal const string Advapi32 = "advapi32.dll";

		internal const string Authz = "authz.dll";

		internal const string BCrypt = "BCrypt.dll";

		internal const string Credui = "credui.dll";

		internal const string Crypt32 = "crypt32.dll";

		internal const string CryptUI = "cryptui.dll";

		internal const string Dnsapi = "dnsapi.dll";

		internal const string Dsrole = "dsrole.dll";

		internal const string Gdi32 = "gdi32.dll";

		internal const string HttpApi = "httpapi.dll";

		internal const string IpHlpApi = "iphlpapi.dll";

		internal const string Kernel32 = "kernel32.dll";

		internal const string Logoncli = "logoncli.dll";

		internal const string Mswsock = "mswsock.dll";

		internal const string NCrypt = "ncrypt.dll";

		internal const string Netapi32 = "netapi32.dll";

		internal const string Netutils = "netutils.dll";

		internal const string NtDll = "ntdll.dll";

		internal const string Odbc32 = "odbc32.dll";

		internal const string Ole32 = "ole32.dll";

		internal const string OleAut32 = "oleaut32.dll";

		internal const string Pdh = "pdh.dll";

		internal const string Secur32 = "secur32.dll";

		internal const string Shell32 = "shell32.dll";

		internal const string SspiCli = "sspicli.dll";

		internal const string User32 = "user32.dll";

		internal const string Version = "version.dll";

		internal const string WebSocket = "websocket.dll";

		internal const string Wevtapi = "wevtapi.dll";

		internal const string WinHttp = "winhttp.dll";

		internal const string WinMM = "winmm.dll";

		internal const string Wkscli = "wkscli.dll";

		internal const string Wldap32 = "wldap32.dll";

		internal const string Ws2_32 = "ws2_32.dll";

		internal const string Wtsapi32 = "wtsapi32.dll";

		internal const string CompressionNative = "System.IO.Compression.Native";

		internal const string GlobalizationNative = "System.Globalization.Native";

		internal const string MsQuic = "msquic.dll";

		internal const string HostPolicy = "hostpolicy";

		internal const string Ucrtbase = "ucrtbase.dll";

		internal const string Xolehlp = "xolehlp.dll";

		internal const string Comdlg32 = "comdlg32.dll";

		internal const string Gdiplus = "gdiplus.dll";

		internal const string Oleaut32 = "oleaut32.dll";

		internal const string Winspool = "winspool.drv";
	}

	internal static class WinMM
	{
		internal enum MMSYSERR
		{
			NOERROR = 0,
			ERROR = 1,
			BADDEVICEID = 2,
			NOTENABLED = 3,
			ALLOCATED = 4,
			INVALHANDLE = 5,
			NODRIVER = 6,
			NOMEM = 7,
			NOTSUPPORTED = 8,
			BADERRNUM = 9,
			INVALFLAG = 10,
			INVALPARAM = 11,
			HANDLEBUSY = 12,
			INVALIDALIAS = 13,
			BADDB = 14,
			KEYNOTFOUND = 15,
			READERROR = 16,
			WRITEERROR = 17,
			DELETEERROR = 18,
			VALNOTFOUND = 19,
			NODRIVERCB = 20,
			LASTERROR = 20
		}

		internal struct WAVEOUTCAPS
		{
			private const int szPnameLength = 32;

			private ushort wMid;

			private ushort wPid;

			private uint vDriverVersion;

			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
			internal string szPname;

			private uint dwFormats;

			private ushort wChannels;

			private ushort wReserved1;

			private ushort dwSupport;
		}

		internal enum MM_MSG
		{
			MM_WOM_OPEN = 955,
			MM_WOM_CLOSE,
			MM_WOM_DONE
		}

		internal delegate void WaveOutProc(IntPtr hwo, MM_MSG uMsg, IntPtr dwInstance, IntPtr dwParam1, IntPtr dwParam2);

		internal struct WAVEHDR
		{
			internal IntPtr lpData;

			internal uint dwBufferLength;

			internal uint dwBytesRecorded;

			internal uint dwUser;

			internal uint dwFlags;

			internal uint dwLoops;

			internal IntPtr lpNext;

			internal uint reserved;
		}

		internal const uint CALLBACK_WINDOW = 65536u;

		internal const uint CALLBACK_NULL = 0u;

		internal const uint CALLBACK_FUNCTION = 196608u;

		[DllImport("winmm.dll", ExactSpelling = true)]
		[LibraryImport("winmm.dll")]
		internal static extern MMSYSERR waveOutClose(IntPtr hwo);

		[DllImport("winmm.dll", EntryPoint = "waveOutGetDevCapsW", ExactSpelling = true)]
		[LibraryImport("winmm.dll", EntryPoint = "waveOutGetDevCapsW")]
		internal static extern MMSYSERR waveOutGetDevCaps(IntPtr uDeviceID, ref WAVEOUTCAPS caps, int cbwoc);

		[DllImport("winmm.dll", ExactSpelling = true)]
		[LibraryImport("winmm.dll")]
		internal static extern int waveOutGetNumDevs();

		[DllImport("winmm.dll", ExactSpelling = true)]
		[LibraryImport("winmm.dll")]
		internal static extern MMSYSERR waveOutOpen(ref IntPtr phwo, int uDeviceID, byte[] pwfx, WaveOutProc dwCallback, IntPtr dwInstance, uint fdwOpen);

		[DllImport("winmm.dll", ExactSpelling = true)]
		[LibraryImport("winmm.dll")]
		internal static extern MMSYSERR waveOutPause(IntPtr hwo);

		[DllImport("winmm.dll", ExactSpelling = true)]
		[LibraryImport("winmm.dll")]
		internal static extern MMSYSERR waveOutPrepareHeader(IntPtr hwo, IntPtr pwh, int cbwh);

		[DllImport("winmm.dll", ExactSpelling = true)]
		[LibraryImport("winmm.dll")]
		internal static extern MMSYSERR waveOutUnprepareHeader(IntPtr hwo, IntPtr pwh, int cbwh);

		[DllImport("winmm.dll", ExactSpelling = true)]
		[LibraryImport("winmm.dll")]
		internal static extern MMSYSERR waveOutReset(IntPtr hwo);

		[DllImport("winmm.dll", ExactSpelling = true)]
		[LibraryImport("winmm.dll")]
		internal static extern MMSYSERR waveOutRestart(IntPtr hwo);

		[DllImport("winmm.dll", ExactSpelling = true)]
		[LibraryImport("winmm.dll")]
		internal static extern MMSYSERR waveOutWrite(IntPtr hwo, IntPtr pwh, int cbwh);
	}
}
namespace System
{
	internal static class Obsoletions
	{
		internal const string SharedUrlFormat = "https://aka.ms/dotnet-warnings/{0}";

		internal const string SystemTextEncodingUTF7Message = "The UTF-7 encoding is insecure and should not be used. Consider using UTF-8 instead.";

		internal const string SystemTextEncodingUTF7DiagId = "SYSLIB0001";

		internal const string PrincipalPermissionAttributeMessage = "PrincipalPermissionAttribute is not honored by the runtime and must not be used.";

		internal const string PrincipalPermissionAttributeDiagId = "SYSLIB0002";

		internal const string CodeAccessSecurityMessage = "Code Access Security is not supported or honored by the runtime.";

		internal const string CodeAccessSecurityDiagId = "SYSLIB0003";

		internal const string ConstrainedExecutionRegionMessage = "The Constrained Execution Region (CER) feature is not supported.";

		internal const string ConstrainedExecutionRegionDiagId = "SYSLIB0004";

		internal const string GlobalAssemblyCacheMessage = "The Global Assembly Cache is not supported.";

		internal const string GlobalAssemblyCacheDiagId = "SYSLIB0005";

		internal const string ThreadAbortMessage = "Thread.Abort is not supported and throws PlatformNotSupportedException.";

		internal const string ThreadResetAbortMessage = "Thread.ResetAbort is not supported and throws PlatformNotSupportedException.";

		internal const string ThreadAbortDiagId = "SYSLIB0006";

		internal const string DefaultCryptoAlgorithmsMessage = "The default implementation of this cryptography algorithm is not supported.";

		internal const string DefaultCryptoAlgorithmsDiagId = "SYSLIB0007";

		internal const string CreatePdbGeneratorMessage = "The CreatePdbGenerator API is not supported and throws PlatformNotSupportedException.";

		internal const string CreatePdbGeneratorDiagId = "SYSLIB0008";

		internal const string AuthenticationManagerMessage = "The AuthenticationManager Authenticate and PreAuthenticate methods are not supported and throw PlatformNotSupportedException.";

		internal const string AuthenticationManagerDiagId = "SYSLIB0009";

		internal const string RemotingApisMessage = "This Remoting API is not supported and throws PlatformNotSupportedException.";

		internal const string RemotingApisDiagId = "SYSLIB0010";

		internal const string BinaryFormatterMessage = "BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.";

		internal const string BinaryFormatterDiagId = "SYSLIB0011";

		internal const string CodeBaseMessage = "Assembly.CodeBase and Assembly.EscapedCodeBase are only included for .NET Framework compatibility. Use Assembly.Location instead.";

		internal const string CodeBaseDiagId = "SYSLIB0012";

		internal const string EscapeUriStringMessage = "Uri.EscapeUriString can corrupt the Uri string in some cases. Consider using Uri.EscapeDataString for query string components instead.";

		internal const string EscapeUriStringDiagId = "SYSLIB0013";

		internal const string WebRequestMessage = "WebRequest, HttpWebRequest, ServicePoint, and WebClient are obsolete. Use HttpClient instead.";

		internal const string WebRequestDiagId = "SYSLIB0014";

		internal const string DisablePrivateReflectionAttributeMessage = "DisablePrivateReflectionAttribute has no effect in .NET 6.0+.";

		internal const string DisablePrivateReflectionAttributeDiagId = "SYSLIB0015";

		internal const string GetContextInfoMessage = "Use the Graphics.GetContextInfo overloads that accept arguments for better performance and fewer allocations.";

		internal const string GetContextInfoDiagId = "SYSLIB0016";

		internal const string StrongNameKeyPairMessage = "Strong name signing is not supported and throws PlatformNotSupportedException.";

		internal const string StrongNameKeyPairDiagId = "SYSLIB0017";

		internal const string ReflectionOnlyLoadingMessage = "ReflectionOnly loading is not supported and throws PlatformNotSupportedException.";

		internal const string ReflectionOnlyLoadingDiagId = "SYSLIB0018";

		internal const string RuntimeEnvironmentMessage = "RuntimeEnvironment members SystemConfigurationFile, GetRuntimeInterfaceAsIntPtr, and GetRuntimeInterfaceAsObject are not supported and throw PlatformNotSupportedException.";

		internal const string RuntimeEnvironmentDiagId = "SYSLIB0019";

		internal const string JsonSerializerOptionsIgnoreNullValuesMessage = "JsonSerializerOptions.IgnoreNullValues is obsolete. To ignore null values when serializing, set DefaultIgnoreCondition to JsonIgnoreCondition.WhenWritingNull.";

		internal const string JsonSerializerOptionsIgnoreNullValuesDiagId = "SYSLIB0020";

		internal const string DerivedCryptographicTypesMessage = "Derived cryptographic types are obsolete. Use the Create method on the base type instead.";

		internal const string DerivedCryptographicTypesDiagId = "SYSLIB0021";

		internal const string RijndaelMessage = "The Rijndael and RijndaelManaged types are obsolete. Use Aes instead.";

		internal const string RijndaelDiagId = "SYSLIB0022";

		internal const string RNGCryptoServiceProviderMessage = "RNGCryptoServiceProvider is obsolete. To generate a random number, use one of the RandomNumberGenerator static methods instead.";

		internal const string RNGCryptoServiceProviderDiagId = "SYSLIB0023";

		internal const string AppDomainCreateUnloadMessage = "Creating and unloading AppDomains is not supported and throws an exception.";

		internal const string AppDomainCreateUnloadDiagId = "SYSLIB0024";

		internal const string SuppressIldasmAttributeMessage = "SuppressIldasmAttribute has no effect in .NET 6.0+.";

		internal const string SuppressIldasmAttributeDiagId = "SYSLIB0025";

		internal const string X509CertificateImmutableMessage = "X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.";

		internal const string X509CertificateImmutableDiagId = "SYSLIB0026";

		internal const string PublicKeyPropertyMessage = "PublicKey.Key is obsolete. Use the appropriate method to get the public key, such as GetRSAPublicKey.";

		internal const string PublicKeyPropertyDiagId = "SYSLIB0027";

		internal const string X509CertificatePrivateKeyMessage = "X509Certificate2.PrivateKey is obsolete. Use the appropriate method to get the private key, such as GetRSAPrivateKey, or use the CopyWithPrivateKey method to create a new instance with a private key.";

		internal const string X509CertificatePrivateKeyDiagId = "SYSLIB0028";

		internal const string ProduceLegacyHmacValuesMessage = "ProduceLegacyHmacValues is obsolete. Producing legacy HMAC values is not supported.";

		internal const string ProduceLegacyHmacValuesDiagId = "SYSLIB0029";

		internal const string UseManagedSha1Message = "HMACSHA1 always uses the algorithm implementation provided by the platform. Use a constructor without the useManagedSha1 parameter.";

		internal const string UseManagedSha1DiagId = "SYSLIB0030";

		internal const string CryptoConfigEncodeOIDMessage = "EncodeOID is obsolete. Use the ASN.1 functionality provided in System.Formats.Asn1.";

		internal const string CryptoConfigEncodeOIDDiagId = "SYSLIB0031";

		internal const string CorruptedStateRecoveryMessage = "Recovery from corrupted process state exceptions is not supported; HandleProcessCorruptedStateExceptionsAttribute is ignored.";

		internal const string CorruptedStateRecoveryDiagId = "SYSLIB0032";

		internal const string Rfc2898CryptDeriveKeyMessage = "Rfc2898DeriveBytes.CryptDeriveKey is obsolete and is not supported. Use PasswordDeriveBytes.CryptDeriveKey instead.";

		internal const string Rfc2898CryptDeriveKeyDiagId = "SYSLIB0033";

		internal const string CmsSignerCspParamsCtorMessage = "CmsSigner(CspParameters) is obsolete and is not supported. Use an alternative constructor instead.";

		internal const string CmsSignerCspParamsCtorDiagId = "SYSLIB0034";

		internal const string SignerInfoCounterSigMessage = "ComputeCounterSignature without specifying a CmsSigner is obsolete and is not supported. Use the overload that accepts a CmsSigner.";

		internal const string SignerInfoCounterSigDiagId = "SYSLIB0035";

		internal const string RegexCompileToAssemblyMessage = "Regex.CompileToAssembly is obsolete and not supported. Use the GeneratedRegexAttribute with the regular expression source generator instead.";

		internal const string RegexCompileToAssemblyDiagId = "SYSLIB0036";

		internal const string AssemblyNameMembersMessage = "AssemblyName members HashAlgorithm, ProcessorArchitecture, and VersionCompatibility are obsolete and not supported.";

		internal const string AssemblyNameMembersDiagId = "SYSLIB0037";

		internal const string SystemDataSerializationFormatBinaryMessage = "SerializationFormat.Binary is obsolete and should not be used. See https://aka.ms/serializationformat-binary-obsolete for more information.";

		internal const string SystemDataSerializationFormatBinaryDiagId = "SYSLIB0038";

		internal const string TlsVersion10and11Message = "TLS versions 1.0 and 1.1 have known vulnerabilities and are not recommended. Use a newer TLS version instead, or use SslProtocols.None to defer to OS defaults.";

		internal const string TlsVersion10and11DiagId = "SYSLIB0039";

		internal const string EncryptionPolicyMessage = "EncryptionPolicy.NoEncryption and AllowEncryption significantly reduce security and should not be used in production code.";

		internal const string EncryptionPolicyDiagId = "SYSLIB0040";

		internal const string Rfc2898OutdatedCtorMessage = "The default hash algorithm and iteration counts in Rfc2898DeriveBytes constructors are outdated and insecure. Use a constructor that accepts the hash algorithm and the number of iterations.";

		internal const string Rfc2898OutdatedCtorDiagId = "SYSLIB0041";

		internal const string EccXmlExportImportMessage = "ToXmlString and FromXmlString have no implementation for ECC types, and are obsolete. Use a standard import and export format such as ExportSubjectPublicKeyInfo or ImportSubjectPublicKeyInfo for public keys and ExportPkcs8PrivateKey or ImportPkcs8PrivateKey for private keys.";

		internal const string EccXmlExportImportDiagId = "SYSLIB0042";

		internal const string EcDhPublicKeyBlobMessage = "ECDiffieHellmanPublicKey.ToByteArray() and the associated constructor do not have a consistent and interoperable implementation on all platforms. Use ECDiffieHellmanPublicKey.ExportSubjectPublicKeyInfo() instead.";

		internal const string EcDhPublicKeyBlobDiagId = "SYSLIB0043";

		internal const string AssemblyNameCodeBaseMessage = "AssemblyName.CodeBase and AssemblyName.EscapedCodeBase are obsolete. Using them for loading an assembly is not supported.";

		internal const string AssemblyNameCodeBaseDiagId = "SYSLIB0044";

		internal const string CryptoStringFactoryMessage = "Cryptographic factory methods accepting an algorithm name are obsolete. Use the parameterless Create factory method on the algorithm type instead.";

		internal const string CryptoStringFactoryDiagId = "SYSLIB0045";

		internal const string ControlledExecutionRunMessage = "ControlledExecution.Run method may corrupt the process and should not be used in production code.";

		internal const string ControlledExecutionRunDiagId = "SYSLIB0046";

		internal const string XmlSecureResolverMessage = "XmlSecureResolver is obsolete. Use XmlResolver.ThrowingResolver instead when attempting to forbid XML external entity resolution.";

		internal const string XmlSecureResolverDiagId = "SYSLIB0047";

		internal const string RsaEncryptDecryptValueMessage = "RSA.EncryptValue and DecryptValue are not supported and throw NotSupportedException. Use RSA.Encrypt and RSA.Decrypt instead.";

		internal const string RsaEncryptDecryptDiagId = "SYSLIB0048";

		internal const string JsonSerializerOptionsAddContextMessage = "JsonSerializerOptions.AddContext is obsolete. To register a JsonSerializerContext, use either the TypeInfoResolver or TypeInfoResolverChain properties.";

		internal const string JsonSerializerOptionsAddContextDiagId = "SYSLIB0049";

		internal const string LegacyFormatterMessage = "Formatter-based serialization is obsolete and should not be used.";

		internal const string LegacyFormatterDiagId = "SYSLIB0050";

		internal const string LegacyFormatterImplMessage = "This API supports obsolete formatter-based serialization. It should not be called or extended by application code.";

		internal const string LegacyFormatterImplDiagId = "SYSLIB0051";

		internal const string RegexExtensibilityImplMessage = "This API supports obsolete mechanisms for Regex extensibility. It is not supported.";

		internal const string RegexExtensibilityDiagId = "SYSLIB0052";

		internal const string AesGcmTagConstructorMessage = "AesGcm should indicate the required tag size for encryption and decryption. Use a constructor that accepts the tag size.";

		internal const string AesGcmTagConstructorDiagId = "SYSLIB0053";
	}
}
namespace System.Runtime.InteropServices
{
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	internal sealed class LibraryImportAttribute : Attribute
	{
		public string LibraryName { get; }

		public string EntryPoint { get; set; }

		public StringMarshalling StringMarshalling { get; set; }

		public Type StringMarshallingCustomType { get; set; }

		public bool SetLastError { get; set; }

		public LibraryImportAttribute(string libraryName)
		{
			LibraryName = libraryName;
		}
	}
	internal enum StringMarshalling
	{
		Custom,
		Utf8,
		Utf16
	}
}
namespace System.Speech
{
	internal static class SR
	{
		private static ResourceManager s_resourceManager = new ResourceManager("ExceptionStringTable", typeof(SR).Assembly);

		internal static string Get(SRID id, params object[] args)
		{
			string text = s_resourceManager.GetString(id.ToString());
			if (string.IsNullOrEmpty(text))
			{
				text = s_resourceManager.GetString("Unavailable");
			}
			else if (args != null && args.Length != 0)
			{
				text = string.Format(text, args);
			}
			return text;
		}
	}
	internal enum SRID
	{
		NullParamIllegal,
		ArrayOfNullIllegal,
		ParamsEntryNullIllegal,
		Unavailable,
		UnexpectedError,
		CollectionReadOnly,
		StringCanNotBeEmpty,
		EnumInvalid,
		NotSupportedWithThisVersionOfSAPI,
		NotSupportedWithThisVersionOfSAPI2,
		NotSupportedWithThisVersionOfSAPIBaseUri,
		NotSupportedWithThisVersionOfSAPITagFormat,
		NotSupportedWithThisVersionOfSAPICompareOption,
		MustBeGreaterThanZero,
		InvalidXml,
		OperationAborted,
		InvariantCultureInfo,
		DuplicatedEntry,
		StreamMustBeReadable,
		StreamMustBeWriteable,
		StreamMustBeSeekable,
		StreamEndedUnexpectedly,
		CannotReadFromDirectory,
		UnknownMimeFormat,
		CannotLoadResourceFromManifest,
		TokenInUse,
		TokenDeleted,
		TokenUninitialized,
		InvalidTokenId,
		NotFound,
		NoBackSlash,
		InvalidRegistryEntry,
		TokenCannotCreateInstance,
		InvalidXmlFormat,
		IncorrectAttributeValue,
		MissingRequiredAttribute,
		InvalidRuleRefSelf,
		InvalidDynamicExport,
		InvalidToken,
		MetaNameHTTPEquiv,
		EmptyRule,
		InvalidTokenString,
		InvalidQuotedString,
		ExportDynamicRule,
		EmptyDisplayString,
		EmptyPronunciationString,
		InvalidPhoneme,
		MuliplePronunciationString,
		MultipleDisplayString,
		RuleRedefinition,
		EmptyOneOf,
		InvalidGrammarOrdering,
		MinMaxOutOfRange,
		InvalidExampleOrdering,
		GrammarDefTwice,
		UnsupportedFormat,
		InvalidImport,
		DuplicatedRuleName,
		RootRuleAlreadyDefined,
		RuleNameIdConflict,
		RuleNotDynamic,
		StateWithNoArcs,
		NoTerminatingRulePath,
		RuleRefNoUri,
		UnavailableProperty,
		MinGreaterThanMax,
		ReqConfidenceNotSupported,
		SapiPropertiesAndSemantics,
		InvalidAttributeDefinedTwice,
		GrammarCompilerError,
		RuleScriptNotFound,
		DynamicRuleNotFound,
		RuleScriptInvalidParameters,
		RuleScriptInvalidReturnType,
		NoClassname,
		EmbeddedClassLibraryFailed,
		CannotFindClass,
		StrongTypedGrammarNotAGrammar,
		NoScriptsForRules,
		ClassNotPublic,
		MethodNotPublic,
		IncompatibleLanguageProperties,
		IncompatibleNamespaceProperties,
		IncompatibleDebugProperties,
		CannotLoadDotNetSemanticCode,
		InvalidSemanticProcessingType,
		InvalidScriptDefinition,
		InvalidMethodName,
		ConstructorNotAllowed,
		OverloadNotAllowed,
		OnInitOnPublicRule,
		ArgumentMismatch,
		CantGetPropertyFromSerializedInfo,
		CantFindAConstructor,
		TooManyArcs,
		TooManyRulesWithSemanticsGlobals,
		MaxTransitionsCount,
		UnknownElement,
		CircularRuleRef,
		InvalidFlagsSet,
		RuleDefinedMultipleTimes,
		RuleDefinedMultipleTimes2,
		RuleNotDefined,
		RootNotDefined,
		InvalidLanguage,
		InvalidRuleId,
		InvalidRepeatProbability,
		InvalidConfidence,
		InvalidMinRepeat,
		InvalidMaxRepeat,
		InvalidWeight,
		InvalidName,
		InvalidValueType,
		TagFormatNotSet,
		NoName,
		NoName1,
		InvalidSpecialRuleRef,
		InvalidRuleRef,
		InvalidNotEmptyElement,
		InvalidEmptyElement,
		InvalidEmptyRule,
		UndefRuleRef,
		UnsupportedLanguage,
		UnsupportedPhoneticAlphabet,
		UnsupportedLexicon,
		InvalidScriptAttribute,
		NoLanguageSet,
		MethodAttributeDefinedMultipleTimes,
		RuleAttributeDefinedMultipleTimes,
		InvalidAssemblyReferenceAttribute,
		InvalidImportNamespaceAttribute,
		NoUriForSpecialRuleRef,
		NoAliasForSpecialRuleRef,
		NoSmlData,
		InvalidNameValueProperty,
		InvalidTagInAnEmptyItem,
		InvalidSrgs,
		InvalidSrgsNamespace,
		Line,
		Position,
		InvalidVersion,
		InvalidTagFormat,
		MissingTagFormat,
		InvalidGrammarMode,
		InvalidGrammarAttribute,
		InvalidRuleAttribute,
		InvalidRulerefAttribute,
		InvalidOneOfAttribute,
		InvalidItemAttribute,
		InvalidTokenAttribute,
		InvalidItemRepeatAttribute,
		InvalidReqConfAttribute,
		InvalidTagAttribute,
		InvalidLexiconAttribute,
		InvalidMetaAttribute,
		InvalidItemAttribute2,
		InvalidElement,
		InvalidRuleScope,
		InvalidDynamicSetting,
		InvalidSubsetAttribute,
		InvalidVoiceElementInPromptOutput,
		NoRuleId,
		PromptBuilderInvalideState,
		PromptBuilderStateEnded,
		PromptBuilderStateSentence,
		PromptBuilderStateParagraph,
		PromptBuilderStateVoice,
		PromptBuilderStateStyle,
		PromptBuilderAgeOutOfRange,
		PromptBuilderMismatchStyle,
		PromptBuilderMismatchVoice,
		PromptBuilderMismatchParagraph,
		PromptBuilderMismatchSentence,
		PromptBuilderNestedParagraph,
		PromptBuilderNestedSentence,
		PromptBuilderInvalidAttribute,
		PromptBuilderInvalidElement,
		PromptBuilderInvalidVariant,
		PromptBuilderDatabaseName,
		PromptAsyncOperationCancelled,
		SynthesizerPauseResumeMismatched,
		SynthesizerInvalidMediaType,
		SynthesizerUnknownMediaType,
		SynthesizerSpeakError,
		SynthesizerInvalidWaveFile,
		SynthesizerPromptInUse,
		SynthesizerUnknownPriority,
		SynthesizerUnknownEvent,
		SynthesizerVoiceFailed,
		SynthesizerSetVoiceNoMatch,
		SynthesizerNoCulture,
		SynthesizerSyncSpeakWhilePaused,
		SynthesizerSyncSetOutputWhilePaused,
		SynthesizerNoCulture2,
		SynthesizerNoSpeak,
		SynthesizerSetOutputSpeaking,
		InvalidSpeakAttribute,
		UnsupportedAlphabet,
		GrammarInvalidWeight,
		GrammarInvalidPriority,
		DictationInvalidTopic,
		DictationTopicNotFound,
		RecognizerGrammarNotFound,
		RecognizerRuleNotFound,
		RecognizerInvalidBinaryGrammar,
		RecognizerRuleNotFoundStream,
		RecognizerNoRootRuleToActivate,
		RecognizerNoRootRuleToActivate1,
		RecognizerRuleActivationFailed,
		RecognizerAlreadyRecognizing,
		RecognizerHasNoGrammar,
		NegativeTimesNotSupported,
		AudioDeviceFormatError,
		AudioDeviceError,
		AudioDeviceInternalError,
		RecognizerNotFound,
		RecognizerNotEnabled,
		RecognitionNotSupported,
		RecognitionNotSupportedOn64bit,
		GrammarAlreadyLoaded,
		RecognizerNoInputSource,
		GrammarNotLoaded,
		GrammarLoadingInProgress,
		GrammarLoadFailed,
		GrammarWrongRecognizer,
		NotSupportedOnDictationGrammars,
		LocalFilesOnly,
		NotValidAudioFile,
		NotValidAudioStream,
		FileNotFound,
		CannotSetPriorityOnDictation,
		RecognizerUpdateTableTooLarge,
		MaxAlternatesInvalid,
		RecognizerSettingGetError,
		RecognizerSettingUpdateError,
		RecognizerSettingNotSupported,
		ResourceUsageOutOfRange,
		RateOutOfRange,
		EndSilenceOutOfRange,
		RejectionThresholdOutOfRange,
		ReferencedGrammarNotFound,
		SapiErrorRuleNotFound2,
		NoAudioAvailable,
		ResultNotGrammarAvailable,
		ResultInvalidFormat,
		UnhandledVariant,
		DupSemanticKey,
		DupSemanticValue,
		CannotUseCustomFormat,
		NoPromptEngine,
		NoPromptEngineInterface,
		SeekNotSupported,
		ExtraDataNotPresent,
		BitsPerSampleInvalid,
		DataBlockSizeInvalid,
		NotWholeNumberBlocks,
		BlockSignatureInvalid,
		NumberOfSamplesInvalid,
		SapiErrorUninitialized,
		SapiErrorAlreadyInitialized,
		SapiErrorNotSupportedFormat,
		SapiErrorInvalidFlags,
		SapiErrorEndOfStream,
		SapiErrorDeviceBusy,
		SapiErrorDeviceNotSupported,
		SapiErrorDeviceNotEnabled,
		SapiErrorNoDriver,
		SapiErrorFileMustBeUnicode,
		InsufficientData,
		SapiErrorInvalidPhraseID,
		SapiErrorBufferTooSmall,
		SapiErrorFormatNotSpecified,
		SapiErrorAudioStopped0,
		AudioPaused,
		SapiErrorRuleNotFound,
		SapiErrorTTSEngineException,
		SapiErrorTTSNLPException,
		SapiErrorEngineBUSY,
		AudioConversionEnabled,
		NoHypothesisAvailable,
		SapiErrorCantCreate,
		AlreadyInLex,
		SapiErrorNotInLex,
		LexNothingToSync,
		SapiErrorLexVeryOutOfSync,
		SapiErrorUndefinedForwardRuleRef,
		SapiErrorEmptyRule,
		SapiErrorGrammarCompilerInternalError,
		SapiErrorRuleNotDynamic,
		SapiErrorDuplicateRuleName,
		SapiErrorDuplicateResourceName,
		SapiErrorTooManyGrammars,
		SapiErrorCircularReference,
		SapiErrorInvalidImport,
		SapiErrorInvalidWAVFile,
		RequestPending,
		SapiErrorAllWordsOptional,
		SapiErrorInstanceChangeInvalid,
		SapiErrorRuleNameIdConflict,
		SapiErrorNoRules,
		SapiErrorCircularRuleRef,
		NoParseFound,
		SapiErrorInvalidHandle,
		SapiErrorRemoteCallTimedout,
		SapiErrorAudioBufferOverflow,
		SapiErrorNoAudioData,
		SapiErrorDeadAlternate,
		SapiErrorHighLowConfidence,
		SapiErrorInvalidFormatString,
		SPNotSupportedOnStreamInput,
		SapiErrorAppLexReadOnly,
		SapiErrorNoTerminatingRulePath,
		WordExistsWithoutPronunciation,
		SapiErrorStreamClosed,
		SapiErrorNoMoreItems,
		SapiErrorNotFound,
		SapiErrorInvalidAudioState,
		SapiErrorGenericMMSYS,
		SapiErrorMarshalerException,
		SapiErrorNotDynamicGrammar,
		SapiErrorAmbiguousProperty,
		SapiErrorInvalidRegistrykey,
		SapiErrorInvalidTokenId,
		SapiErrorXMLBadSyntax,
		SapiErrorXMLResourceNotFound,
		SapiErrorTokenInUse,
		SapiErrorTokenDeleted,
		SapiErrorMultilingualNotSupported,
		SapiErrorExportDynamicRule,
		SapiErrorSTGF,
		SapiErrorWordFormat,
		SapiErrorStreamNotActive,
		SapiErrorEngineResponseInvalid,
		SapiErrorSREngineException,
		SapiErrorStreamPosInvalid,
		SapiErrorRecognizerInactive,
		SapiErrorRemoteCallOnWrongThread,
		SapiErrorRemoteProcessTerminated,
		SapiErrorRemoteProcessAlreadyRunning,
		SapiErrorLangIdMismatch,
		SapiErrorPartialParseFound,
		SapiErrorNotTopLevelRule,
		SapiErrorNoRuleActive,
		SapiErrorLexRequiresCookie,
		SapiErrorStreamUninitialized,
		SapiErrorUnused0,
		SapiErrorNotSupportedLang,
		SapiErrorVoicePaused,
		SapiErrorAudioBufferUnderflow,
		SapiErrorAudioStoppedUnexpectedly,
		SapiErrorNoWordPronunciation,
		SapiErrorAlternatesWouldBeInconsistent,
		SapiErrorNotSupportedForSharedRecognizer,
		SapiErrorTimeOut,
		SapiErrorReenterSynchronize,
		SapiErrorStateWithNoArcs,
		SapiErrorNotActiveSession,
		SapiErrorAlreadyDeleted,
		SapiErrorAudioStopped,
		SapiErrorRecoXMLGenerationFail,
		SapiErrorSMLGenerationFail,
		SapiErrorNotPromptVoice,
		SapiErrorRootRuleAlreadyDefined,
		SapiErrorUnused1,
		SapiErrorUnused2,
		SapiErrorUnused3,
		SapiErrorUnused4,
		SapiErrorUnused5,
		SapiErrorUnused6,
		SapiErrorScriptDisallowed,
		SapiErrorRemoteCallTimedOutStart,
		SapiErrorRemoteCallTimedOutConnect,
		SapiErrorSecMgrChangeNotAllowed,
		SapiErrorCompleteButExtendable,
		SapiErrorFailedToDeleteFile,
		SapiErrorSharedEngineDisabled,
		SapiErrorRecognizerNotFound,
		SapiErrorAudioNotFound,
		SapiErrorNoVowel,
		SapiErrorNotSupportedPhoneme,
		SapiErrorNoRulesToActivate,
		SapiErrorNoWordEntryNotification,
		SapiErrorWordNeedsNormalization,
		SapiErrorCannotNormalize,
		LimitReached,
		NotSupported,
		SapiErrorTopicNotAdaptable,
		SapiErrorPhonemeConversion,
		SapiErrorNotSupportedForInprocRecognizer,
		SapiErrorOverload,
		SapiLexInvalidData,
		SapiConfigInvalidData,
		SapiLexUnexpectedFormat,
		SapiStringTooLong,
		SapiStringEmpty,
		SapiErrorUnused7,
		SapiErrorUnused8,
		SapiErrorUnused9,
		SapiErrorUnused10,
		SapiErrorUnused11,
		SapiErrorUnused12,
		SapiNonWordTransition,
		SapiSisrAttributesNotAllowed,
		SapiSisrMixedNotAllowed,
		SapiVoiceNotFound
	}
}
namespace System.Speech.Synthesis
{
	public class BookmarkReachedEventArgs : PromptEventArgs
	{
		private string _bookmark;

		private TimeSpan _audioPosition;

		public string Bookmark => _bookmark;

		public TimeSpan AudioPosition => _audioPosition;

		internal BookmarkReachedEventArgs(Prompt prompt, string bookmark, TimeSpan audioPosition)
			: base(prompt)
		{
			_bookmark = bookmark;
			_audioPosition = audioPosition;
		}
	}
	[DebuggerDisplay("{_text}")]
	public class FilePrompt : Prompt
	{
		public FilePrompt(string path, SynthesisMediaType media)
			: this(new Uri(path, UriKind.Relative), media)
		{
		}

		public FilePrompt(Uri promptFile, SynthesisMediaType media)
			: base(promptFile, media)
		{
		}
	}
	[DebuggerDisplay("{VoiceInfo.Name} = [{Enabled ? \"Enabled\" : \"Disabled\"}]")]
	public class InstalledVoice
	{
		private VoiceInfo _voice;

		private bool _enabled;

		private VoiceSynthesis _voiceSynthesizer;

		public VoiceInfo VoiceInfo => _voice;

		public bool Enabled
		{
			get
			{
				return _enabled;
			}
			set
			{
				SetEnabledFlag(value, switchContext: true);
			}
		}

		internal InstalledVoice(VoiceSynthesis voiceSynthesizer, VoiceInfo voice)
		{
			_voiceSynthesizer = voiceSynthesizer;
			_voice = voice;
			_enabled = true;
		}

		public override bool Equals(object obj)
		{
			if (!(obj is InstalledVoice installedVoice))
			{
				return false;
			}
			if (VoiceInfo.Name == installedVoice.VoiceInfo.Name && VoiceInfo.Age == installedVoice.VoiceInfo.Age && VoiceInfo.Gender == installedVoice.VoiceInfo.Gender)
			{
				return VoiceInfo.Culture.Equals(installedVoice.VoiceInfo.Culture);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return VoiceInfo.Name.GetHashCode();
		}

		internal static InstalledVoice Find(List<InstalledVoice> list, VoiceInfo voiceId)
		{
			foreach (InstalledVoice item in list)
			{
				if (item.Enabled && item.VoiceInfo.Equals(voiceId))
				{
					return item;
				}
			}
			return null;
		}

		internal static InstalledVoice FirstEnabled(List<InstalledVoice> list, CultureInfo culture)
		{
			InstalledVoice installedVoice = null;
			foreach (InstalledVoice item in list)
			{
				if (item.Enabled)
				{
					if (Helpers.CompareInvariantCulture(item.VoiceInfo.Culture, culture))
					{
						return item;
					}
					if (installedVoice == null)
					{
						installedVoice = item;
					}
				}
			}
			return installedVoice;
		}

		internal void SetEnabledFlag(bool value, bool switchContext)
		{
			try
			{
				if (_enabled == value)
				{
					return;
				}
				_enabled = value;
				if (!_enabled)
				{
					if (_voice.Equals(_voiceSynthesizer.CurrentVoice(switchContext).VoiceInfo))
					{
						_voiceSynthesizer.Voice = null;
					}
				}
				else
				{
					_voiceSynthesizer.Voice = null;
				}
			}
			catch (InvalidOperationException)
			{
				_voiceSynthesizer.Voice = null;
			}
		}
	}
	public class PhonemeReachedEventArgs : PromptEventArgs
	{
		private string _currentPhoneme;

		private TimeSpan _audioPosition;

		private TimeSpan _duration;

		private SynthesizerEmphasis _emphasis;

		private string _nextPhoneme;

		public string Phoneme => _currentPhoneme;

		public TimeSpan AudioPosition => _audioPosition;

		public TimeSpan Duration => _duration;

		public SynthesizerEmphasis Emphasis => _emphasis;

		public string NextPhoneme => _nextPhoneme;

		internal PhonemeReachedEventArgs(Prompt prompt, string currentPhoneme, TimeSpan audioPosition, TimeSpan duration, SynthesizerEmphasis emphasis, string nextPhoneme)
			: base(prompt)
		{
			_currentPhoneme = currentPhoneme;
			_audioPosition = audioPosition;
			_duration = duration;
			_emphasis = emphasis;
			_nextPhoneme = nextPhoneme;
		}
	}
	[DebuggerDisplay("{_text}")]
	public class Prompt
	{
		internal string _text;

		internal Uri _audio;

		internal SynthesisMediaType _media;

		internal bool _syncSpeak;

		private bool _completed;

		private object _synthesizer;

		private static ResourceLoader s_resourceLoader = new ResourceLoader();

		public bool IsCompleted
		{
			get
			{
				return _completed;
			}
			internal set
			{
				_completed = value;
			}
		}

		internal object Synthesizer
		{
			set
			{
				if (value != null && (_synthesizer != null || _completed))
				{
					throw new ArgumentException(SR.Get(SRID.SynthesizerPromptInUse), "value");
				}
				_synthesizer = value;
			}
		}

		internal Exception Exception { get; set; }

		public Prompt(string textToSpeak)
			: this(textToSpeak, SynthesisTextFormat.Text)
		{
		}

		public Prompt(PromptBuilder promptBuilder)
		{
			Helpers.ThrowIfNull(promptBuilder, "promptBuilder");
			_text = promptBuilder.ToXml();
			_media = SynthesisMediaType.Ssml;
		}

		public Prompt(string textToSpeak, SynthesisTextFormat media)
		{
			Helpers.ThrowIfNull(textToSpeak, "textToSpeak");
			if ((uint)(_media = (SynthesisMediaType)media) <= 1u)
			{
				_text = textToSpeak;
				return;
			}
			throw new ArgumentException(SR.Get(SRID.SynthesizerUnknownMediaType), "media");
		}

		internal Prompt(Uri promptFile, SynthesisMediaType media)
		{
			Helpers.ThrowIfNull(promptFile, "promptFile");
			switch (_media = media)
			{
			case SynthesisMediaType.Text:
			case SynthesisMediaType.Ssml:
			{
				string mimeType;
				Uri baseUri;
				string localPath;
				using Stream stream = s_resourceLoader.LoadFile(promptFile, out mimeType, out baseUri, out localPath);
				try
				{
					using StreamReader streamReader = new StreamReader(stream);
					_text = streamReader.ReadToEnd();
					break;
				}
				finally
				{
					s_resourceLoader.UnloadFile(localPath);
				}
			}
			case SynthesisMediaType.WaveAudio:
				_text = promptFile.ToString();
				_audio = promptFile;
				break;
			default:
				throw new ArgumentException(SR.Get(SRID.SynthesizerUnknownMediaType), "media");
			}
		}
	}
	public enum SynthesisMediaType
	{
		Text,
		Ssml,
		WaveAudio
	}
	public enum SynthesisTextFormat
	{
		Text,
		Ssml
	}
	[Serializable]
	public class PromptBuilder
	{
		internal enum SsmlState
		{
			Header = 1,
			Paragraph = 2,
			Sentence = 4,
			StyleEmphasis = 8,
			StyleProsody = 0x10,
			Voice = 0x20,
			Ended = 0x40
		}

		[Serializable]
		private struct StackElement
		{
			internal SsmlElement _possibleChildren;

			internal SsmlState _state;

			internal CultureInfo _culture;

			internal StackElement(SsmlElement possibleChildren, SsmlState state, CultureInfo culture)
			{
				_possibleChildren = possibleChildren;
				_state = state;
				_culture = culture;
			}
		}

		private enum ElementType
		{
			Prosody,
			Emphasis,
			SayAs,
			Phoneme,
			Sub,
			Break,
			Audio,
			Bookmark,
			StartVoice,
			StartParagraph,
			StartSentence,
			EndSentence,
			EndParagraph,
			StartStyle,
			EndStyle,
			EndVoice,
			Text,
			SsmlMarkup
		}

		[Serializable]
		private struct AttributeItem
		{
			internal string _key;

			internal string _value;

			internal string _namespace;

			internal AttributeItem(string key, string value)
			{
				_key = key;
				_value = value;
				_namespace = null;
			}

			internal AttributeItem(string ns, string key, string value)
				: this(key, value)
			{
				_namespace = ns;
			}
		}

		[Serializable]
		private sealed class Element
		{
			internal ElementType _type;

			internal string _text;

			internal Collection<AttributeItem> _attributes;

			internal Element(ElementType type)
			{
				_type = type;
			}

			internal Element(ElementType type, string text)
				: this(type)
			{
				_text = text;
			}
		}

		private Stack<StackElement> _elementStack = new Stack<StackElement>();

		private CultureInfo _culture;

		private List<Element> _elements = new List<Element>();

		private static ResourceLoader s_resourceLoader = new ResourceLoader();

		private const string _xmlnsDefault = "http://www.w3.org/2001/10/synthesis";

		private static readonly string[] s_promptBuilderElementName = new string[11]
		{
			"prosody", "emphasis", "say-as", "phoneme", "sub", "break", "audio", "mark", "voice", "p",
			"s"
		};

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

		public CultureInfo Culture
		{
			get
			{
				return _culture;
			}
			set
			{
				if (value == null)
				{
					throw new ArgumentNullException("value");
				}
				_culture = value;
			}
		}

		public PromptBuilder()
			: this(CultureInfo.CurrentUICulture)
		{
		}

		public PromptBuilder(CultureInfo culture)
		{
			Helpers.ThrowIfNull(culture, "culture");
			if (culture.Equals(CultureInfo.InvariantCulture))
			{
				throw new ArgumentException(SR.Get(SRID.InvariantCultureInfo), "culture");
			}
			_culture = culture;
			ClearContent();
		}

		public void ClearContent()
		{
			_elements.Clear();
			_elementStack.Push(new StackElement(SsmlElement.AudioMarkTextWithStyle | SsmlElement.ParagraphOrSentence | SsmlElement.Lexicon | SsmlElement.Meta | SsmlElement.MetaData, SsmlState.Header, _culture));
		}

		public void AppendText(string textToSpeak)
		{
			Helpers.ThrowIfNull(textToSpeak, "textToSpeak");
			ValidateElement(_elementStack.Peek(), SsmlElement.Text);
			_elements.Add(new Element(ElementType.Text, textToSpeak));
		}

		public void AppendText(string textToSpeak, PromptRate rate)
		{
			Helpers.ThrowIfNull(textToSpeak, "textToSpeak");
			if (rate < PromptRate.NotSet || rate > PromptRate.ExtraSlow)
			{
				throw new ArgumentOutOfRangeException("rate");
			}
			ValidateElement(_elementStack.Peek(), SsmlElement.Text);
			Element element = new Element(ElementType.Prosody, textToSpeak);
			_elements.Add(element);
			string value = null;
			switch (rate)
			{
			case PromptRate.ExtraFast:
				value = "x-fast";
				break;
			case PromptRate.ExtraSlow:
				value = "x-slow";
				break;
			default:
				value = rate.ToString().ToLowerInvariant();
				break;
			case PromptRate.NotSet:
				break;
			}
			if (!string.IsNullOrEmpty(value))
			{
				element._attributes = new Collection<AttributeItem>();
				element._attributes.Add(new AttributeItem("rate", value));
			}
		}

		public void AppendText(string textToSpeak, PromptVolume volume)
		{
			Helpers.ThrowIfNull(textToSpeak, "textToSpeak");
			if (volume < PromptVolume.NotSet || volume > PromptVolume.Default)
			{
				throw new ArgumentOutOfRangeException("volume");
			}
			ValidateElement(_elementStack.Peek(), SsmlElement.Text);
			Element element = new Element(ElementType.Prosody, textToSpeak);
			_elements.Add(element);
			string value = null;
			switch (volume)
			{
			case PromptVolume.ExtraSoft:
				value = "x-soft";
				break;
			case PromptVolume.ExtraLoud:
				value = "x-loud";
				break;
			default:
				value = volume.ToString().ToLowerInvariant();
				break;
			case PromptVolume.NotSet:
				break;
			}
			if (!string.IsNullOrEmpty(value))
			{
				element._attributes = new Collection<AttributeItem>();
				element._attributes.Add(new AttributeItem("volume", value));
			}
		}

		public void AppendText(string textToSpeak, PromptEmphasis emphasis)
		{
			Helpers.ThrowIfNull(textToSpeak, "textToSpeak");
			if (emphasis < PromptEmphasis.NotSet || emphasis > PromptEmphasis.Reduced)
			{
				throw new ArgumentOutOfRangeException("emphasis");
			}
			ValidateElement(_elementStack.Peek(), SsmlElement.Text);
			Element element = new Element(ElementType.Emphasis, textToSpeak);
			_elements.Add(element);
			if (emphasis != 0)
			{
				element._attributes = new Collection<AttributeItem>();
				element._attributes.Add(new AttributeItem("level", emphasis.ToString().ToLowerInvariant()));
			}
		}

		public void StartStyle(PromptStyle style)
		{
			Helpers.ThrowIfNull(style, "style");
			StackElement stackElement = _elementStack.Peek();
			ValidateElement(stackElement, SsmlElement.Prosody);
			SsmlState ssmlState = (SsmlState)0;
			SsmlElement possibleChildren = stackElement._possibleChildren;
			_elements.Add(new Element(ElementType.StartStyle));
			if (style.Emphasis != 0)
			{
				Element element = new Element(ElementType.Emphasis);
				_elements.Add(element);
				element._attributes = new Collection<AttributeItem>();
				element._attributes.Add(new AttributeItem("level", style.Emphasis.ToString().ToLowerInvariant()));
				possibleChildren = SsmlElement.AudioMarkTextWithStyle;
				ssmlState = SsmlState.StyleEmphasis;
			}
			if (style.Rate != 0 || style.Volume != 0)
			{
				if (ssmlState != 0)
				{
					_elements.Add(new Element(ElementType.StartStyle));
				}
				Element element2 = new Element(ElementType.Prosody);
				_elements.Add(element2);
				if (style.Rate != 0)
				{
					string value = style.Rate switch
					{
						PromptRate.ExtraFast => "x-fast", 
						PromptRate.ExtraSlow => "x-slow", 
						_ => style.Rate.ToString().ToLowerInvariant(), 
					};
					element2._attributes = new Collection<AttributeItem>();
					element2._attributes.Add(new AttributeItem("rate", value));
				}
				if (style.Volume != 0)
				{
					string value2 = style.Volume switch
					{
						PromptVolume.ExtraSoft => "x-soft", 
						PromptVolume.ExtraLoud => "x-loud", 
						_ => style.Volume.ToString().ToLowerInvariant(), 
					};
					Element element3 = element2;
					if (element3._attributes == null)
					{
						element3._attributes = new Collection<AttributeItem>();
					}
					element2._attributes.Add(new AttributeItem("volume", value2));
				}
				possibleChildren = SsmlElement.AudioMarkTextWithStyle | SsmlElement.ParagraphOrSentence;
				ssmlState |= SsmlState.StyleProsody;
			}
			_elementStack.Push(new StackElement(possibleChildren, ssmlState, stackElement._culture));
		}

		public void EndStyle()
		{
			StackElement stackElement = _elementStack.Pop();
			if (stackElement._state != 0)
			{
				if ((stackElement._state & (SsmlState)24) == 0)
				{
					throw new InvalidOperationException(SR.Get(SRID.PromptBuilderMismatchStyle));
				}
				_elements.Add(new Element(ElementType.EndStyle));
				if (stackElement._state == (SsmlState)24)
				{
					_elements.Add(new Element(ElementType.EndStyle));
				}
			}
		}

		public void StartVoice(VoiceInfo voice)
		{
			Helpers.ThrowIfNull(voice, "voice");
			if (!VoiceInfo.ValidateGender(voice.Gender))
			{
				throw new ArgumentException(SR.Get(SRID.EnumInvalid, "VoiceGender"), "voice");
			}
			if (!VoiceInfo.ValidateAge(voice.Age))
			{
				throw new ArgumentException(SR.Get(SRID.EnumInvalid, "VoiceAge"), "voice");
			}
			StackElement stackElement = _elementStack.Peek();
			ValidateElement(stackElement, SsmlElement.Voice);
			CultureInfo culture = voice.Culture ?? stackElement._culture;
			Element element = new Element(ElementType.StartVoice);
			element._attributes = new Collection<AttributeItem>();
			_elements.Add(element);
			if (!string.IsNullOrEmpty(voice.Name))
			{
				element._attributes.Add(new AttributeItem("name", voice.Name));
			}
			if (voice.Culture != null)
			{
				element._attributes.Add(new AttributeItem("xml", "lang", voice.Culture.Name));
			}
			if (voice.Gender != 0)
			{
				element._attributes.Add(new AttributeItem("gender", voice.Gender.ToString().ToLowerInvariant()));
			}
			if (voice.Age != 0)
			{
				element._attributes.Add(new AttributeItem("age", ((int)voice.Age).ToString(CultureInfo.InvariantCulture)));
			}
			if (voice.Variant >= 0)
			{
				element._attributes.Add(new AttributeItem("variant", voice.Variant.ToString(CultureInfo.InvariantCulture)));
			}
			_elementStack.Push(new StackElement(SsmlElement.AudioMarkTextWithStyle | SsmlElement.Sentence, SsmlState.Voice, culture));
		}

		public void StartVoice(string name)
		{
			Helpers.ThrowIfEmptyOrNull(name, "name");
			StartVoice(new VoiceInfo(name));
		}

		public void StartVoice(VoiceGender gender)
		{
			StartVoice(new VoiceInfo(gender));
		}

		public void StartVoice(VoiceGender gender, VoiceAge age)
		{
			StartVoice(new VoiceInfo(gender, age));
		}

		public void StartVoice(VoiceGender gender, VoiceAge age, int voiceAlternate)
		{
			StartVoice(new VoiceInfo(gender, age, voiceAlternate));
		}

		public void StartVoice(CultureInfo culture)
		{
			StartVoice(new VoiceInfo(culture));
		}

		public void EndVoice()
		{
			if (_elementStack.Pop()._state != SsmlState.Voice)
			{
				throw new InvalidOperationException(SR.Get(SRID.PromptBuilderMismatchVoice));
			}
			_elements.Add(new Element(ElementType.EndVoice));
		}

		public void StartParagraph()
		{
			StartParagraph(null);
		}

		public void StartParagraph(CultureInfo culture)
		{
			StackElement stackElement = _elementStack.Peek();
			ValidateElement(stackElement, SsmlElement.Paragraph);
			Element element = new Element(ElementType.StartParagraph);
			_elements.Add(element);
			if (culture != null)
			{
				if (culture.Equals(CultureInfo.InvariantCulture))
				{
					throw new ArgumentException(SR.Get(SRID.InvariantCultureInfo), "culture");
				}
				element._attributes = new Collection<AttributeItem>();
				element._attributes.Add(new AttributeItem("xml", "lang", culture.Name));
			}
			else
			{
				culture = stackElement._culture;
			}
			_elementStack.Push(new StackElement(SsmlElement.AudioMarkTextWithStyle | SsmlElement.Sentence, SsmlState.Paragraph, culture));
		}

		public void EndParagraph()
		{
			if (_elementStack.Pop()._state != SsmlState.Paragraph)
			{
				throw new InvalidOperationException(SR.Get(SRID.PromptBuilderMismatchParagraph));
			}
			_elements.Add(new Element(ElementType.EndParagraph));
		}

		public void StartSentence()
		{
			StartSentence(null);
		}

		public void StartSentence(CultureInfo culture)
		{
			StackElement stackElement = _elementStack.Peek();
			ValidateElement(stackElement, SsmlElement.Sentence);
			Element element = new Element(ElementType.StartSentence);
			_elements.Add(element);
			if (culture != null)
			{
				if (culture.Equals(CultureInfo.InvariantCulture))
				{
					throw new ArgumentException(SR.Get(SRID.InvariantCultureInfo), "culture");
				}
				element._attributes = new Collection<AttributeItem>();
				element._attributes.Add(new AttributeItem("xml", "lang", culture.Name));
			}
			else
			{
				culture = stackElement._culture;
			}
			_elementStack.Push(new StackElement(SsmlElement.AudioMarkTextWithStyle, SsmlState.Sentence, culture));
		}

		public void EndSentence()
		{
			if (_elementStack.Pop()._state != SsmlState.Sentence)
			{
				throw new InvalidOperationException(SR.Get(SRID.PromptBuilderMismatchSentence));
			}
			_elements.Add(new Element(ElementType.EndSentence));
		}

		public void AppendTextWithHint(string textToSpeak, SayAs sayAs)
		{
			Helpers.ThrowIfNull(textToSpeak, "textToSpeak");
			if (sayAs < SayAs.SpellOut || sayAs > SayAs.Text)
			{
				throw new ArgumentOutOfRangeException("sayAs");
			}
			ValidateElement(_elementStack.Peek(), SsmlElement.Text);
			if (sayAs != SayAs.Text)
			{
				Element element = new Element(ElementType.SayAs, textToSpeak);
				_elements.Add(element);
				element._attributes = new Collection<AttributeItem>();
				string value = null;
				string value2 = null;
				switch (sayAs)
				{
				case SayAs.SpellOut:
					value = "characters";
					break;
				case SayAs.NumberOrdinal:
					value = "ordinal";
					break;
				case SayAs.NumberCardinal:
					value = "cardinal";
					break;
				case SayAs.Date:
					value = "date";
					break;
				case SayAs.DayMonthYear:
					value = "date";
					value2 = "dmy";
					break;
				case SayAs.MonthDayYear:
					value = "date";
					value2 = "mdy";
					break;
				case SayAs.YearMonthDay:
					value = "date";
					value2 = "ymd";
					break;
				case SayAs.YearMonth:
					value = "date";
					value2 = "ym";
					break;
				case SayAs.MonthYear:
					value = "date";
					value2 = "my";
					break;
				case SayAs.MonthDay:
					value = "date";
					value2 = "md";
					break;
				case SayAs.DayMonth:
					value = "date";
					value2 = "dm";
					break;
				case SayAs.Year:
					value = "date";
					value2 = "y";
					break;
				case SayAs.Month:
					value = "date";
					value2 = "m";
					break;
				case SayAs.Day:
					value = "date";
					value2 = "d";
					break;
				case SayAs.Time:
					value = "time";
					break;
				case SayAs.Time24:
					value = "time";
					value2 = "hms24";
					break;
				case SayAs.Time12:
					value = "time";
					value2 = "hms12";
					break;
				case SayAs.Telephone:
					value = "telephone";
					break;
				}
				element._attributes.Add(new AttributeItem("interpret-as", value));
				if (!string.IsNullOrEmpty(value2))
				{
					element._attributes.Add(new AttributeItem("format", value2));
				}
			}
			else
			{
				AppendText(textToSpeak);
			}
		}

		public void AppendTextWithHint(string textToSpeak, string sayAs)
		{
			Helpers.ThrowIfNull(textToSpeak, "textToSpeak");
			Helpers.ThrowIfEmptyOrNull(sayAs, "sayAs");
			ValidateElement(_elementStack.Peek(), SsmlElement.Text);
			Element element = new Element(ElementType.SayAs, textToSpeak);
			_elements.Add(element);
			element._attributes = new Collection<AttributeItem>();
			element._attributes.Add(new AttributeItem("interpret-as", sayAs));
		}

		public void AppendTextWithPronunciation(string textToSpeak, string pronunciation)
		{
			Helpers.ThrowIfEmptyOrNull(textToSpeak, "textToSpeak");
			Helpers.ThrowIfEmptyOrNull(pronunciation, "pronunciation");
			ValidateElement(_elementStack.Peek(), SsmlElement.Text);
			PhonemeConverter.ValidateUpsIds(pronunciation);
			Element element = new Element(ElementType.Phoneme, textToSpeak);
			_elements.Add(element);
			element._attributes = new Collection<AttributeItem>();
			element._attributes.Add(new AttributeItem("ph", pronunciation));
		}

		public void AppendTextWithAlias(string textToSpeak, string substitute)
		{
			Helpers.ThrowIfNull(textToSpeak, "textToSpeak");
			Helpers.ThrowIfNull(substitute, "substitute");
			ValidateElement(_elementStack.Peek(), SsmlElement.Text);
			Element element = new Element(ElementType.Sub, textToSpeak);
			_elements.Add(element);
			element._attributes = new Collection<AttributeItem>();
			element._attributes.Add(new AttributeItem("alias", substitute));
		}

		public void AppendBreak()
		{
			ValidateElement(_elementStack.Peek(), SsmlElement.Break);
			_elements.Add(new Element(ElementType.Break));
		}

		public void AppendBreak(PromptBreak strength)
		{
			ValidateElement(_elementStack.Peek(), SsmlElement.Break);
			Element element = new Element(ElementType.Break);
			_elements.Add(element);
			string text = null;
			text = strength switch
			{
				PromptBreak.None => "none", 
				PromptBreak.ExtraSmall => "x-weak", 
				PromptBreak.Small => "weak", 
				PromptBreak.Medium => "medium", 
				PromptBreak.Large => "strong", 
				PromptBreak.ExtraLarge => "x-strong", 
				_ => throw new ArgumentNullException("strength"), 
			};
			element._attributes = new Collection<AttributeItem>();
			element._attributes.Add(new AttributeItem("strength", text));
		}

		public void AppendBreak(TimeSpan duration)
		{
			ValidateElement(_elementStack.Peek(), SsmlElement.Break);
			if (duration.Ticks < 0)
			{
				throw new ArgumentOutOfRangeException("duration");
			}
			Element element = new Element(ElementType.Break);
			_elements.Add(element);
			element._attributes = new Collection<AttributeItem>();
			element._attributes.Add(new AttributeItem("time", duration.TotalMilliseconds + "ms"));
		}

		public void AppendAudio(string path)
		{
			Helpers.ThrowIfEmptyOrNull(path, "path");
			Uri audioFile;
			try
			{
				audioFile = new Uri(path, UriKind.RelativeOrAbsolute);
			}
			catch (UriFormatException ex)
			{
				throw new ArgumentException(ex.Message, path, ex);
			}
			ValidateElement(_elementStack.Peek(), SsmlElement.Audio);
			AppendAudio(audioFile);
		}

		public void AppendAudio(Uri audioFile)
		{
			Helpers.ThrowIfNull(audioFile, "audioFile");
			ValidateElement(_elementStack.Peek(), SsmlElement.Audio);
			Element element = new Element(ElementType.Audio);
			_elements.Add(element);
			element._attributes = new Collection<AttributeItem>();
			element._attributes.Add(new AttributeItem("src", audioFile.ToString()));
		}

		public void AppendAudio(Uri audioFile, string alternateText)
		{
			Helpers.ThrowIfNull(audioFile, "audioFile");
			Helpers.ThrowIfNull(alternateText, "alternateText");
			ValidateElement(_elementStack.Peek(), SsmlElement.Audio);
			Element element = new Element(ElementType.Audio, alternateText);
			_elements.Add(element);
			element._attributes = new Collection<AttributeItem>();
			element._attributes.Add(new AttributeItem("src", audioFile.ToString()));
		}

		public void AppendBookmark(string bookmarkName)
		{
			Helpers.ThrowIfEmptyOrNull(bookmarkName, "bookmarkName");
			ValidateElement(_elementStack.Peek(), SsmlElement.Mark);
			Element element = new Element(ElementType.Bookmark);
			_elements.Add(element);
			element._attributes = new Collection<AttributeItem>();
			element._attributes.Add(new AttributeItem("name", bookmarkName));
		}

		public void AppendPromptBuilder(PromptBuilder promptBuilder)
		{
			Helpers.ThrowIfNull(promptBuilder, "promptBuilder");
			StringReader stringReader = new StringReader(promptBuilder.ToXml());
			XmlTextReader xmlTextReader = new XmlTextReader(stringReader);
			AppendSsml(xmlTextReader);
			xmlTextReader.Close();
			stringReader.Close();
		}

		public void AppendSsml(string path)
		{
			Helpers.ThrowIfEmptyOrNull(path, "path");
			AppendSsml(new Uri(path, UriKind.Relative));
		}

		public void AppendSsml(Uri ssmlFile)
		{
			Helpers.ThrowIfNull(ssmlFile, "ssmlFile");
			string localPath;
			Uri redirectedUri;
			using Stream input = s_resourceLoader.LoadFile(ssmlFile, out localPath, out redirectedUri);
			try
			{
				AppendSsml(new XmlTextReader(input));
			}
			finally
			{
				s_resourceLoader.UnloadFile(localPath);
			}
		}

		public void AppendSsml(XmlReader ssmlFile)
		{
			Helpers.ThrowIfNull(ssmlFile, "ssmlFile");
			AppendSsmlInternal(ssmlFile);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public void AppendSsmlMarkup(string ssmlMarkup)
		{
			Helpers.ThrowIfEmptyOrNull(ssmlMarkup, "ssmlMarkup");
			_elements.Add(new Element(ElementType.SsmlMarkup, ssmlMarkup));
		}

		public string ToXml()
		{
			using StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
			using XmlTextWriter writer = new XmlTextWriter(stringWriter);
			WriteXml(writer);
			SsmlState state = _elementStack.Peek()._state;
			if (state != SsmlState.Header)
			{
				string text = SR.Get(SRID.PromptBuilderInvalideState);
				switch (state)
				{
				case SsmlState.Ended:
					text += SR.Get(SRID.PromptBuilderStateEnded);
					break;
				case SsmlState.Sentence:
					text += SR.Get(SRID.PromptBuilderStateSentence);
					break;
				case SsmlState.Paragraph:
					text += SR.Get(SRID.PromptBuilderStateParagraph);
					break;
				case SsmlState.StyleEmphasis:
				case SsmlState.StyleProsody:
				case (SsmlState)24:
					text += SR.Get(SRID.PromptBuilderStateStyle);
					break;
				case SsmlState.Voice:
					text += SR.Get(SRID.PromptBuilderStateVoice);
					break;
				default:
					throw new NotSupportedException();
				}
				throw new InvalidOperationException(text);
			}
			return stringWriter.ToString();
		}

		private void WriteXml(XmlTextWriter writer)
		{
			writer.WriteStartElement("speak");
			writer.WriteAttributeString("version", "1.0");
			writer.WriteAttributeString("xmlns", "http://www.w3.org/2001/10/synthesis");
			writer.WriteAttributeString("xml", "lang", null, _culture.Name);
			bool flag = false;
			foreach (Element element in _elements)
			{
				flag = flag || element._type == ElementType.StartSentence || element._type == ElementType.StartParagraph || element._type == ElementType.StartStyle || element._type == ElementType.StartVoice;
				switch (element._type)
				{
				case ElementType.Text:
					writer.WriteString(element._text);
					break;
				case ElementType.SsmlMarkup:
					writer.WriteRaw(element._text);
					break;
				case ElementType.Prosody:
				case ElementType.Emphasis:
				case ElementType.SayAs:
				case ElementType.Phoneme:
				case ElementType.Sub:
				case ElementType.Break:
				case ElementType.Audio:
				case ElementType.Bookmark:
				case ElementType.StartVoice:
				case ElementType.StartParagraph:
				case ElementType.StartSentence:
					writer.WriteStartElement(s_promptBuilderElementName[(int)element._type]);
					if (element._attributes != null)
					{
						foreach (AttributeItem attribute in element._attributes)
						{
							if (attribute._namespace == null)
							{
								writer.WriteAttributeString(attribute._key, attribute._value);
							}
							else
							{
								writer.WriteAttributeString(attribute._namespace, attribute._key, null, attribute._value);
							}
						}
					}
					if (element._text != null)
					{
						writer.WriteString(element._text);
					}
					if (!flag)
					{
						writer.WriteEndElement();
					}
					flag = false;
					break;
				case ElementType.EndSentence:
				case ElementType.EndParagraph:
				case ElementType.EndStyle:
				case ElementType.EndVoice:
					writer.WriteEndElement();
					break;
				default:
					throw new NotSupportedException();
				case ElementType.StartStyle:
					break;
				}
			}
			writer.WriteEndElement();
		}

		private static void ValidateElement(StackElement stackElement, SsmlElement currentElement)
		{
			if ((stackElement._possibleChildren & currentElement) == 0)
			{
				throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, SR.Get(SRID.PromptBuilderInvalidElement), currentElement.ToString(), stackElement._state.ToString()));
			}
		}

		private void AppendSsmlInternal(XmlReader ssmlFile)
		{
			StackElement stackElement = _elementStack.Peek();
			ValidateElement(_elementStack.Peek(), SsmlElement.Voice);
			using StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
			using (XmlTextWriter writer = new XmlTextWriter(stringWriter))
			{
				TextWriterEngine engine = new TextWriterEngine(writer, stackElement._culture);
				SsmlParser.Parse(ssmlFile, engine, null);
			}
			_elements.Add(new Element(ElementType.SsmlMarkup, stringWriter.ToString()));
		}
	}
	public abstract class PromptEventArgs : AsyncCompletedEventArgs
	{
		private Prompt _prompt;

		public Prompt Prompt => _prompt;

		internal PromptEventArgs(Prompt prompt)
			: base(prompt.Exception, prompt.Exception != null, prompt)
		{
			_prompt = prompt;
		}
	}
	public class SpeakStartedEventArgs : PromptEventArgs
	{
		internal SpeakStartedEventArgs(Prompt prompt)
			: base(prompt)
		{
		}
	}
	[Serializable]
	public class PromptStyle
	{
		private PromptRate _rate;

		private PromptVolume _volume;

		private PromptEmphasis _emphasis;

		public PromptRate Rate
		{
			get
			{
				return _rate;
			}
			set
			{
				_rate = value;
			}
		}

		public PromptVolume Volume
		{
			get
			{
				return _volume;
			}
			set
			{
				_volume = value;
			}
		}

		public PromptEmphasis Emphasis
		{
			get
			{
				return _emphasis;
			}
			set
			{
				_emphasis = value;
			}
		}

		public PromptStyle()
		{
		}

		public PromptStyle(PromptRate rate)
		{
			Rate = rate;
		}

		public PromptStyle(PromptVolume volume)
		{
			Volume = volume;
		}

		public PromptStyle(PromptEmphasis emphasis)
		{
			Emphasis = emphasis;
		}
	}
	public enum SayAs
	{
		SpellOut,
		NumberOrdinal,
		NumberCardinal,
		Date,
		DayMonthYear,
		MonthDayYear,
		YearMonthDay,
		YearMonth,
		MonthYear,
		MonthDay,
		DayMonth,
		Year,
		Month,
		Day,
		Time,
		Time24,
		Time12,
		Telephone,
		Text
	}
	public enum VoiceGender
	{
		NotSet,
		Male,
		Female,
		Neutral
	}
	public enum VoiceAge
	{
		NotSet = 0,
		Child = 10,
		Teen = 15,
		Adult = 30,
		Senior = 65
	}
	public enum PromptRate
	{
		NotSet,
		ExtraFast,
		Fast,
		Medium,
		Slow,
		ExtraSlow
	}
	public enum PromptVolume
	{
		NotSet,
		Silent,
		ExtraSoft,
		Soft,
		Medium,
		Loud,
		ExtraLoud,
		Default
	}
	public enum PromptEmphasis
	{
		NotSet,
		Strong,
		Moderate,
		None,
		Reduced
	}
	public enum PromptBreak
	{
		None,
		ExtraSmall,
		Small,
		Medium,
		Large,
		ExtraLarge
	}
	public class SpeakCompletedEventArgs : PromptEventArgs
	{
		internal SpeakCompletedEventArgs(Prompt prompt)
			: base(prompt)
		{
		}
	}
	public class SpeakProgressEventArgs : PromptEventArgs
	{
		private TimeSpan _audioPosition;

		private int _iWordPos;

		private int _cWordLen;

		private string _word;

		public TimeSpan AudioPosition => _audioPosition;

		public int CharacterPosition => _iWordPos;

		public int CharacterCount
		{
			get
			{
				return _cWordLen;
			}
			internal set
			{
				_cWordLen = value;
			}
		}

		public string Text
		{
			get
			{
				return _word;
			}
			internal set
			{
				_word = value;
			}
		}

		internal SpeakProgressEventArgs(Prompt prompt, TimeSpan audioPosition, int iWordPos, int cWordLen)
			: base(prompt)
		{
			_audioPosition = audioPosition;
			_iWordPos = iWordPos;
			_cWordLen = cWordLen;
		}
	}
	public sealed class SpeechSynthesizer : IDisposable
	{
		private VoiceSynthesis _voiceSynthesis;

		private bool _isDisposed;

		private bool _paused;

		private Stream _outputStream;

		private bool _closeStreamOnExit;

		public SynthesizerState State => VoiceSynthesizer.State;

		public int Rate
		{
			get
			{
				return VoiceSynthesizer.Rate;
			}
			set
			{
				if (value < -10 || value > 10)
				{
					throw new ArgumentOutOfRangeException("value", SR.Get(SRID.RateOutOfRange));
				}
				VoiceSynthesizer.Rate = value;
			}
		}

		public int Volume
		{
			get
			{
				return VoiceSynthesizer.Volume;
			}
			set
			{
				if (value < 0 || value > 100)
				{
					throw new ArgumentOutOfRangeException("value", SR.Get(SRID.ResourceUsageOutOfRange));
				}
				VoiceSynthesizer.Volume = value;
			}
		}

		public VoiceInfo Voice => VoiceSynthesizer.CurrentVoice(switchContext: true).VoiceInfo;

		private VoiceSynthesis VoiceSynthesizer
		{
			get
			{
				if (_voiceSynthesis == null && _isDisposed)
				{
					throw new ObjectDisposedException("SpeechSynthesizer");
				}
				if (_voiceSynthesis == null)
				{
					WeakReference speechSynthesizer = new WeakReference(this);
					_voiceSynthesis = new VoiceSynthesis(speechSynthesizer);
				}
				return _voiceSynthesis;
			}
		}

		public event EventHandler<SpeakStartedEventArgs> SpeakStarted
		{
			[MethodImpl(MethodImplOptions.Synchronized)]
			add
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesis voiceSynthesizer = VoiceSynthesizer;
				voiceSynthesizer._speakStarted = (EventHandler<SpeakStartedEventArgs>)Delegate.Combine(voiceSynthesizer._speakStarted, value);
			}
			[MethodImpl(MethodImplOptions.Synchronized)]
			remove
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesis voiceSynthesizer = VoiceSynthesizer;
				voiceSynthesizer._speakStarted = (EventHandler<SpeakStartedEventArgs>)Delegate.Remove(voiceSynthesizer._speakStarted, value);
			}
		}

		public event EventHandler<SpeakCompletedEventArgs> SpeakCompleted
		{
			[MethodImpl(MethodImplOptions.Synchronized)]
			add
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesis voiceSynthesizer = VoiceSynthesizer;
				voiceSynthesizer._speakCompleted = (EventHandler<SpeakCompletedEventArgs>)Delegate.Combine(voiceSynthesizer._speakCompleted, value);
			}
			[MethodImpl(MethodImplOptions.Synchronized)]
			remove
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesis voiceSynthesizer = VoiceSynthesizer;
				voiceSynthesizer._speakCompleted = (EventHandler<SpeakCompletedEventArgs>)Delegate.Remove(voiceSynthesizer._speakCompleted, value);
			}
		}

		public event EventHandler<SpeakProgressEventArgs> SpeakProgress
		{
			[MethodImpl(MethodImplOptions.Synchronized)]
			add
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesizer.AddEvent(TtsEventId.WordBoundary, ref VoiceSynthesizer._speakProgress, value);
			}
			[MethodImpl(MethodImplOptions.Synchronized)]
			remove
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesizer.RemoveEvent(TtsEventId.WordBoundary, ref VoiceSynthesizer._speakProgress, value);
			}
		}

		public event EventHandler<BookmarkReachedEventArgs> BookmarkReached
		{
			[MethodImpl(MethodImplOptions.Synchronized)]
			add
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesizer.AddEvent(TtsEventId.Bookmark, ref VoiceSynthesizer._bookmarkReached, value);
			}
			[MethodImpl(MethodImplOptions.Synchronized)]
			remove
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesizer.RemoveEvent(TtsEventId.Bookmark, ref VoiceSynthesizer._bookmarkReached, value);
			}
		}

		public event EventHandler<VoiceChangeEventArgs> VoiceChange
		{
			[MethodImpl(MethodImplOptions.Synchronized)]
			add
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesizer.AddEvent(TtsEventId.VoiceChange, ref VoiceSynthesizer._voiceChange, value);
			}
			[MethodImpl(MethodImplOptions.Synchronized)]
			remove
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesizer.RemoveEvent(TtsEventId.VoiceChange, ref VoiceSynthesizer._voiceChange, value);
			}
		}

		public event EventHandler<PhonemeReachedEventArgs> PhonemeReached
		{
			[MethodImpl(MethodImplOptions.Synchronized)]
			add
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesizer.AddEvent(TtsEventId.Phoneme, ref VoiceSynthesizer._phonemeReached, value);
			}
			[MethodImpl(MethodImplOptions.Synchronized)]
			remove
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesizer.RemoveEvent(TtsEventId.Phoneme, ref VoiceSynthesizer._phonemeReached, value);
			}
		}

		public event EventHandler<VisemeReachedEventArgs> VisemeReached
		{
			[MethodImpl(MethodImplOptions.Synchronized)]
			add
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesizer.AddEvent(TtsEventId.Viseme, ref VoiceSynthesizer._visemeReached, value);
			}
			[MethodImpl(MethodImplOptions.Synchronized)]
			remove
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesizer.RemoveEvent(TtsEventId.Viseme, ref VoiceSynthesizer._visemeReached, value);
			}
		}

		public event EventHandler<StateChangedEventArgs> StateChanged
		{
			[MethodImpl(MethodImplOptions.Synchronized)]
			add
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesis voiceSynthesizer = VoiceSynthesizer;
				voiceSynthesizer._stateChanged = (EventHandler<StateChangedEventArgs>)Delegate.Combine(voiceSynthesizer._stateChanged, value);
			}
			[MethodImpl(MethodImplOptions.Synchronized)]
			remove
			{
				Helpers.ThrowIfNull(value, "value");
				VoiceSynthesis voiceSynthesizer = VoiceSynthesizer;
				voiceSynthesizer._stateChanged = (EventHandler<StateChangedEventArgs>)Delegate.Remove(voiceSynthesizer._stateChanged, value);
			}
		}

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

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		public void SelectVoice(string name)
		{
			Helpers.ThrowIfEmptyOrNull(name, "name");
			TTSVoice engine = VoiceSynthesizer.GetEngine(name, CultureInfo.CurrentUICulture, VoiceGender.NotSet, VoiceAge.NotSet, 1, switchContext: true);
			if (engine == null || name != engine.VoiceInfo.Name)
			{
				throw new ArgumentException(SR.Get(SRID.SynthesizerSetVoiceNoMatch));
			}
			VoiceSynthesizer.Voice = engine;
		}

		public void SelectVoiceByHints(VoiceGender gender)
		{
			SelectVoiceByHints(gender, VoiceAge.NotSet, 1, CultureInfo.CurrentUICulture);
		}

		public void SelectVoiceByHints(VoiceGender gender, VoiceAge age)
		{
			SelectVoiceByHints(gender, age, 1, CultureInfo.CurrentUICulture);
		}

		public void SelectVoiceByHints(VoiceGender gender, VoiceAge age, int voiceAlternate)
		{
			SelectVoiceByHints(gender, age, voiceAlternate, CultureInfo.CurrentUICulture);
		}

		public void SelectVoiceByHints(VoiceGender gender, VoiceAge age, int voiceAlternate, CultureInfo culture)
		{
			Helpers.ThrowIfNull(culture, "culture");
			if (voiceAlternate < 0)
			{
				throw new ArgumentOutOfRangeException("voiceAlternate", SR.Get(SRID.PromptBuilderInvalidVariant));
			}
			if (!VoiceInfo.ValidateGender(gender))
			{
				throw new ArgumentException(SR.Get(SRID.EnumInvalid, "VoiceGender"), "gender");
			}
			if (!VoiceInfo.ValidateAge(age))
			{
				throw new ArgumentException(SR.Get(SRID.EnumInvalid, "VoiceAge"), "age");
			}
			TTSVoice engine = VoiceSynthesizer.GetEngine(null, culture, gender, age, voiceAlternate, switchContext: true);
			if (engine == null)
			{
				throw new InvalidOperationException(SR.Get(SRID.SynthesizerSetVoiceNoMatch));
			}
			VoiceSynthesizer.Voice = engine;
		}

		public Prompt SpeakAsync(string textToSpeak)
		{
			Helpers.ThrowIfNull(textToSpeak, "textToSpeak");
			Prompt prompt = new Prompt(textToSpeak, SynthesisTextFormat.Text);
			SpeakAsync(prompt);
			return prompt;
		}

		public void SpeakAsync(Prompt prompt)
		{
			Helpers.ThrowIfNull(prompt, "prompt");
			prompt.Synthesizer = this;
			VoiceSynthesizer.SpeakAsync(prompt);
		}

		public Prompt SpeakSsmlAsync(string textToSpeak)
		{
			Helpers.ThrowIfNull(textToSpeak, "textToSpeak");
			Prompt prompt = new Prompt(textToSpeak, SynthesisTextFormat.Ssml);
			SpeakAsync(prompt);
			return prompt;
		}

		public Prompt SpeakAsync(PromptBuilder promptBuilder)
		{
			Helpers.ThrowIfNull(promptBuilder, "promptBuilder");
			Prompt prompt = new Prompt(promptBuilder);
			SpeakAsync(prompt);
			return prompt;
		}

		public void Speak(string textToSpeak)
		{
			Speak(new Prompt(textToSpeak, SynthesisTextFormat.Text));
		}

		public void Speak(Prompt prompt)
		{
			Helpers.ThrowIfNull(prompt, "prompt");
			if (State == SynthesizerState.Paused)
			{
				throw new InvalidOperationException(SR.Get(SRID.SynthesizerSyncSpeakWhilePaused));
			}
			prompt.Synthesizer = this;
			prompt._syncSpeak = true;
			VoiceSynthesizer.Speak(prompt);
		}

		public void Speak(PromptBuilder promptBuilder)
		{
			Speak(new Prompt(promptBuilder));
		}

		public void SpeakSsml(string textToSpeak)
		{
			Speak(new Prompt(textToSpeak, SynthesisTextFormat.Ssml));
		}

		public void Pause()
		{
			if (!_paused)
			{
				VoiceSynthesizer.Pause();
				_paused = true;
			}
		}

		public void Resume()
		{
			if (_paused)
			{
				VoiceSynthesizer.Resume();
				_paused = false;
			}
		}

		public void SpeakAsyncCancel(Prompt prompt)
		{
			Helpers.ThrowIfNull(prompt, "prompt");
			VoiceSynthesizer.Abort(prompt);
		}

		public void SpeakAsyncCancelAll()
		{
			VoiceSynthesizer.Abort();
		}

		public void SetOutputToWaveFile(string path)
		{
			Helpers.ThrowIfEmptyOrNull(path, "path");
			SetOutputToNull();
			SetOutputStream(new FileStream(path, FileMode.Create, FileAccess.Write), null, headerInfo: true, closeStreamOnExit: true);
		}

		public void SetOutputToWaveFile(string path, SpeechAudioFormatInfo formatInfo)
		{
			Helpers.ThrowIfEmptyOrNull(path, "path");
			Helpers.ThrowIfNull(formatInfo, "formatInfo");
			SetOutputToNull();
			SetOutputStream(new FileStream(path, FileMode.Create, FileAccess.Write), formatInfo, headerInfo: true, closeStreamOnExit: true);
		}

		public void SetOutputToWaveStream(Stream audioDestination)
		{
			Helpers.ThrowIfNull(audioDestination, "audioDestination");
			SetOutputStream(audioDestination, null, headerInfo: true, closeStreamOnExit: false);
		}

		public void SetOutputToAudioStream(Stream audioDestination, SpeechAudioFormatInfo formatInfo)
		{
			Helpers.ThrowIfNull(audioDestination, "audioDestination");
			Helpers.ThrowIfNull(formatInfo, "formatInfo");
			SetOutputStream(audioDestination, formatInfo, headerInfo: false, closeStreamOnExit: false);
		}

		public void SetOutputToDefaultAudioDevice()
		{
			SetOutputStream(null, null, headerInfo: true, closeStreamOnExit: false);
		}

		public void SetOutputToNull()
		{
			if (_outputStream != Stream.Null)
			{
				VoiceSynthesizer.SetOutput(Stream.Null, null, headerInfo: true);
			}
			if (_outputStream != null && _closeStreamOnExit)
			{
				_outputStream.Close();
			}
			_outputStream = Stream.Null;
		}

		public Prompt GetCurrentlySpokenPrompt()
		{
			return VoiceSynthesizer.Prompt;
		}

		public ReadOnlyCollection<InstalledVoice> GetInstalledVoices()
		{
			return VoiceSynthesizer.GetInstalledVoices(null);
		}

		public ReadOnlyCollection<InstalledVoice> GetInstalledVoices(CultureInfo culture)
		{
			Helpers.ThrowIfNull(culture, "culture");
			if (culture.Equals(CultureInfo.InvariantCulture))
			{
				throw new ArgumentException(SR.Get(SRID.InvariantCultureInfo), "culture");
			}
			return VoiceSynthesizer.GetInstalledVoices(culture);
		}

		public void AddLexicon(Uri uri, string mediaType)
		{
			Helpers.ThrowIfNull(uri, "uri");
			VoiceSynthesizer.AddLexicon(uri, mediaType);
		}

		public void RemoveLexicon(Uri uri)
		{
			Helpers.ThrowIfNull(uri, "uri");
			VoiceSynthesizer.RemoveLexicon(uri);
		}

		private void SetOutputStream(Stream stream, SpeechAudioFormatInfo formatInfo, bool headerInfo, bool closeStreamOnExit)
		{
			SetOutputToNull();
			_outputStream = stream;
			_closeStreamOnExit = closeStreamOnExit;
			VoiceSynthesizer.SetOutput(stream, formatInfo, headerInfo);
		}

		private void Dispose(bool disposing)
		{
			if (!_isDisposed && disposing && _voiceSynthesis != null)
			{
				_isDisposed = true;
				SpeakAsyncCancelAll();
				if (_outputStream != null)
				{
					if (_closeStreamOnExit)
					{
						_outputStream.Close();
					}
					else
					{
						_outputStream.Flush();
					}
					_outputStream = null;
				}
			}
			if (_voiceSynthesis != null)
			{
				_voiceSynthesis.Dispose();
				_voiceSynthesis = null;
			}
			_isDisposed = true;
		}
	}
	public enum SynthesizerState
	{
		Ready,
		Speaking,
		Paused
	}
	[Flags]
	public enum SynthesizerEmphasis
	{
		Stressed = 1,
		Emphasized = 2
	}
	public class StateChangedEventArgs : EventArgs
	{
		private SynthesizerState _state;

		private SynthesizerState _previousState;

		public SynthesizerState State => _state;

		public SynthesizerState PreviousState => _previousState;

		internal StateChangedEventArgs(SynthesizerState state, SynthesizerState previousState)
		{
			_state = state;
			_previousState = previousState;
		}
	}
	public class VisemeReachedEventArgs : PromptEventArgs
	{
		private int _currentViseme;

		private TimeSpan _audioPosition;

		private TimeSpan _duration;

		private SynthesizerEmphasis _emphasis;

		private int _nextViseme;

		public int Viseme => _currentViseme;

		public TimeSpan AudioPosition => _audioPosition;

		public TimeSpan Duration => _duration;

		public SynthesizerEmphasis Emphasis => _emphasis;

		public int NextViseme => _nextViseme;

		internal VisemeReachedEventArgs(Prompt speakPrompt, int currentViseme, TimeSpan audioPosition, TimeSpan duration, SynthesizerEmphasis emphasis, int nextViseme)
			: base(speakPrompt)
		{
			_currentViseme = currentViseme;
			_audioPosition = audioPosition;
			_duration = duration;
			_emphasis = emphasis;
			_nextViseme = nextViseme;
		}
	}
	public class VoiceChangeEventArgs : PromptEventArgs
	{
		private VoiceInfo _voice;

		public VoiceInfo Voice => _voice;

		internal VoiceChangeEventArgs(Prompt prompt, VoiceInfo voice)
			: base(prompt)
		{
			_voice = voice;
		}
	}
	[Serializable]
	[DebuggerDisplay("{(_name != null ? \"'\" + _name + \"' \" : \"\") +  (_culture != null ? \" '\" + _culture.ToString () + \"' \" : \"\") + (_gender != VoiceGender.NotSet ? \" '\" + _gender.ToString () + \"' \" : \"\") + (_age != VoiceAge.NotSet ? \" '\" + _age.ToString () + \"' \" : \"\") + (_variant > 0 ? \" \" + _variant.ToString () : \"\")}")]
	public class VoiceInfo
	{
		private string _name;

		private CultureInfo _culture;

		private VoiceGender _gender;

		private VoiceAge _age;

		private int _variant = -1;

		[NonSerialized]
		private string _id;

		[NonSerialized]
		private string _registryKeyPath;

		[NonSerialized]
		private string _assemblyName;

		[NonSerialized]
		private string _clsid;

		[NonSerialized]
		private string _description;

		[NonSerialized]
		private ReadOnlyDictionary<string, string> _attributes;

		[NonSerialized]
		private ReadOnlyCollection<SpeechAudioFormatInfo> _audioFormats;

		public VoiceGender Gender => _gender;

		public VoiceAge Age => _age;

		public string Name => _name;

		public CultureInfo Culture => _culture;

		public string Id => _id;

		public string Description => _description ?? string.Empty;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public ReadOnlyCollection<SpeechAudioFormatInfo> SupportedAudioFormats => _audioFormats;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public IDictionary<string, string> AdditionalInfo => _attributes ?? (_attributes = new ReadOnlyDictionary<string, string>(new Dictionary<string, string>(0)));

		internal int Variant => _variant;

		internal string AssemblyName => _assemblyName;

		internal string Clsid => _clsid;

		internal string RegistryKeyPath => _registryKeyPath;

		internal VoiceInfo(string name)
		{
			Helpers.ThrowIfEmptyOrNull(name, "name");
			_name = name;
		}

		internal VoiceInfo(CultureInfo culture)
		{
			Helpers.ThrowIfNull(culture, "culture");
			if (culture.Equals(CultureInfo.InvariantCulture))
			{
				throw new ArgumentException(SR.Get(SRID.InvariantCultureInfo), "culture");
			}
			_culture = culture;
		}

		internal VoiceInfo(ObjectToken token)
		{
			_registryKeyPath = token._sKeyId;
			_id = token.Name;
			_description = token.Description;
			_name = token.TokenName();
			SsmlParserHelpers.TryConvertAge(token.Age.ToLowerInvariant(), out _age);
			SsmlParserHelpers.TryConvertGender(token.Gender.ToLowerInvariant(), out _gender);
			if (token.Attributes.TryGetString("Language", out var value))
			{
				_culture = SapiAttributeParser.GetCultureInfoFromLanguageString(value);
			}
			if (token.TryGetString("Assembly", out var value2))
			{
				_assemblyName = value2;
			}
			if (token.TryGetString("CLSID", out var value3))
			{
				_clsid = value3;
			}
			if (token.Attributes != null)
			{
				Dictionary<string, string> dictionary = new Dictionary<string, string>();
				string[] valueNames = token.Attributes.GetValueNames();
				foreach (string text in valueNames)
				{
					if (token.Attributes.TryGetString(text, out var value4))
					{
						dictionary.Add(text, value4);
					}
				}
				_attributes = new ReadOnlyDictionary<string, string>(dictionary);
			}
			if (token.Attributes != null && token.Attributes.TryGetString("AudioFormats", out var value5))
			{
				_audioFormats = new ReadOnlyCollection<SpeechAudioFormatInfo>(SapiAttributeParser.GetAudioFormatsFromString(value5));
			}
			else
			{
				_audioFormats = new ReadOnlyCollection<SpeechAudioFormatInfo>(new List<SpeechAudioFormatInfo>());
			}
		}

		internal VoiceInfo(VoiceGender gender)
		{
			_gender = gender;
		}

		internal VoiceInfo(VoiceGender gender, VoiceAge age)
		{
			_gender = gender;
			_age = age;
		}

		internal VoiceInfo(VoiceGender gender, VoiceAge age, int voiceAlternate)
		{
			if (voiceAlternate < 0)
			{
				throw new ArgumentOutOfRangeException("voiceAlternate", SR.Get(SRID.PromptBuilderInvalidVariant));
			}
			_gender = gender;
			_age = age;
			_variant = voiceAlternate + 1;
		}

		public override bool Equals(object obj)
		{
			if (obj is VoiceInfo voiceInfo && _name == voiceInfo._name && (_age == voiceInfo._age || _age == VoiceAge.NotSet || voiceInfo._age == VoiceAge.NotSet) && (_gender == voiceInfo._gender || _gender == VoiceGender.NotSet || voiceInfo._gender == VoiceGender.NotSet))
			{
				if (_culture != null && voiceInfo._culture != null)
				{
					return _culture.Equals(voiceInfo._culture);
				}
				return true;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return _name.GetHashCode();
		}

		internal static bool ValidateGender(VoiceGender gender)
		{
			if (gender != VoiceGender.Female && gender != VoiceGender.Male && gender != VoiceGender.Neutral)
			{
				return gender == VoiceGender.NotSet;
			}
			return true;
		}

		internal static bool ValidateAge(VoiceAge age)
		{
			if (age != VoiceAge.Adult && age != VoiceAge.Child && age != 0 && age != VoiceAge.Senior)
			{
				return age == VoiceAge.Teen;
			}
			return true;
		}
	}
}
namespace System.Speech.Synthesis.TtsEngine
{
	[ComImport]
	[Guid("A74D7C8E-4CC5-4F2F-A6EB-804DEE18500E")]
	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
	internal interface ITtsEngine
	{
		[PreserveSig]
		void Speak(SPEAKFLAGS dwSpeakFlags, ref Guid rguidFormatId, IntPtr pWaveFormatEx, IntPtr pTextFragList, IntPtr pOutputSite);

		[PreserveSig]
		void GetOutputFormat(ref Guid pTargetFmtId, IntPtr pTargetWaveFormatEx, out Guid pOutputFormatId, out IntPtr ppCoMemOutputWaveFormatEx);
	}
	[StructLayout(LayoutKind.Sequential)]
	internal class SPVTEXTFRAG
	{
		public IntPtr pNext;

		public SPVSTATE State;

		public IntPtr pTextStart;

		public int ulTextLen;

		public int ulTextSrcOffset;

		public GCHandle gcText;

		public GCHandle gcNext;

		public GCHandle gcPhoneme;

		public GCHandle gcSayAsCategory;
	}
	[ComConversionLoss]
	[TypeLibType(16)]
	internal struct SPVSTATE
	{
		public SPVACTIONS eAction;

		public short LangID;

		public short wReserved;

		public int EmphAdj;

		public int RateAdj;

		public int Volume;

		public SPVPITCH PitchAdj;

		public int SilenceMSecs;

		public IntPtr pPhoneIds;

		public SPPARTOFSPEECH ePartOfSpeech;

		public SPVCONTEXT Context;
	}
	[TypeLibType(16)]
	internal struct SPVCONTEXT
	{
		public IntPtr pCategory;

		public IntPtr pBefore;

		public IntPtr pAfter;
	}
	[TypeLibType(16)]
	internal struct SPVPITCH
	{
		public int MiddleAdj;

		public int RangeAdj;
	}
	internal static class SAPIGuids
	{
		internal static readonly Guid SPDFID_WaveFormatEx = new Guid("C31ADBAE-527F-4ff5-A230-F62BB61FF70C");
	}
	[Flags]
	internal enum SPEAKFLAGS
	{
		SPF_DEFAULT = 0,
		SPF_ASYNC = 1,
		SPF_PURGEBEFORESPEAK = 2,
		SPF_IS_FILENAME = 4,
		SPF_IS_XML = 8,
		SPF_IS_NOT_XML = 0x10,
		SPF_PERSIST_XML = 0x20,
		SPF_NLP_SPEAK_PUNC = 0x40,
		SPF_PARSE_SAPI = 0x80,
		SPF_PARSE_SSML = 0x100
	}
	[Flags]
	internal enum SPVESACTIONS
	{
		SPVES_CONTINUE = 0,
		SPVES_ABORT = 1,
		SPVES_SKIP = 2,
		SPVES_RATE = 4,
		SPVES_VOLUME = 8
	}
	[TypeLibType(16)]
	internal enum SPVACTIONS
	{
		SPVA_Speak,
		SPVA_Silence,
		SPVA_Pronounce,
		SPVA_Bookmark,
		SPVA_SpellOut,
		SPVA_Section,
		SPVA_ParseUnknownTag
	}
	[TypeLibType(16)]
	internal enum SPPARTOFSPEECH
	{
		SPPS_NotOverridden = -1,
		SPPS_Unknown = 0,
		SPPS_Noun = 4096,
		SPPS_Verb = 8192,
		SPPS_Modifier = 12288,
		SPPS_Function = 16384,
		SPPS_Interjection = 20480,
		SPPS_SuppressWord = 61440
	}
	public abstract class TtsEngineSsml
	{
		protected TtsEngineSsml(string registryKey)
		{
		}

		public abstract IntPtr GetOutputFormat(SpeakOutputFormat speakOutputFormat, IntPtr targetWaveFormat);

		public abstract void AddLexicon(Uri uri, string mediaType, ITtsEngineSite site);

		public abstract void RemoveLexicon(Uri uri, ITtsEngineSite site);

		public abstract void Speak(TextFragment[] fragment, IntPtr waveHeader, ITtsEngineSite site);
	}
	[ImmutableObject(true)]
	public struct SpeechEventInfo : IEquatable<SpeechEventInfo>
	{
		private short _eventId;

		private short _parameterType;

		private int _param1;

		private IntPtr _param2;

		public short EventId
		{
			get
			{
				return _eventId;
			}
			internal set
			{
				_eventId = value;
			}
		}

		public short ParameterType
		{
			get
			{
				return _parameterType;
			}
			internal set
			{
				_parameterType = value;
			}
		}

		public int Param1
		{
			get
			{
				return _param1;
			}
			internal set
			{
				_param1 = value;
			}
		}

		public IntPtr Param2
		{
			get
			{
				return _param2;
			}
			internal set
			{
				_param2 = value;
			}
		}

		public SpeechEventInfo(short eventId, short parameterType, int param1, IntPtr param2)
		{
			_eventId = eventId;
			_parameterType = parameterType;
			_param1 = param1;
			_param2 = param2;
		}

		public static bool operator ==(SpeechEventInfo event1, SpeechEventInfo event2)
		{
			if (event1.EventId == event2.EventId && event1.ParameterType == event2.ParameterType && event1.Param1 == event2.Param1)
			{
				return event1.Param2 == event2.Param2;
			}
			return false;
		}

		public static bool operator !=(SpeechEventInfo event1, SpeechEventInfo event2)
		{
			return !(event1 == event2);
		}

		public bool Equals(SpeechEventInfo other)
		{
			return this == other;
		}

		public override bool Equals(object obj)
		{
			if (!(obj is SpeechEventInfo))
			{
				return false;
			}
			return Equals((SpeechEventInfo)obj);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}
	}
	public interface ITtsEngineSite
	{
		int EventInterest { get; }

		int Actions { get; }

		int Rate { get; }

		int Volume { get; }

		void AddEvents(SpeechEventInfo[] events, int count);

		int Write(IntPtr data, int count);

		SkipInfo GetSkipInfo();

		void CompleteSkip(int skipped);

		Stream LoadResource(Uri uri, string mediaType);
	}
	public class SkipInfo
	{
		private int _type;

		private int _count;

		public int Type
		{
			get
			{
				return _type;
			}
			set
			{
				_type = value;
			}
		}

		public int Count
		{
			get
			{
				return _count;
			}
			set
			{
				_count = value;
			}
		}

		internal SkipInfo(int type, int count)
		{
			_type = type;
			_count = count;
		}

		public SkipInfo()
		{
		}
	}
	[StructLayout(LayoutKind.Sequential)]
	[DebuggerDisplay("{State.Action} = {TextToSpeak!=null?TextToSpeak:\"\"}")]
	public class TextFragment
	{
		private FragmentState _state;

		[MarshalAs(UnmanagedType.LPWStr)]
		private string _textToSpeak = string.Empty;

		private int _textOffset;

		private int _textLength;

		public FragmentState State
		{
			get
			{
				return _state;
			}
			set
			{
				_state = value;
			}
		}

		public string TextToSpeak
		{
			get
			{
				return _textToSpeak;
			}
			set
			{
				Helpers.ThrowIfEmptyOrNull(value, "value");
				_textToSpeak = value;
			}
		}

		public int TextOffset
		{
			get
			{
				return _textOffset;
			}
			set
			{
				_textOffset = value;
			}
		}

		public int TextLength
		{
			get
			{
				return _textLength;
			}
			set
			{
				_textLength = value;
			}
		}

		public TextFragment()
		{
		}

		internal TextFragment(FragmentState fragState)
			: this(fragState, null, null, 0, 0)
		{
		}

		internal TextFragment(FragmentState fragState, string textToSpeak)
			: this(fragState, textToSpeak, textToSpeak, 0, textToSpeak.Length)
		{
		}

		internal TextFragment(FragmentState fragState, string textToSpeak, string textFrag, int offset, int length)
		{
			if (fragState.Action == TtsEngineAction.Speak || fragState.Action == TtsEngineAction.Pronounce)
			{
				textFrag = textToSpeak;
			}
			if (!string.IsNullOrEmpty(textFrag))
			{
				TextToSpeak = textFrag;
			}
			State = fragState;
			TextOffset = offset;
			TextLength = length;
		}
	}
	[ImmutableObject(true)]
	public struct FragmentState : IEquatable<FragmentState>
	{
		private TtsEngineAction _action;

		private int _langId;

		private int _emphasis;

		private int _duration;

		private SayAs _sayAs;

		private Prosody _prosody;

		private char[] _phoneme;

		public TtsEngineAction Action
		{
			get
			{
				return _action;
			}
			internal set
			{
				_action = value;
			}
		}

		public int LangId
		{
			get
			{
				return _langId;
			}
			internal set
			{
				_langId = value;
			}
		}

		public int Emphasis
		{
			get
			{
				return _emphasis;
			}
			internal set
			{
				_emphasis = value;
			}
		}

		public int Duration
		{
			get
			{
				return _duration;
			}
			internal set
			{
				_duration = value;
			}
		}

		public SayAs SayAs
		{
			get
			{
				return _sayAs;
			}
			internal set
			{
				Helpers.ThrowIfNull(value, "value");
				_sayAs = value;
			}
		}

		public Prosody Prosody
		{
			get
			{
				return _prosody;
			}
			internal set
			{
				Helpers.ThrowIfNull(value, "value");
				_prosody = value;
			}
		}

		public char[] Phoneme
		{
			get
			{
				return _phoneme;
			}
			internal set
			{
				Helpers.ThrowIfNull(value, "value");
				_phoneme = value;
			}
		}

		public FragmentState(TtsEngineAction action, int langId, int emphasis, int duration, SayAs sayAs, Prosody prosody, char[] phonemes)
		{
			_action = action;
			_langId = langId;
			_emphasis = emphasis;
			_duration = duration;
			_sayAs = sayAs;
			_prosody = prosody;
			_phoneme = phonemes;
		}

		public static bool operator ==(FragmentState state1, FragmentState state2)
		{
			if (state1.Action == state2.Action && state1.LangId == state2.LangId && state1.Emphasis == state2.Emphasis && state1.Duration == state2.Duration && state1.SayAs == state2.SayAs && state1.Prosody == state2.Prosody)
			{
				return object.Equals(state1.Phoneme, state2.Phoneme);
			}
			return false;
		}

		public static bool operator !=(FragmentState state1, FragmentState state2)
		{
			return !(state1 == state2);
		}

		public bool Equals(FragmentState other)
		{
			return this == other;
		}

		public override bool Equals(object obj)
		{
			if (!(obj is FragmentState))
			{
				return false;
			}
			return Equals((FragmentState)obj);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}
	}
	[StructLayout(LayoutKind.Sequential)]
	public class Prosody
	{
		internal ProsodyNumber _pitch;

		internal ProsodyNumber _range;

		internal ProsodyNumber _rate;

		internal int _duration;

		internal ProsodyNumber _volume;

		internal ContourPoint[] _contourPoints;

		public ProsodyNumber Pitch
		{
			get
			{
				return _pitch;
			}
			set
			{
				_pitch = value;
			}
		}

		public ProsodyNumber Range
		{
			get
			{
				return _range;
			}
			set
			{
				_range = value;
			}
		}

		public ProsodyNumber Rate
		{
			get
			{
				return _rate;
			}
			set
			{
				_rate = value;
			}
		}

		public int Duration
		{
			get
			{
				return _duration;
			}
			set
			{
				_duration = value;
			}
		}

		public ProsodyNumber Volume
		{
			get
			{
				return _volume;
			}
			set
			{
				_volume = value;
			}
		}

		public ContourPoint[] GetContourPoints()
		{
			return _contourPoints;
		}

		public void SetContourPoints(ContourPoint[] points)
		{
			Helpers.ThrowIfNull(points, "points");
			_contourPoints = (ContourPoint[])points.Clone();
		}

		public Prosody()
		{
			Pitch = new ProsodyNumber(0);
			Range = new ProsodyNumber(0);
			Rate = new ProsodyNumber(0);
			Volume = new ProsodyNumber(-1);
		}

		internal Prosody Clone()
		{
			Prosody prosody = new Prosody();
			prosody._pitch = _pitch;
			prosody._range = _range;
			prosody._rate = _rate;
			prosody._duration = _duration;
			prosody._volume = _volume;
			return prosody;
		}
	}
	[ImmutableObject(true)]
	public struct ContourPoint : IEquatable<ContourPoint>
	{
		private float _start;

		private float _change;

		private ContourPointChangeType _changeType;

		public float Start => _start;

		public float Change => _change;

		public ContourPointChangeType ChangeType => _changeType;

		public ContourPoint(float start, float change, ContourPointChangeType changeType)
		{
			_start = start;
			_change = change;
			_changeType = changeType;
		}

		public static bool operator ==(ContourPoint point1, ContourPoint point2)
		{
			if (point1.Start.Equals(point2.Start) && point1.Change.Equals(point2.Change))
			{
				return point1.ChangeType.Equals(point2.ChangeType);
			}
			return false;
		}

		public static bool operator !=(ContourPoint point1, ContourPoint point2)
		{
			return !(point1 == point2);
		}

		public bool Equals(ContourPoint other)
		{
			return this == other;
		}

		public override bool Equals(object obj)
		{
			if (!(obj is ContourPoint))
			{
				return false;
			}
			return Equals((ContourPoint)obj);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}
	}
	[ImmutableObject(true)]
	public struct ProsodyNumber : IEquatable<ProsodyNumber>
	{
		public const int AbsoluteNumber = int.MaxValue;

		private int _ssmlAttributeId;

		private bool _isPercent;

		private float _number;

		private ProsodyUnit _unit;

		public int SsmlAttributeId
		{
			get
			{
				return _ssmlAttributeId;
			}
			internal set
			{
				_ssmlAttributeId = value;
			}
		}

		public bool IsNumberPercent
		{
			get
			{
				return _isPercent;
			}
			internal set
			{
				_isPercent = value;
			}
		}

		public float Number
		{
			get
			{
				return _number;
			}
			internal set
			{
				_number = value;
			}
		}

		public ProsodyUnit Unit
		{
			get
			{
				return _unit;
			}
			internal set
			{
				_unit = value;
			}
		}

		public ProsodyNumber(int ssmlAttributeId)
		{
			_ssmlAttributeId = ssmlAttributeId;
			_number = 1f;
			_isPercent = true;
			_unit = ProsodyUnit.Default;
		}

		public ProsodyNumber(float number)
		{
			_ssmlAttributeId = int.MaxValue;
			_number = number;
			_isPercent = false;
			_unit = ProsodyUnit.Default;
		}

		public static bool operator ==(ProsodyNumber prosodyNumber1, ProsodyNumber prosodyNumber2)
		{
			if (prosodyNumber1._ssmlAttributeId == prosodyNumber2._ssmlAttributeId && prosodyNumber1.Number.Equals(prosodyNumber2.Number) && prosodyNumber1.IsNumberPercent == prosodyNumber2.IsNumberPercent)
			{
				return prosodyNumber1.Unit == prosodyNumber2.Unit;
			}
			return false;
		}

		public static bool operator !=(ProsodyNumber prosodyNumber1, ProsodyNumber prosodyNumber2)
		{
			return !(prosodyNumber1 == prosodyNumber2);
		}

		public bool Equals(ProsodyNumber other)
		{
			return this == other;
		}

		public override bool Equals(object obj)
		{
			if (!(obj is ProsodyNumber))
			{
				return false;
			}
			return Equals((ProsodyNumber)obj);
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}
	}
	[StructLayout(LayoutKind.Sequential)]
	public class SayAs
	{
		[MarshalAs(UnmanagedType.LPWStr)]
		private string _interpretAs;

		[MarshalAs(UnmanagedType.LPWStr)]
		private string _format;

		[MarshalAs(UnmanagedType.LPWStr)]
		private string _detail;

		public string InterpretAs
		{
			get
			{
				return _interpretAs;
			}
			set
			{
				Helpers.ThrowIfEmptyOrNull(value, "value");
				_interpretAs = value;
			}
		}

		public string Format
		{
			get
			{
				return _format;
			}
			set
			{
				Helpers.ThrowIfEmptyOrNull(value, "value");
				_format = value;
			}
		}

		public string Detail
		{
			get
			{
				return _detail;
			}
			set
			{
				Helpers.ThrowIfEmptyOrNull(value, "value");
				_detail = value;
			}
		}
	}
	public enum TtsEngineAction
	{
		Speak,
		Silence,
		Pronounce,
		Bookmark,
		SpellOut,
		StartSentence,
		StartParagraph,
		ParseUnknownTag
	}
	public enum EmphasisWord
	{
		Default,
		Strong,
		Moderate,
		None,
		Reduced
	}
	public enum EmphasisBreak
	{
		None = -1,
		ExtraWeak = -2,
		Weak = -3,
		Medium = -4,
		Strong = -5,
		ExtraStrong = -6,
		Default = -7
	}
	public enum ProsodyPitch
	{
		Default,
		ExtraLow,
		Low,
		Medium,
		High,
		ExtraHigh
	}
	public enum ProsodyRange
	{
		Default,
		ExtraLow,
		Low,
		Medium,
		High,
		ExtraHigh
	}
	public enum ProsodyRate
	{
		Default,
		ExtraSlow,
		Slow,
		Medium,
		Fast,
		ExtraFast
	}
	public enum ProsodyVolume
	{
		Default = -1,
		Silent = -2,
		ExtraSoft = -3,
		Soft = -4,
		Medium = -5,
		Loud = -6,
		ExtraLoud = -7
	}
	public enum ProsodyUnit
	{
		Default,
		Hz,
		Semitone
	}
	public enum TtsEventId
	{
		StartInputStream = 1,
		EndInputStream,
		VoiceChange,
		Bookmark,
		WordBoundary,
		Phoneme,
		SentenceBoundary,
		Viseme,
		AudioLevel
	}
	public enum EventParameterType
	{
		Undefined,
		Token,
		Object,
		Pointer,
		String
	}
	public enum SpeakOutputFormat
	{
		WaveFormat,
		Text
	}
	public enum ContourPointChangeType
	{
		Hz,
		Percentage
	}
}
namespace System.Speech.Recognition
{
	public class AudioLevelUpdatedEventArgs : EventArgs
	{
		private int _audioLevel;

		public int AudioLevel => _audioLevel;

		internal AudioLevelUpdatedEventArgs(int audioLevel)
		{
			_audioLevel = audioLevel;
		}
	}
	public enum AudioSignalProblem
	{
		None,
		TooNoisy,
		NoSignal,
		TooLoud,
		TooSoft,
		TooFast,
		TooSlow
	}
	public class AudioSignalProblemOccurredEventArgs : EventArgs
	{
		private AudioSignalProblem _audioSignalProblem;

		private TimeSpan _recognizerPosition;

		private TimeSpan _audioPosition;

		private int _audioLevel;

		public AudioSignalProblem AudioSignalProblem => _audioSignalProblem;

		public int AudioLevel => _audioLevel;

		public TimeSpan AudioPosition => _audioPosition;

		public TimeSpan RecognizerAudioPosition => _recognizerPosition;

		internal AudioSignalProblemOccurredEventArgs(AudioSignalProblem audioSignalProblem, int audioLevel, TimeSpan audioPosition, TimeSpan recognizerPosition)
		{
			_audioSignalProblem = audioSignalProblem;