genesis-3d_engine/Engine/script/frameworklibrary/Math/FrameworkResources.cs

/****************************************************************************
Copyright (c) 2011-2013,WebJet Business Division,CYOU
 
http://www.genesis-3d.com.cn

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
namespace ScriptRuntime
{
    using System;
    using System.CodeDom.Compiler;
    using System.ComponentModel;
    using System.Diagnostics;
    using System.Globalization;
    using System.Resources;
    using System.Runtime.CompilerServices;

    [CompilerGenerated, GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0"), DebuggerNonUserCode]
    internal class FrameworkResources
    {
        private static CultureInfo resourceCulture;
        private static System.Resources.ResourceManager resourceMan;

        internal FrameworkResources()
        {
        }

        internal static string AllPlayersFolder
        {
            get
            {
                return ResourceManager.GetString("AllPlayersFolder", resourceCulture);
            }
        }

        internal static string AloneInTheParty
        {
            get
            {
                return ResourceManager.GetString("AloneInTheParty", resourceCulture);
            }
        }

        internal static string Apply3DBeforePlaying
        {
            get
            {
                return ResourceManager.GetString("Apply3DBeforePlaying", resourceCulture);
            }
        }

        internal static string ArrayMultipleFour
        {
            get
            {
                return ResourceManager.GetString("ArrayMultipleFour", resourceCulture);
            }
        }

        internal static string BackBufferBadSize
        {
            get
            {
                return ResourceManager.GetString("BackBufferBadSize", resourceCulture);
            }
        }

        internal static string BadXnb
        {
            get
            {
                return ResourceManager.GetString("BadXnb", resourceCulture);
            }
        }

        internal static string BadXnbGraphicsProfile
        {
            get
            {
                return ResourceManager.GetString("BadXnbGraphicsProfile", resourceCulture);
            }
        }

        internal static string BadXnbMagic
        {
            get
            {
                return ResourceManager.GetString("BadXnbMagic", resourceCulture);
            }
        }

        internal static string BadXnbPlatform
        {
            get
            {
                return ResourceManager.GetString("BadXnbPlatform", resourceCulture);
            }
        }

        internal static string BadXnbSize
        {
            get
            {
                return ResourceManager.GetString("BadXnbSize", resourceCulture);
            }
        }

        internal static string BadXnbTypeVersion
        {
            get
            {
                return ResourceManager.GetString("BadXnbTypeVersion", resourceCulture);
            }
        }

        internal static string BadXnbVersion
        {
            get
            {
                return ResourceManager.GetString("BadXnbVersion", resourceCulture);
            }
        }

        internal static string BadXnbWrongType
        {
            get
            {
                return ResourceManager.GetString("BadXnbWrongType", resourceCulture);
            }
        }

        internal static string BeginMustBeCalledBeforeDraw
        {
            get
            {
                return ResourceManager.GetString("BeginMustBeCalledBeforeDraw", resourceCulture);
            }
        }

        internal static string BeginMustBeCalledBeforeEnd
        {
            get
            {
                return ResourceManager.GetString("BeginMustBeCalledBeforeEnd", resourceCulture);
            }
        }

        internal static string BindPoseNotAvailable
        {
            get
            {
                return ResourceManager.GetString("BindPoseNotAvailable", resourceCulture);
            }
        }

        internal static string BlobStreamIsNotExpandable
        {
            get
            {
                return ResourceManager.GetString("BlobStreamIsNotExpandable", resourceCulture);
            }
        }

        internal static string BoundingBoxZeroPoints
        {
            get
            {
                return ResourceManager.GetString("BoundingBoxZeroPoints", resourceCulture);
            }
        }

        internal static string BoundingSphereZeroPoints
        {
            get
            {
                return ResourceManager.GetString("BoundingSphereZeroPoints", resourceCulture);
            }
        }

        internal static string BoundStateObject
        {
            get
            {
                return ResourceManager.GetString("BoundStateObject", resourceCulture);
            }
        }

        internal static string BuiltInEffectWrongTextureType
        {
            get
            {
                return ResourceManager.GetString("BuiltInEffectWrongTextureType", resourceCulture);
            }
        }

        internal static string CallFrameworkDispatcherUpdate
        {
            get
            {
                return ResourceManager.GetString("CallFrameworkDispatcherUpdate", resourceCulture);
            }
        }

        internal static string CannotCallSpriteBeginTwice
        {
            get
            {
                return ResourceManager.GetString("CannotCallSpriteBeginTwice", resourceCulture);
            }
        }

        internal static string CannotClearNullDepth
        {
            get
            {
                return ResourceManager.GetString("CannotClearNullDepth", resourceCulture);
            }
        }

        internal static string CannotDrawNoData
        {
            get
            {
                return ResourceManager.GetString("CannotDrawNoData", resourceCulture);
            }
        }

        internal static string CannotDrawNoShader
        {
            get
            {
                return ResourceManager.GetString("CannotDrawNoShader", resourceCulture);
            }
        }

        internal static string CannotEndTwice
        {
            get
            {
                return ResourceManager.GetString("CannotEndTwice", resourceCulture);
            }
        }

        internal static string CannotGetBackBufferActiveRenderTargets
        {
            get
            {
                return ResourceManager.GetString("CannotGetBackBufferActiveRenderTargets", resourceCulture);
            }
        }

        internal static string CannotMixShader2and3
        {
            get
            {
                return ResourceManager.GetString("CannotMixShader2and3", resourceCulture);
            }
        }

        internal static string CannotNextSpriteBeginImmediate
        {
            get
            {
                return ResourceManager.GetString("CannotNextSpriteBeginImmediate", resourceCulture);
            }
        }

        internal static string CannotPresentActiveRenderTargets
        {
            get
            {
                return ResourceManager.GetString("CannotPresentActiveRenderTargets", resourceCulture);
            }
        }

        internal static string CannotSetAlreadyUsedRenderTarget
        {
            get
            {
                return ResourceManager.GetString("CannotSetAlreadyUsedRenderTarget", resourceCulture);
            }
        }

        internal static string CannotUseFormatTypeAsManualWhenLocking
        {
            get
            {
                return ResourceManager.GetString("CannotUseFormatTypeAsManualWhenLocking", resourceCulture);
            }
        }

        internal static string CantDisableLighting
        {
            get
            {
                return ResourceManager.GetString("CantDisableLighting", resourceCulture);
            }
        }

        internal static string CantRemoveLocalMachine
        {
            get
            {
                return ResourceManager.GetString("CantRemoveLocalMachine", resourceCulture);
            }
        }

        internal static string CantSerializeMember
        {
            get
            {
                return ResourceManager.GetString("CantSerializeMember", resourceCulture);
            }
        }

        internal static string CantSerializeReadOnlyNull
        {
            get
            {
                return ResourceManager.GetString("CantSerializeReadOnlyNull", resourceCulture);
            }
        }

        internal static string CharacterNotInFont
        {
            get
            {
                return ResourceManager.GetString("CharacterNotInFont", resourceCulture);
            }
        }

        internal static string ContentManagerCannotChangeRootDirectory
        {
            get
            {
                return ResourceManager.GetString("ContentManagerCannotChangeRootDirectory", resourceCulture);
            }
        }

        internal static string CouldNotCreateResource
        {
            get
            {
                return ResourceManager.GetString("CouldNotCreateResource", resourceCulture);
            }
        }

        internal static string CouldNotDeleteContainerAlreadyInUse
        {
            get
            {
                return ResourceManager.GetString("CouldNotDeleteContainerAlreadyInUse", resourceCulture);
            }
        }

        internal static string CouldNotReadKeyboard
        {
            get
            {
                return ResourceManager.GetString("CouldNotReadKeyboard", resourceCulture);
            }
        }

        internal static string CueNotFound
        {
            get
            {
                return ResourceManager.GetString("CueNotFound", resourceCulture);
            }
        }

        [EditorBrowsable(EditorBrowsableState.Advanced)]
        internal static CultureInfo Culture
        {
            get
            {
                return resourceCulture;
            }
            set
            {
                resourceCulture = value;
            }
        }

        internal static string DataNotAvailable
        {
            get
            {
                return ResourceManager.GetString("DataNotAvailable", resourceCulture);
            }
        }

        internal static string DecompressionError
        {
            get
            {
                return ResourceManager.GetString("DecompressionError", resourceCulture);
            }
        }

        internal static string DeviceCannotBeNullOnResourceCreate
        {
            get
            {
                return ResourceManager.GetString("DeviceCannotBeNullOnResourceCreate", resourceCulture);
            }
        }

        internal static string DriverError
        {
            get
            {
                return ResourceManager.GetString("DriverError", resourceCulture);
            }
        }

        internal static string DuplicateVertexElement
        {
            get
            {
                return ResourceManager.GetString("DuplicateVertexElement", resourceCulture);
            }
        }

        internal static string DxtNotMultipleOfFour
        {
            get
            {
                return ResourceManager.GetString("DxtNotMultipleOfFour", resourceCulture);
            }
        }

        internal static string DynamicSoundEffectInstancePacketLimit
        {
            get
            {
                return ResourceManager.GetString("DynamicSoundEffectInstancePacketLimit", resourceCulture);
            }
        }

        internal static string DynamicSoundEffectInvalidBuffer
        {
            get
            {
                return ResourceManager.GetString("DynamicSoundEffectInvalidBuffer", resourceCulture);
            }
        }

        internal static string DynamicSoundEffectInvalidLoopRegion
        {
            get
            {
                return ResourceManager.GetString("DynamicSoundEffectInvalidLoopRegion", resourceCulture);
            }
        }

        internal static string DynamicSoundEffectInvalidOffset
        {
            get
            {
                return ResourceManager.GetString("DynamicSoundEffectInvalidOffset", resourceCulture);
            }
        }

        internal static string DynamicSoundEffectInvalidPlayLength
        {
            get
            {
                return ResourceManager.GetString("DynamicSoundEffectInvalidPlayLength", resourceCulture);
            }
        }

        internal static string EmptySongCollectionsCannotBePlayed
        {
            get
            {
                return ResourceManager.GetString("EmptySongCollectionsCannotBePlayed", resourceCulture);
            }
        }

        internal static string EndMustBeCalledBeforeBegin
        {
            get
            {
                return ResourceManager.GetString("EndMustBeCalledBeforeBegin", resourceCulture);
            }
        }

        internal static string Expired
        {
            get
            {
                return ResourceManager.GetString("Expired", resourceCulture);
            }
        }

        internal static string GamerAlreadyInSession
        {
            get
            {
                return ResourceManager.GetString("GamerAlreadyInSession", resourceCulture);
            }
        }

        internal static string GamerInvalid
        {
            get
            {
                return ResourceManager.GetString("GamerInvalid", resourceCulture);
            }
        }

        internal static string GamerNull
        {
            get
            {
                return ResourceManager.GetString("GamerNull", resourceCulture);
            }
        }

        internal static string GamerServicesAlreadyInitialized
        {
            get
            {
                return ResourceManager.GetString("GamerServicesAlreadyInitialized", resourceCulture);
            }
        }

        internal static string GamerServicesCancelButton
        {
            get
            {
                return ResourceManager.GetString("GamerServicesCancelButton", resourceCulture);
            }
        }

        internal static string GamerServicesGuideAlreadyVisible
        {
            get
            {
                return ResourceManager.GetString("GamerServicesGuideAlreadyVisible", resourceCulture);
            }
        }

        internal static string GamerServicesInitializeFromNonUIThread
        {
            get
            {
                return ResourceManager.GetString("GamerServicesInitializeFromNonUIThread", resourceCulture);
            }
        }

        internal static string GamerServicesNotInitialized
        {
            get
            {
                return ResourceManager.GetString("GamerServicesNotInitialized", resourceCulture);
            }
        }

        internal static string GamerServicesOkButton
        {
            get
            {
                return ResourceManager.GetString("GamerServicesOkButton", resourceCulture);
            }
        }

        internal static string GesturesNotAvailable
        {
            get
            {
                return ResourceManager.GetString("GesturesNotAvailable", resourceCulture);
            }
        }

        internal static string GesturesNotEnabled
        {
            get
            {
                return ResourceManager.GetString("GesturesNotEnabled", resourceCulture);
            }
        }

        internal static string GuideIsShowing
        {
            get
            {
                return ResourceManager.GetString("GuideIsShowing", resourceCulture);
            }
        }

        internal static string IAsyncNotFromBegin
        {
            get
            {
                return ResourceManager.GetString("IAsyncNotFromBegin", resourceCulture);
            }
        }

        internal static string InCallback
        {
            get
            {
                return ResourceManager.GetString("InCallback", resourceCulture);
            }
        }

        internal static string IndexBuffersMustBeSizedCorrectly
        {
            get
            {
                return ResourceManager.GetString("IndexBuffersMustBeSizedCorrectly", resourceCulture);
            }
        }

        internal static string InstallingTitleUpdate
        {
            get
            {
                return ResourceManager.GetString("InstallingTitleUpdate", resourceCulture);
            }
        }

        internal static string InstancePlayFailedDueToLimit
        {
            get
            {
                return ResourceManager.GetString("InstancePlayFailedDueToLimit", resourceCulture);
            }
        }

        internal static string InvalidAccelerometer
        {
            get
            {
                return ResourceManager.GetString("InvalidAccelerometer", resourceCulture);
            }
        }

        internal static string InvalidApply3DCall
        {
            get
            {
                return ResourceManager.GetString("InvalidApply3DCall", resourceCulture);
            }
        }

        internal static string InvalidBufferSize
        {
            get
            {
                return ResourceManager.GetString("InvalidBufferSize", resourceCulture);
            }
        }

        internal static string InvalidBytesPerCluster
        {
            get
            {
                return ResourceManager.GetString("InvalidBytesPerCluster", resourceCulture);
            }
        }

        internal static string InvalidCacheContainerOpenAsyncResult
        {
            get
            {
                return ResourceManager.GetString("InvalidCacheContainerOpenAsyncResult", resourceCulture);
            }
        }

        internal static string InvalidCall
        {
            get
            {
                return ResourceManager.GetString("InvalidCall", resourceCulture);
            }
        }

        internal static string InvalidCategory
        {
            get
            {
                return ResourceManager.GetString("InvalidCategory", resourceCulture);
            }
        }

        internal static string InvalidContentVersion
        {
            get
            {
                return ResourceManager.GetString("InvalidContentVersion", resourceCulture);
            }
        }

        internal static string InvalidController
        {
            get
            {
                return ResourceManager.GetString("InvalidController", resourceCulture);
            }
        }

        internal static string InvalidCue
        {
            get
            {
                return ResourceManager.GetString("InvalidCue", resourceCulture);
            }
        }

        internal static string InvalidDataSize
        {
            get
            {
                return ResourceManager.GetString("InvalidDataSize", resourceCulture);
            }
        }

        internal static string InvalidDevice
        {
            get
            {
                return ResourceManager.GetString("InvalidDevice", resourceCulture);
            }
        }

        internal static string InvalidDisplayOrientation
        {
            get
            {
                return ResourceManager.GetString("InvalidDisplayOrientation", resourceCulture);
            }
        }

        internal static string InvalidEmitterDopplerScale
        {
            get
            {
                return ResourceManager.GetString("InvalidEmitterDopplerScale", resourceCulture);
            }
        }

        internal static string InvalidEntryCount
        {
            get
            {
                return ResourceManager.GetString("InvalidEntryCount", resourceCulture);
            }
        }

        internal static string InvalidFileCacheSize
        {
            get
            {
                return ResourceManager.GetString("InvalidFileCacheSize", resourceCulture);
            }
        }

        internal static string InvalidInstanceStreams
        {
            get
            {
                return ResourceManager.GetString("InvalidInstanceStreams", resourceCulture);
            }
        }

        internal static string InvalidMicrophoneBufferDuration
        {
            get
            {
                return ResourceManager.GetString("InvalidMicrophoneBufferDuration", resourceCulture);
            }
        }

        internal static string InvalidNativeHandle
        {
            get
            {
                return ResourceManager.GetString("InvalidNativeHandle", resourceCulture);
            }
        }

        internal static string InvalidRectangle
        {
            get
            {
                return ResourceManager.GetString("InvalidRectangle", resourceCulture);
            }
        }

        internal static string InvalidServiceProvider
        {
            get
            {
                return ResourceManager.GetString("InvalidServiceProvider", resourceCulture);
            }
        }

        internal static string InvalidSessionState
        {
            get
            {
                return ResourceManager.GetString("InvalidSessionState", resourceCulture);
            }
        }

        internal static string InvalidSoundOffsetOrIndex
        {
            get
            {
                return ResourceManager.GetString("InvalidSoundOffsetOrIndex", resourceCulture);
            }
        }

        internal static string InvalidStoragePath
        {
            get
            {
                return ResourceManager.GetString("InvalidStoragePath", resourceCulture);
            }
        }

        internal static string InvalidStringFormat
        {
            get
            {
                return ResourceManager.GetString("InvalidStringFormat", resourceCulture);
            }
        }

        internal static string InvalidTitleContainerName
        {
            get
            {
                return ResourceManager.GetString("InvalidTitleContainerName", resourceCulture);
            }
        }

        internal static string InvalidTotalSize
        {
            get
            {
                return ResourceManager.GetString("InvalidTotalSize", resourceCulture);
            }
        }

        internal static string InvalidTouchPanel
        {
            get
            {
                return ResourceManager.GetString("InvalidTouchPanel", resourceCulture);
            }
        }

        internal static string InvalidTrackIndex
        {
            get
            {
                return ResourceManager.GetString("InvalidTrackIndex", resourceCulture);
            }
        }

        internal static string InvalidUsage
        {
            get
            {
                return ResourceManager.GetString("InvalidUsage", resourceCulture);
            }
        }

        internal static string InvalidVariableIndex
        {
            get
            {
                return ResourceManager.GetString("InvalidVariableIndex", resourceCulture);
            }
        }

        internal static string InvalidWaveIndex
        {
            get
            {
                return ResourceManager.GetString("InvalidWaveIndex", resourceCulture);
            }
        }

        internal static string InvalidWaveStream
        {
            get
            {
                return ResourceManager.GetString("InvalidWaveStream", resourceCulture);
            }
        }

        internal static string InvalidXactVolume
        {
            get
            {
                return ResourceManager.GetString("InvalidXactVolume", resourceCulture);
            }
        }

        internal static string InviteeNotSignedIn
        {
            get
            {
                return ResourceManager.GetString("InviteeNotSignedIn", resourceCulture);
            }
        }

        internal static string IsCompleteMustBeCalled
        {
            get
            {
                return ResourceManager.GetString("IsCompleteMustBeCalled", resourceCulture);
            }
        }

        internal static string LeaderboardColumnNotFound
        {
            get
            {
                return ResourceManager.GetString("LeaderboardColumnNotFound", resourceCulture);
            }
        }

        internal static string LeaderboardColumnOverflow
        {
            get
            {
                return ResourceManager.GetString("LeaderboardColumnOverflow", resourceCulture);
            }
        }

        internal static string LeaderboardIsArbitrated
        {
            get
            {
                return ResourceManager.GetString("LeaderboardIsArbitrated", resourceCulture);
            }
        }

        internal static string LeaderboardNotLocal
        {
            get
            {
                return ResourceManager.GetString("LeaderboardNotLocal", resourceCulture);
            }
        }

        internal static string LeaderboardReaderCannotPage
        {
            get
            {
                return ResourceManager.GetString("LeaderboardReaderCannotPage", resourceCulture);
            }
        }

        internal static string LeaderboardWriteOverflow
        {
            get
            {
                return ResourceManager.GetString("LeaderboardWriteOverflow", resourceCulture);
            }
        }

        internal static string LIVEn400BadRequest
        {
            get
            {
                return ResourceManager.GetString("LIVEn400BadRequest", resourceCulture);
            }
        }

        internal static string LIVEn401Unauthorized
        {
            get
            {
                return ResourceManager.GetString("LIVEn401Unauthorized", resourceCulture);
            }
        }

        internal static string LIVEn500InternalServerError
        {
            get
            {
                return ResourceManager.GetString("LIVEn500InternalServerError", resourceCulture);
            }
        }

        internal static string LIVEn503ServiceUnavailable
        {
            get
            {
                return ResourceManager.GetString("LIVEn503ServiceUnavailable", resourceCulture);
            }
        }

        internal static string LIVEnAccountBanned
        {
            get
            {
                return ResourceManager.GetString("LIVEnAccountBanned", resourceCulture);
            }
        }

        internal static string LIVEnAccountSuspended
        {
            get
            {
                return ResourceManager.GetString("LIVEnAccountSuspended", resourceCulture);
            }
        }

        internal static string LIVEnCountryNotSupported
        {
            get
            {
                return ResourceManager.GetString("LIVEnCountryNotSupported", resourceCulture);
            }
        }

        internal static string LIVEnFlashUpdateRequired
        {
            get
            {
                return ResourceManager.GetString("LIVEnFlashUpdateRequired", resourceCulture);
            }
        }

        internal static string LIVEnGamertagChangeRequired
        {
            get
            {
                return ResourceManager.GetString("LIVEnGamertagChangeRequired", resourceCulture);
            }
        }

        internal static string LIVEnGamertagUpdateRequired
        {
            get
            {
                return ResourceManager.GetString("LIVEnGamertagUpdateRequired", resourceCulture);
            }
        }

        internal static string LIVEnInvalidUser
        {
            get
            {
                return ResourceManager.GetString("LIVEnInvalidUser", resourceCulture);
            }
        }

        internal static string LIVEnNotSupportedTitle
        {
            get
            {
                return ResourceManager.GetString("LIVEnNotSupportedTitle", resourceCulture);
            }
        }

        internal static string LIVEnServiceNotProvisioned
        {
            get
            {
                return ResourceManager.GetString("LIVEnServiceNotProvisioned", resourceCulture);
            }
        }

        internal static string LIVEnTermsOfServiceNotAccepted
        {
            get
            {
                return ResourceManager.GetString("LIVEnTermsOfServiceNotAccepted", resourceCulture);
            }
        }

        internal static string LIVEnTitleUpdateRequired
        {
            get
            {
                return ResourceManager.GetString("LIVEnTitleUpdateRequired", resourceCulture);
            }
        }

        internal static string LIVEnUnexpectedNetworkError
        {
            get
            {
                return ResourceManager.GetString("LIVEnUnexpectedNetworkError", resourceCulture);
            }
        }

        internal static string LIVEnXBLConnectionUnavailable
        {
            get
            {
                return ResourceManager.GetString("LIVEnXBLConnectionUnavailable", resourceCulture);
            }
        }

        internal static string LIVEnXBLNotEnabled
        {
            get
            {
                return ResourceManager.GetString("LIVEnXBLNotEnabled", resourceCulture);
            }
        }

        internal static string LocalDeviceLibrary
        {
            get
            {
                return ResourceManager.GetString("LocalDeviceLibrary", resourceCulture);
            }
        }

        internal static string MissingNativeDependency
        {
            get
            {
                return ResourceManager.GetString("MissingNativeDependency", resourceCulture);
            }
        }

        internal static string MissingVertexShaderInput
        {
            get
            {
                return ResourceManager.GetString("MissingVertexShaderInput", resourceCulture);
            }
        }

        internal static string MissingVertexShaderInputDetails
        {
            get
            {
                return ResourceManager.GetString("MissingVertexShaderInputDetails", resourceCulture);
            }
        }

        internal static string MobileNoInstancing
        {
            get
            {
                return ResourceManager.GetString("MobileNoInstancing", resourceCulture);
            }
        }

        internal static string ModelHasNoEffect
        {
            get
            {
                return ResourceManager.GetString("ModelHasNoEffect", resourceCulture);
            }
        }

        internal static string ModelHasNoIEffectMatrices
        {
            get
            {
                return ResourceManager.GetString("ModelHasNoIEffectMatrices", resourceCulture);
            }
        }

        internal static string MoreData
        {
            get
            {
                return ResourceManager.GetString("MoreData", resourceCulture);
            }
        }

        internal static string MustBeValidIndex
        {
            get
            {
                return ResourceManager.GetString("MustBeValidIndex", resourceCulture);
            }
        }

        internal static string MustCallBeginSprite
        {
            get
            {
                return ResourceManager.GetString("MustCallBeginSprite", resourceCulture);
            }
        }

        internal static string MustDrawSomething
        {
            get
            {
                return ResourceManager.GetString("MustDrawSomething", resourceCulture);
            }
        }

        internal static string MustResolveRenderTarget
        {
            get
            {
                return ResourceManager.GetString("MustResolveRenderTarget", resourceCulture);
            }
        }

        internal static string MustRetrieveAtLeastOne
        {
            get
            {
                return ResourceManager.GetString("MustRetrieveAtLeastOne", resourceCulture);
            }
        }

        internal static string MustUserShaderCode
        {
            get
            {
                return ResourceManager.GetString("MustUserShaderCode", resourceCulture);
            }
        }

        internal static string NegativePlaneDistance
        {
            get
            {
                return ResourceManager.GetString("NegativePlaneDistance", resourceCulture);
            }
        }

        internal static string NegativeRadius
        {
            get
            {
                return ResourceManager.GetString("NegativeRadius", resourceCulture);
            }
        }

        internal static string NetworkError
        {
            get
            {
                return ResourceManager.GetString("NetworkError", resourceCulture);
            }
        }

        internal static string NetworkGamerDisposed
        {
            get
            {
                return ResourceManager.GetString("NetworkGamerDisposed", resourceCulture);
            }
        }

        internal static string NetworkGamerNotLocal
        {
            get
            {
                return ResourceManager.GetString("NetworkGamerNotLocal", resourceCulture);
            }
        }

        internal static string NetworkGamerRequired
        {
            get
            {
                return ResourceManager.GetString("NetworkGamerRequired", resourceCulture);
            }
        }

        internal static string NetworkGamerWrongSession
        {
            get
            {
                return ResourceManager.GetString("NetworkGamerWrongSession", resourceCulture);
            }
        }

        internal static string NetworkNotAvailable
        {
            get
            {
                return ResourceManager.GetString("NetworkNotAvailable", resourceCulture);
            }
        }

        internal static string NetworkSessionPropertiesReadOnly
        {
            get
            {
                return ResourceManager.GetString("NetworkSessionPropertiesReadOnly", resourceCulture);
            }
        }

        internal static string NoAudioPlaybackDevicesFound
        {
            get
            {
                return ResourceManager.GetString("NoAudioPlaybackDevicesFound", resourceCulture);
            }
        }

        internal static string NoCreatorsClub
        {
            get
            {
                return ResourceManager.GetString("NoCreatorsClub", resourceCulture);
            }
        }

        internal static string NoDefaultConstructor
        {
            get
            {
                return ResourceManager.GetString("NoDefaultConstructor", resourceCulture);
            }
        }

        internal static string NoDeviceConnected
        {
            get
            {
                return ResourceManager.GetString("NoDeviceConnected", resourceCulture);
            }
        }

        internal static string NoGraphicsDevice
        {
            get
            {
                return ResourceManager.GetString("NoGraphicsDevice", resourceCulture);
            }
        }

        internal static string NoGraphicsDeviceContent
        {
            get
            {
                return ResourceManager.GetString("NoGraphicsDeviceContent", resourceCulture);
            }
        }

        internal static string NoJoinInProgress
        {
            get
            {
                return ResourceManager.GetString("NoJoinInProgress", resourceCulture);
            }
        }

        internal static string NonZeroInstanceFrequency
        {
            get
            {
                return ResourceManager.GetString("NonZeroInstanceFrequency", resourceCulture);
            }
        }

        internal static string NoProjectGuid
        {
            get
            {
                return ResourceManager.GetString("NoProjectGuid", resourceCulture);
            }
        }

        internal static string NoPublicSlots
        {
            get
            {
                return ResourceManager.GetString("NoPublicSlots", resourceCulture);
            }
        }

        internal static string NotCurrentTechnique
        {
            get
            {
                return ResourceManager.GetString("NotCurrentTechnique", resourceCulture);
            }
        }

        internal static string NotEnoughCorners
        {
            get
            {
                return ResourceManager.GetString("NotEnoughCorners", resourceCulture);
            }
        }

        internal static string NotEnoughPacketSpace
        {
            get
            {
                return ResourceManager.GetString("NotEnoughPacketSpace", resourceCulture);
            }
        }

        internal static string NotEnoughSourceSize
        {
            get
            {
                return ResourceManager.GetString("NotEnoughSourceSize", resourceCulture);
            }
        }

        internal static string NotEnoughTargetSize
        {
            get
            {
                return ResourceManager.GetString("NotEnoughTargetSize", resourceCulture);
            }
        }

        internal static string NotFound
        {
            get
            {
                return ResourceManager.GetString("NotFound", resourceCulture);
            }
        }

        internal static string NotInvited
        {
            get
            {
                return ResourceManager.GetString("NotInvited", resourceCulture);
            }
        }

        internal static string NoWaveBank
        {
            get
            {
                return ResourceManager.GetString("NoWaveBank", resourceCulture);
            }
        }

        internal static string NullGraphicsDeviceService
        {
            get
            {
                return ResourceManager.GetString("NullGraphicsDeviceService", resourceCulture);
            }
        }

        internal static string NullNotAllowed
        {
            get
            {
                return ResourceManager.GetString("NullNotAllowed", resourceCulture);
            }
        }

        internal static string NullWindowHandleNotAllowed
        {
            get
            {
                return ResourceManager.GetString("NullWindowHandleNotAllowed", resourceCulture);
            }
        }

        internal static string NumberVerticesMustBeGreaterZero
        {
            get
            {
                return ResourceManager.GetString("NumberVerticesMustBeGreaterZero", resourceCulture);
            }
        }

        internal static string ObjectDisposedException
        {
            get
            {
                return ResourceManager.GetString("ObjectDisposedException", resourceCulture);
            }
        }

        internal static string OffsetNotValid
        {
            get
            {
                return ResourceManager.GetString("OffsetNotValid", resourceCulture);
            }
        }

        internal static string OnlyOneCacheContainer
        {
            get
            {
                return ResourceManager.GetString("OnlyOneCacheContainer", resourceCulture);
            }
        }

        internal static string OnlySupportedForLIVEn
        {
            get
            {
                return ResourceManager.GetString("OnlySupportedForLIVEn", resourceCulture);
            }
        }

        internal static string OnlySupportedForXboxLIVE
        {
            get
            {
                return ResourceManager.GetString("OnlySupportedForXboxLIVE", resourceCulture);
            }
        }

        internal static string OpenResourceNotBinary
        {
            get
            {
                return ResourceManager.GetString("OpenResourceNotBinary", resourceCulture);
            }
        }

        internal static string OpenResourceNotFound
        {
            get
            {
                return ResourceManager.GetString("OpenResourceNotFound", resourceCulture);
            }
        }

        internal static string OpenStreamError
        {
            get
            {
                return ResourceManager.GetString("OpenStreamError", resourceCulture);
            }
        }

        internal static string OpenStreamNotFound
        {
            get
            {
                return ResourceManager.GetString("OpenStreamNotFound", resourceCulture);
            }
        }

        internal static string OppositePlanes
        {
            get
            {
                return ResourceManager.GetString("OppositePlanes", resourceCulture);
            }
        }

        internal static string OutOfMemoryDrawUserPrimitives
        {
            get
            {
                return ResourceManager.GetString("OutOfMemoryDrawUserPrimitives", resourceCulture);
            }
        }

        internal static string OutRangeFieldOfView
        {
            get
            {
                return ResourceManager.GetString("OutRangeFieldOfView", resourceCulture);
            }
        }

        internal static string PacketArrayTooSmall
        {
            get
            {
                return ResourceManager.GetString("PacketArrayTooSmall", resourceCulture);
            }
        }

        internal static string PacketQueueFull
        {
            get
            {
                return ResourceManager.GetString("PacketQueueFull", resourceCulture);
            }
        }

        internal static string PlayerDeviceAlreadyOpened
        {
            get
            {
                return ResourceManager.GetString("PlayerDeviceAlreadyOpened", resourceCulture);
            }
        }

        internal static string PlayerFourFolder
        {
            get
            {
                return ResourceManager.GetString("PlayerFourFolder", resourceCulture);
            }
        }

        internal static string PlayerOneFolder
        {
            get
            {
                return ResourceManager.GetString("PlayerOneFolder", resourceCulture);
            }
        }

        internal static string PlayerThreeFolder
        {
            get
            {
                return ResourceManager.GetString("PlayerThreeFolder", resourceCulture);
            }
        }

        internal static string PlayerTwoFolder
        {
            get
            {
                return ResourceManager.GetString("PlayerTwoFolder", resourceCulture);
            }
        }

        internal static string ProFeatureNotSupported
        {
            get
            {
                return ResourceManager.GetString("ProFeatureNotSupported", resourceCulture);
            }
        }

        internal static string ProfileAspectRatio
        {
            get
            {
                return ResourceManager.GetString("ProfileAspectRatio", resourceCulture);
            }
        }

        internal static string ProfileDataCountRange
        {
            get
            {
                return ResourceManager.GetString("ProfileDataCountRange", resourceCulture);
            }
        }

        internal static string ProfileDataIndexOutOfRange
        {
            get
            {
                return ResourceManager.GetString("ProfileDataIndexOutOfRange", resourceCulture);
            }
        }

        internal static string ProfileDataOffsetRange
        {
            get
            {
                return ResourceManager.GetString("ProfileDataOffsetRange", resourceCulture);
            }
        }

        internal static string ProfileDataSizeTooBig
        {
            get
            {
                return ResourceManager.GetString("ProfileDataSizeTooBig", resourceCulture);
            }
        }

        internal static string ProfileFeatureNotSupported
        {
            get
            {
                return ResourceManager.GetString("ProfileFeatureNotSupported", resourceCulture);
            }
        }

        internal static string ProfileFormatNotSupported
        {
            get
            {
                return ResourceManager.GetString("ProfileFormatNotSupported", resourceCulture);
            }
        }

        internal static string ProfileInvalidBlendFormat
        {
            get
            {
                return ResourceManager.GetString("ProfileInvalidBlendFormat", resourceCulture);
            }
        }

        internal static string ProfileInvalidDevice
        {
            get
            {
                return ResourceManager.GetString("ProfileInvalidDevice", resourceCulture);
            }
        }

        internal static string ProfileInvalidFilterFormat
        {
            get
            {
                return ResourceManager.GetString("ProfileInvalidFilterFormat", resourceCulture);
            }
        }

        internal static string ProfileMaxPrimitiveCount
        {
            get
            {
                return ResourceManager.GetString("ProfileMaxPrimitiveCount", resourceCulture);
            }
        }

        internal static string ProfileMaxRenderTargets
        {
            get
            {
                return ResourceManager.GetString("ProfileMaxRenderTargets", resourceCulture);
            }
        }

        internal static string ProfileMaxVertexElements
        {
            get
            {
                return ResourceManager.GetString("ProfileMaxVertexElements", resourceCulture);
            }
        }

        internal static string ProfileMaxVertexStreams
        {
            get
            {
                return ResourceManager.GetString("ProfileMaxVertexStreams", resourceCulture);
            }
        }

        internal static string ProfileMaxVertexStride
        {
            get
            {
                return ResourceManager.GetString("ProfileMaxVertexStride", resourceCulture);
            }
        }

        internal static string ProfileNoIndexElementSize32
        {
            get
            {
                return ResourceManager.GetString("ProfileNoIndexElementSize32", resourceCulture);
            }
        }

        internal static string ProfileNoMinMaxSrcDestBlend
        {
            get
            {
                return ResourceManager.GetString("ProfileNoMinMaxSrcDestBlend", resourceCulture);
            }
        }

        internal static string ProfileNoSeparateAlphaBlend
        {
            get
            {
                return ResourceManager.GetString("ProfileNoSeparateAlphaBlend", resourceCulture);
            }
        }

        internal static string ProfileNotPowerOfTwo
        {
            get
            {
                return ResourceManager.GetString("ProfileNotPowerOfTwo", resourceCulture);
            }
        }

        internal static string ProfileNotPowerOfTwoDXT
        {
            get
            {
                return ResourceManager.GetString("ProfileNotPowerOfTwoDXT", resourceCulture);
            }
        }

        internal static string ProfileNotPowerOfTwoMipped
        {
            get
            {
                return ResourceManager.GetString("ProfileNotPowerOfTwoMipped", resourceCulture);
            }
        }

        internal static string ProfileNotPrivileged
        {
            get
            {
                return ResourceManager.GetString("ProfileNotPrivileged", resourceCulture);
            }
        }

        internal static string ProfileNotSignedIn
        {
            get
            {
                return ResourceManager.GetString("ProfileNotSignedIn", resourceCulture);
            }
        }

        internal static string ProfileNoWrapNonPow2
        {
            get
            {
                return ResourceManager.GetString("ProfileNoWrapNonPow2", resourceCulture);
            }
        }

        internal static string ProfilePixelShaderModel
        {
            get
            {
                return ResourceManager.GetString("ProfilePixelShaderModel", resourceCulture);
            }
        }

        internal static string ProfileTooBig
        {
            get
            {
                return ResourceManager.GetString("ProfileTooBig", resourceCulture);
            }
        }

        internal static string ProfileVertexShaderModel
        {
            get
            {
                return ResourceManager.GetString("ProfileVertexShaderModel", resourceCulture);
            }
        }

        internal static string ProfileVertexTextureFormatNotSupported
        {
            get
            {
                return ResourceManager.GetString("ProfileVertexTextureFormatNotSupported", resourceCulture);
            }
        }

        internal static string ProxyAlreadyRunning
        {
            get
            {
                return ResourceManager.GetString("ProxyAlreadyRunning", resourceCulture);
            }
        }

        internal static string ProxyCreateFailed
        {
            get
            {
                return ResourceManager.GetString("ProxyCreateFailed", resourceCulture);
            }
        }

        internal static string ProxyInitializeFailed
        {
            get
            {
                return ResourceManager.GetString("ProxyInitializeFailed", resourceCulture);
            }
        }

        internal static string ProxyMissingDependency
        {
            get
            {
                return ResourceManager.GetString("ProxyMissingDependency", resourceCulture);
            }
        }

        internal static string ProxyUpdateFailed
        {
            get
            {
                return ResourceManager.GetString("ProxyUpdateFailed", resourceCulture);
            }
        }

        internal static string RankedNoJoinInProgress
        {
            get
            {
                return ResourceManager.GetString("RankedNoJoinInProgress", resourceCulture);
            }
        }

        internal static string ReaderConstructedNewInstance
        {
            get
            {
                return ResourceManager.GetString("ReaderConstructedNewInstance", resourceCulture);
            }
        }

        internal static string ReadOnly
        {
            get
            {
                return ResourceManager.GetString("ReadOnly", resourceCulture);
            }
        }

        internal static string ReadOnlySharedResource
        {
            get
            {
                return ResourceManager.GetString("ReadOnlySharedResource", resourceCulture);
            }
        }

        internal static string ReflectiveReaderTypeNotFound
        {
            get
            {
                return ResourceManager.GetString("ReflectiveReaderTypeNotFound", resourceCulture);
            }
        }

        internal static string RenderTargetsMustMatch
        {
            get
            {
                return ResourceManager.GetString("RenderTargetsMustMatch", resourceCulture);
            }
        }

        internal static string RequireNonNullAudioEngine
        {
            get
            {
                return ResourceManager.GetString("RequireNonNullAudioEngine", resourceCulture);
            }
        }

        internal static string ResourceDataMustBeCorrectSize
        {
            get
            {
                return ResourceManager.GetString("ResourceDataMustBeCorrectSize", resourceCulture);
            }
        }

        internal static string ResourceInUse
        {
            get
            {
                return ResourceManager.GetString("ResourceInUse", resourceCulture);
            }
        }

        [EditorBrowsable(EditorBrowsableState.Advanced)]
        internal static System.Resources.ResourceManager ResourceManager
        {
            get
            {
                if (object.ReferenceEquals(resourceMan, null))
                {
                    System.Resources.ResourceManager manager = new System.Resources.ResourceManager("Microsoft.Xna.Framework.FrameworkResources", typeof(FrameworkResources).Assembly);
                    resourceMan = manager;
                }
                return resourceMan;
            }
        }

        internal static string ResourcesMustBeGreaterThanZeroSize
        {
            get
            {
                return ResourceManager.GetString("ResourcesMustBeGreaterThanZeroSize", resourceCulture);
            }
        }

        internal static string ResourceTooLarge
        {
            get
            {
                return ResourceManager.GetString("ResourceTooLarge", resourceCulture);
            }
        }

        internal static string SavedGameFolder
        {
            get
            {
                return ResourceManager.GetString("SavedGameFolder", resourceCulture);
            }
        }

        internal static string ScissorInvalid
        {
            get
            {
                return ResourceManager.GetString("ScissorInvalid", resourceCulture);
            }
        }

        internal static string SelectVariation
        {
            get
            {
                return ResourceManager.GetString("SelectVariation", resourceCulture);
            }
        }

        internal static string SessionAlreadyExists
        {
            get
            {
                return ResourceManager.GetString("SessionAlreadyExists", resourceCulture);
            }
        }

        internal static string SessionEnded
        {
            get
            {
                return ResourceManager.GetString("SessionEnded", resourceCulture);
            }
        }

        internal static string SessionFindLocal
        {
            get
            {
                return ResourceManager.GetString("SessionFindLocal", resourceCulture);
            }
        }

        internal static string SessionFull
        {
            get
            {
                return ResourceManager.GetString("SessionFull", resourceCulture);
            }
        }

        internal static string SessionNotFound
        {
            get
            {
                return ResourceManager.GetString("SessionNotFound", resourceCulture);
            }
        }

        internal static string SessionNotHost
        {
            get
            {
                return ResourceManager.GetString("SessionNotHost", resourceCulture);
            }
        }

        internal static string SessionNotJoinable
        {
            get
            {
                return ResourceManager.GetString("SessionNotJoinable", resourceCulture);
            }
        }

        internal static string ShaderCodeSizeMustBeDword
        {
            get
            {
                return ResourceManager.GetString("ShaderCodeSizeMustBeDword", resourceCulture);
            }
        }

        internal static string ShadersMustBeCompiled
        {
            get
            {
                return ResourceManager.GetString("ShadersMustBeCompiled", resourceCulture);
            }
        }

        internal static string ShowSignInPaneCountInvalid
        {
            get
            {
                return ResourceManager.GetString("ShowSignInPaneCountInvalid", resourceCulture);
            }
        }

        internal static string SimulateMarketplacePurchaseCancelString
        {
            get
            {
                return ResourceManager.GetString("SimulateMarketplacePurchaseCancelString", resourceCulture);
            }
        }

        internal static string SimulateMarketplacePurchaseOkString
        {
            get
            {
                return ResourceManager.GetString("SimulateMarketplacePurchaseOkString", resourceCulture);
            }
        }

        internal static string SimulateMarketplacePurchaseString
        {
            get
            {
                return ResourceManager.GetString("SimulateMarketplacePurchaseString", resourceCulture);
            }
        }

        internal static string SimulateMarketplaceTitleString
        {
            get
            {
                return ResourceManager.GetString("SimulateMarketplaceTitleString", resourceCulture);
            }
        }

        internal static string SkinnedEffectMaxBones
        {
            get
            {
                return ResourceManager.GetString("SkinnedEffectMaxBones", resourceCulture);
            }
        }

        internal static string SkinnedEffectWeightsPerVertex
        {
            get
            {
                return ResourceManager.GetString("SkinnedEffectWeightsPerVertex", resourceCulture);
            }
        }

        internal static string SongPlaybackFailed
        {
            get
            {
                return ResourceManager.GetString("SongPlaybackFailed", resourceCulture);
            }
        }

        internal static string StaleSearchResult
        {
            get
            {
                return ResourceManager.GetString("StaleSearchResult", resourceCulture);
            }
        }

        internal static string StreamNotSeekable
        {
            get
            {
                return ResourceManager.GetString("StreamNotSeekable", resourceCulture);
            }
        }

        internal static string StreamTooLong
        {
            get
            {
                return ResourceManager.GetString("StreamTooLong", resourceCulture);
            }
        }

        internal static string StringCollectionInvalid
        {
            get
            {
                return ResourceManager.GetString("StringCollectionInvalid", resourceCulture);
            }
        }

        internal static string StringNullEmptyOrTooLong
        {
            get
            {
                return ResourceManager.GetString("StringNullEmptyOrTooLong", resourceCulture);
            }
        }

        internal static string StringTooLong
        {
            get
            {
                return ResourceManager.GetString("StringTooLong", resourceCulture);
            }
        }

        internal static string TitleNameNotNull
        {
            get
            {
                return ResourceManager.GetString("TitleNameNotNull", resourceCulture);
            }
        }

        internal static string TooManyOperations
        {
            get
            {
                return ResourceManager.GetString("TooManyOperations", resourceCulture);
            }
        }

        internal static string TooManyPendingAsyncOperations
        {
            get
            {
                return ResourceManager.GetString("TooManyPendingAsyncOperations", resourceCulture);
            }
        }

        internal static string TooManyRegions
        {
            get
            {
                return ResourceManager.GetString("TooManyRegions", resourceCulture);
            }
        }

        internal static string TrialMode
        {
            get
            {
                return ResourceManager.GetString("TrialMode", resourceCulture);
            }
        }

        internal static string TrueSkillNotHost
        {
            get
            {
                return ResourceManager.GetString("TrueSkillNotHost", resourceCulture);
            }
        }

        internal static string TypeReaderDuplicate
        {
            get
            {
                return ResourceManager.GetString("TypeReaderDuplicate", resourceCulture);
            }
        }

        internal static string TypeReaderInvalid
        {
            get
            {
                return ResourceManager.GetString("TypeReaderInvalid", resourceCulture);
            }
        }

        internal static string TypeReaderNotFound
        {
            get
            {
                return ResourceManager.GetString("TypeReaderNotFound", resourceCulture);
            }
        }

        internal static string TypeReaderNotRegistered
        {
            get
            {
                return ResourceManager.GetString("TypeReaderNotRegistered", resourceCulture);
            }
        }

        internal static string UnexpectedError
        {
            get
            {
                return ResourceManager.GetString("UnexpectedError", resourceCulture);
            }
        }

        internal static string UnknownError
        {
            get
            {
                return ResourceManager.GetString("UnknownError", resourceCulture);
            }
        }

        internal static string VertexElementBadUsage
        {
            get
            {
                return ResourceManager.GetString("VertexElementBadUsage", resourceCulture);
            }
        }

        internal static string VertexElementOffsetNotMultipleFour
        {
            get
            {
                return ResourceManager.GetString("VertexElementOffsetNotMultipleFour", resourceCulture);
            }
        }

        internal static string VertexElementOutsideStride
        {
            get
            {
                return ResourceManager.GetString("VertexElementOutsideStride", resourceCulture);
            }
        }

        internal static string VertexElementsOverlap
        {
            get
            {
                return ResourceManager.GetString("VertexElementsOverlap", resourceCulture);
            }
        }

        internal static string VertexStrideTooSmall
        {
            get
            {
                return ResourceManager.GetString("VertexStrideTooSmall", resourceCulture);
            }
        }

        internal static string VertexTypeNotIVertexType
        {
            get
            {
                return ResourceManager.GetString("VertexTypeNotIVertexType", resourceCulture);
            }
        }

        internal static string VertexTypeNotValueType
        {
            get
            {
                return ResourceManager.GetString("VertexTypeNotValueType", resourceCulture);
            }
        }

        internal static string VertexTypeNullDeclaration
        {
            get
            {
                return ResourceManager.GetString("VertexTypeNullDeclaration", resourceCulture);
            }
        }

        internal static string VertexTypeWrongSize
        {
            get
            {
                return ResourceManager.GetString("VertexTypeWrongSize", resourceCulture);
            }
        }

        internal static string ViewportInvalid
        {
            get
            {
                return ResourceManager.GetString("ViewportInvalid", resourceCulture);
            }
        }

        internal static string VisualizationArrayTooSmall
        {
            get
            {
                return ResourceManager.GetString("VisualizationArrayTooSmall", resourceCulture);
            }
        }

        internal static string VoiceDestructionFailed
        {
            get
            {
                return ResourceManager.GetString("VoiceDestructionFailed", resourceCulture);
            }
        }

        internal static string WaveBankNotPrepared
        {
            get
            {
                return ResourceManager.GetString("WaveBankNotPrepared", resourceCulture);
            }
        }

        internal static string WmpMediaSource
        {
            get
            {
                return ResourceManager.GetString("WmpMediaSource", resourceCulture);
            }
        }

        internal static string WriteLeaderboardException
        {
            get
            {
                return ResourceManager.GetString("WriteLeaderboardException", resourceCulture);
            }
        }

        internal static string WriteOnlyGetNotSupported
        {
            get
            {
                return ResourceManager.GetString("WriteOnlyGetNotSupported", resourceCulture);
            }
        }

        internal static string WrongNumberOfGamers
        {
            get
            {
                return ResourceManager.GetString("WrongNumberOfGamers", resourceCulture);
            }
        }

        internal static string WrongTextureFormat
        {
            get
            {
                return ResourceManager.GetString("WrongTextureFormat", resourceCulture);
            }
        }

        internal static string XactReadFile
        {
            get
            {
                return ResourceManager.GetString("XactReadFile", resourceCulture);
            }
        }

        internal static string XBLIGFeatureNotSupported
        {
            get
            {
                return ResourceManager.GetString("XBLIGFeatureNotSupported", resourceCulture);
            }
        }

        internal static string XlastAchievement
        {
            get
            {
                return ResourceManager.GetString("XlastAchievement", resourceCulture);
            }
        }

        internal static string XlastContextValue
        {
            get
            {
                return ResourceManager.GetString("XlastContextValue", resourceCulture);
            }
        }

        internal static string XlastGameMode
        {
            get
            {
                return ResourceManager.GetString("XlastGameMode", resourceCulture);
            }
        }

        internal static string XlastGamerPicture
        {
            get
            {
                return ResourceManager.GetString("XlastGamerPicture", resourceCulture);
            }
        }

        internal static string XlastLeaderboard
        {
            get
            {
                return ResourceManager.GetString("XlastLeaderboard", resourceCulture);
            }
        }

        internal static string XlastPresenceMode
        {
            get
            {
                return ResourceManager.GetString("XlastPresenceMode", resourceCulture);
            }
        }

        internal static string XlastProperty
        {
            get
            {
                return ResourceManager.GetString("XlastProperty", resourceCulture);
            }
        }

        internal static string XlastUnknown
        {
            get
            {
                return ResourceManager.GetString("XlastUnknown", resourceCulture);
            }
        }
    }
}