potentially dead corelib internals

gistfile1.txt

  C:\git\coreclr\bin\Product\Windows_NT.x64.Debug\System.Private.CoreLib.dll  
[2 C:\bak\System.Private.CoreLib.dll 2]
namespace  {
}
namespace Microsoft.Win32 {
    internal static class OAVariantLib   {
      internal static readonly Type[] ClassTypes;  
      private static void .cctor();  
      internal static Variant ChangeType(Variant source, Type targetClass, short options, CultureInfo culture);  
      private static void ChangeTypeEx(ref Variant result, ref Variant source, int lcid, IntPtr typeHandle, int cvType, short flags);  
      private static int GetCVTypeFromClass(Type ctype);  
  }
  internal static class Win32Native {
      internal static extern bool FindNextFile(SafeFindHandle hndFindFile, Win32Native.WIN32_FIND_DATA lpFindFileData);  
      internal static extern int RegQueryInfoKey(SafeRegistryHandle hKey, StringBuilder lpClass, int[] lpcbClass, IntPtr lpReserved_MustBeZero, ref int lpcSubKeys, int[] lpcbMaxSubKeyLen, int[] lpcbMaxClassLen, ref int lpcValues, int[] lpcbMaxValueNameLen, int[] lpcbMaxValueLen, int[] lpcbSecurityDescriptor, int[] lpftLastWriteTime);  
      internal static extern IntPtr SysAllocStringByteLen(byte[] str, uint len);  
      internal static extern uint SysStringByteLen(IntPtr bstr);  
      internal struct NlsVersionInfoEx   {
        internal Guid guidCustomVersion;  
        internal int dwDefinedVersion;  
        internal int dwEffectiveId;  
        internal int dwNLSVersion;  
        internal int dwNLSVersionInfoSize;  
    }
      internal class OSVERSIONINFO   {
        internal int BuildNumber;  
        internal int MajorVersion;  
        internal int MinorVersion;  
        internal int OSVersionInfoSize;  
        internal int PlatformId;  
        internal string CSDVersion;  
        internal OSVERSIONINFO();  
    }
  }
}
namespace System {
    internal class __Canon   {
      public __Canon();  
  }
  internal class __ComObject : MarshalByRefObject {
      private Hashtable m_ObjectToDataMap;  
      private object CreateEventProvider(RuntimeType t);  
      internal object GetData(object key);  
      internal object GetEventProvider(RuntimeType t);  
      internal void ReleaseAllData();  
      internal bool SetData(object key, object data);  
  }
  public sealed class Activator {
      private Activator();  
  }
  internal static class AppContextSwitches {
      private static int _noAsyncCurrentCulture;  
      public static bool NoAsyncCurrentCulture { get; }  
  }
  internal sealed class AppDomain {
      public bool IsFullyTrusted { get; }  
      private void CreateAppDomainManager();  
      internal AppDomainHandle GetNativeHandle();  
      internal static RuntimeAssembly GetRuntimeAssembly(Assembly asm);  
      private void InitializeCompatibilityFlags();  
      internal void nCreateContext();  
      private static string NormalizeAppPaths(string values);  
      internal static string NormalizePath(string path, bool fullCheck);  
      private static extern void nSetNativeDllSearchDirectories(string paths);  
      private static extern void nSetupBindingPaths(string trustedPlatformAssemblies, string platformResourceRoots, string appPath, string appNiPaths, string appLocalWinMD);  
      private void nSetupFriendlyName(string friendlyName);  
      private void OnAssemblyLoadEvent(RuntimeAssembly LoadedAssembly);  
      private RuntimeAssembly OnAssemblyResolveEvent(RuntimeAssembly assembly, string assemblyFullName);  
      private string[] OnDesignerNamespaceResolveEvent(string namespaceName);  
      private RuntimeAssembly OnResourceResolveEvent(RuntimeAssembly assembly, string resourceName);  
      private RuntimeAssembly OnTypeResolveEvent(RuntimeAssembly assembly, string typeName);  
      private static object PrepareDataForSetup(string friendlyName, AppDomainSetup setup, string[] propertyNames, string[] propertyValues);  
      private static object Setup(object arg);  
      internal void SetupBindingPaths(string trustedPlatformAssemblies, string platformResourceRoots, string appPath, string appNiPaths, string appLocalWinMD);  
      private void SetupDomain(bool allowRedirects, string path, string configFile, string[] propertyNames, string[] propertyValues);  
      private void SetupFusionStore(AppDomainSetup info, AppDomainSetup oldInfo);  
  }
    internal struct AppDomainHandle   {
      private IntPtr m_appDomainHandle;  
      internal AppDomainHandle(IntPtr domainHandle);  
  }
  internal class AppDomainManager : MarshalByRefObject {
      internal static AppDomainManager CurrentAppDomainManager { get; }  
      public virtual void InitializeNewDomain(AppDomainSetup appDomainInfo);  
  }
  internal sealed class AppDomainSetup {
      private string _AppBase;  
      public AppDomainSetup();  
      public string ApplicationName { get; set; }  
      internal Dictionary<string, object> GetCompatibilityFlags();  
      internal void SetupDefaults(string imageLocation, bool imageLocationAlreadyNormalized=false);  
      internal enum LoaderInformation   {
        ApplicationBaseValue = 0,  
        ApplicationNameValue = 4,  
        CachePathValue = 9,  
        ConfigurationBytesValue = 15,  
        ConfigurationFileValue = 1,  
        DevPathValue = 3,  
        DisallowAppBaseProbingValue = 14,  
        DisallowBindingRedirectsValue = 13,  
        DisallowCodeDownloadValue = 12,  
        DisallowPublisherPolicyValue = 11,  
        DynamicBaseValue = 2,  
        LicenseFileValue = 10,  
        LoaderMaximum = 18,  
        PrivateBinPathProbeValue = 6,  
        PrivateBinPathValue = 5,  
        ShadowCopyDirectoriesValue = 7,  
        ShadowCopyFilesValue = 8,  
      }
  }
  internal class CLRConfig {
      public CLRConfig();  
  }
    internal static class CommonlyUsedGenericInstantiations   {
      private static void .cctor();  
      private static Task<string> AsyncHelper2<T>();  
      private static Task AsyncHelper3();  
      private static void AsyncHelper<T>();  
      private static void CommonlyUsedWinRTRedirectedInterfaceStubs();  
      private static T NullableHelper<T>() where T : struct;  
      private static void SZArrayHelper<T>(SZArrayHelper oSZArrayHelper);  
      private static void WinRT_IDictionary<K, V>(MapToDictionaryAdapter mapToDictionaryAdapter, MapToCollectionAdapter mapToCollectionAdapter, DictionaryToMapAdapter dictionaryToMapAdapter, IMap<K, V> map);  
      private static void WinRT_IEnumerable<T>(IterableToEnumerableAdapter iterableToEnumerableAdapter, EnumerableToIterableAdapter enumerableToIterableAdapter, IIterable<T> iterable);  
      private static void WinRT_IList<T>(VectorToListAdapter vectorToListAdapter, VectorToCollectionAdapter vectorToCollectionAdapter, ListToVectorAdapter listToVectorAdapter, IVector<T> vector);  
      private static void WinRT_IReadOnlyCollection<T>(VectorViewToReadOnlyCollectionAdapter vectorViewToReadOnlyCollectionAdapter);  
      private static void WinRT_IReadOnlyDictionary<K, V>(IMapViewToIReadOnlyDictionaryAdapter mapToDictionaryAdapter, IReadOnlyDictionaryToIMapViewAdapter dictionaryToMapAdapter, IMapView<K, V> mapView, MapViewToReadOnlyCollectionAdapter mapViewToReadOnlyCollectionAdapter);  
      private static void WinRT_IReadOnlyList<T>(IVectorViewToIReadOnlyListAdapter vectorToListAdapter, IReadOnlyListToIVectorViewAdapter listToVectorAdapter, IVectorView<T> vectorView);  
      private static void WinRT_Nullable<T>() where T : struct;  
  }
    internal static class CompatibilitySwitches   {
      private static bool s_AreSwitchesSet;  
      public static bool IsCompatibilityBehaviorDefined { get; }  
      internal static void InitializeSwitches();  
  }
  internal class CoreLib {
      public CoreLib();  
  }
    internal sealed class CrossAppDomainMarshaledException : SystemException   {
      public CrossAppDomainMarshaledException(string message, int errorCode);  
      internal override string InternalToString();  
  }
  internal static class Environment {
      public static Version Version { get; }  
      internal static void FooBar();  
      internal static string GetResourceStringLocal(string key);  
      private static void SetCommandLineArgs(string[] cmdLineArgs);  
  }
    internal enum InternalGCCollectionMode   {
      Blocking = 2,  
      Compacting = 8,  
      NonBlocking = 1,  
      Optimized = 4,  
  }
  internal static class NotImplemented {
      internal static Exception ByDesignWithMessage(string message);  
  }
  internal class Number {
      private Number();  
  }
  public class ObjectDisposedException : InvalidOperationException {
      private ObjectDisposedException();  
  }
    internal class OleAutBinder : DefaultBinder   {
      public OleAutBinder();  
      public override object ChangeType(object value, Type type, CultureInfo cultureInfo);  
  }
  internal static class ParseNumbers {
      public static int StringToInt(string s, int radix, int flags, ref int currPos);  
      public static long StringToLong(string s, int radix, int flags, ref int currPos);  
  }
  internal abstract class Resolver {
      internal abstract byte[] GetCodeInfo(ref int stackSize, ref int initLocals, ref int EHCount);  
      internal unsafe abstract void GetEHInfo(int EHNumber, void* exception);  
      internal abstract RuntimeType GetJitContext(ref int securityControlFlags);  
      internal abstract byte[] GetLocalsSignature();  
      internal abstract byte[] GetRawEHInfo();  
      internal abstract string GetStringLiteral(int token);  
      internal abstract byte[] ResolveSignature(int token, int fromMethod);  
      internal abstract void ResolveToken(int token, out IntPtr typeHandle, out IntPtr methodHandle, out IntPtr fieldHandle);  
      internal struct CORINFO_EH_CLAUSE   {
        internal int ClassTokenOrFilterOffset;  
        internal int Flags;  
        internal int HandlerLength;  
        internal int HandlerOffset;  
        internal int TryLength;  
        internal int TryOffset;  
    }
  }
  public struct RuntimeArgumentHandle {
      internal IntPtr Value { get; }  
  }
  public struct RuntimeFieldHandle : ISerializable {
      internal RuntimeFieldHandle GetNativeHandle();  
  }
    internal class RuntimeFieldInfoStub : IRuntimeFieldInfo   {
      private int m_b;  
      private object m_c;  
      private object m_d;  
      private object m_e;  
      private object m_keepalive;  
      private RuntimeFieldHandleInternal m_fieldHandle;  
      public RuntimeFieldInfoStub();  
      RuntimeFieldHandleInternal System.IRuntimeFieldInfo.Value { get; }  
  }
  public struct RuntimeMethodHandle : ISerializable {
      private static IntPtr GetValueInternal(RuntimeMethodHandle rmh);  
  }
  internal struct RuntimeMethodHandleInternal {
      internal static RuntimeMethodHandleInternal EmptyHandle { get; }  
  }
  internal class RuntimeMethodInfoStub : IRuntimeMethodInfo {
      private object m_a;  
      private object m_b;  
      private object m_c;  
      private object m_d;  
      private object m_e;  
      private object m_f;  
      private object m_g;  
  }
  internal class RuntimeType : TypeInfo, ICloneable {
  }
  public struct RuntimeTypeHandle : ISerializable {
      internal static IntPtr GetValueInternal(RuntimeTypeHandle handle);  
  }
  internal static class SR {
      internal static string Acc_CreateAbst { get; }  
      internal static string Acc_CreateGeneric { get; }  
      internal static string Acc_CreateInterface { get; }  
      internal static string AppDomain_AppBaseNotSet { get; }  
      internal static string ArgumentException_OtherNotArrayOfCorrectLength { get; }  
      internal static string ArgumentNull_AssemblyName { get; }  
      internal static string ArgumentNull_AssemblyNameName { get; }  
      internal static string ArgumentNull_Collection { get; }  
      internal static string ArgumentNull_FileName { get; }  
      internal static string ArgumentNull_GUID { get; }  
      internal static string ArgumentNull_SafeHandle { get; }  
      internal static string ArgumentNull_Type { get; }  
      internal static string ArgumentNull_TypedRefType { get; }  
      internal static string ArgumentOutOfRange_ArrayLB { get; }  
      internal static string ArgumentOutOfRange_ArrayLBAndLength { get; }  
      internal static string ArgumentOutOfRange_BiggerThanCollection { get; }  
      internal static string ArgumentOutOfRange_EndIndexStartIndex { get; }  
      internal static string ArgumentOutOfRange_HugeArrayNotSupported { get; }  
      internal static string ArgumentOutOfRange_IndexLargerThanMaxValue { get; }  
      internal static string ArgumentOutOfRange_ListInsert { get; }  
      internal static string ArgumentOutOfRange_NeedValidId { get; }  
      internal static string Argument_AddingDuplicate { get; }  
      internal static string Argument_AlreadyACCW { get; }  
      internal static string Argument_ArgumentZero { get; }  
      internal static string Argument_BadConstantValue { get; }  
      internal static string Argument_BadFormatSpecifier { get; }  
      internal static string Argument_BadObjRef { get; }  
      internal static string Argument_CannotCreateTypedReference { get; }  
      internal static string Argument_CantCallSecObjFunc { get; }  
      internal static string Argument_CORDBBadMethod { get; }  
      internal static string Argument_CORDBBadVarArgCallConv { get; }  
      internal static string Argument_EmptyFileName { get; }  
      internal static string Argument_HandleLeak { get; }  
      internal static string Argument_IndexOutOfArrayBounds { get; }  
      internal static string Argument_InsufficientSpaceToCopyCollection { get; }  
      internal static string Argument_InterfaceMap { get; }  
      internal static string Argument_InvalidArgumentForComparison { get; }  
      internal static string Argument_InvalidArrayType { get; }  
      internal static string Argument_InvalidAssemblyName { get; }  
      internal static string Argument_InvalidGenericArg { get; }  
      internal static string Argument_InvalidRegistryViewCheck { get; }  
      internal static string Argument_InvalidTypeName { get; }  
      internal static string Argument_InvalidUnity { get; }  
      internal static string Argument_InvalidValue { get; }  
      internal static string Argument_MustHaveLayoutOrBeBlittable { get; }  
      internal static string Argument_NeedNonGenericObject { get; }  
      internal static string Argument_NeedStructWithNoRefs { get; }  
      internal static string Argument_NoDomainManager { get; }  
      internal static string Argument_NotATP { get; }  
      internal static string Argument_NoUnderlyingCCW { get; }  
      internal static string Argument_NoUninitializedStrings { get; }  
      internal static string Argument_PathEmpty { get; }  
      internal static string Argument_StructMustNotBeValueClass { get; }  
      internal static string Argument_TimeZoneInfoBadTZif { get; }  
      internal static string Argument_TimeZoneInfoInvalidTZif { get; }  
      internal static string Argument_TypeMustBeVisibleFromCom { get; }  
      internal static string Argument_Unexpected_TypeSource { get; }  
      internal static string Argument_UnrecognizedLoaderOptimization { get; }  
      internal static string Argument_VerStringTooLong { get; }  
      internal static string Argument_WinRTSystemRuntimeType { get; }  
      internal static string Arg_CannotHaveNegativeValue { get; }  
      internal static string Arg_DriveNotFoundException { get; }  
      internal static string Arg_EmptyOrNullString { get; }  
      internal static string Arg_InvalidANSIString { get; }  
      internal static string Arg_InvalidSearchPattern { get; }  
      internal static string Arg_InvalidUTF8String { get; }  
      internal static string Arg_LongerThanDestArray { get; }  
      internal static string Arg_LongerThanSrcArray { get; }  
      internal static string Arg_LowerBoundsMustMatch { get; }  
      internal static string Arg_MethodAccessException_WithMethodName { get; }  
      internal static string Arg_MustBeInterface { get; }  
      internal static string Arg_MustBeStatic { get; }  
      internal static string Arg_MustContainEnumInfo { get; }  
      internal static string Arg_Need1DArray { get; }  
      internal static string Arg_Need2DArray { get; }  
      internal static string Arg_Need3DArray { get; }  
      internal static string Arg_NeedAtLeast1Rank { get; }  
      internal static string Arg_NoITypeInfo { get; }  
      internal static string Arg_NoITypeLib { get; }  
      internal static string Arg_NonZeroLowerBound { get; }  
      internal static string Arg_NotFoundIFace { get; }  
      internal static string Arg_NullIndex { get; }  
      internal static string Arg_ObjObj { get; }  
      internal static string Arg_PrimWiden { get; }  
      internal static string Arg_RankIndices { get; }  
      internal static string Arg_RanksAndBounds { get; }  
      internal static string Arg_RegKeyStrLenBug { get; }  
      internal static string Arg_RegSetMismatchedKind { get; }  
      internal static string Arg_RegSetStrArrNull { get; }  
      internal static string Arg_RegSubKeyValueAbsent { get; }  
      internal static string Arg_RemoveArgNotFound { get; }  
      internal static string Arg_ThreadStartException { get; }  
      internal static string ArrayTypeMismatch_CantAssignType { get; }  
      internal static string ArrayTypeMismatch_ConstrainedCopy { get; }  
      internal static string AssertionFailed { get; }  
      internal static string AssertionFailed_Cnd { get; }  
      internal static string AssumptionFailed { get; }  
      internal static string AssumptionFailed_Cnd { get; }  
      internal static string AsyncMethodBuilder_InstanceNotInitialized { get; }  
      internal static string CancellationToken_SourceDisposed { get; }  
      internal static string ConcurrentDictionary_ArrayIncorrectType { get; }  
      internal static string ConcurrentDictionary_ArrayNotLargeEnough { get; }  
      internal static string ConcurrentDictionary_CapacityMustNotBeNegative { get; }  
      internal static string ConcurrentDictionary_ConcurrencyLevelMustBePositive { get; }  
      internal static string ConcurrentDictionary_IndexIsNegative { get; }  
      internal static string ConcurrentDictionary_ItemKeyIsNull { get; }  
      internal static string ConcurrentDictionary_KeyAlreadyExisted { get; }  
      internal static string ConcurrentDictionary_TypeOfKeyIncorrect { get; }  
      internal static string ConcurrentDictionary_TypeOfValueIncorrect { get; }  
      internal static string EventSource_AbstractMustNotDeclareEventMethods { get; }  
      internal static string EventSource_AbstractMustNotDeclareKTOC { get; }  
      internal static string EventSource_AddScalarOutOfRange { get; }  
      internal static string EventSource_ChannelTypeDoesNotMatchEventChannelValue { get; }  
      internal static string EventSource_DataDescriptorsOutOfRange { get; }  
      internal static string EventSource_DuplicateStringKey { get; }  
      internal static string EventSource_EnumKindMismatch { get; }  
      internal static string EventSource_EventChannelOutOfRange { get; }  
      internal static string EventSource_EventIdReused { get; }  
      internal static string EventSource_EventMustHaveTaskIfNonDefaultOpcode { get; }  
      internal static string EventSource_EventMustNotBeExplicitImplementation { get; }  
      internal static string EventSource_EventNameDoesNotEqualTaskPlusOpcode { get; }  
      internal static string EventSource_EventNameReused { get; }  
      internal static string EventSource_EventParametersMismatch { get; }  
      internal static string EventSource_EventSourceGuidInUse { get; }  
      internal static string EventSource_EventWithAdminChannelMustHaveMessage { get; }  
      internal static string EventSource_IllegalKeywordsValue { get; }  
      internal static string EventSource_IllegalOpcodeValue { get; }  
      internal static string EventSource_IllegalTaskValue { get; }  
      internal static string EventSource_IncorrentlyAuthoredTypeInfo { get; }  
      internal static string EventSource_InvalidCommand { get; }  
      internal static string EventSource_InvalidEventFormat { get; }  
      internal static string EventSource_KeywordCollision { get; }  
      internal static string EventSource_KeywordNeedPowerOfTwo { get; }  
      internal static string EventSource_ListenerCreatedInsideCallback { get; }  
      internal static string EventSource_ListenerNotFound { get; }  
      internal static string EventSource_ListenerWriteFailure { get; }  
      internal static string EventSource_MaxChannelExceeded { get; }  
      internal static string EventSource_MismatchIdToWriteEvent { get; }  
      internal static string EventSource_NeedGuid { get; }  
      internal static string EventSource_NeedName { get; }  
      internal static string EventSource_NeedPositiveId { get; }  
      internal static string EventSource_NoFreeBuffers { get; }  
      internal static string EventSource_NonCompliantTypeError { get; }  
      internal static string EventSource_NoRelatedActivityId { get; }  
      internal static string EventSource_NotSupportedArrayOfBinary { get; }  
      internal static string EventSource_NotSupportedArrayOfNil { get; }  
      internal static string EventSource_NotSupportedArrayOfNullTerminatedString { get; }  
      internal static string EventSource_NotSupportedCustomSerializedData { get; }  
      internal static string EventSource_NotSupportedNestedArraysEnums { get; }  
      internal static string EventSource_NullInput { get; }  
      internal static string EventSource_OpcodeCollision { get; }  
      internal static string EventSource_PinArrayOutOfRange { get; }  
      internal static string EventSource_RecursiveTypeDefinition { get; }  
      internal static string EventSource_SessionIdError { get; }  
      internal static string EventSource_StopsFollowStarts { get; }  
      internal static string EventSource_TaskCollision { get; }  
      internal static string EventSource_TaskOpcodePairReused { get; }  
      internal static string EventSource_TooManyArgs { get; }  
      internal static string EventSource_TooManyFields { get; }  
      internal static string EventSource_ToString { get; }  
      internal static string EventSource_TypeMustBeSealedOrAbstract { get; }  
      internal static string EventSource_TypeMustDeriveFromEventSource { get; }  
      internal static string EventSource_UndefinedChannel { get; }  
      internal static string EventSource_UndefinedKeyword { get; }  
      internal static string EventSource_UndefinedOpcode { get; }  
      internal static string EventSource_UnsupportedEventTypeInManifest { get; }  
      internal static string EventSource_UnsupportedMessageProperty { get; }  
      internal static string EventSource_VarArgsParameterMismatch { get; }  
      internal static string event_Barrier_PhaseFinished { get; }  
      internal static string event_ConcurrentBag_TryPeekSteals { get; }  
      internal static string event_ConcurrentBag_TryTakeSteals { get; }  
      internal static string event_ConcurrentDictionary_AcquiringAllLocks { get; }  
      internal static string event_ConcurrentStack_FastPopFailed { get; }  
      internal static string event_ConcurrentStack_FastPushFailed { get; }  
      internal static string event_ParallelFork { get; }  
      internal static string event_ParallelInvokeBegin { get; }  
      internal static string event_ParallelInvokeEnd { get; }  
      internal static string event_ParallelJoin { get; }  
      internal static string event_ParallelLoopBegin { get; }  
      internal static string event_ParallelLoopEnd { get; }  
      internal static string event_SpinLock_FastPathFailed { get; }  
      internal static string event_SpinWait_NextSpinWillYield { get; }  
      internal static string event_TaskCompleted { get; }  
      internal static string event_TaskScheduled { get; }  
      internal static string event_TaskStarted { get; }  
      internal static string event_TaskWaitBegin { get; }  
      internal static string event_TaskWaitEnd { get; }  
      internal static string Format_BadBase { get; }  
      internal static string Format_BadDatePattern { get; }  
      internal static string Format_BadDateTime { get; }  
      internal static string Format_BadDateTimeCalendar { get; }  
      internal static string Format_BadDayOfWeek { get; }  
      internal static string Format_BadTimeSpan { get; }  
      internal static string Format_DateOutOfRange { get; }  
      internal static string Format_EmptyInputString { get; }  
      internal static string Format_ExtraJunkAtEnd { get; }  
      internal static string Format_GuidBrace { get; }  
      internal static string Format_GuidBraceAfterLastNumber { get; }  
      internal static string Format_GuidComma { get; }  
      internal static string Format_GuidDashes { get; }  
      internal static string Format_GuidEndBrace { get; }  
      internal static string Format_GuidHexPrefix { get; }  
      internal static string Format_GuidInvalidChar { get; }  
      internal static string Format_GuidInvLen { get; }  
      internal static string Format_MissingIncompleteDate { get; }  
      internal static string Format_NoParsibleDigits { get; }  
      internal static string Format_OffsetOutOfRange { get; }  
      internal static string Format_RepeatDateTimePattern { get; }  
      internal static string Format_UnknowDateTimeWord { get; }  
      internal static string Format_UTCOutOfRange { get; }  
      internal static string Globalization_cp_1200 { get; }  
      internal static string Globalization_cp_12000 { get; }  
      internal static string Globalization_cp_12001 { get; }  
      internal static string Globalization_cp_1201 { get; }  
      internal static string Globalization_cp_20127 { get; }  
      internal static string Globalization_cp_28591 { get; }  
      internal static string Globalization_cp_65000 { get; }  
      internal static string Globalization_cp_65001 { get; }  
      internal static string IndexOutOfRange_ArrayRankIndex { get; }  
      internal static string Interop_COM_TypeMismatch { get; }  
      internal static string InvalidCast_CannotCoerceByRefVariant { get; }  
      internal static string InvalidCast_DownCastArrayElement { get; }  
      internal static string InvalidCast_OATypeMismatch { get; }  
      internal static string InvalidCast_StoreArrayElement { get; }  
      internal static string InvalidCast_WinRTIPropertyValueArrayCoersion { get; }  
      internal static string InvalidCast_WinRTIPropertyValueCoersion { get; }  
      internal static string InvalidCast_WinRTIPropertyValueElement { get; }  
      internal static string InvalidOperation_AsyncIOInProgress { get; }  
      internal static string InvalidOperation_CannotRemoveLastFromEmptyCollection { get; }  
      internal static string InvalidOperation_CantInstantiateAbstractClass { get; }  
      internal static string InvalidOperation_CantInstantiateFunctionPointer { get; }  
      internal static string InvalidOperation_CollectionBackingDictionaryTooLarge { get; }  
      internal static string InvalidOperation_CollectionBackingListTooLarge { get; }  
      internal static string InvalidOperation_CriticalTransparentAreMutuallyExclusive { get; }  
      internal static string InvalidOperation_GetVersion { get; }  
      internal static string InvalidOperation_HandleIsNotInitialized { get; }  
      internal static string InvalidOperation_NoValue { get; }  
      internal static string InvalidOperation_NullArray { get; }  
      internal static string InvalidOperation_SetData_OnlyOnce { get; }  
      internal static string InvalidOperation_StrongNameKeyPairRequired { get; }  
      internal static string InvalidOperation_TypeCannotBeBoxed { get; }  
      internal static string InvalidOperation_WrongAsyncResultOrEndCalledMultiple { get; }  
      internal static string InvalidTimeZone_InvalidFileData { get; }  
      internal static string InvalidTimeZone_JulianDayNotSupported { get; }  
      internal static string InvalidTimeZone_NoTTInfoStructures { get; }  
      internal static string InvalidTimeZone_UnparseablePosixMDateString { get; }  
      internal static string InvariantFailed { get; }  
      internal static string InvariantFailed_Cnd { get; }  
      internal static string IO_FileTooLong2GB { get; }  
      internal static string Loader_ContextPolicies { get; }  
      internal static string Loader_NoContextPolicies { get; }  
      internal static string MissingManifestResource_LooselyLinked { get; }  
      internal static string NotSupported_ByRefLike { get; }  
      internal static string NotSupported_ByRefLikeArray { get; }  
      internal static string NotSupported_CollectibleAssemblyResolve { get; }  
      internal static string NotSupported_CollectibleBoundNonCollectible { get; }  
      internal static string NotSupported_CollectibleCOM { get; }  
      internal static string NotSupported_CollectibleDelegateMarshal { get; }  
      internal static string NotSupported_Constructor { get; }  
      internal static string NotSupported_DBNullSerial { get; }  
      internal static string NotSupported_DelegateMarshalToWrongDomain { get; }  
      internal static string NotSupported_DelegateSerHolderSerial { get; }  
      internal static string NotSupported_DynamicAssemblyNoRunAccess { get; }  
      internal static string NotSupported_FixedSizeCollection { get; }  
      internal static string NotSupported_GenericMethod { get; }  
      internal static string NotSupported_GlobalMethodSerialization { get; }  
      internal static string NotSupported_IDispInvokeDefaultMemberWithNamedArgs { get; }  
      internal static string NotSupported_KeyCollectionSet { get; }  
      internal static string NotSupported_ManagedActivation { get; }  
      internal static string NotSupported_NativeCallableTarget { get; }  
      internal static string NotSupported_NonBlittableTypes { get; }  
      internal static string NotSupported_NonStaticMethod { get; }  
      internal static string NotSupported_OleAutBadVarType { get; }  
      internal static string NotSupported_OpenType { get; }  
      internal static string NotSupported_PIAInAppxProcess { get; }  
      internal static string NotSupported_ReadOnlyCollection { get; }  
      internal static string NotSupported_SignalAndWaitSTAThread { get; }  
      internal static string NotSupported_TooManyArgs { get; }  
      internal static string NotSupported_Type { get; }  
      internal static string NotSupported_TypeCannotDeserialized { get; }  
      internal static string NotSupported_UnitySerHolder { get; }  
      internal static string NotSupported_UnknownTypeCode { get; }  
      internal static string NotSupported_ValueClassCM { get; }  
      internal static string NotSupported_ValueCollectionSet { get; }  
      internal static string NotSupported_VoidArray { get; }  
      internal static string NotSupported_WinRT_PartialTrust { get; }  
      internal static string NullReference_This { get; }  
      internal static string ObjectDisposed_ReaderClosed { get; }  
      internal static string ObjectDisposed_RegKeyClosed { get; }  
      internal static string OutOfMemory_GCHandleMDA { get; }  
      internal static string Overflow_Currency { get; }  
      internal static string Overflow_NegativeUnsigned { get; }  
      internal static string Overflow_TimeSpanElementTooLarge { get; }  
      internal static string PlatformNotSupported_ComInterop { get; }  
      internal static string PlatformNotSupported_NamedSynchronizationPrimitives { get; }  
      internal static string PlatformNotSupported_NamedSyncObjectWaitAnyWaitAll { get; }  
      internal static string PlatformNotSupported_OSXFileLocking { get; }  
      internal static string PlatformNotSupported_OverlappedIO { get; }  
      internal static string Policy_CannotLoadSemiTrustAssembliesDuringInit { get; }  
      internal static string PostconditionFailed { get; }  
      internal static string PostconditionFailed_Cnd { get; }  
      internal static string PostconditionOnExceptionFailed { get; }  
      internal static string PostconditionOnExceptionFailed_Cnd { get; }  
      internal static string PreconditionFailed { get; }  
      internal static string PreconditionFailed_Cnd { get; }  
      internal static string Rank_MultiDimNotSupported { get; }  
      internal static string Rank_MustMatch { get; }  
      internal static string ReflectionTypeLoad_LoadFailed { get; }  
      internal static string Remoting_AppDomainUnloaded_ThreadUnwound { get; }  
      internal static string Security_CannotReadFileData { get; }  
      internal static string Security_RegistryPermission { get; }  
      internal static string Serialization_InsufficientDeserializationState { get; }  
      internal static string Serialization_InvalidDelegateType { get; }  
      internal static string Serialization_InvalidFieldState { get; }  
      internal static string Serialization_MemberOutOfRange { get; }  
      internal static string Serialization_MemberTypeNotRecognized { get; }  
      internal static string Serialization_MissField { get; }  
      internal static string Serialization_NullSignature { get; }  
      internal static string Serialization_UnableToFindModule { get; }  
      internal static string Serialization_UnknownMember { get; }  
      internal static string TaskCompletionSourceT_TrySetException_NoExceptions { get; }  
      internal static string TaskCompletionSourceT_TrySetException_NullException { get; }  
      internal static string TaskT_TransitionToFinal_AlreadyCompleted { get; }  
      internal static string Task_ContinueWith_NotOnAnything { get; }  
      internal static string Task_Delay_InvalidDelay { get; }  
      internal static string Task_Delay_InvalidMillisecondsDelay { get; }  
      internal static string Task_Dispose_NotCompleted { get; }  
      internal static string Task_RunSynchronously_AlreadyStarted { get; }  
      internal static string Task_RunSynchronously_Continuation { get; }  
      internal static string Task_RunSynchronously_Promise { get; }  
      internal static string Task_RunSynchronously_TaskCompleted { get; }  
      internal static string Task_Start_AlreadyStarted { get; }  
      internal static string Task_Start_ContinuationTask { get; }  
      internal static string Task_Start_Promise { get; }  
      internal static string Task_Start_TaskCompleted { get; }  
      internal static string Task_ThrowIfDisposed { get; }  
      internal static string Task_WaitMulti_NullTask { get; }  
      internal static string TypeInitialization_Default { get; }  
      internal static string UnauthorizedAccess_RegistryNoWrite { get; }  
      internal static string UnauthorizedAccess_SystemDomain { get; }  
      internal static string Format(string resourceFormat, object p1, object p2, object p3);  
  }
    internal sealed class SZArrayHelper   {
      private SZArrayHelper();  
      private void Add<T>(T value);  
      private void Clear<T>();  
      private bool Contains<T>(T value);  
      private void CopyTo<T>(T[] array, int index);  
      internal IEnumerator<T> GetEnumerator<T>();  
      internal int get_Count<T>();  
      private bool get_IsReadOnly<T>();  
      internal T get_Item<T>(int index);  
      private int IndexOf<T>(T value);  
      private void Insert<T>(int index, T value);  
      private bool Remove<T>(T value);  
      private void RemoveAt<T>(int index);  
      internal void set_Item<T>(int index, T value);  
      private sealed class SZGenericArrayEnumerator<T> : IDisposable, IEnumerator, IEnumerator<T>   {
        private int _index;  
        internal static readonly SZArrayHelper.SZGenericArrayEnumerator<T> Empty;  
        private readonly T[] _array;  
        internal SZGenericArrayEnumerator(T[] array);  
        public T Current { get; }  
        object System.Collections.IEnumerator.Current { get; }  
        private static void .cctor();  
          public void Dispose();  
        public bool MoveNext();  
          void System.Collections.IEnumerator.Reset();  
    }
  }
  internal static class ThrowHelper {
      private static InvalidOperationException GetInvalidOperationException_EnumCurrent(int index);  
      internal static void ThrowInvalidOperationException_EnumCurrent(int index);  
  }
  public sealed class TimeZoneInfo : IDeserializationCallback, IEquatable<TimeZoneInfo>, ISerializable {
  }
  public sealed class TypeInitializationException : SystemException {
      private TypeInitializationException();  
      internal TypeInitializationException(string message);  
  }
  public class TypeLoadException : SystemException, ISerializable {
      private TypeLoadException(string className, string assemblyName, string messageArg, int resourceId);  
  }
    internal struct Variant   {
      private int m_data1;  
      private int m_data2;  
      private int m_flags;  
      private object m_objref;  
      internal static readonly Type[] ClassTypes;  
      internal static readonly Variant DBNull;  
      internal static readonly Variant Empty;  
      internal static readonly Variant Missing;  
      public Variant(bool val);  
      public Variant(byte val);  
      public Variant(char val);  
      public Variant(DateTime val);  
      public Variant(decimal val);  
      public Variant(double val);  
      public Variant(short val);  
      public Variant(int val);  
      internal Variant(int flags, object or, int data1, int data2);  
      public Variant(long val);  
      public Variant(object obj);  
      public Variant(sbyte val);  
      public Variant(float val);  
      public Variant(ushort val);  
      public Variant(uint val);  
      public Variant(ulong val);  
      internal int CVType { get; }  
      private static void .cctor();  
      private object BoxEnum();  
      internal long GetI8FromVar();  
      internal float GetR4FromVar();  
      internal double GetR8FromVar();  
      internal static void MarshalHelperCastVariant(object pValue, int vt, ref Variant v);  
      internal static void MarshalHelperConvertObjectToVariant(object o, ref Variant v);  
      internal static object MarshalHelperConvertVariantToObject(ref Variant v);  
      internal void SetFieldsObject(object val);  
      internal void SetFieldsR4(float val);  
      internal void SetFieldsR8(double val);  
      public object ToObject();  
  }
}
namespace System.Buffers {
}
namespace System.Collections {
  internal sealed class Comparer : IComparer {
      private Comparer();  
  }
  internal class CompatibleComparer : IEqualityComparer {
      internal IComparer Comparer { get; }  
      internal IHashCodeProvider HashCodeProvider { get; }  
  }
  internal class Hashtable : ICloneable, ICollection, IDeserializationCallback, IDictionary, IEnumerable, ISerializable {
      public Hashtable(int capacity);  
  }
}
namespace System.Collections.Concurrent {
  internal class ConcurrentDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
      internal IEqualityComparer<TKey> m_comparer;  
      public bool IsEmpty { get; }  
      public KeyValuePair<TKey, TValue>[] ToArray();  
  }
  internal class ConcurrentQueue<T> : ICollection, IEnumerable, IEnumerable<T>, IProducerConsumerCollection<T>, IReadOnlyCollection<T> {
      public ConcurrentQueue(IEnumerable<T> collection);  
      public void Clear();  
      public bool TryPeek(out T result);  
  }
  internal class ConcurrentStack<T> : ICollection, IEnumerable, IEnumerable<T>, IProducerConsumerCollection<T>, IReadOnlyCollection<T> {
      public void CopyTo(T[] array, int index);  
      public T[] ToArray();  
  }
  internal interface IProducerConsumerCollection<T> : ICollection, IEnumerable, IEnumerable<T> {
      void CopyTo(T[] array, int index);  
      T[] ToArray();  
  }
}
namespace System.Collections.Generic {
  public class Dictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDeserializationCallback, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue>, ISerializable {
  }
}
namespace System.Collections.ObjectModel {
    internal class ReadOnlyDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue>   {
      private ReadOnlyDictionary<TKey, TValue>.KeyCollection m_keys;  
      private readonly IDictionary<TKey, TValue> m_dictionary;  
      private object m_syncRoot;  
      private ReadOnlyDictionary<TKey, TValue>.ValueCollection m_values;  
      public ReadOnlyDictionary(IDictionary<TKey, TValue> dictionary);  
      public int Count { get; }  
      protected IDictionary<TKey, TValue> Dictionary { get; }  
      public ReadOnlyDictionary<TKey, TValue>.KeyCollection Keys { get; }  
      bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get; }  
      TValue System.Collections.Generic.IDictionary<TKey,TValue>.this[TKey key] { get; set; }  
      ICollection<TKey> System.Collections.Generic.IDictionary<TKey,TValue>.Keys { get; }  
      ICollection<TValue> System.Collections.Generic.IDictionary<TKey,TValue>.Values { get; }  
      IEnumerable<TKey> System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>.Keys { get; }  
      IEnumerable<TValue> System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>.Values { get; }  
      bool System.Collections.ICollection.IsSynchronized { get; }  
      object System.Collections.ICollection.SyncRoot { get; }  
      bool System.Collections.IDictionary.IsFixedSize { get; }  
      bool System.Collections.IDictionary.IsReadOnly { get; }  
      object System.Collections.IDictionary.this[object key] { get; set; }  
      ICollection System.Collections.IDictionary.Keys { get; }  
      ICollection System.Collections.IDictionary.Values { get; }  
      public TValue this[TKey key] { get; }  
      public ReadOnlyDictionary<TKey, TValue>.ValueCollection Values { get; }  
      public bool ContainsKey(TKey key);  
      public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator();  
      private static bool IsCompatibleKey(object key);  
      void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey, TValue> item);  
      void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Clear();  
      bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey, TValue> item);  
      void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex);  
      bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey, TValue> item);  
      void System.Collections.Generic.IDictionary<TKey,TValue>.Add(TKey key, TValue value);  
      bool System.Collections.Generic.IDictionary<TKey,TValue>.Remove(TKey key);  
      void System.Collections.ICollection.CopyTo(Array array, int index);  
      void System.Collections.IDictionary.Add(object key, object value);  
      void System.Collections.IDictionary.Clear();  
      bool System.Collections.IDictionary.Contains(object key);  
      IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator();  
      void System.Collections.IDictionary.Remove(object key);  
      IEnumerator System.Collections.IEnumerable.GetEnumerator();  
      public bool TryGetValue(TKey key, out TValue value);  
      private struct DictionaryEnumerator : IDictionaryEnumerator, IEnumerator   {
        private readonly IDictionary<TKey, TValue> m_dictionary;  
        private IEnumerator<KeyValuePair<TKey, TValue>> m_enumerator;  
        public DictionaryEnumerator(IDictionary<TKey, TValue> dictionary);  
        public object Current { get; }  
        public DictionaryEntry Entry { get; }  
        public object Key { get; }  
        public object Value { get; }  
              public bool MoveNext();  
        public void Reset();  
      }
      public sealed class KeyCollection : ICollection, ICollection<TKey>, IEnumerable, IEnumerable<TKey>, IReadOnlyCollection<TKey>   {
        private readonly ICollection<TKey> m_collection;  
        private object m_syncRoot;  
        internal KeyCollection(ICollection<TKey> collection);  
        public int Count { get; }  
        bool System.Collections.Generic.ICollection<TKey>.IsReadOnly { get; }  
        bool System.Collections.ICollection.IsSynchronized { get; }  
        object System.Collections.ICollection.SyncRoot { get; }  
        public void CopyTo(TKey[] array, int arrayIndex);  
          public IEnumerator<TKey> GetEnumerator();  
        void System.Collections.Generic.ICollection<TKey>.Add(TKey item);  
        void System.Collections.Generic.ICollection<TKey>.Clear();  
        bool System.Collections.Generic.ICollection<TKey>.Contains(TKey item);  
          bool System.Collections.Generic.ICollection<TKey>.Remove(TKey item);  
        void System.Collections.ICollection.CopyTo(Array array, int index);  
            IEnumerator System.Collections.IEnumerable.GetEnumerator();  
    }
      public sealed class ValueCollection : ICollection, ICollection<TValue>, IEnumerable, IEnumerable<TValue>, IReadOnlyCollection<TValue>   {
        private readonly ICollection<TValue> m_collection;  
        private object m_syncRoot;  
        internal ValueCollection(ICollection<TValue> collection);  
        public int Count { get; }  
        bool System.Collections.Generic.ICollection<TValue>.IsReadOnly { get; }  
        bool System.Collections.ICollection.IsSynchronized { get; }  
        object System.Collections.ICollection.SyncRoot { get; }  
        public void CopyTo(TValue[] array, int arrayIndex);  
          public IEnumerator<TValue> GetEnumerator();  
        void System.Collections.Generic.ICollection<TValue>.Add(TValue item);  
        void System.Collections.Generic.ICollection<TValue>.Clear();  
        bool System.Collections.Generic.ICollection<TValue>.Contains(TValue item);  
          bool System.Collections.Generic.ICollection<TValue>.Remove(TValue item);  
        void System.Collections.ICollection.CopyTo(Array array, int index);  
            IEnumerator System.Collections.IEnumerable.GetEnumerator();  
    }
  }
    internal static class ReadOnlyDictionaryHelpers   {
      internal static void CopyToNonGenericICollectionHelper<T>(ICollection<T> collection, Array array, int index);  
  }
}
namespace System.Diagnostics {
  public static class Debugger {
      private static void BreakCanThrow();  
  }
    internal sealed class EditAndContinueHelper   {
      private object _objectReference;  
      public EditAndContinueHelper();  
  }
  internal class LogSwitch {
      private LogSwitch();  
  }
  public class StackTrace {
      private static string GetManagedStackTraceStringHelper(bool fNeedFileInfo);  
  }
}
namespace System.Diagnostics.Contracts {
  internal sealed class ContractException : Exception {
      private ContractException();  
      public string Condition { get; }  
      public string Failure { get; }  
      public ContractFailureKind Kind { get; }  
      public string UserMessage { get; }  
  }
}
namespace System.Diagnostics.Tracing {
  internal class ActivityTracker {
      private Guid CurrentActivityId { get; }  
  }
  internal struct DataCollector {
      internal void AddBinary(Array value, int size);  
  }
  internal sealed class EtwEventProvider : IEventProvider {
      unsafe IntPtr System.Diagnostics.Tracing.IEventProvider.DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level, byte* pMetadata, uint metadataLength);  
      int System.Diagnostics.Tracing.IEventProvider.EventActivityIdControl(UnsafeNativeMethods.ManifestEtw.ActivityControl ControlCode, ref Guid ActivityId);  
  }
  internal struct EventDescriptor {
      public static bool operator ==(EventDescriptor event1, EventDescriptor event2);  
      public static bool operator !=(EventDescriptor event1, EventDescriptor event2);  
  }
  public class EventListener : IDisposable {
      private event EventHandler<EventSourceCreatedEventArgs> _EventSourceCreated;  
      private static void DisposeOnShutdown(object sender, EventArgs e);  
  }
  internal class EventProvider : IDisposable {
      protected EventKeywords MatchAllKeyword { get; set; }  
      public virtual void Close();  
  }
    internal sealed class EventSourceActivity : IDisposable   {
      private EventSourceActivity.State state;  
      private readonly EventSource eventSource;  
      private EventSourceOptions startStopOptions;  
      internal Guid activityId;  
      internal static Guid s_empty;  
      private string eventName;  
      public EventSourceActivity(EventSource eventSource);  
      public EventSource EventSource { get; }  
      public Guid Id { get; }  
      private bool StartEventWasFired { get; }  
      public void Dispose();  
      public static implicit operator EventSourceActivity (EventSource eventSource);  
      public EventSourceActivity Start(string eventName);  
      public EventSourceActivity Start(string eventName, EventSourceOptions options);  
      private EventSourceActivity Start<T>(string eventName, ref EventSourceOptions options, ref T data);  
      public EventSourceActivity Start<T>(string eventName, T data);  
      public void Stop<T>(string eventName);  
      private void Stop<T>(string eventName, ref T data);  
      public void Stop<T>(T data);  
      public void Write(string eventName);  
      public void Write(string eventName, EventSourceOptions options);  
      private void Write<T>(EventSource eventSource, string eventName, ref EventSourceOptions options, ref T data);  
      public void Write<T>(string eventName, EventSourceOptions options, T data);  
      public void Write<T>(string eventName, T data);  
      private enum State   {
        Started = 0,  
        Stopped = 1,  
      }
  }
  internal sealed class FrameworkEventSource : EventSource {
      public void BeginGetRequestStream(object id, string uri, bool success, bool synchronous);  
      public void BeginGetResponse(object id, string uri, bool success, bool synchronous);  
      public void EndGetRequestStream(object id, bool success, bool synchronous);  
      public void EndGetResponse(object id, bool success, bool synchronous, int statusCode);  
      private static string GetName(Assembly assembly);  
      private void GetRequestStreamStart(long id, string uri, bool success, bool synchronous);  
      private void GetRequestStreamStop(long id, bool success, bool synchronous);  
      private void GetResponseStart(long id, string uri, bool success, bool synchronous);  
      private void GetResponseStop(long id, bool success, bool synchronous, int statusCode);  
      private static long IdForObject(object obj);  
      public void ResourceManagerAddingCultureFromConfigFile(string baseName, Assembly mainAssembly, string cultureName);  
      public void ResourceManagerAddingCultureFromConfigFile(string baseName, string mainAssemblyName, string cultureName);  
      public void ResourceManagerCaseInsensitiveResourceStreamLookupFailed(string baseName, Assembly mainAssembly, string assemblyName, string resourceFileName);  
      public void ResourceManagerCaseInsensitiveResourceStreamLookupFailed(string baseName, string mainAssemblyName, string assemblyName, string resourceFileName);  
      public void ResourceManagerCaseInsensitiveResourceStreamLookupSucceeded(string baseName, Assembly mainAssembly, string assemblyName, string resourceFileName);  
      public void ResourceManagerCaseInsensitiveResourceStreamLookupSucceeded(string baseName, string mainAssemblyName, string assemblyName, string resourceFileName);  
      public void ResourceManagerCreatingResourceSet(string baseName, Assembly mainAssembly, string cultureName, string fileName);  
      public void ResourceManagerCreatingResourceSet(string baseName, string mainAssemblyName, string cultureName, string fileName);  
      public void ResourceManagerCultureFoundInConfigFile(string baseName, Assembly mainAssembly, string cultureName);  
      public void ResourceManagerCultureFoundInConfigFile(string baseName, string mainAssemblyName, string cultureName);  
      public void ResourceManagerCultureNotFoundInConfigFile(string baseName, Assembly mainAssembly, string cultureName);  
      public void ResourceManagerCultureNotFoundInConfigFile(string baseName, string mainAssemblyName, string cultureName);  
      public void ResourceManagerFoundResourceSetInCache(string baseName, Assembly mainAssembly, string cultureName);  
      public void ResourceManagerFoundResourceSetInCache(string baseName, string mainAssemblyName, string cultureName);  
      public void ResourceManagerFoundResourceSetInCacheUnexpected(string baseName, Assembly mainAssembly, string cultureName);  
      public void ResourceManagerFoundResourceSetInCacheUnexpected(string baseName, string mainAssemblyName, string cultureName);  
      public void ResourceManagerGetSatelliteAssemblyFailed(string baseName, Assembly mainAssembly, string cultureName, string assemblyName);  
      public void ResourceManagerGetSatelliteAssemblyFailed(string baseName, string mainAssemblyName, string cultureName, string assemblyName);  
      public void ResourceManagerGetSatelliteAssemblySucceeded(string baseName, Assembly mainAssembly, string cultureName, string assemblyName);  
      public void ResourceManagerGetSatelliteAssemblySucceeded(string baseName, string mainAssemblyName, string cultureName, string assemblyName);  
      public void ResourceManagerLookingForResourceSet(string baseName, Assembly mainAssembly, string cultureName);  
      public void ResourceManagerLookingForResourceSet(string baseName, string mainAssemblyName, string cultureName);  
      public void ResourceManagerLookupFailed(string baseName, Assembly mainAssembly, string cultureName);  
      public void ResourceManagerLookupFailed(string baseName, string mainAssemblyName, string cultureName);  
      public void ResourceManagerLookupStarted(string baseName, Assembly mainAssembly, string cultureName);  
      public void ResourceManagerLookupStarted(string baseName, string mainAssemblyName, string cultureName);  
      public void ResourceManagerManifestResourceAccessDenied(string baseName, Assembly mainAssembly, string assemblyName, string canonicalName);  
      public void ResourceManagerManifestResourceAccessDenied(string baseName, string mainAssemblyName, string assemblyName, string canonicalName);  
      public void ResourceManagerNeutralResourceAttributeMissing(Assembly mainAssembly);  
      public void ResourceManagerNeutralResourceAttributeMissing(string mainAssemblyName);  
      public void ResourceManagerNeutralResourcesFound(string baseName, Assembly mainAssembly, string resName);  
      public void ResourceManagerNeutralResourcesFound(string baseName, string mainAssemblyName, string resName);  
      public void ResourceManagerNeutralResourcesNotFound(string baseName, Assembly mainAssembly, string resName);  
      public void ResourceManagerNeutralResourcesNotFound(string baseName, string mainAssemblyName, string resName);  
      public void ResourceManagerNeutralResourcesSufficient(string baseName, Assembly mainAssembly, string cultureName);  
      public void ResourceManagerNeutralResourcesSufficient(string baseName, string mainAssemblyName, string cultureName);  
      public void ResourceManagerNotCreatingResourceSet(string baseName, Assembly mainAssembly, string cultureName);  
      public void ResourceManagerNotCreatingResourceSet(string baseName, string mainAssemblyName, string cultureName);  
      public void ResourceManagerReleasingResources(string baseName, Assembly mainAssembly);  
      public void ResourceManagerReleasingResources(string baseName, string mainAssemblyName);  
      public void ResourceManagerStreamFound(string baseName, Assembly mainAssembly, string cultureName, Assembly loadedAssembly, string resourceFileName);  
      public void ResourceManagerStreamFound(string baseName, string mainAssemblyName, string cultureName, string loadedAssemblyName, string resourceFileName);  
      public void ResourceManagerStreamNotFound(string baseName, Assembly mainAssembly, string cultureName, Assembly loadedAssembly, string resourceFileName);  
      public void ResourceManagerStreamNotFound(string baseName, string mainAssemblyName, string cultureName, string loadedAssemblyName, string resourceFileName);  
      public void ThreadPoolDequeueWork(long workID);  
      public void ThreadPoolDequeueWorkObject(object workID);  
      public void ThreadTransferReceive(long id, int kind, string info);  
      public void ThreadTransferReceiveHandled(long id, int kind, string info);  
      public void ThreadTransferReceiveHandledObj(object id, int kind, string info);  
      public void ThreadTransferReceiveObj(object id, int kind, string info);  
      private void WriteEvent(int eventId, long arg1, bool arg2, bool arg3);  
      private void WriteEvent(int eventId, long arg1, bool arg2, bool arg3, int arg4);  
      private void WriteEvent(int eventId, long arg1, int arg2, string arg3);  
      private void WriteEvent(int eventId, long arg1, string arg2, bool arg3, bool arg4);  
  }
  internal interface IEventProvider {
      IntPtr DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level, byte* pMetadata, uint metadataLength);  
      int EventActivityIdControl(UnsafeNativeMethods.ManifestEtw.ActivityControl ControlCode, ref Guid ActivityId);  
  }
  internal struct SessionMask {
      public SessionMask(SessionMask m);  
      public bool this[int perEventSourceSessionId] { get; set; }  
      public static SessionMask FromId(int perEventSourceSessionId);  
      public bool IsEqualOrSupersetOf(SessionMask m);  
      public static SessionMask operator &(SessionMask m1, SessionMask m2);  
      public static SessionMask operator |(SessionMask m1, SessionMask m2);  
      public static SessionMask operator ^(SessionMask m1, SessionMask m2);  
      public static explicit operator ulong (SessionMask m);  
      public static SessionMask operator ~(SessionMask m);  
  }
  internal static class Statics {
      public static byte Combine(int settingValue1, int settingValue2, byte defaultValue);  
      public static Delegate CreateDelegate(Type delegateType, MethodInfo methodInfo);  
      public static object CreateInstance(Type type, params object[] parameters);  
      public static MethodInfo GetDeclaredStaticMethod(Type declaringType, string name);  
  }
  internal class TraceLoggingDataCollector {
      public TraceLoggingDataCollector AddGroup();  
  }
  public class TraceLoggingEventTypes {
      internal EventKeywords Keywords { get; }  
      internal EventLevel Level { get; }  
      internal EventOpcode Opcode { get; }  
  }
  internal class TraceLoggingMetadataCollector {
      public void AddCustom(string name, TraceLoggingDataType type, byte[] metadata);  
  }
}
  namespace System.Diagnostics.Tracing.Internal   {
    internal static class Environment   {
      private static ResourceManager rm;  
      public static readonly string NewLine;  
      public static int TickCount { get; }  
      private static void .cctor();  
      public static string GetResourceString(string key, params object[] args);  
      public static string GetRuntimeResourceString(string key, params object[] args);  
  }
}
namespace System.Globalization {
  internal class CalendricalCalculationsHelper {
      public CalendricalCalculationsHelper();  
  }
  public class DaylightTime {
      private DaylightTime();  
  }
    internal sealed class GlobalizationAssembly   {
      public GlobalizationAssembly();  
      internal unsafe static byte* GetGlobalizationResourceBytePtr(Assembly assembly, string tableName);  
  }
  internal sealed class GlobalizationMode {
      public GlobalizationMode();  
  }
  internal class HebrewNumber {
      private HebrewNumber();  
  }
  internal class InternalGlobalizationHelper {
      public InternalGlobalizationHelper();  
  }
  internal static class TimeSpanParse {
  }
}
namespace System.IO {
  internal static class __Error {
      internal static void ReaderClosed();  
  }
    internal static class Directory   {
      internal static string InternalGetDirectoryRoot(string path);  
      internal sealed class SearchData   {
        public readonly SearchOption searchOption;  
        public readonly string fullPath;  
        public readonly string userPath;  
        public SearchData(string fullPath, string userPath, SearchOption searchOption);  
    }
  }
  internal class DriveNotFoundException : IOException {
      public DriveNotFoundException();  
      protected DriveNotFoundException(SerializationInfo info, StreamingContext context);  
  }
  internal static class File {
      public static byte[] ReadAllBytes(string path);  
  }
  public class FileLoadException : IOException {
      private FileLoadException(string fileName, string fusionLog, int hResult);  
  }
  public class FileNotFoundException : IOException {
      private FileNotFoundException(string fileName, string fusionLog, int hResult);  
  }
  public class FileStream : Stream {
  }
  internal class PathHelper {
      public PathHelper();  
  }
  internal static class PathInternal {
      internal static void CheckSearchPattern(string searchPattern);  
      internal static string TrimEndingDirectorySeparator(string path);  
  }
    internal enum SearchOption   {
      AllDirectories = 1,  
      TopDirectoryOnly = 0,  
  }
}
namespace System.Reflection {
  public abstract class Assembly : ICustomAttributeProvider, ISerializable {
      internal static Type GetType_Compat(string assemblyString, string typeName);  
  }
  public sealed class AssemblyName : ICloneable, IDeserializationCallback, ISerializable {
      private string nToString();  
      internal void SetHashControl(byte[] hash, AssemblyHashAlgorithm hashAlgorithm);  
  }
  internal static class CustomAttribute {
      internal static bool IsAttributeDefined(RuntimeModule decoratedModule, int decoratedMetadataToken, int attributeCtorToken);  
  }
    internal class MetadataException : Exception   {
      private int m_hr;  
      internal MetadataException(int hr);  
      public override string ToString();  
  }
  internal struct MetadataImport {
      internal static void ThrowError(int hResult);  
  }
  public abstract class MethodBase : MemberInfo {
      internal string FullName { get; }  
      private IntPtr GetMethodDesc();  
  }
  internal sealed class RtFieldInfo : RuntimeFieldInfo, IRuntimeFieldInfo {
      internal string FullName { get; }  
      internal IntPtr GetFieldHandle();  
      private RuntimeAssembly GetRuntimeAssembly();  
  }
  internal class RuntimeAssembly : Assembly {
      private RuntimeModule OnModuleResolveEvent(string moduleName);  
  }
  internal sealed class RuntimeConstructorInfo : ConstructorInfo, IRuntimeMethodInfo {
      private object _empty1;  
      private object _empty2;  
      private object _empty3;  
      internal RuntimeAssembly GetRuntimeAssembly();  
  }
  internal sealed class RuntimeEventInfo : EventInfo {
      internal RuntimeEventInfo();  
  }
  internal abstract class RuntimeFieldInfo : FieldInfo {
      protected RuntimeFieldInfo();  
  }
  internal sealed class RuntimeMethodInfo : MethodInfo, IRuntimeMethodInfo {
      internal RuntimeAssembly GetRuntimeAssembly();  
  }
  internal sealed class RuntimeParameterInfo : ParameterInfo {
      internal MethodBase DefiningMethod { get; }  
  }
}
namespace System.Reflection.Emit {
  internal sealed class __ExceptionInfo {
      private __ExceptionInfo();  
  }
  public sealed class AssemblyBuilder : Assembly {
      private AssemblyBuilder();  
  }
  internal class AssemblyBuilderData {
      internal bool m_hasUnmanagedVersionInfo;  
      internal bool m_isSaved;  
      internal bool m_OverrideUnmanagedVersionInfo;  
      internal byte[] m_resourceBytes;  
      internal int m_iPublicComTypeCount;  
      internal Assembly m_ISymWrapperAssembly;  
      internal NativeVersionInfo m_nativeVersion;  
      internal string m_strResourceFileName;  
      internal Type[] m_publicComTypeList;  
  }
  public sealed class ConstructorBuilder : ConstructorInfo {
      private ConstructorBuilder();  
  }
  public sealed class DynamicMethod : MethodInfo {
      private DynamicMethod();  
    internal class RTDynamicMethod : MethodInfo {
        private RTDynamicMethod();  
    }
  }
  internal class DynamicResolver : Resolver {
      private static int CalculateNumberOfExceptions(__ExceptionInfo[] excp);  
      internal override byte[] GetCodeInfo(ref int stackSize, ref int initLocals, ref int EHCount);  
      internal unsafe override void GetEHInfo(int excNumber, void* exc);  
      internal override RuntimeType GetJitContext(ref int securityControlFlags);  
      internal override byte[] GetLocalsSignature();  
      internal override byte[] GetRawEHInfo();  
      internal override string GetStringLiteral(int token);  
      internal override byte[] ResolveSignature(int token, int fromMethod);  
      internal override void ResolveToken(int token, out IntPtr typeHandle, out IntPtr methodHandle, out IntPtr fieldHandle);  
      internal enum SecurityControlFlags   {
        CanSkipCSEvaluation = 8,  
        Default = 0,  
        HasCreationContext = 4,  
        RestrictedSkipVisibilityChecks = 2,  
        SkipVisibilityChecks = 1,  
      }
  }
  internal class DynamicScope {
      internal string GetString(int token);  
      internal byte[] ResolveSignature(int token, int fromMethod);  
  }
  public sealed class EnumBuilder : TypeInfo {
      private EnumBuilder();  
  }
  public sealed class EventBuilder {
      private EventBuilder();  
  }
  internal struct ExceptionHandler : IEquatable<ExceptionHandler> {
      public static bool operator ==(ExceptionHandler left, ExceptionHandler right);  
      public static bool operator !=(ExceptionHandler left, ExceptionHandler right);  
  }
  public sealed class LocalBuilder : LocalVariableInfo {
      private LocalBuilder();  
  }
  public sealed class MethodBuilder : MethodInfo {
      private ParameterBuilder m_retParam;  
  }
  internal class ModuleBuilderData {
      internal bool m_isSaved;  
      internal byte[] m_resourceBytes;  
      internal string m_strResourceFileName;  
  }
    internal class NativeVersionInfo   {
      internal int m_lcid;  
      internal string m_strCompany;  
      internal string m_strCopyright;  
      internal string m_strDescription;  
      internal string m_strFileVersion;  
      internal string m_strProduct;  
      internal string m_strProductVersion;  
      internal string m_strTitle;  
      internal string m_strTrademark;  
      internal NativeVersionInfo();  
  }
  public class OpCodes {
      private OpCodes();  
  }
  public class ParameterBuilder {
      private ParameterBuilder();  
  }
  public sealed class PropertyBuilder : PropertyInfo {
      private PropertyBuilder();  
  }
  internal class ResWriterData {
      internal Stream m_memoryStream;  
      internal ResWriterData m_nextResWriter;  
      internal ResourceAttributes m_attribute;  
      internal string m_strFileName;  
      internal string m_strFullFileName;  
      internal string m_strName;  
      public ResWriterData();  
  }
  internal class SymWrapperCore {
      private SymWrapperCore();  
  }
}
namespace System.Resources {
  public class ResourceManager {
  }
  public sealed class ResourceReader : IDisposable, IEnumerable, IResourceReader {
  }
}
namespace System.Runtime {
}
namespace System.Runtime.CompilerServices {
  internal class ArrayPinningHelper {
      public byte m_arrayData;  
      public IntPtr m_lengthAndPadding;  
  }
  internal struct AsyncMethodBuilderCore {
      internal static Action TryGetStateMachineForDebugger(Action action);  
  }
  public struct AsyncTaskMethodBuilder {
      private object ObjectIdForDebugger { get; }  
      internal void SetNotificationForWaitCompletion(bool enabled);  
  }
  public struct AsyncTaskMethodBuilder<TResult> {
      private object ObjectIdForDebugger { get; }  
      internal void SetNotificationForWaitCompletion(bool enabled);  
  }
  public struct AsyncVoidMethodBuilder {
      private object ObjectIdForDebugger { get; }  
  }
    internal class ICastableHelpers   {
      public ICastableHelpers();  
      internal static RuntimeType GetImplType(ICastable castable, RuntimeType interfaceType);  
      internal static bool IsInstanceOfInterface(ICastable castable, RuntimeType type, out Exception castError);  
  }
  public static class RuntimeHelpers {
      internal static void ExecuteBackoutCodeHelper(object backoutCode, object userData, bool exceptionThrown);  
  }
  internal static class Unsafe {
      public static void WriteUnaligned<T>(ref byte destination, T value);  
  }
}
namespace System.Runtime.ConstrainedExecution {
    internal sealed class PrePrepareMethodAttribute : Attribute   {
      public PrePrepareMethodAttribute();  
  }
}
namespace System.Runtime.InteropServices {
  public abstract class CriticalHandle : CriticalFinalizerObject, IDisposable {
      private CriticalHandle();  
  }
  public static class Marshal {
      internal static void InitializeWrapperForWinRT(object o, ref IntPtr pUnk);  
      private static IntPtr LoadLicenseManager();  
  }
    internal enum PInvokeMap   {
      BestFitDisabled = 32,  
      BestFitEnabled = 16,  
      BestFitMask = 48,  
      BestFitUseAsm = 48,  
      CallConvCdecl = 512,  
      CallConvFastcall = 1280,  
      CallConvMask = 1792,  
      CallConvStdcall = 768,  
      CallConvThiscall = 1024,  
      CallConvWinapi = 256,  
      CharSetAnsi = 2,  
      CharSetAuto = 6,  
      CharSetMask = 6,  
      CharSetNotSpec = 0,  
      CharSetUnicode = 4,  
      NoMangle = 1,  
      PinvokeOLE = 32,  
      SupportsLastError = 64,  
      ThrowOnUnmappableCharDisabled = 8192,  
      ThrowOnUnmappableCharEnabled = 4096,  
      ThrowOnUnmappableCharMask = 12288,  
      ThrowOnUnmappableCharUseAsm = 12288,  
  }
  internal static class RuntimeEnvironment {
      internal static string GetModuleFileName();  
  }
  internal struct StringBuffer {
      public bool Contains(char value);  
      public void TrimEnd(char[] values);  
  }
}
  namespace System.Runtime.InteropServices.Expando   {
    internal interface IExpando : IReflect   {
      FieldInfo AddField(string name);  
      void RemoveMember(MemberInfo m);  
  }
}
namespace System.Runtime.InteropServices.WindowsRuntime {
    internal sealed class BindableIterableToEnumerableAdapter   {
      private BindableIterableToEnumerableAdapter();  
      internal IEnumerator GetEnumerator_Stub();  
      private sealed class NonGenericToGenericIterator : IIterator<object>   {
        private IBindableIterator iterator;  
        public NonGenericToGenericIterator(IBindableIterator iterator);  
        public object Current { get; }  
        public bool HasCurrent { get; }  
          public int GetMany(object[] items);  
          public bool MoveNext();  
    }
  }
    internal sealed class BindableVectorToCollectionAdapter   {
      private BindableVectorToCollectionAdapter();  
      internal void CopyTo(Array array, int arrayIndex);  
      internal int Count();  
      internal bool IsSynchronized();  
      internal object SyncRoot();  
  }
    internal sealed class BindableVectorToListAdapter   {
      private BindableVectorToListAdapter();  
      internal int Add(object value);  
      internal void Clear();  
      internal bool Contains(object item);  
      private static object GetAt(IBindableVector _this, uint index);  
      internal object Indexer_Get(int index);  
      internal void Indexer_Set(int index, object value);  
      internal int IndexOf(object item);  
      internal void Insert(int index, object item);  
      private static void InsertAtHelper(IBindableVector _this, uint index, object item);  
      internal bool IsFixedSize();  
      internal bool IsReadOnly();  
      internal void Remove(object item);  
      internal void RemoveAt(int index);  
      private static void RemoveAtHelper(IBindableVector _this, uint index);  
      private static void SetAt(IBindableVector _this, uint index, object value);  
  }
    internal sealed class CLRIKeyValuePairImpl<K, V> : IGetProxyTarget, IKeyValuePair<K, V>   {
      private readonly KeyValuePair<K, V> _pair;  
      public CLRIKeyValuePairImpl(ref KeyValuePair<K, V> pair);  
      public K Key { get; }  
      public V Value { get; }  
      internal static object BoxHelper(object pair);  
      object System.Runtime.InteropServices.WindowsRuntime.IGetProxyTarget.GetTarget();  
      public override string ToString();  
      internal static object UnboxHelper(object wrapper);  
  }
    internal class CLRIPropertyValueImpl : IPropertyValue   {
      private object _data;  
      private PropertyType _type;  
      private static Tuple<Type, PropertyType>[] s_numericScalarTypes;  
      internal CLRIPropertyValueImpl(PropertyType type, object data);  
      public bool IsNumericScalar { get; }  
      private static Tuple<Type, PropertyType>[] NumericScalarTypes { get; }  
      public PropertyType Type { get; }  
      private T[] CoerceArrayValue<T>(PropertyType unboxType);  
      private T CoerceScalarValue<T>(PropertyType unboxType);  
      private static T CoerceScalarValue<T>(PropertyType type, object value);  
      public bool GetBoolean();  
      public bool[] GetBooleanArray();  
      public char GetChar16();  
      public char[] GetChar16Array();  
      public DateTimeOffset GetDateTime();  
      public DateTimeOffset[] GetDateTimeArray();  
      public double GetDouble();  
      public double[] GetDoubleArray();  
      public Guid GetGuid();  
      public Guid[] GetGuidArray();  
      public object[] GetInspectableArray();  
      public short GetInt16();  
      public short[] GetInt16Array();  
      public int GetInt32();  
      public int[] GetInt32Array();  
      public long GetInt64();  
      public long[] GetInt64Array();  
      public Point GetPoint();  
      public Point[] GetPointArray();  
      public Rect GetRect();  
      public Rect[] GetRectArray();  
      public float GetSingle();  
      public float[] GetSingleArray();  
      public Size GetSize();  
      public Size[] GetSizeArray();  
      public string GetString();  
      public string[] GetStringArray();  
      public TimeSpan GetTimeSpan();  
      public TimeSpan[] GetTimeSpanArray();  
      public ushort GetUInt16();  
      public ushort[] GetUInt16Array();  
      public uint GetUInt32();  
      public uint[] GetUInt32Array();  
      public ulong GetUInt64();  
      public ulong[] GetUInt64Array();  
      public byte GetUInt8();  
      public byte[] GetUInt8Array();  
      private static bool IsCoercable(PropertyType type, object data);  
      private static bool IsNumericScalarImpl(PropertyType type, object data);  
      public override string ToString();  
      private T Unbox<T>(Type expectedBoxedType) where T : struct;  
      private T[] UnboxArray<T>(Type expectedArrayElementType) where T : struct;  
  }
    internal sealed class CLRIReferenceArrayImpl<T> : CLRIPropertyValueImpl, ICollection, IEnumerable, IGetProxyTarget, IList, IPropertyValue, IReferenceArray<T>   {
      private IList _list;  
      private T[] _value;  
      public CLRIReferenceArrayImpl(PropertyType type, T[] obj);  
      int System.Collections.ICollection.Count { get; }  
      bool System.Collections.ICollection.IsSynchronized { get; }  
      object System.Collections.ICollection.SyncRoot { get; }  
      bool System.Collections.IList.IsFixedSize { get; }  
      bool System.Collections.IList.IsReadOnly { get; }  
      object System.Collections.IList.this[int index] { get; set; }  
      public T[] Value { get; }  
      void System.Collections.ICollection.CopyTo(Array array, int index);  
      IEnumerator System.Collections.IEnumerable.GetEnumerator();  
      int System.Collections.IList.Add(object value);  
      void System.Collections.IList.Clear();  
      bool System.Collections.IList.Contains(object value);  
      int System.Collections.IList.IndexOf(object value);  
      void System.Collections.IList.Insert(int index, object value);  
      void System.Collections.IList.Remove(object value);  
      void System.Collections.IList.RemoveAt(int index);  
      object System.Runtime.InteropServices.WindowsRuntime.IGetProxyTarget.GetTarget();  
      public override string ToString();  
      internal static object UnboxHelper(object wrapper);  
  }
    internal sealed class CLRIReferenceImpl<T> : CLRIPropertyValueImpl, IGetProxyTarget, IPropertyValue, IReference<T>   {
      private T _value;  
      public CLRIReferenceImpl(PropertyType type, T obj);  
      public T Value { get; }  
      object System.Runtime.InteropServices.WindowsRuntime.IGetProxyTarget.GetTarget();  
      public override string ToString();  
      internal static object UnboxHelper(object wrapper);  
  }
    internal sealed class ConstantSplittableMap<TKey, TValue> : IEnumerable, IEnumerable<IKeyValuePair<TKey, TValue>>, IIterable<IKeyValuePair<TKey, TValue>>, IMapView<TKey, TValue>   {
      private static readonly ConstantSplittableMap<TKey, TValue>.KeyValuePairComparator keyValuePairComparator;  
      private readonly KeyValuePair<TKey, TValue>[] items;  
      private readonly int firstItemIndex;  
      private readonly int lastItemIndex;  
      internal ConstantSplittableMap(IReadOnlyDictionary<TKey, TValue> data);  
      private ConstantSplittableMap(KeyValuePair<TKey, TValue>[] items, int firstItemIndex, int lastItemIndex);  
      public int Count { get; }  
      public uint Size { get; }  
      private static void .cctor();  
      private KeyValuePair<TKey, TValue>[] CreateKeyValueArray(int count, IEnumerator<KeyValuePair<TKey, TValue>> data);  
      public IIterator<IKeyValuePair<TKey, TValue>> First();  
      public IEnumerator<IKeyValuePair<TKey, TValue>> GetEnumerator();  
      public bool HasKey(TKey key);  
      public TValue Lookup(TKey key);  
      public void Split(out IMapView<TKey, TValue> firstPartition, out IMapView<TKey, TValue> secondPartition);  
      IEnumerator System.Collections.IEnumerable.GetEnumerator();  
      public bool TryGetValue(TKey key, out TValue value);  
      internal struct IKeyValuePairEnumerator : IDisposable, IEnumerator, IEnumerator<IKeyValuePair<TKey, TValue>>   {
        private KeyValuePair<TKey, TValue>[] _array;  
        private int _current;  
        private int _end;  
        private int _start;  
        internal IKeyValuePairEnumerator(KeyValuePair<TKey, TValue>[] items, int first, int end);  
        public IKeyValuePair<TKey, TValue> Current { get; }  
        object System.Collections.IEnumerator.Current { get; }  
          public void Dispose();  
        public bool MoveNext();  
          void System.Collections.IEnumerator.Reset();  
    }
      private class KeyValuePairComparator : IComparer<KeyValuePair<TKey, TValue>>   {
        private static readonly IComparer<TKey> keyComparator;  
        public KeyValuePairComparator();  
        private static void .cctor();  
        public int Compare(KeyValuePair<TKey, TValue> x, KeyValuePair<TKey, TValue> y);  
    }
  }
    internal sealed class CustomPropertyImpl : ICustomProperty   {
      private PropertyInfo m_property;  
      public CustomPropertyImpl(PropertyInfo propertyInfo);  
      public bool CanRead { get; }  
      public bool CanWrite { get; }  
      public string Name { get; }  
      public Type Type { get; }  
      public object GetValue(object target);  
      public object GetValue(object target, object indexValue);  
      private object InvokeInternal(object target, object[] args, bool getValue);  
      public void SetValue(object target, object value);  
      public void SetValue(object target, object value, object indexValue);  
  }
    internal class DesignerNamespaceResolveEventArgs : EventArgs   {
      private Collection<string> _ResolvedAssemblyFiles;  
      private string _NamespaceName;  
      public DesignerNamespaceResolveEventArgs(string namespaceName);  
      public Collection<string> ResolvedAssemblyFiles { get; }  
  }
    internal sealed class DictionaryKeyCollection<TKey, TValue> : ICollection<TKey>, IEnumerable, IEnumerable<TKey>   {
      private readonly IDictionary<TKey, TValue> dictionary;  
      public DictionaryKeyCollection(IDictionary<TKey, TValue> dictionary);  
      public int Count { get; }  
      bool System.Collections.Generic.ICollection<TKey>.IsReadOnly { get; }  
      public bool Contains(TKey item);  
      public void CopyTo(TKey[] array, int index);  
      public IEnumerator<TKey> GetEnumerator();  
      void System.Collections.Generic.ICollection<TKey>.Add(TKey item);  
      void System.Collections.Generic.ICollection<TKey>.Clear();  
      bool System.Collections.Generic.ICollection<TKey>.Remove(TKey item);  
      IEnumerator System.Collections.IEnumerable.GetEnumerator();  
  }
    internal sealed class DictionaryKeyEnumerator<TKey, TValue> : IDisposable, IEnumerator, IEnumerator<TKey>   {
      private readonly IDictionary<TKey, TValue> dictionary;  
      private IEnumerator<KeyValuePair<TKey, TValue>> enumeration;  
      public DictionaryKeyEnumerator(IDictionary<TKey, TValue> dictionary);  
      public TKey Current { get; }  
      object System.Collections.IEnumerator.Current { get; }  
      public bool MoveNext();  
      public void Reset();  
      void System.IDisposable.Dispose();  
  }
    internal sealed class DictionaryToMapAdapter   {
      private DictionaryToMapAdapter();  
      internal void Clear<K, V>();  
      internal IReadOnlyDictionary<K, V> GetView<K, V>();  
      internal bool HasKey<K, V>(K key);  
      internal bool Insert<K, V>(K key, V value);  
      internal V Lookup<K, V>(K key);  
      internal void Remove<K, V>(K key);  
      internal uint Size<K, V>();  
  }
    internal sealed class DictionaryValueCollection<TKey, TValue> : ICollection<TValue>, IEnumerable, IEnumerable<TValue>   {
      private readonly IDictionary<TKey, TValue> dictionary;  
      public DictionaryValueCollection(IDictionary<TKey, TValue> dictionary);  
      public int Count { get; }  
      bool System.Collections.Generic.ICollection<TValue>.IsReadOnly { get; }  
      public bool Contains(TValue item);  
      public void CopyTo(TValue[] array, int index);  
      public IEnumerator<TValue> GetEnumerator();  
      void System.Collections.Generic.ICollection<TValue>.Add(TValue item);  
      void System.Collections.Generic.ICollection<TValue>.Clear();  
      bool System.Collections.Generic.ICollection<TValue>.Remove(TValue item);  
      IEnumerator System.Collections.IEnumerable.GetEnumerator();  
  }
    internal sealed class DictionaryValueEnumerator<TKey, TValue> : IDisposable, IEnumerator, IEnumerator<TValue>   {
      private readonly IDictionary<TKey, TValue> dictionary;  
      private IEnumerator<KeyValuePair<TKey, TValue>> enumeration;  
      public DictionaryValueEnumerator(IDictionary<TKey, TValue> dictionary);  
      public TValue Current { get; }  
      object System.Collections.IEnumerator.Current { get; }  
      public bool MoveNext();  
      public void Reset();  
      void System.IDisposable.Dispose();  
  }
    internal sealed class EnumerableToBindableIterableAdapter   {
      private EnumerableToBindableIterableAdapter();  
      internal IBindableIterator First_Stub();  
      internal sealed class NonGenericToGenericEnumerator : IDisposable, IEnumerator, IEnumerator<object>   {
        private IEnumerator enumerator;  
        public NonGenericToGenericEnumerator(IEnumerator enumerator);  
        public object Current { get; }  
          public void Dispose();  
        public bool MoveNext();  
        public void Reset();  
    }
  }
    internal sealed class EnumerableToIterableAdapter   {
      private EnumerableToIterableAdapter();  
      internal IIterator<T> First_Stub<T>();  
  }
    internal sealed class EnumeratorToIteratorAdapter<T> : IBindableIterator, IIterator<T>   {
      private bool m_firstItem;  
      private bool m_hasCurrent;  
      private IEnumerator<T> m_enumerator;  
      internal EnumeratorToIteratorAdapter(IEnumerator<T> enumerator);  
      public T Current { get; }  
      public bool HasCurrent { get; }  
      object System.Runtime.InteropServices.WindowsRuntime.IBindableIterator.Current { get; }  
      public int GetMany(T[] items);  
      public bool MoveNext();  
  }
  public sealed class EventRegistrationTokenTable<T> where T : class {
      internal T ExtractHandler(EventRegistrationToken token);  
  }
    internal delegate IEnumerator<T> GetEnumerator_Delegate<out T>();  
    internal interface IBindableIterable   {
      IBindableIterator First();  
  }
    internal interface IBindableIterator   {
      object Current { get; }  
      bool HasCurrent { get; }  
      bool MoveNext();  
  }
    internal interface IBindableVector : IBindableIterable   {
      uint Size { get; }  
      void Append(object value);  
      void Clear();  
      object GetAt(uint index);  
      IBindableVectorView GetView();  
      bool IndexOf(object value, out uint index);  
      void InsertAt(uint index, object value);  
      void RemoveAt(uint index);  
      void RemoveAtEnd();  
      void SetAt(uint index, object value);  
  }
    internal interface IBindableVectorView : IBindableIterable   {
      uint Size { get; }  
      object GetAt(uint index);  
      bool IndexOf(object value, out uint index);  
  }
    internal interface IClosable   {
      void Close();  
  }
    internal sealed class IClosableToIDisposableAdapter   {
      private IClosableToIDisposableAdapter();  
      private void Dispose();  
  }
    internal interface ICustomProperty   {
      bool CanRead { get; }  
      bool CanWrite { get; }  
      string Name { get; }  
      Type Type { get; }  
      object GetValue(object target);  
      object GetValue(object target, object indexValue);  
      void SetValue(object target, object value);  
      void SetValue(object target, object value, object indexValue);  
  }
    internal static class ICustomPropertyProviderImpl   {
      internal unsafe static ICustomProperty CreateIndexedProperty(object target, string propertyName, TypeNameNative* pIndexedParamType);  
      internal static ICustomProperty CreateIndexedProperty(object target, string propertyName, Type indexedParamType);  
      internal static ICustomProperty CreateProperty(object target, string propertyName);  
      internal unsafe static void GetType(object target, TypeNameNative* pIndexedParamType);  
  }
    internal class ICustomPropertyProviderProxy<T1, T2> : IBindableIterable, IBindableVector, IBindableVectorView, ICustomQueryInterface, IEnumerable, IGetProxyTarget   {
      private object _target;  
      private InterfaceForwardingSupport _flags;  
      internal ICustomPropertyProviderProxy(object target, InterfaceForwardingSupport flags);  
      uint System.Runtime.InteropServices.WindowsRuntime.IBindableVector.Size { get; }  
      uint System.Runtime.InteropServices.WindowsRuntime.IBindableVectorView.Size { get; }  
      private static T ConvertTo<T>(object value);  
      internal static object CreateInstance(object target);  
      public IEnumerator GetEnumerator();  
      private IBindableVector GetIBindableVectorNoThrow();  
      private IBindableVectorView GetIBindableVectorViewNoThrow();  
      public CustomQueryInterfaceResult GetInterface(ref Guid iid, out IntPtr ppv);  
      private IVector_Raw<T1> GetVectorOfT();  
      private IVectorView<T2> GetVectorViewOfT();  
      IBindableIterator System.Runtime.InteropServices.WindowsRuntime.IBindableIterable.First();  
      void System.Runtime.InteropServices.WindowsRuntime.IBindableVector.Append(object value);  
      void System.Runtime.InteropServices.WindowsRuntime.IBindableVector.Clear();  
      object System.Runtime.InteropServices.WindowsRuntime.IBindableVector.GetAt(uint index);  
      IBindableVectorView System.Runtime.InteropServices.WindowsRuntime.IBindableVector.GetView();  
      bool System.Runtime.InteropServices.WindowsRuntime.IBindableVector.IndexOf(object value, out uint index);  
      void System.Runtime.InteropServices.WindowsRuntime.IBindableVector.InsertAt(uint index, object value);  
      void System.Runtime.InteropServices.WindowsRuntime.IBindableVector.RemoveAt(uint index);  
      void System.Runtime.InteropServices.WindowsRuntime.IBindableVector.RemoveAtEnd();  
      void System.Runtime.InteropServices.WindowsRuntime.IBindableVector.SetAt(uint index, object value);  
      object System.Runtime.InteropServices.WindowsRuntime.IBindableVectorView.GetAt(uint index);  
      bool System.Runtime.InteropServices.WindowsRuntime.IBindableVectorView.IndexOf(object value, out uint index);  
      object System.Runtime.InteropServices.WindowsRuntime.IGetProxyTarget.GetTarget();  
      public override string ToString();  
      private sealed class IteratorOfTToIteratorAdapter<T> : IBindableIterator   {
        private IIterator<T> _iterator;  
        public IteratorOfTToIteratorAdapter(IIterator<T> iterator);  
        public object Current { get; }  
        public bool HasCurrent { get; }  
            public bool MoveNext();  
    }
      private sealed class IVectorViewToIBindableVectorViewAdapter<T> : IBindableIterable, IBindableVectorView   {
        private IVectorView<T> _vectorView;  
        public IVectorViewToIBindableVectorViewAdapter(IVectorView<T> vectorView);  
        uint System.Runtime.InteropServices.WindowsRuntime.IBindableVectorView.Size { get; }  
        IBindableIterator System.Runtime.InteropServices.WindowsRuntime.IBindableIterable.First();  
        object System.Runtime.InteropServices.WindowsRuntime.IBindableVectorView.GetAt(uint index);  
          bool System.Runtime.InteropServices.WindowsRuntime.IBindableVectorView.IndexOf(object value, out uint index);  
    }
  }
    internal sealed class IDisposableToIClosableAdapter   {
      private IDisposableToIClosableAdapter();  
      public void Close();  
  }
    internal interface IGetProxyTarget   {
      object GetTarget();  
  }
    internal interface IIterable<T> : IEnumerable, IEnumerable<T>   {
      IIterator<T> First();  
  }
    internal interface IIterator<T>   {
      T Current { get; }  
      bool HasCurrent { get; }  
      int GetMany(T[] items);  
      bool MoveNext();  
  }
    internal interface IKeyValuePair<K, V>   {
      K Key { get; }  
      V Value { get; }  
  }
  internal interface IManagedActivationFactory {
      void RunClassConstructor();  
  }
    internal interface IMap<K, V> : IEnumerable, IEnumerable<IKeyValuePair<K, V>>, IIterable<IKeyValuePair<K, V>>   {
      uint Size { get; }  
      void Clear();  
      IReadOnlyDictionary<K, V> GetView();  
      bool HasKey(K key);  
      bool Insert(K key, V value);  
      V Lookup(K key);  
      void Remove(K key);  
  }
    internal interface IMapView<K, V> : IEnumerable, IEnumerable<IKeyValuePair<K, V>>, IIterable<IKeyValuePair<K, V>>   {
      uint Size { get; }  
      bool HasKey(K key);  
      V Lookup(K key);  
      void Split(out IMapView<K, V> first, out IMapView<K, V> second);  
  }
    internal sealed class IMapViewToIReadOnlyDictionaryAdapter   {
      private IMapViewToIReadOnlyDictionaryAdapter();  
      internal bool ContainsKey<K, V>(K key);  
      internal V Indexer_Get<K, V>(K key);  
      internal IEnumerable<K> Keys<K, V>();  
      private static V Lookup<K, V>(IMapView<K, V> _this, K key);  
      internal bool TryGetValue<K, V>(K key, out V value);  
      internal IEnumerable<V> Values<K, V>();  
  }
    internal delegate T Indexer_Get_Delegate<out T>(int index);  
    internal enum InterfaceForwardingSupport   {
      IBindableIterableOrIIterable = 16,  
      IBindableVector = 1,  
      IBindableVectorView = 4,  
      IVector = 2,  
      IVectorView = 8,  
      None = 0,  
  }
    internal interface IPropertyValue   {
      bool IsNumericScalar { get; }  
      PropertyType Type { get; }  
      bool GetBoolean();  
      bool[] GetBooleanArray();  
      char GetChar16();  
      char[] GetChar16Array();  
      DateTimeOffset GetDateTime();  
      DateTimeOffset[] GetDateTimeArray();  
      double GetDouble();  
      double[] GetDoubleArray();  
      Guid GetGuid();  
      Guid[] GetGuidArray();  
      object[] GetInspectableArray();  
      short GetInt16();  
      short[] GetInt16Array();  
      int GetInt32();  
      int[] GetInt32Array();  
      long GetInt64();  
      long[] GetInt64Array();  
      Point GetPoint();  
      Point[] GetPointArray();  
      Rect GetRect();  
      Rect[] GetRectArray();  
      float GetSingle();  
      float[] GetSingleArray();  
      Size GetSize();  
      Size[] GetSizeArray();  
      string GetString();  
      string[] GetStringArray();  
      TimeSpan GetTimeSpan();  
      TimeSpan[] GetTimeSpanArray();  
      ushort GetUInt16();  
      ushort[] GetUInt16Array();  
      uint GetUInt32();  
      uint[] GetUInt32Array();  
      ulong GetUInt64();  
      ulong[] GetUInt64Array();  
      byte GetUInt8();  
      byte[] GetUInt8Array();  
  }
    internal sealed class IReadOnlyDictionaryToIMapViewAdapter   {
      private IReadOnlyDictionaryToIMapViewAdapter();  
      internal bool HasKey<K, V>(K key);  
      internal V Lookup<K, V>(K key);  
      internal uint Size<K, V>();  
      internal void Split<K, V>(out IMapView<K, V> first, out IMapView<K, V> second);  
  }
    internal sealed class IReadOnlyListToIVectorViewAdapter   {
      private IReadOnlyListToIVectorViewAdapter();  
      private static void EnsureIndexInt32(uint index, int listCapacity);  
      internal T GetAt<T>(uint index);  
      internal uint GetMany<T>(uint startIndex, T[] items);  
      internal bool IndexOf<T>(T value, out uint index);  
      internal uint Size<T>();  
  }
    internal interface IReference<T> : IPropertyValue   {
      T Value { get; }  
  }
    internal interface IReferenceArray<T> : IPropertyValue   {
      T[] Value { get; }  
  }
    internal static class IReferenceFactory   {
      internal static readonly Type s_pointType;  
      internal static readonly Type s_rectType;  
      internal static readonly Type s_sizeType;  
      private static void .cctor();  
      internal static object CreateIReference(object obj);  
      internal static object CreateIReferenceArray(Array obj);  
  }
  internal interface IRestrictedErrorInfo {
      void GetErrorDetails(out string description, out int error, out string restrictedDescription, out string capabilitySid);  
      void GetReference(out string reference);  
  }
    internal class IStringableHelper   {
      public IStringableHelper();  
      internal static string ToString(object obj);  
  }
    internal sealed class IterableToEnumerableAdapter   {
      private IterableToEnumerableAdapter();  
      internal IEnumerator<T> GetEnumerator_Stub<T>();  
      internal IEnumerator<T> GetEnumerator_Variance_Stub<T>() where T : class;  
  }
    internal sealed class IteratorToEnumeratorAdapter<T> : IDisposable, IEnumerator, IEnumerator<T>   {
      private bool m_hadCurrent;  
      private bool m_isInitialized;  
      private IIterator<T> m_iterator;  
      private T m_current;  
      internal IteratorToEnumeratorAdapter(IIterator<T> iterator);  
      public T Current { get; }  
      object System.Collections.IEnumerator.Current { get; }  
      public void Dispose();  
      public bool MoveNext();  
      public void Reset();  
  }
    internal interface IVector<T> : IEnumerable, IEnumerable<T>, IIterable<T>   {
      uint Size { get; }  
      void Append(T value);  
      void Clear();  
      T GetAt(uint index);  
      uint GetMany(uint startIndex, T[] items);  
      IReadOnlyList<T> GetView();  
      bool IndexOf(T value, out uint index);  
      void InsertAt(uint index, T value);  
      void RemoveAt(uint index);  
      void RemoveAtEnd();  
      void ReplaceAll(T[] items);  
      void SetAt(uint index, T value);  
  }
    internal interface IVector_Raw<T> : IEnumerable, IEnumerable<T>, IIterable<T>   {
      uint Size { get; }  
      void Append(T value);  
      void Clear();  
      T GetAt(uint index);  
      IVectorView<T> GetView();  
      bool IndexOf(T value, out uint index);  
      void InsertAt(uint index, T value);  
      void RemoveAt(uint index);  
      void RemoveAtEnd();  
      void SetAt(uint index, T value);  
  }
    internal interface IVectorView<T> : IEnumerable, IEnumerable<T>, IIterable<T>   {
      uint Size { get; }  
      T GetAt(uint index);  
      uint GetMany(uint startIndex, T[] items);  
      bool IndexOf(T value, out uint index);  
  }
    internal sealed class IVectorViewToIReadOnlyListAdapter   {
      private IVectorViewToIReadOnlyListAdapter();  
      internal T Indexer_Get<T>(int index);  
      internal T Indexer_Get_Variance<T>(int index) where T : class;  
  }
    internal sealed class ListToBindableVectorAdapter   {
      private ListToBindableVectorAdapter();  
      internal void Append(object value);  
      internal void Clear();  
      private static void EnsureIndexInt32(uint index, int listCapacity);  
      internal object GetAt(uint index);  
      internal IBindableVectorView GetView();  
      internal bool IndexOf(object value, out uint index);  
      internal void InsertAt(uint index, object value);  
      internal void RemoveAt(uint index);  
      internal void RemoveAtEnd();  
      internal void SetAt(uint index, object value);  
      internal uint Size();  
  }
    internal sealed class ListToBindableVectorViewAdapter : IBindableIterable, IBindableVectorView   {
      private readonly IList list;  
      internal ListToBindableVectorViewAdapter(IList list);  
      public uint Size { get; }  
      private static void EnsureIndexInt32(uint index, int listCapacity);  
      public IBindableIterator First();  
      public object GetAt(uint index);  
      public bool IndexOf(object value, out uint index);  
  }
    internal sealed class ListToVectorAdapter   {
      private ListToVectorAdapter();  
      internal void Append<T>(T value);  
      internal void Clear<T>();  
      private static void EnsureIndexInt32(uint index, int listCapacity);  
      internal T GetAt<T>(uint index);  
      internal uint GetMany<T>(uint startIndex, T[] items);  
      private static uint GetManyHelper<T>(IList<T> sourceList, uint startIndex, T[] items);  
      internal IReadOnlyList<T> GetView<T>();  
      internal bool IndexOf<T>(T value, out uint index);  
      internal void InsertAt<T>(uint index, T value);  
      internal void RemoveAt<T>(uint index);  
      internal void RemoveAtEnd<T>();  
      internal void ReplaceAll<T>(T[] items);  
      internal void SetAt<T>(uint index, T value);  
      internal uint Size<T>();  
  }
  internal sealed class ManagedActivationFactory : IActivationFactory, IManagedActivationFactory {
      void System.Runtime.InteropServices.WindowsRuntime.IManagedActivationFactory.RunClassConstructor();  
  }
    internal sealed class MapToCollectionAdapter   {
      private MapToCollectionAdapter();  
      internal void Add<K, V>(KeyValuePair<K, V> item);  
      internal void Clear<K, V>();  
      internal bool Contains<K, V>(KeyValuePair<K, V> item);  
      internal void CopyTo<K, V>(KeyValuePair<K, V>[] array, int arrayIndex);  
      internal int Count<K, V>();  
      internal bool IsReadOnly<K, V>();  
      internal bool Remove<K, V>(KeyValuePair<K, V> item);  
  }
    internal sealed class MapToDictionaryAdapter   {
      private MapToDictionaryAdapter();  
      internal void Add<K, V>(K key, V value);  
      internal bool ContainsKey<K, V>(K key);  
      internal V Indexer_Get<K, V>(K key);  
      internal void Indexer_Set<K, V>(K key, V value);  
      private static bool Insert<K, V>(IMap<K, V> _this, K key, V value);  
      internal ICollection<K> Keys<K, V>();  
      private static V Lookup<K, V>(IMap<K, V> _this, K key);  
      internal bool Remove<K, V>(K key);  
      internal bool TryGetValue<K, V>(K key, out V value);  
      internal ICollection<V> Values<K, V>();  
  }
    internal sealed class MapViewToReadOnlyCollectionAdapter   {
      private MapViewToReadOnlyCollectionAdapter();  
      internal int Count<K, V>();  
  }
    internal enum PropertyType   {
      Boolean = 11,  
      BooleanArray = 1035,  
      Char16 = 10,  
      Char16Array = 1034,  
      DateTime = 14,  
      DateTimeArray = 1038,  
      Double = 9,  
      DoubleArray = 1033,  
      Empty = 0,  
      Guid = 16,  
      GuidArray = 1040,  
      Inspectable = 13,  
      InspectableArray = 1037,  
      Int16 = 2,  
      Int16Array = 1026,  
      Int32 = 4,  
      Int32Array = 1028,  
      Int64 = 6,  
      Int64Array = 1030,  
      Other = 20,  
      OtherArray = 1044,  
      Point = 17,  
      PointArray = 1041,  
      Rect = 19,  
      RectArray = 1043,  
      Single = 8,  
      SingleArray = 1032,  
      Size = 18,  
      SizeArray = 1042,  
      String = 12,  
      StringArray = 1036,  
      TimeSpan = 15,  
      TimeSpanArray = 1039,  
      UInt16 = 3,  
      UInt16Array = 1027,  
      UInt32 = 5,  
      UInt32Array = 1029,  
      UInt64 = 7,  
      UInt64Array = 1031,  
      UInt8 = 1,  
      UInt8Array = 1025,  
  }
    internal sealed class ReadOnlyDictionaryKeyCollection<TKey, TValue> : IEnumerable, IEnumerable<TKey>   {
      private readonly IReadOnlyDictionary<TKey, TValue> dictionary;  
      public ReadOnlyDictionaryKeyCollection(IReadOnlyDictionary<TKey, TValue> dictionary);  
      public IEnumerator<TKey> GetEnumerator();  
      IEnumerator System.Collections.IEnumerable.GetEnumerator();  
  }
    internal sealed class ReadOnlyDictionaryKeyEnumerator<TKey, TValue> : IDisposable, IEnumerator, IEnumerator<TKey>   {
      private IEnumerator<KeyValuePair<TKey, TValue>> enumeration;  
      private readonly IReadOnlyDictionary<TKey, TValue> dictionary;  
      public ReadOnlyDictionaryKeyEnumerator(IReadOnlyDictionary<TKey, TValue> dictionary);  
      public TKey Current { get; }  
      object System.Collections.IEnumerator.Current { get; }  
      public bool MoveNext();  
      public void Reset();  
      void System.IDisposable.Dispose();  
  }
    internal sealed class ReadOnlyDictionaryValueCollection<TKey, TValue> : IEnumerable, IEnumerable<TValue>   {
      private readonly IReadOnlyDictionary<TKey, TValue> dictionary;  
      public ReadOnlyDictionaryValueCollection(IReadOnlyDictionary<TKey, TValue> dictionary);  
      public IEnumerator<TValue> GetEnumerator();  
      IEnumerator System.Collections.IEnumerable.GetEnumerator();  
  }
    internal sealed class ReadOnlyDictionaryValueEnumerator<TKey, TValue> : IDisposable, IEnumerator, IEnumerator<TValue>   {
      private IEnumerator<KeyValuePair<TKey, TValue>> enumeration;  
      private readonly IReadOnlyDictionary<TKey, TValue> dictionary;  
      public ReadOnlyDictionaryValueEnumerator(IReadOnlyDictionary<TKey, TValue> dictionary);  
      public TValue Current { get; }  
      object System.Collections.IEnumerator.Current { get; }  
      public bool MoveNext();  
      public void Reset();  
      void System.IDisposable.Dispose();  
  }
    internal abstract class RuntimeClass : __ComObject   {
      protected RuntimeClass();  
      public override bool Equals(object obj);  
      public override int GetHashCode();  
      internal IntPtr GetRedirectedEqualsMD();  
      internal IntPtr GetRedirectedGetHashCodeMD();  
      internal IntPtr GetRedirectedToStringMD();  
      internal bool RedirectEquals(object obj, IntPtr pMD);  
      internal int RedirectGetHashCode(IntPtr pMD);  
      internal string RedirectToString(IntPtr pMD);  
      public override string ToString();  
  }
  internal static class UnsafeNativeMethods {
      internal unsafe static extern int WindowsCreateStringReference(char* sourceString, int length, HSTRING_HEADER* hstringHeader, IntPtr* hstring);  
  }
    internal sealed class VectorToCollectionAdapter   {
      private VectorToCollectionAdapter();  
      internal void Add<T>(T item);  
      internal void Clear<T>();  
      internal bool Contains<T>(T item);  
      internal void CopyTo<T>(T[] array, int arrayIndex);  
      internal int Count<T>();  
      internal bool IsReadOnly<T>();  
      internal bool Remove<T>(T item);  
  }
    internal sealed class VectorToListAdapter   {
      private VectorToListAdapter();  
      internal static T GetAt<T>(IVector<T> _this, uint index);  
      internal T Indexer_Get<T>(int index);  
      internal void Indexer_Set<T>(int index, T value);  
      internal int IndexOf<T>(T item);  
      internal void Insert<T>(int index, T item);  
      private static void InsertAtHelper<T>(IVector<T> _this, uint index, T item);  
      internal void RemoveAt<T>(int index);  
      internal static void RemoveAtHelper<T>(IVector<T> _this, uint index);  
      private static void SetAt<T>(IVector<T> _this, uint index, T value);  
  }
    internal sealed class VectorViewToReadOnlyCollectionAdapter   {
      private VectorViewToReadOnlyCollectionAdapter();  
      internal int Count<T>();  
  }
    internal delegate void WindowsFoundationEventHandler<T>(object sender, T args);  
    internal static class WindowsRuntimeBufferHelper   {
      internal unsafe static void StoreOverlappedInCCW(object windowsRuntimeBuffer, NativeOverlapped* overlapped);  
      private unsafe static extern void StoreOverlappedPtrInCCW(ObjectHandleOnStack windowsRuntimeBuffer, NativeOverlapped* overlapped);  
  }
    internal sealed class WindowsRuntimeImportAttribute : Attribute   {
      internal WindowsRuntimeImportAttribute();  
  }
  public static class WindowsRuntimeMarshal {
      internal static IntPtr GetActivationFactoryForType(Type type);  
      internal static Exception GetExceptionForHR(int hresult, Exception innerException);  
      internal static Exception GetExceptionForHR(int hresult, Exception innerException, string messageResource);  
      internal static int GetRegistrationTokenCacheSize();  
  }
    internal static class WindowsRuntimeMetadata   {
      private static EventHandler<DesignerNamespaceResolveEventArgs> DesignerNamespaceResolve;  
      internal static string[] OnDesignerNamespaceResolveEvent(AppDomain appDomain, string namespaceName);  
  }
}
namespace System.Runtime.Serialization {
    internal class FormatterConverter : IFormatterConverter   {
      public FormatterConverter();  
      public object Convert(object value, Type type);  
      public object Convert(object value, TypeCode typeCode);  
      public bool ToBoolean(object value);  
      public byte ToByte(object value);  
      public char ToChar(object value);  
      public DateTime ToDateTime(object value);  
      public decimal ToDecimal(object value);  
      public double ToDouble(object value);  
      public short ToInt16(object value);  
      public int ToInt32(object value);  
      public long ToInt64(object value);  
      public sbyte ToSByte(object value);  
      public float ToSingle(object value);  
      public string ToString(object value);  
      public ushort ToUInt16(object value);  
      public uint ToUInt32(object value);  
      public ulong ToUInt64(object value);  
  }
}
namespace System.Security {
    internal sealed class DynamicSecurityMethodAttribute : Attribute   {
      public DynamicSecurityMethodAttribute();  
  }
}
namespace System.Security.AccessControl {
  internal class EventWaitHandleSecurity {
      public EventWaitHandleSecurity();  
  }
}
namespace System.StubHelpers {
    internal static class AnsiBSTRMarshaler   {
      internal static void ClearNative(IntPtr pNative);  
      internal static string ConvertToManaged(IntPtr bstr);  
      internal static IntPtr ConvertToNative(int flags, string strManaged);  
  }
  internal static class AnsiCharMarshaler {
      internal static char ConvertToManaged(byte nativeChar);  
      internal static byte ConvertToNative(char managedChar, bool fBestFit, bool fThrowOnUnmappableChar);  
  }
  internal struct AsAnyMarshaler {
      internal enum AsAnyFlags   {
        In = 268435456,  
        IsAnsi = 16711680,  
        IsBestFit = 255,  
        IsThrowOn = 65280,  
        Out = 536870912,  
      }
  }
    internal static class BSTRMarshaler   {
      internal static void ClearNative(IntPtr pNative);  
      internal static string ConvertToManaged(IntPtr bstr);  
      internal static IntPtr ConvertToNative(string strManaged, IntPtr pNativeBuffer);  
  }
  internal sealed class CleanupWorkList {
      public void Add(CleanupWorkListElement elem);  
  }
  internal static class CSTRMarshaler {
      internal static void ClearNative(IntPtr pNative);  
      internal static string ConvertToManaged(IntPtr cstr);  
  }
    internal static class DateMarshaler   {
      internal static long ConvertToManaged(double nativeDate);  
      internal static double ConvertToNative(DateTime managedDate);  
  }
    internal struct DateTimeNative   {
      public long UniversalTime;  
  }
    internal static class DateTimeOffsetMarshaler   {
      internal static void ConvertToManaged(out DateTimeOffset managedLocalDTO, ref DateTimeNative nativeTicks);  
      internal static void ConvertToNative(ref DateTimeOffset managedDTO, out DateTimeNative dateTime);  
  }
    internal static class EventArgsMarshaler   {
      internal static IntPtr CreateNativeNCCEventArgsInstance(int action, object newItems, object oldItems, int newIndex, int oldIndex);  
      internal static extern IntPtr CreateNativeNCCEventArgsInstanceHelper(int action, IntPtr newItem, IntPtr oldItem, int newIndex, int oldIndex);  
      internal static extern IntPtr CreateNativePCEventArgsInstance(string name);  
  }
    internal static class HResultExceptionMarshaler   {
      internal static Exception ConvertToManaged(int hr);  
      internal static int ConvertToNative(Exception ex);  
  }
    internal static class HStringMarshaler   {
      internal static void ClearNative(IntPtr hstring);  
      internal static string ConvertToManaged(IntPtr hstring);  
      internal static IntPtr ConvertToNative(string managed);  
      internal unsafe static IntPtr ConvertToNativeReference(string managed, HSTRING_HEADER* hstringHeader);  
  }
    internal static class InterfaceMarshaler   {
      internal static extern void ClearNative(IntPtr pUnk);  
      internal static object ConvertToManaged(IntPtr pUnk, IntPtr itfMT, IntPtr classMT, int flags);  
      internal static object ConvertToManagedWithoutUnboxing(IntPtr pNative);  
      internal static IntPtr ConvertToNative(object objSrc, IntPtr itfMT, IntPtr classMT, int flags);  
  }
    internal static class KeyValuePairMarshaler   {
      internal static KeyValuePair<K, V> ConvertToManaged<K, V>(IntPtr pInsp);  
      internal static object ConvertToManagedBox<K, V>(IntPtr pInsp);  
      internal static IntPtr ConvertToNative<K, V>(ref KeyValuePair<K, V> pair);  
  }
    internal static class MngdHiddenLengthArrayMarshaler   {
      internal static void ClearNativeContents(IntPtr pMarshalState, IntPtr pNativeHome, int cElements);  
      internal static void ClearNativeContents_Type(IntPtr pNativeHome, int cElements);  
      internal static void ConvertContentsToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);  
      internal static void ConvertContentsToManaged_DateTime(ref DateTimeOffset[] managedArray, IntPtr pNativeHome);  
      internal static void ConvertContentsToManaged_Exception(ref Exception[] managedArray, IntPtr pNativeHome);  
      internal static void ConvertContentsToManaged_KeyValuePair<K, V>(ref KeyValuePair<K, V>[] managedArray, IntPtr pNativeHome);  
      internal static void ConvertContentsToManaged_Nullable<T>(ref Nullable<T>[] managedArray, IntPtr pNativeHome) where T : struct;  
      internal static void ConvertContentsToManaged_Type(ref Type[] managedArray, IntPtr pNativeHome);  
      internal static void ConvertContentsToNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);  
      internal static void ConvertContentsToNative_DateTime(ref DateTimeOffset[] managedArray, IntPtr pNativeHome);  
      internal static void ConvertContentsToNative_Exception(ref Exception[] managedArray, IntPtr pNativeHome);  
      internal static void ConvertContentsToNative_KeyValuePair<K, V>(ref KeyValuePair<K, V>[] managedArray, IntPtr pNativeHome);  
      internal static void ConvertContentsToNative_Nullable<T>(ref Nullable<T>[] managedArray, IntPtr pNativeHome) where T : struct;  
      internal static void ConvertContentsToNative_Type(ref Type[] managedArray, IntPtr pNativeHome);  
      internal static void ConvertSpaceToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome, int elementCount);  
      internal static void ConvertSpaceToNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);  
      internal static void CreateMarshaler(IntPtr pMarshalState, IntPtr pMT, IntPtr cbElementSize, ushort vt);  
  }
  internal static class MngdNativeArrayMarshaler {
      internal static void ClearNative(IntPtr pMarshalState, IntPtr pNativeHome, int cElements);  
      internal static void ClearNativeContents(IntPtr pMarshalState, IntPtr pNativeHome, int cElements);  
      internal static void ConvertSpaceToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome, int cElements);  
  }
    internal static class MngdRefCustomMarshaler   {
      internal static void ClearManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);  
      internal static void ClearNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);  
      internal static void ConvertContentsToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);  
      internal static void ConvertContentsToNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);  
      internal static void CreateMarshaler(IntPtr pMarshalState, IntPtr pCMHelper);  
  }
    internal static class MngdSafeArrayMarshaler   {
      internal static void ClearNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);  
      internal static void ConvertContentsToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);  
      internal static void ConvertContentsToNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome, object pOriginalManaged);  
      internal static void ConvertSpaceToManaged(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);  
      internal static void ConvertSpaceToNative(IntPtr pMarshalState, ref object pManagedHome, IntPtr pNativeHome);  
      internal static void CreateMarshaler(IntPtr pMarshalState, IntPtr pMT, int iRank, int dwFlags);  
  }
    internal struct NativeVariant   {
      private IntPtr data1;  
      private IntPtr data2;  
      private ushort vt;  
      private ushort wReserved1;  
      private ushort wReserved2;  
      private ushort wReserved3;  
  }
    internal static class NullableMarshaler   {
      internal static Nullable<T> ConvertToManaged<T>(IntPtr pNative) where T : struct;  
      internal static void ConvertToManagedRetVoid<T>(IntPtr pNative, ref Nullable<T> retObj) where T : struct;  
      internal static IntPtr ConvertToNative<T>(ref Nullable<T> pManaged) where T : struct;  
  }
    internal static class ObjectMarshaler   {
      internal static void ClearNative(IntPtr pVariant);  
      internal static object ConvertToManaged(IntPtr pSrcVariant);  
      internal static void ConvertToNative(object objSrc, IntPtr pDstVariant);  
  }
  internal static class StubHelpers {
      internal static IntPtr AddToCleanupList(ref CleanupWorkList pCleanupWorkList, SafeHandle handle);  
      internal static object AllocateInternal(IntPtr typeHandle);  
      internal static void ArrayTypeCheck(object o, object[] arr);  
      internal static uint CalcVaListSize(IntPtr va_list);  
      internal static void ClearLastError();  
      internal static IntPtr CreateCustomMarshalerHelper(IntPtr pMD, int paramToken, IntPtr hndManagedType);  
      internal static void DecimalCanonicalizeInternal(ref decimal dec);  
      internal static Exception GetCOMHRExceptionObject(int hr, IntPtr pCPCMD, object pThis);  
      internal static Exception GetCOMHRExceptionObject_WinRT(int hr, IntPtr pCPCMD, object pThis);  
      internal static IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget, out bool pfNeedsRelease);  
      internal static IntPtr GetCOMIPFromRCW_WinRT(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget);  
      internal static IntPtr GetCOMIPFromRCW_WinRTDelegate(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget);  
      internal static IntPtr GetCOMIPFromRCW_WinRTSharedGeneric(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget);  
      internal static IntPtr GetDelegateInvokeMethod(Delegate pThis);  
      internal static IntPtr GetDelegateTarget(Delegate pThis, ref IntPtr pStubArg);  
      internal static Exception GetHRExceptionObject(int hr);  
      internal static IntPtr GetNDirectTarget(IntPtr pMD);  
      internal static IntPtr GetOuterInspectable(object pThis, IntPtr pCtorMD);  
      internal static IntPtr GetStubContext();  
      internal static IntPtr GetStubContextAddr();  
      internal static Delegate GetTargetForAmbiguousVariantCall(object objSrc, IntPtr pMT, out bool fUseString);  
      internal static object GetWinRTFactoryObject(IntPtr pCPCMD);  
      internal static IntPtr GetWinRTFactoryReturnValue(object pThis, IntPtr pCtorEntry);  
      internal static void InitDeclaringType(IntPtr pMD);  
      internal static Exception InternalGetCOMHRExceptionObject(int hr, IntPtr pCPCMD, object pThis, bool fForWinRT);  
      internal static Exception InternalGetHRExceptionObject(int hr);  
      internal static bool IsQCall(IntPtr pMD);  
      internal unsafe static void LayoutDestroyNativeInternal(byte* pNative, IntPtr pMT);  
      internal static void LogPinnedArgument(IntPtr localDesc, IntPtr nativeArg);  
      internal static void MarshalToManagedVaListInternal(IntPtr va_list, IntPtr pArgIterator);  
      internal static void MarshalToUnmanagedVaListInternal(IntPtr va_list, uint vaListSize, IntPtr pArgIterator);  
      internal static void MulticastDebuggerTraceHelper(object o, int count);  
      internal static IntPtr ProfilerBeginTransitionCallback(IntPtr pSecretParam, IntPtr pThread, object pThis);  
      internal static void ProfilerEndTransitionCallback(IntPtr pMD, IntPtr pThread);  
      internal static IntPtr SafeHandleAddRef(SafeHandle pHandle, ref bool success);  
      internal static void SetLastError();  
      internal static bool ShouldCallWinRTInterface(object objSrc, IntPtr pCPCMD);  
      internal static void StubRegisterRCW(object pThis);  
      internal static void StubUnregisterRCW(object pThis);  
      internal static void ThrowInteropParamException(int resID, int paramIdx);  
      internal static void ValidateByref(IntPtr byref, IntPtr pMD, object pThis);  
      internal static void ValidateObject(object obj, IntPtr pMD, object pThis);  
  }
    internal static class SystemTypeMarshaler   {
      internal unsafe static void ClearNative(TypeNameNative* pNativeType);  
      internal unsafe static void ConvertToManaged(TypeNameNative* pNativeType, ref Type managedType);  
      internal unsafe static void ConvertToNative(Type managedType, TypeNameNative* pNativeType);  
  }
    internal enum TypeKind   {
      Metadata = 1,  
      Primitive = 0,  
      Projection = 2,  
  }
    internal struct TypeNameNative   {
      internal IntPtr typeName;  
      internal TypeKind typeKind;  
  }
    internal static class UriMarshaler   {
      internal static IntPtr CreateNativeUriInstance(string rawUri);  
      internal unsafe static IntPtr CreateNativeUriInstanceHelper(char* rawUri, int strLen);  
      internal static string GetRawUriFromNative(IntPtr pUri);  
  }
    internal static class UTF8BufferMarshaler   {
      internal static void ConvertToManaged(StringBuilder sb, IntPtr pNative);  
      internal static IntPtr ConvertToNative(StringBuilder sb, IntPtr pNativeBuffer, int flags);  
  }
    internal static class UTF8Marshaler   {
      internal static void ClearNative(IntPtr pNative);  
      internal static string ConvertToManaged(IntPtr cstr);  
      internal static IntPtr ConvertToNative(int flags, string strManaged, IntPtr pNativeBuffer);  
  }
    internal static class ValueClassMarshaler   {
      internal static void ClearNative(IntPtr dst, IntPtr pMT);  
      internal static void ConvertToManaged(IntPtr dst, IntPtr src, IntPtr pMT);  
      internal static void ConvertToNative(IntPtr dst, IntPtr src, IntPtr pMT, ref CleanupWorkList pCleanupWorkList);  
  }
    internal static class VBByValStrMarshaler   {
      internal static void ClearNative(IntPtr pNative);  
      internal static string ConvertToManaged(IntPtr pNative, int cch);  
      internal static IntPtr ConvertToNative(string strManaged, bool fBestFit, bool fThrowOnUnmappableChar, ref int cch);  
  }
    internal static class WinRTTypeNameConverter   {
      internal static string ConvertToWinRTTypeName(Type managedType, out bool isPrimitive);  
      internal static Type GetTypeFromWinRTTypeName(string typeName, out bool isPrimitive);  
  }
    internal static class WSTRBufferMarshaler   {
      internal static void ClearNative(IntPtr pNative);  
      internal static string ConvertToManaged(IntPtr bstr);  
      internal static IntPtr ConvertToNative(string strManaged);  
  }
}
namespace System.Text {
  internal class DecoderNLS : Decoder {
      internal DecoderNLS();  
  }
  internal class EncoderNLS : Encoder {
      internal EncoderNLS();  
  }
  public abstract class Encoding : ICloneable {
    internal class EncodingByteBuffer {
        internal bool AddByte(byte b1, byte b2, byte b3);  
        internal bool AddByte(byte b1, byte b2, byte b3, byte b4);  
        internal bool AddByte(byte b1, byte b2, byte b3, int moreBytesExpected);  
        internal bool Fallback(char charFallback);  
    }
    internal class EncodingCharBuffer {
        internal bool AddChar(char ch1, char ch2, int numBytes);  
        internal bool EvenMoreData(int count);  
        internal bool Fallback(byte byte1, byte byte2);  
        internal bool Fallback(byte byte1, byte byte2, byte byte3, byte byte4);  
    }
  }
    internal enum ExtendedNormalizationForms   {
      FormC = 1,  
      FormCDisallowUnassigned = 257,  
      FormD = 2,  
      FormDDisallowUnassigned = 258,  
      FormIdna = 13,  
      FormIdnaDisallowUnassigned = 269,  
      FormKC = 5,  
      FormKCDisallowUnassigned = 261,  
      FormKD = 6,  
      FormKDDisallowUnassigned = 262,  
  }
  internal class Normalization {
      public Normalization();  
  }
}
namespace System.Threading {
  internal class _IOCompletionCallback {
      internal unsafe static void PerformIOCompletionCallback(uint errorCode, uint numBytes, NativeOverlapped* pOVERLAP);  
  }
    internal static class _ThreadPoolWaitCallback   {
      internal static bool PerformWaitCallback();  
  }
  internal class _ThreadPoolWaitOrTimerCallback {
      internal static void PerformWaitOrTimerCallback(object state, bool timedOut);  
  }
  public struct CancellationToken {
      private static void ThrowObjectDisposedException();  
  }
  public struct CancellationTokenRegistration : IDisposable, IEquatable<CancellationTokenRegistration> {
      internal bool TryDeregister();  
  }
  public class CancellationTokenSource : IDisposable {
      internal bool IsDisposed { get; }  
  }
  internal struct FastRandom {
      public int Next(int maxValue);  
  }
  public static class Interlocked {
      internal static int CompareExchange(ref int location1, int value, int comparand, ref bool succeeded);  
  }
    internal delegate object InternalCrossContextDelegate(object[] args);  
  internal interface IThreadPoolWorkItem {
      void ExecuteWorkItem();  
      void MarkAborted(ThreadAbortException tae);  
  }
  public sealed class Mutex : WaitHandle {
    internal class MutexSecurity {
        public MutexSecurity();  
    }
  }
  public class Overlapped {
      internal _IOCompletionCallback iocbHelper { get; }  
      internal IOCompletionCallback UserCallback { get; }  
  }
  internal sealed class OverlappedData {
      internal unsafe static void CheckVMForIOPacket(out NativeOverlapped* pOVERLAP, out uint errorCode, out uint numBytes);  
  }
  internal sealed class QueueUserWorkItemCallback : IThreadPoolWorkItem {
      private void MarkExecuted(bool aborted);  
      void System.Threading.IThreadPoolWorkItem.ExecuteWorkItem();  
      void System.Threading.IThreadPoolWorkItem.MarkAborted(ThreadAbortException tae);  
  }
  internal sealed class QueueUserWorkItemCallbackDefaultContext : IThreadPoolWorkItem {
      private void MarkExecuted(bool aborted);  
      void System.Threading.IThreadPoolWorkItem.ExecuteWorkItem();  
      void System.Threading.IThreadPoolWorkItem.MarkAborted(ThreadAbortException tae);  
  }
  public class SemaphoreSlim : IDisposable {
    private sealed class TaskNode : Task<bool>, IThreadPoolWorkItem {
        void System.Threading.IThreadPoolWorkItem.ExecuteWorkItem();  
        void System.Threading.IThreadPoolWorkItem.MarkAborted(ThreadAbortException tae);  
    }
  }
  internal sealed class Thread : RuntimeThread {
      public CultureInfo CurrentCulture { get; set; }  
      public CultureInfo CurrentUICulture { get; set; }  
      internal static IntPtr InternalGetCurrentThread();  
      private static extern void nativeInitCultureAccessors();  
      public static void Sleep(TimeSpan timeout);  
  }
  public static class ThreadPool {
      internal static IEnumerable<IThreadPoolWorkItem> GetGloballyQueuedWorkItems();  
      internal static object[] GetGloballyQueuedWorkItemsForDebugger();  
      internal static IEnumerable<IThreadPoolWorkItem> GetLocallyQueuedWorkItems();  
      internal static object[] GetLocallyQueuedWorkItemsForDebugger();  
      internal static object[] GetQueuedWorkItemsForDebugger();  
      internal static bool NotifyWorkItemComplete();  
      internal static void ReportThreadStatus(bool isWorking);  
      private static object[] ToObjectArray(IEnumerable<IThreadPoolWorkItem> workitems);  
  }
  internal sealed class ThreadPoolWorkQueue {
      public IThreadPoolWorkItem Dequeue(ThreadPoolWorkQueueThreadLocals tl, ref bool missedSteal);  
      internal static bool Dispatch();  
      public ThreadPoolWorkQueueThreadLocals EnsureCurrentThreadHasQueue();  
      internal void MarkThreadRequestSatisfied();  
    internal sealed class WorkStealingQueue {
        public bool CanSteal { get; }  
          public IThreadPoolWorkItem TrySteal(ref bool missedSteal);  
    }
  }
  public sealed class ThreadStartException : SystemException {
      internal ThreadStartException();  
      internal ThreadStartException(Exception reason);  
  }
  internal class TimerQueue {
      private static WaitCallback s_fireQueuedTimerCompletion;  
      internal static void AppDomainTimerCallback();  
      private void FireNextTimers();  
      private static void FireQueuedTimerCompletion(object state);  
      private static void QueueTimerCompletion(TimerQueueTimer timer);  
  }
  internal sealed class TimerQueueTimer {
      internal void CallCallback();  
      internal void Fire();  
  }
  public abstract class WaitHandle : MarshalByRefObject, IDisposable {
      internal bool WaitOneWithoutFAS();  
  }
}
namespace System.Threading.Tasks {
  internal class AwaitTaskContinuation : TaskContinuation, IThreadPoolWorkItem {
      private void ExecuteWorkItemHelper();  
      internal override Delegate[] GetDelegateContinuationsForDebugger();  
      void System.Threading.IThreadPoolWorkItem.ExecuteWorkItem();  
      void System.Threading.IThreadPoolWorkItem.MarkAborted(ThreadAbortException tae);  
  }
  internal sealed class CompletionActionInvoker : IThreadPoolWorkItem {
      void System.Threading.IThreadPoolWorkItem.ExecuteWorkItem();  
      void System.Threading.IThreadPoolWorkItem.MarkAborted(ThreadAbortException tae);  
  }
  internal class StandardTaskContinuation : TaskContinuation {
      internal override Delegate[] GetDelegateContinuationsForDebugger();  
  }
  public class Task : IAsyncResult, IDisposable, IThreadPoolWorkItem {
      private Task ParentForDebugger { get; }  
      private int StateFlagsForDebugger { get; }  
      internal static Task FromCancellation(CancellationToken cancellationToken);  
      internal static Task<TResult> FromCancellation<TResult>(CancellationToken cancellationToken);  
      private static Task GetActiveTaskFromId(int taskId);  
      private static Task[] GetActiveTasks();  
      internal virtual Delegate[] GetDelegateContinuationsForDebugger();  
      internal static Delegate[] GetDelegatesFromContinuationObject(object continuationObject);  
      void System.Threading.IThreadPoolWorkItem.ExecuteWorkItem();  
      void System.Threading.IThreadPoolWorkItem.MarkAborted(ThreadAbortException tae);  
  }
  internal abstract class TaskContinuation {
      internal abstract Delegate[] GetDelegateContinuationsForDebugger();  
  }
  public abstract class TaskScheduler {
      internal Task[] GetScheduledTasksForDebugger();  
      internal static TaskScheduler[] GetTaskSchedulersForDebugger();  
  }
  internal sealed class TplEtwProvider : EventSource {
    public class Keywords {
        public Keywords();  
    }
    public class Tasks {
        public Tasks();  
    }
  }
}
namespace Windows.Foundation.Diagnostics {
  internal interface IAsyncCausalityTracerStatics {
      void remove_TracingStatusChanged(EventRegistrationToken token);  
  }
  internal interface ITracingStatusChangedEventArgs {
      bool Enabled { get; }  
      CausalityTraceLevel TraceLevel { get; }  
  }
  internal sealed class TracingStatusChangedEventArgs : ITracingStatusChangedEventArgs {
      public CausalityTraceLevel TraceLevel { get; }  
  }
}