#include <stdlib.h>

#include "il2cpp-config.h"

#include "os/Messages.h"

#define N_ELEMENTS(e) \
    (sizeof (e) / sizeof ((e)[0]))

namespace il2cpp
{
namespace os
{
    ErrorDesc common_messages[] =
    {
        { kErrorCodeSuccess, "Success" },
        { kErrorCodeFileNotFound, "Cannot find the specified file" },
        { kErrorCodePathNotFound, "Cannot find the specified file" },
        { kErrorCodeTooManyOpenFiles, "Too many open files" },
        { kErrorCodeAccessDenied, "Access denied" },
        { kErrorCodeInvalidHandle, "Invalid handle" },
        { kErrorInvalidData, "Invalid data" },
        { kErrorOutofmemory, "Out of memory" },
        { kErrorCodeNotSameDevice, "Not same device" },
        { kErrorCodeNoMoreFiles, "No more files" },
        { kErrorBadLength, "Bad length" },
        { kErrorCodeGenFailure, "General failure" },
        { kErrorCodeSharingViolation, "Sharing violation" },
        { kErrorCodeLockViolation, "Lock violation" },
        { kErrorNotSupported, "Operation not supported" },
        { kErrorCodeInvalidParameter, "Invalid parameter" },
        { kErrorCallNotImplemented, "Call not implemented" },
        { kErrorCodeInvalidName, "Invalid name" },
        { kErrorProcNotFound, "Process not found" },
        { kErrorCodeAlreadyExists, "Already exists" },
        { kErrorDirectory, "Is a directory" },
        { kErrorCodeEncryptionFailed, "Encryption failed" },
        { kWSAeintr, "interrupted" },
        { kWSAebadf, "Bad file number" },
        { kWSAeacces, "Access denied" },
        { kWSAefault, "Bad address" },
        { kWSAeinval, "Invalid arguments" },
        { kWSAemfile, "Too many open files" },
        { kWSAewouldblock, "Operation on non-blocking socket would block" },
        { kWSAeinprogress, "Operation in progress" },
        { kWSAealready, "Operation already in progress" },
        { kWSAenotsock, "The descriptor is not a socket" },
        { kWSAedestaddrreq, "Destination address required" },
        { kWSAemsgsize, "Message too long" },
        { kWSAeprototype, "Protocol wrong type for socket" },
        { kWSAenoprotoopt, "Protocol option not supported" },
        { kWSAeprotonosupport, "Protocol not supported" },
        { kWSAesocktnosupport, "Socket not supported" },
        { kWSAeopnotsupp, "Operation not supported" },
        { kWSAepfnosupport, "Protocol family not supported" },
        { kWSAeafnosupport, "An address incompatible with the requested protocol was used" },
        { kWSAeaddrinuse, "Address already in use" },
        { kWSAeaddrnotavail, "The requested address is not valid in this context" },
        { kWSAenetdown, "Network subsystem is down" },
        { kWSAenetunreach, "Network is unreachable" },
        { kWSAenetreset, "Connection broken, keep-alive detected a problem" },
        { kWSAeconnaborted, "An established connection was aborted in your host machine." },
        { kWSAeconnreset, "Connection reset by peer" },
        { kWSAenobufs, "Not enough buffer space is available" },
        { kWSAeisconn, "Socket is already connected" },
        { kWSAenotconn, "The socket is not connected" },
        { kWSAeshutdown, "The socket has been shut down" },
        { kWSAetoomanyrefs, "Too many references: cannot splice" },
        { kWSAetimedout, "Connection timed out" },
        { kWSAeconnrefused, "Connection refused" },
        { kWSAeloop, "Too many symbolic links encountered" },
        { kWSAenametoolong, "File name too long" },
        { kWSAehostdown, "Host is down" },
        { kWSAehostunreach, "No route to host" },
        { kWSAenotempty, "Directory not empty" },
        { kWSAeproclim, "EPROCLIM" },
        { kWSAeusers, "Too many users" },
        { kWSAedquot, "Quota exceeded" },
        { kWSAestale, "Stale NFS file handle" },
        { kWSAeremote, "Object is remote" },
        { kWSAsysnotready, "SYSNOTREADY" },
        { kWSAvernotsupported, "VERNOTSUPPORTED" },
        { kWSAnotinitialised, "Winsock not initialised" },
        { kWSAediscon, "EDISCON" },
        { kWSAenomore, "ENOMORE" },
        { kWSAecancelled, "Operation canceled" },
        { kWSAeinvalidproctable, "EINVALIDPROCTABLE" },
        { kWSAeinvalidprovider, "EINVALIDPROVIDER" },
        { kWSAeproviderfailedinit, "EPROVIDERFAILEDINIT" },
        { kWSAsyscallfailure, "System call failed" },
        { kWSAserviceNotFound, "SERVICE_NOT_FOUND" },
        { kWSAtypeNotFound, "TYPE_NOT_FOUND" },
        { kWSAENoMore, "E_NO_MORE" },
        { kWSAECancelled, "E_CANCELLED" },
        { kWSAerefused, "EREFUSED" },
        { kWSAhostNotFound, "No such host is known" },
        { kWSAtryAgain, "A temporary error occurred on an authoritative name server.  Try again later." },
        { kWSAnoRecovery, "No recovery" },
        { kWSAnoData, "No data" },
    };

#ifndef IL2CPP_DISABLE_FULL_MESSAGES
    ErrorDesc messages[] =
    {
        { kErrorInvalidFunction, "Invalid function" },
        { kErrorArenaTrashed, "Arena trashed" },
        { kErrorNotEnoughMemory, "Not enough memory" },
        { kErrorInvalidBlock, "Invalid block" },
        { kErrorBadEnvironment, "Bad environment" },
        { kErrorBadFormat, "Bad format" },
        { kErrorInvalidAccess, "Invalid access" },
        { kErrorInvalidDrive, "Invalid drive" },
        { kErrorCurrentDirectory, "Current directory" },
        { kErrorWriteProtect, "Write protect" },
        { kErrorBadUnit, "Bad unit" },
        { kErrorNotReady, "Not ready" },
        { kErrorBadCommand, "Bad command" },
        { kErrorCrc, "CRC" },
        { kErrorSeek, "Seek" },
        { kErrorNotDosDisk, "Not DOS disk" },
        { kErrorSectorNotFound, "Sector not found" },
        { kErrorOutOfPaper, "Out of paper" },
        { kErrorWriteFault, "Write fault" },
        { kErrorReadFault, "Read fault" },
        { kErrorWrongDisk, "Wrong disk" },
        { kErrorSharingBufferExceeded, "Sharing buffer exceeded" },
        { kErrorHandleEof, "Handle EOF" },
        { kErrorHandleDiskFull, "Handle disk full" },
        { kErrorRemNotList, "Rem not list" },
        { kErrorDupName, "Duplicate name" },
        { kErrorBadNetpath, "Bad netpath" },
        { kErrorNetworkBusy, "Network busy" },
        { kErrorDevNotExist, "Device does not exist" },
        { kErrorTooManyCmds, "Too many commands" },
        { kErrorAdapHdwErr, "ADAP HDW error" },
        { kErrorBadNetResp, "Bad net response" },
        { kErrorUnexpNetErr, "Unexpected net error" },
        { kErrorBadRemAdap, "Bad rem adap" },
        { kErrorPrintqFull, "Print queue full" },
        { kErrorNoSpoolSpace, "No spool space" },
        { kErrorPrintCancelled, "Print cancelled" },
        { kErrorNetnameDeleted, "Netname deleted" },
        { kErrorNetworkAccessDenied, "Network access denied" },
        { kErrorBadDevType, "Bad device type" },
        { kErrorBadNetName, "Bad net name" },
        { kErrorTooManyNames, "Too many names" },
        { kErrorTooManySess, "Too many sessions" },
        { kErrorSharingPaused, "Sharing paused" },
        { kErrorReqNotAccep, "Req not accep" },
        { kErrorRedirPaused, "Redir paused" },
        { kErrorFileExists, "File exists" },
        { kErrorCannotMake, "Cannot make" },
        { kErrorFailI24, "Fail i24" },
        { kErrorOutOfStructures, "Out of structures" },
        { kErrorAlreadyAssigned, "Already assigned" },
        { kErrorInvalidPassword, "Invalid password" },
        { kErrorNetWriteFault, "Net write fault" },
        { kErrorNoProcSlots, "No proc slots" },
        { kErrorTooManySemaphores, "Too many semaphores" },
        { kErrorExclSemAlreadyOwned, "Exclusive semaphore already owned" },
        { kErrorSemIsSet, "Semaphore is set" },
        { kErrorTooManySemRequests, "Too many semaphore requests" },
        { kErrorInvalidAtInterruptTime, "Invalid at interrupt time" },
        { kErrorSemOwnerDied, "Semaphore owner died" },
        { kErrorSemUserLimit, "Semaphore user limit" },
        { kErrorDiskChange, "Disk change" },
        { kErrorDriveLocked, "Drive locked" },
        { kErrorBrokenPipe, "Broken pipe" },
        { kErrorOpenFailed, "Open failed" },
        { kErrorBufferOverflow, "Buffer overflow" },
        { kErrorDiskFull, "Disk full" },
        { kErrorNoMoreSearchHandles, "No more search handles" },
        { kErrorInvalidTargetHandle, "Invalid target handle" },
        { kErrorInvalidCategory, "Invalid category" },
        { kErrorInvalidVerifySwitch, "Invalid verify switch" },
        { kErrorBadDriverLevel, "Bad driver level" },
        { kErrorSemTimeout, "Semaphore timeout" },
        { kErrorInsufficientBuffer, "Insufficient buffer" },
        { kErrorInvalidLevel, "Invalid level" },
        { kErrorNoVolumeLabel, "No volume label" },
        { kErrorModNotFound, "Module not found" },
        { kErrorWaitNoChildren, "Wait no children" },
        { kErrorChildNotComplete, "Child not complete" },
        { kErrorDirectAccessHandle, "Direct access handle" },
        { kErrorNegativeSeek, "Negative seek" },
        { kErrorSeekOnDevice, "Seek on device" },
        { kErrorIsJoinTarget, "Is join target" },
        { kErrorIsJoined, "Is joined" },
        { kErrorIsSubsted, "Is substed" },
        { kErrorNotJoined, "Not joined" },
        { kErrorNotSubsted, "Not substed" },
        { kErrorJoinToJoin, "Join to join" },
        { kErrorSubstToSubst, "Subst to subst" },
        { kErrorJoinToSubst, "Join to subst" },
        { kErrorSubstToJoin, "Subst to join" },
        { kErrorBusyDrive, "Busy drive" },
        { kErrorSameDrive, "Same drive" },
        { kErrorDirNotRoot, "Directory not root" },
        { kErrorDirNotEmpty, "Directory not empty" },
        { kErrorIsSubstPath, "Is subst path" },
        { kErrorIsJoinPath, "Is join path" },
        { kErrorPathBusy, "Path busy" },
        { kErrorIsSubstTarget, "Is subst target" },
        { kErrorSystemTrace, "System trace" },
        { kErrorInvalidEventCount, "Invalid event count" },
        { kErrorTooManyMuxwaiters, "Too many muxwaiters" },
        { kErrorInvalidListFormat, "Invalid list format" },
        { kErrorLabelTooLong, "Label too long" },
        { kErrorTooManyTcbs, "Too many TCBs" },
        { kErrorSignalRefused, "Signal refused" },
        { kErrorDiscarded, "Discarded" },
        { kErrorNotLocked, "Not locked" },
        { kErrorBadThreadidAddr, "Bad thread ID addr" },
        { kErrorBadArguments, "Bad arguments" },
        { kErrorBadPathname, "Bad pathname" },
        { kErrorSignalPending, "Signal pending" },
        { kErrorMaxThrdsReached, "Max thrds reached" },
        { kErrorLockFailed, "Lock failed" },
        { kErrorBusy, "Busy" },
        { kErrorCancelViolation, "Cancel violation" },
        { kErrorAtomicLocksNotSupported, "Atomic locks not supported" },
        { kErrorInvalidSegmentNumber, "Invalid segment number" },
        { kErrorInvalidOrdinal, "Invalid ordinal" },
        { kErrorInvalidFlagNumber, "Invalid flag number" },
        { kErrorSemNotFound, "Sem not found" },
        { kErrorInvalidStartingCodeseg, "Invalid starting codeseg" },
        { kErrorInvalidStackseg, "Invalid stackseg" },
        { kErrorInvalidModuletype, "Invalid moduletype" },
        { kErrorInvalidExeSignature, "Invalid exe signature" },
        { kErrorExeMarkedInvalid, "Exe marked invalid" },
        { kErrorBadExeFormat, "Bad exe format" },
        { kErrorIteratedDataExceeds64k, "Iterated data exceeds 64k (and that should be enough for anybody!)" },
        { kErrorInvalidMinallocsize, "Invalid minallocsize" },
        { kErrorDynlinkFromInvalidRing, "Dynlink from invalid ring" },
        { kErrorIoplNotEnabled, "IOPL not enabled" },
        { kErrorInvalidSegdpl, "Invalid segdpl" },
        { kErrorAutodatasegExceeds64k, "Autodataseg exceeds 64k" },
        { kErrorRing2segMustBeMovable, "Ring2seg must be movable" },
        { kErrorRelocChainXeedsSeglim, "Reloc chain exceeds seglim" },
        { kErrorInfloopInRelocChain, "Infloop in reloc chain" },
        { kErrorEnvvarNotFound, "Env var not found" },
        { kErrorNoSignalSent, "No signal sent" },
        { kErrorFilenameExcedRange, "Filename exceeds range" },
        { kErrorRing2StackInUse, "Ring2 stack in use" },
        { kErrorMetaExpansionTooLong, "Meta expansion too long" },
        { kErrorInvalidSignalNumber, "Invalid signal number" },
        { kErrorThread1Inactive, "Thread 1 inactive" },
        { kErrorLocked, "Locked" },
        { kErrorTooManyModules, "Too many modules" },
        { kErrorNestingNotAllowed, "Nesting not allowed" },
        { kErrorExeMachineTypeMismatch, "Exe machine type mismatch" },
        { kErrorBadPipe, "Bad pipe" },
        { kErrorPipeBusy, "Pipe busy" },
        { kErrorNoData, "No data" },
        { kErrorPipeNotConnected, "Pipe not connected" },
        { kErrorMoreData, "More data" },
        { kErrorVcDisconnected, "VC disconnected" },
        { kErrorInvalidEaName, "Invalid EA name" },
        { kErrorEaListInconsistent, "EA list inconsistent" },
        { kWaitTimeout, "Wait timeout" },
        { kErrorNoMoreItems, "No more items" },
        { kErrorCannotCopy, "Cannot copy" },
        { kErrorEasDidntFit, "EAS didnt fit" },
        { kErrorEaFileCorrupt, "EA file corrupt" },
        { kErrorEaTableFull, "EA table full" },
        { kErrorInvalidEaHandle, "Invalid EA handle" },
        { kErrorEasNotSupported, "EAs not supported" },
        { kErrorNotOwner, "Not owner" },
        { kErrorTooManyPosts, "Too many posts" },
        { kErrorPartialCopy, "Partial copy" },
        { kErrorOplockNotGranted, "Oplock not granted" },
        { kErrorInvalidOplockProtocol, "Invalid oplock protocol" },
        { kErrorDiskTooFragmented, "Disk too fragmented" },
        { kErrorDeletePending, "Delete pending" },
        { kErrorMrMidNotFound, "Mr Mid not found" },
        { kErrorInvalidAddress, "Invalid address" },
        { kErrorArithmeticOverflow, "Arithmetic overflow" },
        { kErrorPipeConnected, "Pipe connected" },
        { kErrorPipeListening, "Pipe listening" },
        { kErrorEaAccessDenied, "EA access denied" },
        { kErrorOperationAborted, "Operation aborted" },
        { kErrorIoIncomplete, "IO incomplete" },
        { kErrorIoPending, "IO pending" },
        { kErrorNoaccess, "No access" },
        { kErrorSwaperror, "Swap error" },
        { kErrorStackOverflow, "Stack overflow" },
        { kErrorInvalidMessage, "Invalid message" },
        { kErrorCanNotComplete, "Can not complete" },
        { kErrorInvalidFlags, "Invalid flags" },
        { kErrorUnrecognizedVolume, "Unrecognised volume" },
        { kErrorFileInvalid, "File invalid" },
        { kErrorFullscreenMode, "Full screen mode" },
        { kErrorNoToken, "No token" },
        { kErrorBaddb, "Bad DB" },
        { kErrorBadkey, "Bad key" },
        { kErrorCantopen, "Can't open" },
        { kErrorCantread, "Can't read" },
        { kErrorCantwrite, "Can't write" },
        { kErrorRegistryRecovered, "Registry recovered" },
        { kErrorRegistryCorrupt, "Registry corrupt" },
        { kErrorRegistryIoFailed, "Registry IO failed" },
        { kErrorNotRegistryFile, "Not registry file" },
        { kErrorKeyDeleted, "Key deleted" },
        { kErrorNoLogSpace, "No log space" },
        { kErrorKeyHasChildren, "Key has children" },
        { kErrorChildMustBeVolatile, "Child must be volatile" },
        { kErrorNotifyEnumDir, "Notify enum dir" },
        { kErrorDependentServicesRunning, "Dependent services running" },
        { kErrorInvalidServiceControl, "Invalid service control" },
        { kErrorServiceRequestTimeout, "Service request timeout" },
        { kErrorServiceNoThread, "Service no thread" },
        { kErrorServiceDatabaseLocked, "Service database locked" },
        { kErrorServiceAlreadyRunning, "Service already running" },
        { kErrorInvalidServiceAccount, "Invalid service account" },
        { kErrorServiceDisabled, "Service disabled" },
        { kErrorCircularDependency, "Circular dependency" },
        { kErrorServiceDoesNotExist, "Service does not exist" },
        { kErrorServiceCannotAcceptCtrl, "Service cannot accept ctrl" },
        { kErrorServiceNotActive, "Service not active" },
        { kErrorFailedServiceControllerConnect, "Failed service controller connect" },
        { kErrorExceptionInService, "Exception in service" },
        { kErrorDatabaseDoesNotExist, "Database does not exist" },
        { kErrorServiceSpecificError, "Service specific error" },
        { kErrorProcessAborted, "Process aborted" },
        { kErrorServiceDependencyFail, "Service dependency fail" },
        { kErrorServiceLogonFailed, "Service logon failed" },
        { kErrorServiceStartHang, "Service start hang" },
        { kErrorInvalidServiceLock, "Invalid service lock" },
        { kErrorServiceMarkedForDelete, "Service marked for delete" },
        { kErrorServiceExists, "Service exists" },
        { kErrorAlreadyRunningLkg, "Already running lkg" },
        { kErrorServiceDependencyDeleted, "Service dependency deleted" },
        { kErrorBootAlreadyAccepted, "Boot already accepted" },
        { kErrorServiceNeverStarted, "Service never started" },
        { kErrorDuplicateServiceName, "Duplicate service name" },
        { kErrorDifferentServiceAccount, "Different service account" },
        { kErrorCannotDetectDriverFailure, "Cannot detect driver failure" },
        { kErrorCannotDetectProcessAbort, "Cannot detect process abort" },
        { kErrorNoRecoveryProgram, "No recovery program" },
        { kErrorServiceNotInExe, "Service not in exe" },
        { kErrorNotSafebootService, "Not safeboot service" },
        { kErrorEndOfMedia, "End of media" },
        { kErrorFilemarkDetected, "Filemark detected" },
        { kErrorBeginningOfMedia, "Beginning of media" },
        { kErrorSetmarkDetected, "Setmark detected" },
        { kErrorNoDataDetected, "No data detected" },
        { kErrorPartitionFailure, "Partition failure" },
        { kErrorInvalidBlockLength, "Invalid block length" },
        { kErrorDeviceNotPartitioned, "Device not partitioned" },
        { kErrorUnableToLockMedia, "Unable to lock media" },
        { kErrorUnableToUnloadMedia, "Unable to unload media" },
        { kErrorMediaChanged, "Media changed" },
        { kErrorBusReset, "Bus reset" },
        { kErrorNoMediaInDrive, "No media in drive" },
        { kErrorNoUnicodeTranslation, "No unicode translation" },
        { kErrorDllInitFailed, "DLL init failed" },
        { kErrorShutdownInProgress, "Shutdown in progress" },
        { kErrorNoShutdownInProgress, "No shutdown in progress" },
        { kErrorIoDevice, "IO device" },
        { kErrorSerialNoDevice, "Serial IO device" },
        { kErrorIrqBusy, "IRQ busy" },
        { kErrorMoreWrites, "More writes" },
        { kErrorCounterTimeout, "Counter timeout" },
        { kErrorFloppyIdMarkNotFound, "Floppy ID mark not found" },
        { kErrorFloppyWrongCylinder, "Floppy wrong cylinder" },
        { kErrorFloppyUnknownError, "Floppy unknown error" },
        { kErrorFloppyBadRegisters, "Floppy bad registers" },
        { kErrorDiskRecalibrateFailed, "Disk recalibrate failed" },
        { kErrorDiskOperationFailed, "Disk operation failed" },
        { kErrorDiskResetFailed, "Disk reset failed" },
        { kErrorEomOverflow, "EOM overflow" },
        { kErrorNotEnoughServerMemory, "Not enough server memory" },
        { kErrorPossibleDeadlock, "Possible deadlock" },
        { kErrorMappedAlignment, "Mapped alignment" },
        { kErrorSetPowerStateVetoed, "Set power state vetoed" },
        { kErrorSetPowerStateFailed, "Set power state failed" },
        { kErrorTooManyLinks, "Too many links" },
        { kErrorOldWinVersion, "Old win version" },
        { kErrorAppWrongOs, "App wrong OS" },
        { kErrorSingleInstanceApp, "Single instance app" },
        { kErrorRmodeApp, "Rmode app" },
        { kErrorInvalidDll, "Invalid DLL" },
        { kErrorNoAssociation, "No association" },
        { kErrorDdeFail, "DDE fail" },
        { kErrorDllNotFound, "DLL not found" },
        { kErrorNoMoreUserHandles, "No more user handles" },
        { kErrorMessageSyncOnly, "Message sync only" },
        { kErrorSourceElementEmpty, "Source element empty" },
        { kErrorDestinationElementFull, "Destination element full" },
        { kErrorIllegalElementAddress, "Illegal element address" },
        { kErrorMagazineNotPresent, "Magazine not present" },
        { kErrorDeviceReinitializationNeeded, "Device reinitialization needed" },
        { kErrorDeviceRequiresCleaning, "Device requires cleaning" },
        { kErrorDeviceDoorOpen, "Device door open" },
        { kErrorDeviceNotConnected, "Device not connected" },
        { kErrorNotFound, "Not found" },
        { kErrorNoMatch, "No match" },
        { kErrorSetNotFound, "Set not found" },
        { kErrorPointNotFound, "Point not found" },
        { kErrorNoTrackingService, "No tracking service" },
        { kErrorNoVolumeId, "No volume ID" },
        { kErrorUnableToRemoveReplaced, "Unable to remove replaced" },
        { kErrorUnableToMoveReplacement, "Unable to move replacement" },
        { kErrorUnableToMoveReplacement2, "Unable to move replacement 2" },
        { kErrorJournalDeleteInProgress, "Journal delete in progress" },
        { kErrorJournalNotActive, "Journal not active" },
        { kErrorPotentialFileFound, "Potential file found" },
        { kErrorJournalEntryDeleted, "Journal entry deleted" },
        { kErrorBadDevice, "Bad device" },
        { kErrorConnectionUnavail, "Connection unavail" },
        { kErrorDeviceAlreadyRemembered, "Device already remembered" },
        { kErrorNoNetOrBadPath, "No net or bad path" },
        { kErrorBadProvider, "Bad provider" },
        { kErrorCannotOpenProfile, "Cannot open profile" },
        { kErrorBadProfile, "Bad profile" },
        { kErrorNotContainer, "Not container" },
        { kErrorExtendedError, "Extended error" },
        { kErrorInvalidGroupname, "Invalid group name" },
        { kErrorInvalidComputername, "Invalid computer name" },
        { kErrorInvalidEventname, "Invalid event name" },
        { kErrorInvalidDomainname, "Invalid domain name" },
        { kErrorInvalidServicename, "Invalid service name" },
        { kErrorInvalidNetname, "Invalid net name" },
        { kErrorInvalidSharename, "Invalid share name" },
        { kErrorInvalidPasswordname, "Invalid password name" },
        { kErrorInvalidMessagename, "Invalid message name" },
        { kErrorInvalidMessagedest, "Invalid message dest" },
        { kErrorSessionCredentialConflict, "Session credential conflict" },
        { kErrorRemoteSessionLimitExceeded, "Remote session limit exceeded" },
        { kErrorDupDomainname, "Dup domain name" },
        { kErrorNoNetwork, "No network" },
        { kErrorCancelled, "Cancelled" },
        { kErrorUserMappedFile, "User mapped file" },
        { kErrorConnectionRefused, "Connection refused" },
        { kErrorGracefulDisconnect, "Graceful disconnect" },
        { kErrorAddressAlreadyAssociated, "Address already associated" },
        { kErrorAddressNotAssociated, "Address not associated" },
        { kErrorConnectionInvalid, "Connected invalid" },
        { kErrorConnectionActive, "Connection active" },
        { kErrorNetworkUnreachable, "Network unreachable" },
        { kErrorHostUnreachable, "Host unreachable" },
        { kErrorProtocolUnreachable, "Protocol unreachable" },
        { kErrorPortUnreachable, "Port unreachable" },
        { kErrorRequestAborted, "Request aborted" },
        { kErrorConnectionAborted, "Connection aborted" },
        { kErrorRetry, "Retry" },
        { kErrorConnectionCountLimit, "Connection count limit" },
        { kErrorLoginTimeRestriction, "Login time restriction" },
        { kErrorLoginWkstaRestriction, "Login wksta restriction" },
        { kErrorIncorrectAddress, "Incorrect address" },
        { kErrorAlreadyRegistered, "Already registered" },
        { kErrorServiceNotFound, "Service not found" },
        { kErrorNotAuthenticated, "Not authenticated" },
        { kErrorNotLoggedOn, "Not logged on" },
        { kErrorContinue, "Continue" },
        { kErrorAlreadyInitialized, "Already initialised" },
        { kErrorNoMoreDevices, "No more devices" },
        { kErrorNoSuchSite, "No such site" },
        { kErrorDomainControllerExists, "Domain controller exists" },
        { kErrorOnlyIfConnected, "Only if connected" },
        { kErrorOverrideNochanges, "Override no changes" },
        { kErrorBadUserProfile, "Bad user profile" },
        { kErrorNotSupportedOnSbs, "Not supported on SBS" },
        { kErrorServerShutdownInProgress, "Server shutdown in progress" },
        { kErrorHostDown, "Host down" },
        { kErrorNonAccountSid, "Non account sid" },
        { kErrorNonDomainSid, "Non domain sid" },
        { kErrorApphelpBlock, "Apphelp block" },
        { kErrorAccessDisabledByPolicy, "Access disabled by policy" },
        { kErrorRegNatConsumption, "Reg nat consumption" },
        { kErrorCscshareOffline, "CSC share offline" },
        { kErrorPkinitFailure, "PK init failure" },
        { kErrorSmartcardSubsystemFailure, "Smartcard subsystem failure" },
        { kErrorDowngradeDetected, "Downgrade detected" },
        { kSecESmartcardCertRevoked, "Smartcard cert revoked" },
        { kSecEIssuingCaUntrusted, "Issuing CA untrusted" },
        { kSecERevocationOfflineC, "Revocation offline" },
        { kSecEPkinitClientFailur, "PK init client failure" },
        { kSecESmartcardCertExpired, "Smartcard cert expired" },
        { kErrorMachineLocked, "Machine locked" },
        { kErrorCallbackSuppliedInvalidData, "Callback supplied invalid data" },
        { kErrorSyncForegroundRefreshRequired, "Sync foreground refresh required" },
        { kErrorDriverBlocked, "Driver blocked" },
        { kErrorInvalidImportOfNonDll, "Invalid import of non DLL" },
        { kErrorNotAllAssigned, "Not all assigned" },
        { kErrorSomeNotMapped, "Some not mapped" },
        { kErrorNoQuotasForAccount, "No quotas for account" },
        { kErrorLocalUserSessionKey, "Local user session key" },
        { kErrorNullLmPassword, "Null LM password" },
        { kErrorUnknownRevision, "Unknown revision" },
        { kErrorRevisionMismatch, "Revision mismatch" },
        { kErrorInvalidOwner, "Invalid owner" },
        { kErrorInvalidPrimaryGroup, "Invalid primary group" },
        { kErrorNoImpersonationToken, "No impersonation token" },
        { kErrorCantDisableMandatory, "Can't disable mandatory" },
        { kErrorNoLogonServers, "No logon servers" },
        { kErrorNoSuchLogonSession, "No such logon session" },
        { kErrorNoSuchPrivilege, "No such privilege" },
        { kErrorPrivilegeNotHeld, "Privilege not held" },
        { kErrorInvalidAccountName, "Invalid account name" },
        { kErrorUserExists, "User exists" },
        { kErrorNoSuchUser, "No such user" },
        { kErrorGroupExists, "Group exists" },
        { kErrorNoSuchGroup, "No such group" },
        { kErrorMemberInGroup, "Member in group" },
        { kErrorMemberNotInGroup, "Member not in group" },
        { kErrorLastAdmin, "Last admin" },
        { kErrorWrongPassword, "Wrong password" },
        { kErrorIllFormedPassword, "Ill formed password" },
        { kErrorPasswordRestriction, "Password restriction" },
        { kErrorLogonFailure, "Logon failure" },
        { kErrorAccountRestriction, "Account restriction" },
        { kErrorInvalidLogonHours, "Invalid logon hours" },
        { kErrorInvalidWorkstation, "Invalid workstation" },
        { kErrorPasswordExpired, "Password expired" },
        { kErrorAccountDisabled, "Account disabled" },
        { kErrorNoneMapped, "None mapped" },
        { kErrorTooManyLuidsRequested, "Too many LUIDs requested" },
        { kErrorLuidsExhausted, "LUIDs exhausted" },
        { kErrorInvalidSubAuthority, "Invalid sub authority" },
        { kErrorInvalidAcl, "Invalid ACL" },
        { kErrorInvalidSid, "Invalid SID" },
        { kErrorInvalidSecurityDescr, "Invalid security descr" },
        { kErrorBadInheritanceAcl, "Bad inheritance ACL" },
        { kErrorServerDisabled, "Server disabled" },
        { kErrorServerNotDisabled, "Server not disabled" },
        { kErrorInvalidIdAuthority, "Invalid ID authority" },
        { kErrorAllottedSpaceExceeded, "Allotted space exceeded" },
        { kErrorInvalidGroupAttributes, "Invalid group attributes" },
        { kErrorBadImpersonationLevel, "Bad impersonation level" },
        { kErrorCantOpenAnonymous, "Can't open anonymous" },
        { kErrorBadValidationClass, "Bad validation class" },
        { kErrorBadTokenType, "Bad token type" },
        { kErrorNoSecurityOnObject, "No security on object" },
        { kErrorCantAccessDomainInfo, "Can't access domain info" },
        { kErrorInvalidServerState, "Invalid server state" },
        { kErrorInvalidDomainState, "Invalid domain state" },
        { kErrorInvalidDomainRole, "Invalid domain role" },
        { kErrorNoSuchDomain, "No such domain" },
        { kErrorDomainExists, "Domain exists" },
        { kErrorDomainLimitExceeded, "Domain limit exceeded" },
        { kErrorInternalDbCorruption, "Internal DB corruption" },
        { kErrorInternalError, "Internal error" },
        { kErrorGenericNotMapped, "Generic not mapped" },
        { kErrorBadDescriptorFormat, "Bad descriptor format" },
        { kErrorNotLogonProcess, "Not logon process" },
        { kErrorLogonSessionExists, "Logon session exists" },
        { kErrorNoSuchPackage, "No such package" },
        { kErrorBadLogonSessionState, "Bad logon session state" },
        { kErrorLogonSessionCollision, "Logon session collision" },
        { kErrorInvalidLogonType, "Invalid logon type" },
        { kErrorCannotImpersonate, "Cannot impersonate" },
        { kErrorRxactInvalidState, "Rxact invalid state" },
        { kErrorRxactCommitFailure, "Rxact commit failure" },
        { kErrorSpecialAccount, "Special account" },
        { kErrorSpecialGroup, "Special group" },
        { kErrorSpecialUser, "Special user" },
        { kErrorMembersPrimaryGroup, "Members primary group" },
        { kErrorTokenAlreadyInUse, "Token already in use" },
        { kErrorNoSuchAlias, "No such alias" },
        { kErrorMemberNotInAlias, "Member not in alias" },
        { kErrorMemberInAlias, "Member in alias" },
        { kErrorAliasExists, "Alias exists" },
        { kErrorLogonNotGranted, "Logon not granted" },
        { kErrorTooManySecrets, "Too many secrets" },
        { kErrorSecretTooLong, "Secret too long" },
        { kErrorInternalDbError, "Internal DB error" },
        { kErrorTooManyContextIds, "Too many context IDs" },
        { kErrorLogonTypeNotGranted, "Logon type not granted" },
        { kErrorNtCrossEncryptionRequired, "NT cross encryption required" },
        { kErrorNoSuchMember, "No such member" },
        { kErrorInvalidMember, "Invalid member" },
        { kErrorTooManySids, "Too many SIDs" },
        { kErrorLmCrossEncryptionRequired, "LM cross encryption required" },
        { kErrorNoInheritance, "No inheritance" },
        { kErrorFileCorrupt, "File corrupt" },
        { kErrorDiskCorrupt, "Disk corrupt" },
        { kErrorNoUserSessionKey, "No user session key" },
        { kErrorLicenseQuotaExceeded, "Licence quota exceeded" },
        { kErrorWrongTargetName, "Wrong target name" },
        { kErrorMutualAuthFailed, "Mutual auth failed" },
        { kErrorTimeSkew, "Time skew" },
        { kErrorCurrentDomainNotAllowed, "Current domain not allowed" },
        { kErrorInvalidWindowHandle, "Invalid window handle" },
        { kErrorInvalidMenuHandle, "Invalid menu handle" },
        { kErrorInvalidCursorHandle, "Invalid cursor handle" },
        { kErrorInvalidAccelHandle, "Invalid accel handle" },
        { kErrorInvalidHookHandle, "Invalid hook handle" },
        { kErrorInvalidDwpHandle, "Invalid DWP handle" },
        { kErrorTlwWithWschild, "TLW with wschild" },
        { kErrorCannotFindWndClass, "Cannot find WND class" },
        { kErrorWindowOfOtherThread, "Window of other thread" },
        { kErrorHotkeyAlreadyRegistered, "Hotkey already registered" },
        { kErrorClassAlreadyExists, "Class already exists" },
        { kErrorClassDoesNotExist, "Class does not exist" },
        { kErrorClassHasWindows, "Class has windows" },
        { kErrorInvalidIndex, "Invalid index" },
        { kErrorInvalidIconHandle, "Invalid icon handle" },
        { kErrorPrivateDialogIndex, "Private dialog index" },
        { kErrorListboxIdNotFound, "Listbox ID not found" },
        { kErrorNoWildcardCharacters, "No wildcard characters" },
        { kErrorClipboardNotOpen, "Clipboard not open" },
        { kErrorHotkeyNotRegistered, "Hotkey not registered" },
        { kErrorWindowNotDialog, "Window not dialog" },
        { kErrorControlIdNotFound, "Control ID not found" },
        { kErrorInvalidComboboxMessage, "Invalid combobox message" },
        { kErrorWindowNotCombobox, "Window not combobox" },
        { kErrorInvalidEditHeight, "Invalid edit height" },
        { kErrorDcNotFound, "DC not found" },
        { kErrorInvalidHookFilter, "Invalid hook filter" },
        { kErrorInvalidFilterProc, "Invalid filter proc" },
        { kErrorHookNeedsHmod, "Hook needs HMOD" },
        { kErrorGlobalOnlyHook, "Global only hook" },
        { kErrorJournalHookSet, "Journal hook set" },
        { kErrorHookNotInstalled, "Hook not installed" },
        { kErrorInvalidLbMessage, "Invalid LB message" },
        { kErrorSetcountOnBadLb, "Setcount on bad LB" },
        { kErrorLbWithoutTabstops, "LB without tabstops" },
        { kErrorDestroyObjectOfOtherThread, "Destroy object of other thread" },
        { kErrorChildWindowMenu, "Child window menu" },
        { kErrorNoSystemMenu, "No system menu" },
        { kErrorInvalidMsgboxStyle, "Invalid msgbox style" },
        { kErrorInvalidSpiValue, "Invalid SPI value" },
        { kErrorScreenAlreadyLocked, "Screen already locked" },
        { kErrorHwndsHaveDiffParent, "HWNDs have different parent" },
        { kErrorNotChildWindow, "Not child window" },
        { kErrorInvalidGwCommand, "Invalid GW command" },
        { kErrorInvalidThreadId, "Invalid thread ID" },
        { kErrorNonMdichildWindow, "Non MDI child window" },
        { kErrorPopupAlreadyActive, "Popup already active" },
        { kErrorNoScrollbars, "No scrollbars" },
        { kErrorInvalidScrollbarRange, "Invalid scrollbar range" },
        { kErrorInvalidShowwinCommand, "Invalid showwin command" },
        { kErrorNoSystemResources, "No system resources" },
        { kErrorNonpagedSystemResources, "Nonpaged system resources" },
        { kErrorPagedSystemResources, "Paged system resources" },
        { kErrorWorkingSetQuota, "Working set quota" },
        { kErrorPagefileQuota, "Pagefile quota" },
        { kErrorCommitmentLimit, "Commitment limit" },
        { kErrorMenuItemNotFound, "Menu item not found" },
        { kErrorInvalidKeyboardHandle, "Invalid keyboard handle" },
        { kErrorHookTypeNotAllowed, "Hook type not allowed" },
        { kErrorRequiresInteractiveWindowstation, "Requires interactive windowstation" },
        { kErrorTimeout, "Timeout" },
        { kErrorInvalidMonitorHandle, "Invalid monitor handle" },
        { kErrorEventlogFileCorrupt, "Eventlog file corrupt" },
        { kErrorEventlogCantStart, "Eventlog can't start" },
        { kErrorLogFileFull, "Log file full" },
        { kErrorEventlogFileChanged, "Eventlog file changed" },
        { kErrorInstallServiceFailure, "Install service failure" },
        { kErrorInstallUserexit, "Install userexit" },
        { kErrorInstallFailure, "Install failure" },
        { kErrorInstallSuspend, "Install suspend" },
        { kErrorUnknownProduct, "Unknown product" },
        { kErrorUnknownFeature, "Unknown feature" },
        { kErrorUnknownComponent, "Unknown component" },
        { kErrorUnknownProperty, "Unknown property" },
        { kErrorInvalidHandleState, "Invalid handle state" },
        { kErrorBadConfiguration, "Bad configuration" },
        { kErrorIndexAbsent, "Index absent" },
        { kErrorInstallSourceAbsent, "Install source absent" },
        { kErrorInstallPackageVersion, "Install package version" },
        { kErrorProductUninstalled, "Product uninstalled" },
        { kErrorBadQuerySyntax, "Bad query syntax" },
        { kErrorInvalidField, "Invalid field" },
        { kErrorDeviceRemoved, "Device removed" },
        { kErrorInstallAlreadyRunning, "Install already running" },
        { kErrorInstallPackageOpenFailed, "Install package open failed" },
        { kErrorInstallPackageInvalid, "Install package invalid" },
        { kErrorInstallUiFailure, "Install UI failure" },
        { kErrorInstallLogFailure, "Install log failure" },
        { kErrorInstallLanguageUnsupported, "Install language unsupported" },
        { kErrorInstallTransformFailure, "Install transform failure" },
        { kErrorInstallPackageRejected, "Install package rejected" },
        { kErrorFunctionNotCalled, "Function not called" },
        { kErrorFunctionFailed, "Function failed" },
        { kErrorInvalidTable, "Invalid table" },
        { kErrorDatatypeMismatch, "Datatype mismatch" },
        { kErrorUnsupportedType, "Unsupported type" },
        { kErrorCreateFailed, "Create failed" },
        { kErrorInstallTempUnwritable, "Install temp unwritable" },
        { kErrorInstallPlatformUnsupported, "Install platform unsupported" },
        { kErrorInstallNotused, "Install notused" },
        { kErrorPatchPackageOpenFailed, "Patch package open failed" },
        { kErrorPatchPackageInvalid, "Patch package invalid" },
        { kErrorPatchPackageUnsupported, "Patch package unsupported" },
        { kErrorProductVersion, "Product version" },
        { kErrorInvalidCommandLine, "Invalid command line" },
        { kErrorInstallRemoteDisallowed, "Install remote disallowed" },
        { kErrorSuccessRebootInitiated, "Success reboot initiated" },
        { kErrorPatchTargetNotFound, "Patch target not found" },
        { kErrorPatchPackageRejected, "Patch package rejected" },
        { kErrorInstallTransformRejected, "Install transform rejected" },
        { kRpcSInvalidStringBinding, "RPC S Invalid string binding" },
        { kRpcSWrongKindOfBinding, "RPC S Wrong kind of binding" },
        { kRpcSInvalidBinding, "RPC S Invalid binding" },
        { kRpcSProtseqNotSupported, "RPC S Protseq not supported" },
        { kRpcSInvalidRpcProtseq, "RPC S Invalid RPC protseq" },
        { kRpcSInvalidStringUuid, "RPC S Invalid string UUID" },
        { kRpcSInvalidEndpointFormat, "RPC S Invalid endpoint format" },
        { kRpcSInvalidNetAddr, "RPC S Invalid net addr" },
        { kRpcSNoEndpointFound, "RPC S No endpoint found" },
        { kRpcSInvalidTimeout, "RPC S Invalid timeout" },
        { kRpcSObjectNotFound, "RPC S Object not found" },
        { kRpcSAlreadyRegistered, "RPC S Already registered" },
        { kRpcSTypeAlreadyRegistered, "RPC S Type already registered" },
        { kRpcSAlreadyListening, "RPC S Already listening" },
        { kRpcSNoProtseqsRegistered, "RPC S Not protseqs registered" },
        { kRpcSNotListening, "RPC S Not listening" },
        { kRpcSUnknownMgrType, "RPC S Unknown mgr type" },
        { kRpcSUnknownIf, "RPC S Unknown IF" },
        { kRpcSNoBindings, "RPC S No bindings" },
        { kRpcSNoProtseqs, "RPC S Not protseqs" },
        { kRpcSCantCreateEndpoint, "RPC S Can't create endpoint" },
        { kRpcSOutOfResources, "RPC S Out of resources" },
        { kRpcSServerUnavailable, "RPC S Server unavailable" },
        { kRpcSServerTooBusy, "RPC S Server too busy" },
        { kRpcSInvalidNetworkOptions, "RPC S Invalid network options" },
        { kRpcSNoCallActive, "RPC S No call active" },
        { kRpcSCallFailed, "RPC S Call failed" },
        { kRpcSCallFailedDne, "RPC S Call failed DNE" },
        { kRpcSProtocolError, "RPC S Protocol error" },
        { kRpcSUnsupportedTransSyn, "RPC S Unsupported trans syn" },
        { kRpcSUnsupportedType, "RPC S Unsupported type" },
        { kRpcSInvalidTag, "RPC S Invalid tag" },
        { kRpcSInvalidBound, "RPC S Invalid bound" },
        { kRpcSNoEntryName, "RPC S No entry name" },
        { kRpcSInvalidNameSyntax, "RPC S Invalid name syntax" },
        { kRpcSUnsupportedNameSyntax, "RPC S Unsupported name syntax" },
        { kRpcSUuidNoAddress, "RPC S UUID no address" },
        { kRpcSDuplicateEndpoint, "RPC S Duplicate endpoint" },
        { kRpcSUnknownAuthnType, "RPC S Unknown authn type" },
        { kRpcSMaxCallsTooSmall, "RPC S Max calls too small" },
        { kRpcSStringTooLong, "RPC S String too long" },
        { kRpcSProtseqNotFound, "RPC S Protseq not found" },
        { kRpcSProcnumOutOfRange, "RPC S Procnum out of range" },
        { kRpcSBindingHasNoAuth, "RPC S Binding has no auth" },
        { kRpcSUnknownAuthnService, "RPC S Unknown authn service" },
        { kRpcSUnknownAuthnLevel, "RPC S Unknown authn level" },
        { kRpcSInvalidAuthIdentity, "RPC S Invalid auth identity" },
        { kRpcSUnknownAuthzService, "RPC S Unknown authz service" },
        { kEptSInvalidEntry, "EPT S Invalid entry" },
        { kEptSCantPerformOp, "EPT S Can't perform op" },
        { kEptSNotRegistered, "EPT S Not registered" },
        { kRpcSNothingToExport, "RPC S Nothing to export" },
        { kRpcSIncompleteName, "RPC S Incomplete name" },
        { kRpcSInvalidVersOption, "RPC S Invalid vers option" },
        { kRpcSNoMoreMembers, "RPC S No more members" },
        { kRpcSNotAllObjsUnexported, "RPC S Not all objs unexported" },
        { kRpcSInterfaceNotFound, "RPC S Interface not found" },
        { kRpcSEntryAlreadyExists, "RPC S Entry already exists" },
        { kRpcSEntryNotFound, "RPC S Entry not found" },
        { kRpcSNameServiceUnavailable, "RPC S Name service unavailable" },
        { kRpcSInvalidNafId, "RPC S Invalid naf ID" },
        { kRpcSCannotSupport, "RPC S Cannot support" },
        { kRpcSNoContextAvailable, "RPC S No context available" },
        { kRpcSInternalError, "RPC S Internal error" },
        { kRpcSZeroDivide, "RPC S Zero divide" },
        { kRpcSAddressError, "RPC S Address error" },
        { kRpcSFpDivZero, "RPC S FP div zero" },
        { kRpcSFpUnderflow, "RPC S FP Underflow" },
        { kRpcSFpOverflow, "RPC S Overflow" },
        { kRpcXNoMoreEntries, "RPC X No more entries" },
        { kRpcXSsCharTransOpenFail, "RPC X SS char trans open fail" },
        { kRpcXSsCharTransShortFile, "RPC X SS char trans short file" },
        { kRpcXSsInNullContext, "RPC S SS in null context" },
        { kRpcXSsContextDamaged, "RPC X SS context damaged" },
        { kRpcXSsHandlesMismatch, "RPC X SS handles mismatch" },
        { kRpcXSsCannotGetCallHandle, "RPC X SS cannot get call handle" },
        { kRpcXNullRefPointer, "RPC X Null ref pointer" },
        { kRpcXEnumValueOutOfRange, "RPC X enum value out of range" },
        { kRpcXByteCountTooSmall, "RPC X byte count too small" },
        { kRpcXBadStubData, "RPC X bad stub data" },
        { kErrorInvalidUserBuffer, "Invalid user buffer" },
        { kErrorUnrecognizedMedia, "Unrecognised media" },
        { kErrorNoTrustLsaSecret, "No trust lsa secret" },
        { kErrorNoTrustSamAccount, "No trust sam account" },
        { kErrorTrustedDomainFailure, "Trusted domain failure" },
        { kErrorTrustedRelationshipFailure, "Trusted relationship failure" },
        { kErrorTrustFailure, "Trust failure" },
        { kRpcSCallInProgress, "RPC S call in progress" },
        { kErrorNetlogonNotStarted, "Error netlogon not started" },
        { kErrorAccountExpired, "Account expired" },
        { kErrorRedirectorHasOpenHandles, "Redirector has open handles" },
        { kErrorPrinterDriverAlreadyInstalled, "Printer driver already installed" },
        { kErrorUnknownPort, "Unknown port" },
        { kErrorUnknownPrinterDriver, "Unknown printer driver" },
        { kErrorUnknownPrintprocessor, "Unknown printprocessor" },
        { kErrorInvalidSeparatorFile, "Invalid separator file" },
        { kErrorInvalidPriority, "Invalid priority" },
        { kErrorInvalidPrinterName, "Invalid printer name" },
        { kErrorPrinterAlreadyExists, "Printer already exists" },
        { kErrorInvalidPrinterCommand, "Invalid printer command" },
        { kErrorInvalidDatatype, "Invalid datatype" },
        { kErrorInvalidEnvironment, "Invalid environment" },
        { kRpcSNoMoreBindings, "RPC S no more bindings" },
        { kErrorNologonInterdomainTrustAccount, "Nologon interdomain trust account" },
        { kErrorNologonWorkstationTrustAccount, "Nologon workstation trust account" },
        { kErrorNologonServerTrustAccount, "Nologon server trust account" },
        { kErrorDomainTrustInconsistent, "Domain trust inconsistent" },
        { kErrorServerHasOpenHandles, "Server has open handles" },
        { kErrorResourceDataNotFound, "Resource data not found" },
        { kErrorResourceTypeNotFound, "Resource type not found" },
        { kErrorResourceNameNotFound, "Resource name not found" },
        { kErrorResourceLangNotFound, "Resource lang not found" },
        { kErrorNotEnoughQuota, "Not enough quota" },
        { kRpcSNoInterfaces, "RPC S no interfaces" },
        { kRpcSCallCancelled, "RPC S Call cancelled" },
        { kRpcSBindingIncomplete, "RPC S Binding incomplete" },
        { kRpcSCommFailure, "RPC S Comm failure" },
        { kRpcSUnsupportedAuthnLevel, "RPC S Unsupported authn level" },
        { kRpcSNoPrincName, "RPC S No princ name" },
        { kRpcSNotRpcError, "RPC S Not RPC error" },
        { kRpcSUuidLocalOnly, "RPC U UUID local only" },
        { kRpcSSecPkgError, "RPC S Sec pkg error" },
        { kRpcSNotCancelled, "RPC S Not cancelled" },
        { kRpcXInvalidEsAction, "RPC X Invalid ES action" },
        { kRpcXWrongEsVersion, "RPC X Wrong ES version" },
        { kRpcXWrongStubVersion, "RPC X Wrong stub version" },
        { kRpcXInvalidPipeObject, "RPC X Invalid pipe object" },
        { kRpcXWrongPipeOrder, "RPC X Wrong pipe order" },
        { kRpcXWrongPipeVersion, "RPC X Wrong pipe version" },
        { kRpcSGroupMemberNotFound, "RPC S group member not found" },
        { kEptSCantCreate, "EPT S Can't create" },
        { kRpcSInvalidObject, "RPC S Invalid object" },
        { kErrorInvalidTime, "Invalid time" },
        { kErrorInvalidFormName, "Invalid form name" },
        { kErrorInvalidFormSize, "Invalid form size" },
        { kErrorAlreadyWaiting, "Already waiting" },
        { kErrorPrinterDeleted, "Printer deleted" },
        { kErrorInvalidPrinterState, "Invalid printer state" },
        { kErrorPasswordMustChange, "Password must change" },
        { kErrorDomainControllerNotFound, "Domain controller not found" },
        { kErrorAccountLockedOut, "Account locked out" },
        { kOrInvalidOxid, "OR Invalid OXID" },
        { kOrInvalidOid, "OR Invalid OID" },
        { kOrInvalidSet, "OR Invalid set" },
        { kRpcSSendIncomplete, "RPC S Send incomplete" },
        { kRpcSInvalidAsyncHandle, "RPC S Invalid async handle" },
        { kRpcSInvalidAsyncCall, "RPC S Invalid async call" },
        { kRpcXPipeClosed, "RPC X Pipe closed" },
        { kRpcXPipeDisciplineError, "RPC X Pipe discipline error" },
        { kRpcXPipeEmpty, "RPC X Pipe empty" },
        { kErrorNoSitename, "No sitename" },
        { kErrorCantAccessFile, "Can't access file" },
        { kErrorCantResolveFilename, "Can't resolve filename" },
        { kRpcSEntryTypeMismatch, "RPC S Entry type mismatch" },
        { kRpcSNotAllObjsExported, "RPC S Not all objs exported" },
        { kRpcSInterfaceNotExported, "RPC S Interface not exported" },
        { kRpcSProfileNotAdded, "RPC S Profile not added" },
        { kRpcSPrfEltNotAdded, "RPC S PRF ELT not added" },
        { kRpcSPrfEltNotRemoved, "RPC S PRF ELT not removed" },
        { kRpcSGrpEltNotAdded, "RPC S GRP ELT not added" },
        { kRpcSGrpEltNotRemoved, "RPC S GRP ELT not removed" },
        { kErrorKmDriverBlocked, "KM driver blocked" },
        { kErrorContextExpired, "Context expired" },
        { kErrorInvalidPixelFormat, "Invalid pixel format" },
        { kErrorBadDriver, "Bad driver" },
        { kErrorInvalidWindowStyle, "Invalid window style" },
        { kErrorMetafileNotSupported, "Metafile not supported" },
        { kErrorTransformNotSupported, "Transform not supported" },
        { kErrorClippingNotSupported, "Clipping not supported" },
        { kErrorInvalidCmm, "Invalid CMM" },
        { kErrorInvalidProfile, "Invalid profile" },
        { kErrorTagNotFound, "Tag not found" },
        { kErrorTagNotPresent, "Tag not present" },
        { kErrorDuplicateTag, "Duplicate tag" },
        { kErrorProfileNotAssociatedWithDevice, "Profile not associated with device" },
        { kErrorProfileNotFound, "Profile not found" },
        { kErrorInvalidColorspace, "Invalid colorspace" },
        { kErrorIcmNotEnabled, "ICM not enabled" },
        { kErrorDeletingIcmXform, "Deleting ICM xform" },
        { kErrorInvalidTransform, "Invalid transform" },
        { kErrorColorspaceMismatch, "Colorspace mismatch" },
        { kErrorInvalidColorindex, "Invalid colorindex" },
        { kErrorConnectedOtherPassword, "Connected other password" },
        { kErrorConnectedOtherPasswordDefault, "Connected other password default" },
        { kErrorBadUsername, "Bad username" },
        { kErrorNotConnected, "Not connected" },
        { kErrorOpenFiles, "Open files" },
        { kErrorActiveConnections, "Active connections" },
        { kErrorDeviceInUse, "Device in use" },
        { kErrorUnknownPrintMonitor, "Unknown print monitor" },
        { kErrorPrinterDriverInUse, "Printer driver in use" },
        { kErrorSpoolFileNotFound, "Spool file not found" },
        { kErrorSplNoStartdoc, "SPL no startdoc" },
        { kErrorSplNoAddjob, "SPL no addjob" },
        { kErrorPrintProcessorAlreadyInstalled, "Print processor already installed" },
        { kErrorPrintMonitorAlreadyInstalled, "Print monitor already installed" },
        { kErrorInvalidPrintMonitor, "Invalid print monitor" },
        { kErrorPrintMonitorInUse, "Print monitor in use" },
        { kErrorPrinterHasJobsQueued, "Printer has jobs queued" },
        { kErrorSuccessRebootRequired, "Success reboot required" },
        { kErrorSuccessRestartRequired, "Success restart required" },
        { kErrorPrinterNotFound, "Printer not found" },
        { kErrorPrinterDriverWarned, "Printer driver warned" },
        { kErrorPrinterDriverBlocked, "Printer driver blocked" },
        { kErrorWinsInternal, "Wins internal" },
        { kErrorCanNotDelLocalWins, "Can not del local wins" },
        { kErrorStaticInit, "Static init" },
        { kErrorIncBackup, "Inc backup" },
        { kErrorFullBackup, "Full backup" },
        { kErrorRecNonExistent, "Rec not existent" },
        { kErrorRplNotAllowed, "RPL not allowed" },
        { kErrorDhcpAddressConflict, "DHCP address conflict" },
        { kErrorWmiGuidNotFound, "WMU GUID not found" },
        { kErrorWmiInstanceNotFound, "WMI instance not found" },
        { kErrorWmiItemidNotFound, "WMI ItemID not found" },
        { kErrorWmiTryAgain, "WMI try again" },
        { kErrorWmiDpNotFound, "WMI DP not found" },
        { kErrorWmiUnresolvedInstanceRef, "WMI unresolved instance ref" },
        { kErrorWmiAlreadyEnabled, "WMU already enabled" },
        { kErrorWmiGuidDisconnected, "WMU GUID disconnected" },
        { kErrorWmiServerUnavailable, "WMI server unavailable" },
        { kErrorWmiDpFailed, "WMI DP failed" },
        { kErrorWmiInvalidMof, "WMI invalid MOF" },
        { kErrorWmiInvalidReginfo, "WMI invalid reginfo" },
        { kErrorWmiAlreadyDisabled, "WMI already disabled" },
        { kErrorWmiReadOnly, "WMI read only" },
        { kErrorWmiSetFailure, "WMI set failure" },
        { kErrorInvalidMedia, "Invalid media" },
        { kErrorInvalidLibrary, "Invalid library" },
        { kErrorInvalidMediaPool, "Invalid media pool" },
        { kErrorDriveMediaMismatch, "Drive media mismatch" },
        { kErrorMediaOffline, "Media offline" },
        { kErrorLibraryOffline, "Library offline" },
        { kErrorEmpty, "Empty" },
        { kErrorNotEmpty, "Not empty" },
        { kErrorMediaUnavailable, "Media unavailable" },
        { kErrorResourceDisabled, "Resource disabled" },
        { kErrorInvalidCleaner, "Invalid cleaner" },
        { kErrorUnableToClean, "Unable to clean" },
        { kErrorObjectNotFound, "Object not found" },
        { kErrorDatabaseFailure, "Database failure" },
        { kErrorDatabaseFull, "Database full" },
        { kErrorMediaIncompatible, "Media incompatible" },
        { kErrorResourceNotPresent, "Resource not present" },
        { kErrorInvalidOperation, "Invalid operation" },
        { kErrorMediaNotAvailable, "Media not available" },
        { kErrorDeviceNotAvailable, "Device not available" },
        { kErrorRequestRefused, "Request refused" },
        { kErrorInvalidDriveObject, "Invalid drive object" },
        { kErrorLibraryFull, "Library full" },
        { kErrorMediumNotAccessible, "Medium not accessible" },
        { kErrorUnableToLoadMedium, "Unable to load medium" },
        { kErrorUnableToInventoryDrive, "Unable to inventory drive" },
        { kErrorUnableToInventorySlot, "Unable to inventory slot" },
        { kErrorUnableToInventoryTransport, "Unable to inventory transport" },
        { kErrorTransportFull, "Transport full" },
        { kErrorControllingIeport, "Controlling ieport" },
        { kErrorUnableToEjectMountedMedia, "Unable to eject mounted media" },
        { kErrorCleanerSlotSet, "Cleaner slot set" },
        { kErrorCleanerSlotNotSet, "Cleaner slot not set" },
        { kErrorCleanerCartridgeSpent, "Cleaner cartridge spent" },
        { kErrorUnexpectedOmid, "Unexpected omid" },
        { kErrorCantDeleteLastItem, "Can't delete last item" },
        { kErrorMessageExceedsMaxSize, "Message exceeds max size" },
        { kErrorVolumeContainsSysFiles, "Volume contains sys files" },
        { kErrorIndigenousType, "Indigenous type" },
        { kErrorNoSupportingDrives, "No supporting drives" },
        { kErrorCleanerCartridgeInstalled, "Cleaner cartridge installed" },
        { kErrorFileOffline, "Fill offline" },
        { kErrorRemoteStorageNotActive, "Remote storage not active" },
        { kErrorRemoteStorageMediaError, "Remote storage media error" },
        { kErrorNotAReparsePoint, "Not a reparse point" },
        { kErrorReparseAttributeConflict, "Reparse attribute conflict" },
        { kErrorInvalidReparseData, "Invalid reparse data" },
        { kErrorReparseTagInvalid, "Reparse tag invalid" },
        { kErrorReparseTagMismatch, "Reparse tag mismatch" },
        { kErrorVolumeNotSisEnabled, "Volume not sis enabled" },
        { kErrorDependentResourceExists, "Dependent resource exists" },
        { kErrorDependencyNotFound, "Dependency not found" },
        { kErrorDependencyAlreadyExists, "Dependency already exists" },
        { kErrorResourceNotOnline, "Resource not online" },
        { kErrorHostNodeNotAvailable, "Host node not available" },
        { kErrorResourceNotAvailable, "Resource not available" },
        { kErrorResourceNotFound, "Resource not found" },
        { kErrorShutdownCluster, "Shutdown cluster" },
        { kErrorCantEvictActiveNode, "Can't evict active node" },
        { kErrorObjectAlreadyExists, "Object already exists" },
        { kErrorObjectInList, "Object in list" },
        { kErrorGroupNotAvailable, "Group not available" },
        { kErrorGroupNotFound, "Group not found" },
        { kErrorGroupNotOnline, "Group not online" },
        { kErrorHostNodeNotResourceOwner, "Host node not resource owner" },
        { kErrorHostNodeNotGroupOwner, "Host node not group owner" },
        { kErrorResmonCreateFailed, "Resmon create failed" },
        { kErrorResmonOnlineFailed, "Resmon online failed" },
        { kErrorResourceOnline, "Resource online" },
        { kErrorQuorumResource, "Quorum resource" },
        { kErrorNotQuorumCapable, "Not quorum capable" },
        { kErrorClusterShuttingDown, "Cluster shutting down" },
        { kErrorInvalidState, "Invalid state" },
        { kErrorResourcePropertiesStored, "Resource properties stored" },
        { kErrorNotQuorumClass, "Not quorum class" },
        { kErrorCoreResource, "Core resource" },
        { kErrorQuorumResourceOnlineFailed, "Quorum resource online failed" },
        { kErrorQuorumlogOpenFailed, "Quorumlog open failed" },
        { kErrorClusterlogCorrupt, "Clusterlog corrupt" },
        { kErrorClusterlogRecordExceedsMaxsize, "Clusterlog record exceeds maxsize" },
        { kErrorClusterlogExceedsMaxsize, "Clusterlog exceeds maxsize" },
        { kErrorClusterlogChkpointNotFound, "Clusterlog chkpoint not found" },
        { kErrorClusterlogNotEnoughSpace, "Clusterlog not enough space" },
        { kErrorQuorumOwnerAlive, "Quorum owner alive" },
        { kErrorNetworkNotAvailable, "Network not available" },
        { kErrorNodeNotAvailable, "Node not available" },
        { kErrorAllNodesNotAvailable, "All nodes not available" },
        { kErrorResourceFailed, "Resource failed" },
        { kErrorClusterInvalidNode, "Cluster invalid node" },
        { kErrorClusterNodeExists, "Cluster node exists" },
        { kErrorClusterJoinInProgress, "Cluster join in progress" },
        { kErrorClusterNodeNotFound, "Cluster node not found" },
        { kErrorClusterLocalNodeNotFound, "Cluster local node not found" },
        { kErrorClusterNetworkExists, "Cluster network exists" },
        { kErrorClusterNetworkNotFound, "Cluster network not found" },
        { kErrorClusterNetinterfaceExists, "Cluster netinterface exists" },
        { kErrorClusterNetinterfaceNotFound, "Cluster netinterface not found" },
        { kErrorClusterInvalidRequest, "Cluster invalid request" },
        { kErrorClusterInvalidNetworkProvider, "Cluster invalid network provider" },
        { kErrorClusterNodeDown, "Cluster node down" },
        { kErrorClusterNodeUnreachable, "Cluster node unreachable" },
        { kErrorClusterNodeNotMember, "Cluster node not member" },
        { kErrorClusterJoinNotInProgress, "Cluster join not in progress" },
        { kErrorClusterInvalidNetwork, "Cluster invalid network" },
        { kErrorClusterNodeUp, "Cluster node up" },
        { kErrorClusterIpaddrInUse, "Cluster ipaddr in use" },
        { kErrorClusterNodeNotPaused, "Cluster node not paused" },
        { kErrorClusterNoSecurityContext, "Cluster no security context" },
        { kErrorClusterNetworkNotInternal, "Cluster network not internal" },
        { kErrorClusterNodeAlreadyUp, "Cluster node already up" },
        { kErrorClusterNodeAlreadyDown, "Cluster node already down" },
        { kErrorClusterNetworkAlreadyOnline, "Cluster network already online" },
        { kErrorClusterNetworkAlreadyOffline, "Cluster network already offline" },
        { kErrorClusterNodeAlreadyMember, "Cluster node already member" },
        { kErrorClusterLastInternalNetwork, "Cluster last internal network" },
        { kErrorClusterNetworkHasDependents, "Cluster network has dependents" },
        { kErrorInvalidOperationOnQuorum, "Invalid operation on quorum" },
        { kErrorDependencyNotAllowed, "Dependency not allowed" },
        { kErrorClusterNodePaused, "Cluster node paused" },
        { kErrorNodeCantHostResource, "Node can't host resource" },
        { kErrorClusterNodeNotReady, "Cluster node not ready" },
        { kErrorClusterNodeShuttingDown, "Cluster node shutting down" },
        { kErrorClusterJoinAborted, "Cluster join aborted" },
        { kErrorClusterIncompatibleVersions, "Cluster incompatible versions" },
        { kErrorClusterMaxnumOfResourcesExceeded, "Cluster maxnum of resources exceeded" },
        { kErrorClusterSystemConfigChanged, "Cluster system config changed" },
        { kErrorClusterResourceTypeNotFound, "Cluster resource type not found" },
        { kErrorClusterRestypeNotSupported, "Cluster restype not supported" },
        { kErrorClusterResnameNotFound, "Cluster resname not found" },
        { kErrorClusterNoRpcPackagesRegistered, "Cluster no RPC packages registered" },
        { kErrorClusterOwnerNotInPreflist, "Cluster owner not in preflist" },
        { kErrorClusterDatabaseSeqmismatch, "Cluster database seqmismatch" },
        { kErrorResmonInvalidState, "Resmon invalid state" },
        { kErrorClusterGumNotLocker, "Cluster gum not locker" },
        { kErrorQuorumDiskNotFound, "Quorum disk not found" },
        { kErrorDatabaseBackupCorrupt, "Database backup corrupt" },
        { kErrorClusterNodeAlreadyHasDfsRoot, "Cluster node already has DFS root" },
        { kErrorResourcePropertyUnchangeable, "Resource property unchangeable" },
        { kErrorClusterMembershipInvalidState, "Cluster membership invalid state" },
        { kErrorClusterQuorumlogNotFound, "Cluster quorumlog not found" },
        { kErrorClusterMembershipHalt, "Cluster membership halt" },
        { kErrorClusterInstanceIdMismatch, "Cluster instance ID mismatch" },
        { kErrorClusterNetworkNotFoundForIp, "Cluster network not found for IP" },
        { kErrorClusterPropertyDataTypeMismatch, "Cluster property data type mismatch" },
        { kErrorClusterEvictWithoutCleanup, "Cluster evict without cleanup" },
        { kErrorClusterParameterMismatch, "Cluster parameter mismatch" },
        { kErrorNodeCannotBeClustered, "Node cannot be clustered" },
        { kErrorClusterWrongOsVersion, "Cluster wrong OS version" },
        { kErrorClusterCantCreateDupClusterName, "Cluster can't create dup cluster name" },
        { kErrorDecryptionFailed, "Decryption failed" },
        { kErrorFileEncrypted, "File encrypted" },
        { kErrorNoRecoveryPolicy, "No recovery policy" },
        { kErrorNoEfs, "No EFS" },
        { kErrorWrongEfs, "Wrong EFS" },
        { kErrorNoUserKeys, "No user keys" },
        { kErrorFileNotEncrypted, "File not encryped" },
        { kErrorNotExportFormat, "Not export format" },
        { kErrorFileReadOnly, "File read only" },
        { kErrorDirEfsDisallowed, "Dir EFS disallowed" },
        { kErrorEfsServerNotTrusted, "EFS server not trusted" },
        { kErrorBadRecoveryPolicy, "Bad recovery policy" },
        { kErrorEfsAlgBlobTooBig, "ETS alg blob too big" },
        { kErrorVolumeNotSupportEfs, "Volume not support EFS" },
        { kErrorEfsDisabled, "EFS disabled" },
        { kErrorEfsVersionNotSupport, "EFS version not support" },
        { kErrorNoBrowserServersFound, "No browser servers found" },
        { kSchedEServiceNotLocalsystem, "Sched E service not localsystem" },
        { kErrorCtxWinstationNameInvalid, "Ctx winstation name invalid" },
        { kErrorCtxInvalidPd, "Ctx invalid PD" },
        { kErrorCtxPdNotFound, "Ctx PD not found" },
        { kErrorCtxWdNotFound, "Ctx WD not found" },
        { kErrorCtxCannotMakeEventlogEntry, "Ctx cannot make eventlog entry" },
        { kErrorCtxServiceNameCollision, "Ctx service name collision" },
        { kErrorCtxClosePending, "Ctx close pending" },
        { kErrorCtxNoOutbuf, "Ctx no outbuf" },
        { kErrorCtxModemInfNotFound, "Ctx modem inf not found" },
        { kErrorCtxInvalidModemname, "Ctx invalid modemname" },
        { kErrorCtxModemResponseError, "Ctx modem response error" },
        { kErrorCtxModemResponseTimeout, "Ctx modem response timeout" },
        { kErrorCtxModemResponseNoCarrier, "Ctx modem response no carrier" },
        { kErrorCtxModemResponseNoDialtone, "Ctx modem response no dial tone" },
        { kErrorCtxModemResponseBusy, "Ctx modem response busy" },
        { kErrorCtxModemResponseVoice, "Ctx modem response voice" },
        { kErrorCtxTdError, "Ctx TD error" },
        { kErrorCtxWinstationNotFound, "Ctx winstation not found" },
        { kErrorCtxWinstationAlreadyExists, "Ctx winstation already exists" },
        { kErrorCtxWinstationBusy, "Ctx winstation busy" },
        { kErrorCtxBadVideoMode, "Ctx bad video mode" },
        { kErrorCtxGraphicsInvalid, "Ctx graphics invalid" },
        { kErrorCtxLogonDisabled, "Ctx logon disabled" },
        { kErrorCtxNotConsole, "Ctx not console" },
        { kErrorCtxClientQueryTimeout, "Ctx client query timeout" },
        { kErrorCtxConsoleDisconnect, "Ctx console disconnect" },
        { kErrorCtxConsoleConnect, "Ctx console connect" },
        { kErrorCtxShadowDenied, "Ctx shadow denied" },
        { kErrorCtxWinstationAccessDenied, "Ctx winstation access denied" },
        { kErrorCtxInvalidWd, "Ctx invalid WD" },
        { kErrorCtxShadowInvalid, "Ctx shadow invalid" },
        { kErrorCtxShadowDisabled, "Ctx shadow disabled" },
        { kErrorCtxClientLicenseInUse, "Ctx client licence in use" },
        { kErrorCtxClientLicenseNotSet, "Ctx client licence not set" },
        { kErrorCtxLicenseNotAvailable, "Ctx licence not available" },
        { kErrorCtxLicenseClientInvalid, "Ctx licence client invalid" },
        { kErrorCtxLicenseExpired, "Ctx licence expired" },
        { kErrorCtxShadowNotRunning, "Ctx shadow not running" },
        { kErrorCtxShadowEndedByModeChange, "Ctx shadow ended by mode change" },
        { kFrsErrInvalidApiSequence, "FRS err invalid API sequence" },
        { kFrsErrStartingService, "FRS err starting service" },
        { kFrsErrStoppingService, "FRS err stopping service" },
        { kFrsErrInternalApi, "FRS err internal API" },
        { kFrsErrInternal, "FRS err internal" },
        { kFrsErrServiceComm, "FRS err service comm" },
        { kFrsErrInsufficientPriv, "FRS err insufficient priv" },
        { kFrsErrAuthentication, "FRS err authentication" },
        { kFrsErrParentInsufficientPriv, "FRS err parent insufficient priv" },
        { kFrsErrParentAuthentication, "FRS err parent authentication" },
        { kFrsErrChildToParentComm, "FRS err child to parent comm" },
        { kFrsErrParentToChildComm, "FRS err parent to child comm" },
        { kFrsErrSysvolPopulate, "FRS err sysvol populate" },
        { kFrsErrSysvolPopulateTimeout, "FRS err sysvol populate timeout" },
        { kFrsErrSysvolIsBusy, "FRS err sysvol is busy" },
        { kFrsErrSysvolDemote, "FRS err sysvol demote" },
        { kFrsErrInvalidServiceParameter, "FRS err invalid service parameter" },
        { kErrorDsNotInstalled, "DS not installed" },
        { kErrorDsMembershipEvaluatedLocally, "DS membership evaluated locally" },
        { kErrorDsNoAttributeOrValue, "DS no attribute or value" },
        { kErrorDsInvalidAttributeSyntax, "DS invalid attribute syntax" },
        { kErrorDsAttributeTypeUndefined, "DS attribute type undefined" },
        { kErrorDsAttributeOrValueExists, "DS attribute or value exists" },
        { kErrorDsBusy, "DS busy" },
        { kErrorDsUnavailable, "DS unavailable" },
        { kErrorDsNoRidsAllocated, "DS no rids allocated" },
        { kErrorDsNoMoreRids, "DS no more rids" },
        { kErrorDsIncorrectRoleOwner, "DS incorrect role owner" },
        { kErrorDsRidmgrInitError, "DS ridmgr init error" },
        { kErrorDsObjClassViolation, "DS obj class violation" },
        { kErrorDsCantOnNonLeaf, "DS can't on non leaf" },
        { kErrorDsCantOnRdn, "DS can't on rnd" },
        { kErrorDsCantModObjClass, "DS can't mod obj class" },
        { kErrorDsCrossDomMoveError, "DS cross dom move error" },
        { kErrorDsGcNotAvailable, "DS GC not available" },
        { kErrorSharedPolicy, "Shared policy" },
        { kErrorPolicyObjectNotFound, "Policy object not found" },
        { kErrorPolicyOnlyInDs, "Policy only in DS" },
        { kErrorPromotionActive, "Promotion active" },
        { kErrorNoPromotionActive, "No promotion active" },
        { kErrorDsOperationsError, "DS operations error" },
        { kErrorDsProtocolError, "DS protocol error" },
        { kErrorDsTimelimitExceeded, "DS timelimit exceeded" },
        { kErrorDsSizelimitExceeded, "DS sizelimit exceeded" },
        { kErrorDsAdminLimitExceeded, "DS admin limit exceeded" },
        { kErrorDsCompareFalse, "DS compare false" },
        { kErrorDsCompareTrue, "DS compare true" },
        { kErrorDsAuthMethodNotSupported, "DS auth method not supported" },
        { kErrorDsStrongAuthRequired, "DS strong auth required" },
        { kErrorDsInappropriateAuth, "DS inappropriate auth" },
        { kErrorDsAuthUnknown, "DS auth unknown" },
        { kErrorDsReferral, "DS referral" },
        { kErrorDsUnavailableCritExtension, "DS unavailable crit extension" },
        { kErrorDsConfidentialityRequired, "DS confidentiality required" },
        { kErrorDsInappropriateMatching, "DS inappropriate matching" },
        { kErrorDsConstraintViolation, "DS constraint violation" },
        { kErrorDsNoSuchObject, "DS no such object" },
        { kErrorDsAliasProblem, "DS alias problem" },
        { kErrorDsInvalidDnSyntax, "DS invalid dn syntax" },
        { kErrorDsIsLeaf, "DS is leaf" },
        { kErrorDsAliasDerefProblem, "DS alias deref problem" },
        { kErrorDsUnwillingToPerform, "DS unwilling to perform" },
        { kErrorDsLoopDetect, "DS loop detect" },
        { kErrorDsNamingViolation, "DS naming violation" },
        { kErrorDsObjectResultsTooLarge, "DS object results too large" },
        { kErrorDsAffectsMultipleDsas, "DS affects multiple dsas" },
        { kErrorDsServerDown, "DS server down" },
        { kErrorDsLocalError, "DS local error" },
        { kErrorDsEncodingError, "DS encoding error" },
        { kErrorDsDecodingError, "DS decoding error" },
        { kErrorDsFilterUnknown, "DS filter unknown" },
        { kErrorDsParamError, "DS param error" },
        { kErrorDsNotSupported, "DS not supported" },
        { kErrorDsNoResultsReturned, "DS no results returned" },
        { kErrorDsControlNotFound, "DS control not found" },
        { kErrorDsClientLoop, "DS client loop" },
        { kErrorDsReferralLimitExceeded, "DS referral limit exceeded" },
        { kErrorDsSortControlMissing, "DS sort control missing" },
        { kErrorDsOffsetRangeError, "DS offset range error" },
        { kErrorDsRootMustBeNc, "DS root must be nc" },
        { kErrorDsAddReplicaInhibited, "DS and replica inhibited" },
        { kErrorDsAttNotDefInSchema, "DS att not def in schema" },
        { kErrorDsMaxObjSizeExceeded, "DS max obj size exceeded" },
        { kErrorDsObjStringNameExists, "DS obj string name exists" },
        { kErrorDsNoRdnDefinedInSchema, "DS no rdn defined in schema" },
        { kErrorDsRdnDoesntMatchSchema, "DS rdn doesn't match schema" },
        { kErrorDsNoRequestedAttsFound, "DS no requested atts found" },
        { kErrorDsUserBufferToSmall, "DS user buffer too small" },
        { kErrorDsAttIsNotOnObj, "DS att is not on obj" },
        { kErrorDsIllegalModOperation, "DS illegal mod operation" },
        { kErrorDsObjTooLarge, "DS obj too large" },
        { kErrorDsBadInstanceType, "DS bad instance type" },
        { kErrorDsMasterdsaRequired, "DS masterdsa required" },
        { kErrorDsObjectClassRequired, "DS object class required" },
        { kErrorDsMissingRequiredAtt, "DS missing required att" },
        { kErrorDsAttNotDefForClass, "DS att not def for class" },
        { kErrorDsAttAlreadyExists, "DS att already exists" },
        { kErrorDsCantAddAttValues, "DS can't add att values" },
        { kErrorDsSingleValueConstraint, "DS single value constraint" },
        { kErrorDsRangeConstraint, "DS range constraint" },
        { kErrorDsAttValAlreadyExists, "DS att val already exists" },
        { kErrorDsCantRemMissingAtt, "DS can't rem missing att" },
        { kErrorDsCantRemMissingAttVal, "DS can't rem missing att val" },
        { kErrorDsRootCantBeSubref, "DS root can't be subref" },
        { kErrorDsNoChaining, "DS no chaining" },
        { kErrorDsNoChainedEval, "DS no chained eval" },
        { kErrorDsNoParentObject, "DS no parent object" },
        { kErrorDsParentIsAnAlias, "DS parent is an alias" },
        { kErrorDsCantMixMasterAndReps, "DS can't mix master and reps" },
        { kErrorDsChildrenExist, "DS children exist" },
        { kErrorDsObjNotFound, "DS obj not found" },
        { kErrorDsAliasedObjMissing, "DS aliased obj missing" },
        { kErrorDsBadNameSyntax, "DS bad name syntax" },
        { kErrorDsAliasPointsToAlias, "DS alias points to alias" },
        { kErrorDsCantDerefAlias, "DS can't redef alias" },
        { kErrorDsOutOfScope, "DS out of scope" },
        { kErrorDsObjectBeingRemoved, "DS object being removed" },
        { kErrorDsCantDeleteDsaObj, "DS can't delete dsa obj" },
        { kErrorDsGenericError, "DS generic error" },
        { kErrorDsDsaMustBeIntMaster, "DS dsa must be int master" },
        { kErrorDsClassNotDsa, "DS class not dsa" },
        { kErrorDsInsuffAccessRights, "DS insuff access rights" },
        { kErrorDsIllegalSuperior, "DS illegal superior" },
        { kErrorDsAttributeOwnedBySam, "DS attribute owned by sam" },
        { kErrorDsNameTooManyParts, "DS name too many parts" },
        { kErrorDsNameTooLong, "DS name too long" },
        { kErrorDsNameValueTooLong, "DS name value too long" },
        { kErrorDsNameUnparseable, "DS name unparseable" },
        { kErrorDsNameTypeUnknown, "DS name type unknown" },
        { kErrorDsNotAnObject, "DS not an object" },
        { kErrorDsSecDescTooShort, "DS sec desc too short" },
        { kErrorDsSecDescInvalid, "DS sec desc invalid" },
        { kErrorDsNoDeletedName, "DS no deleted name" },
        { kErrorDsSubrefMustHaveParent, "DS subref must have parent" },
        { kErrorDsNcnameMustBeNc, "DS ncname must be nc" },
        { kErrorDsCantAddSystemOnly, "DS can't add system only" },
        { kErrorDsClassMustBeConcrete, "DS class must be concrete" },
        { kErrorDsInvalidDmd, "DS invalid dmd" },
        { kErrorDsObjGuidExists, "DS obj GUID exists" },
        { kErrorDsNotOnBacklink, "DS not on backlink" },
        { kErrorDsNoCrossrefForNc, "DS no crossref for nc" },
        { kErrorDsShuttingDown, "DS shutting down" },
        { kErrorDsUnknownOperation, "DS unknown operation" },
        { kErrorDsInvalidRoleOwner, "DS invalid role owner" },
        { kErrorDsCouldntContactFsmo, "DS couldn't contact fsmo" },
        { kErrorDsCrossNcDnRename, "DS cross nc dn rename" },
        { kErrorDsCantModSystemOnly, "DS can't mod system only" },
        { kErrorDsReplicatorOnly, "DS replicator only" },
        { kErrorDsObjClassNotDefined, "DS obj class not defined" },
        { kErrorDsObjClassNotSubclass, "DS obj class not subclass" },
        { kErrorDsNameReferenceInvalid, "DS name reference invalid" },
        { kErrorDsCrossRefExists, "DS cross ref exists" },
        { kErrorDsCantDelMasterCrossref, "DS can't del master crossref" },
        { kErrorDsSubtreeNotifyNotNcHead, "DS subtree notify not nc head" },
        { kErrorDsNotifyFilterTooComplex, "DS notify filter too complex" },
        { kErrorDsDupRdn, "DS dup rdn" },
        { kErrorDsDupOid, "DS dup oid" },
        { kErrorDsDupMapiId, "DS dup mapi ID" },
        { kErrorDsDupSchemaIdGuid, "DS dup schema ID GUID" },
        { kErrorDsDupLdapDisplayName, "DS dup LDAP display name" },
        { kErrorDsSemanticAttTest, "DS semantic att test" },
        { kErrorDsSyntaxMismatch, "DS syntax mismatch" },
        { kErrorDsExistsInMustHave, "DS exists in must have" },
        { kErrorDsExistsInMayHave, "DS exists in may have" },
        { kErrorDsNonexistentMayHave, "DS nonexistent may have" },
        { kErrorDsNonexistentMustHave, "DS nonexistent must have" },
        { kErrorDsAuxClsTestFail, "DS aux cls test fail" },
        { kErrorDsNonexistentPossSup, "DS nonexistent poss sup" },
        { kErrorDsSubClsTestFail, "DS sub cls test fail" },
        { kErrorDsBadRdnAttIdSyntax, "DS bad rdn att ID syntax" },
        { kErrorDsExistsInAuxCls, "DS exists in aux cls" },
        { kErrorDsExistsInSubCls, "DS exists in sub cls" },
        { kErrorDsExistsInPossSup, "DS exists in poss sup" },
        { kErrorDsRecalcschemaFailed, "DS recalcschema failed" },
        { kErrorDsTreeDeleteNotFinished, "DS tree delete not finished" },
        { kErrorDsCantDelete, "DS can't delete" },
        { kErrorDsAttSchemaReqId, "DS att schema req ID" },
        { kErrorDsBadAttSchemaSyntax, "DS bad att schema syntax" },
        { kErrorDsCantCacheAtt, "DS can't cache att" },
        { kErrorDsCantCacheClass, "DS can't cache class" },
        { kErrorDsCantRemoveAttCache, "DS can't remove att cache" },
        { kErrorDsCantRemoveClassCache, "DS can't remove class cache" },
        { kErrorDsCantRetrieveDn, "DS can't retrieve DN" },
        { kErrorDsMissingSupref, "DS missing supref" },
        { kErrorDsCantRetrieveInstance, "DS can't retrieve instance" },
        { kErrorDsCodeInconsistency, "DS code inconsistency" },
        { kErrorDsDatabaseError, "DS database error" },
        { kErrorDsGovernsidMissing, "DS governsid missing" },
        { kErrorDsMissingExpectedAtt, "DS missing expected att" },
        { kErrorDsNcnameMissingCrRef, "DS ncname missing cr ref" },
        { kErrorDsSecurityCheckingError, "DS security checking error" },
        { kErrorDsSchemaNotLoaded, "DS schema not loaded" },
        { kErrorDsSchemaAllocFailed, "DS schema alloc failed" },
        { kErrorDsAttSchemaReqSyntax, "DS att schema req syntax" },
        { kErrorDsGcverifyError, "DS gcverify error" },
        { kErrorDsDraSchemaMismatch, "DS dra schema mismatch" },
        { kErrorDsCantFindDsaObj, "DS can't find dsa obj" },
        { kErrorDsCantFindExpectedNc, "DS can't find expected nc" },
        { kErrorDsCantFindNcInCache, "DS can't find nc in cache" },
        { kErrorDsCantRetrieveChild, "DS can't retrieve child" },
        { kErrorDsSecurityIllegalModify, "DS security illegal modify" },
        { kErrorDsCantReplaceHiddenRec, "DS can't replace hidden rec" },
        { kErrorDsBadHierarchyFile, "DS bad hierarchy file" },
        { kErrorDsBuildHierarchyTableFailed, "DS build hierarchy table failed" },
        { kErrorDsConfigParamMissing, "DS config param missing" },
        { kErrorDsCountingAbIndicesFailed, "DS counting ab indices failed" },
        { kErrorDsHierarchyTableMallocFailed, "DS hierarchy table malloc failed" },
        { kErrorDsInternalFailure, "DS internal failure" },
        { kErrorDsUnknownError, "DS unknown error" },
        { kErrorDsRootRequiresClassTop, "DS root requires class top" },
        { kErrorDsRefusingFsmoRoles, "DS refusing fmso roles" },
        { kErrorDsMissingFsmoSettings, "DS missing fmso settings" },
        { kErrorDsUnableToSurrenderRoles, "DS unable to surrender roles" },
        { kErrorDsDraGeneric, "DS dra generic" },
        { kErrorDsDraInvalidParameter, "DS dra invalid parameter" },
        { kErrorDsDraBusy, "DS dra busy" },
        { kErrorDsDraBadDn, "DS dra bad dn" },
        { kErrorDsDraBadNc, "DS dra bad nc" },
        { kErrorDsDraDnExists, "DS dra dn exists" },
        { kErrorDsDraInternalError, "DS dra internal error" },
        { kErrorDsDraInconsistentDit, "DS dra inconsistent dit" },
        { kErrorDsDraConnectionFailed, "DS dra connection failed" },
        { kErrorDsDraBadInstanceType, "DS dra bad instance type" },
        { kErrorDsDraOutOfMem, "DS dra out of mem" },
        { kErrorDsDraMailProblem, "DS dra mail problem" },
        { kErrorDsDraRefAlreadyExists, "DS dra ref already exists" },
        { kErrorDsDraRefNotFound, "DS dra ref not found" },
        { kErrorDsDraObjIsRepSource, "DS dra obj is rep source" },
        { kErrorDsDraDbError, "DS dra db error" },
        { kErrorDsDraNoReplica, "DS dra no replica" },
        { kErrorDsDraAccessDenied, "DS dra access denied" },
        { kErrorDsDraNotSupported, "DS dra not supported" },
        { kErrorDsDraRpcCancelled, "DS dra RPC cancelled" },
        { kErrorDsDraSourceDisabled, "DS dra source disabled" },
        { kErrorDsDraSinkDisabled, "DS dra sink disabled" },
        { kErrorDsDraNameCollision, "DS dra name collision" },
        { kErrorDsDraSourceReinstalled, "DS dra source reinstalled" },
        { kErrorDsDraMissingParent, "DS dra missing parent" },
        { kErrorDsDraPreempted, "DS dra preempted" },
        { kErrorDsDraAbandonSync, "DS dra abandon sync" },
        { kErrorDsDraShutdown, "DS dra shutdown" },
        { kErrorDsDraIncompatiblePartialSet, "DS dra incompatible partial set" },
        { kErrorDsDraSourceIsPartialReplica, "DS dra source is partial replica" },
        { kErrorDsDraExtnConnectionFailed, "DS dra extn connection failed" },
        { kErrorDsInstallSchemaMismatch, "DS install schema mismatch" },
        { kErrorDsDupLinkId, "DS dup link ID" },
        { kErrorDsNameErrorResolving, "DS name error resolving" },
        { kErrorDsNameErrorNotFound, "DS name error not found" },
        { kErrorDsNameErrorNotUnique, "DS name error not unique" },
        { kErrorDsNameErrorNoMapping, "DS name error no mapping" },
        { kErrorDsNameErrorDomainOnly, "DS name error domain only" },
        { kErrorDsNameErrorNoSyntacticalMapping, "DS name error no syntactical mapping" },
        { kErrorDsConstructedAttMod, "DS constructed att mod" },
        { kErrorDsWrongOmObjClass, "DS wrong om obj class" },
        { kErrorDsDraReplPending, "DS dra repl pending" },
        { kErrorDsDsRequired, "DS ds required" },
        { kErrorDsInvalidLdapDisplayName, "DS invalid LDAP display name" },
        { kErrorDsNonBaseSearch, "DS non base search" },
        { kErrorDsCantRetrieveAtts, "DS can't retrieve atts" },
        { kErrorDsBacklinkWithoutLink, "DS backlink without link" },
        { kErrorDsEpochMismatch, "DS epoch mismatch" },
        { kErrorDsSrcNameMismatch, "DS src name mismatch" },
        { kErrorDsSrcAndDstNcIdentical, "DS src and dst nc identical" },
        { kErrorDsDstNcMismatch, "DS dst nc mismatch" },
        { kErrorDsNotAuthoritiveForDstNc, "DS not authoritive for dst nc" },
        { kErrorDsSrcGuidMismatch, "DS src GUID mismatch" },
        { kErrorDsCantMoveDeletedObject, "DS can't move deleted object" },
        { kErrorDsPdcOperationInProgress, "DS pdc operation in progress" },
        { kErrorDsCrossDomainCleanupReqd, "DS cross domain cleanup reqd" },
        { kErrorDsIllegalXdomMoveOperation, "DS illegal xdom move operation" },
        { kErrorDsCantWithAcctGroupMembershps, "DS can't with acct group membershps" },
        { kErrorDsNcMustHaveNcParent, "DS nc must have nc parent" },
        { kErrorDsDstDomainNotNative, "DS dst domain not native" },
        { kErrorDsMissingInfrastructureContainer, "DS missing infrastructure container" },
        { kErrorDsCantMoveAccountGroup, "DS can't move account group" },
        { kErrorDsCantMoveResourceGroup, "DS can't move resource group" },
        { kErrorDsInvalidSearchFlag, "DS invalid search flag" },
        { kErrorDsNoTreeDeleteAboveNc, "DS no tree delete above nc" },
        { kErrorDsCouldntLockTreeForDelete, "DS couldn't lock tree for delete" },
        { kErrorDsCouldntIdentifyObjectsForTreeDelete, "DS couldn't identify objects for tree delete" },
        { kErrorDsSamInitFailure, "DS sam init failure" },
        { kErrorDsSensitiveGroupViolation, "DS sensitive group violation" },
        { kErrorDsCantModPrimarygroupid, "DS can't mod primarygroupid" },
        { kErrorDsIllegalBaseSchemaMod, "DS illegal base schema mod" },
        { kErrorDsNonsafeSchemaChange, "DS nonsafe schema change" },
        { kErrorDsSchemaUpdateDisallowed, "DS schema update disallowed" },
        { kErrorDsCantCreateUnderSchema, "DS can't create under schema" },
        { kErrorDsInstallNoSrcSchVersion, "DS install no src sch version" },
        { kErrorDsInstallNoSchVersionInInifile, "DS install no sch version in inifile" },
        { kErrorDsInvalidGroupType, "DS invalid group type" },
        { kErrorDsNoNestGlobalgroupInMixeddomain, "DS no nest globalgroup in mixeddomain" },
        { kErrorDsNoNestLocalgroupInMixeddomain, "DS no nest localgroup in mixeddomain" },
        { kErrorDsGlobalCantHaveLocalMember, "DS global can't have local member" },
        { kErrorDsGlobalCantHaveUniversalMember, "DS global can't have universal member" },
        { kErrorDsUniversalCantHaveLocalMember, "DS universal can't have local member" },
        { kErrorDsGlobalCantHaveCrossdomainMember, "DS global can't have crossdomain member" },
        { kErrorDsLocalCantHaveCrossdomainLocalMember, "DS local can't have crossdomain local member" },
        { kErrorDsHavePrimaryMembers, "DS have primary members" },
        { kErrorDsStringSdConversionFailed, "DS string sd conversion failed" },
        { kErrorDsNamingMasterGc, "DS naming master gc" },
        { kErrorDsLookupFailure, "DS lookup failure" },
        { kErrorDsCouldntUpdateSpns, "DS couldn't update spns" },
        { kErrorDsCantRetrieveSd, "DS can't retrieve sd" },
        { kErrorDsKeyNotUnique, "DS key not unique" },
        { kErrorDsWrongLinkedAttSyntax, "DS wrong linked att syntax" },
        { kErrorDsSamNeedBootkeyPassword, "DS sam need bootkey password" },
        { kErrorDsSamNeedBootkeyFloppy, "DS sam need bootkey floppy" },
        { kErrorDsCantStart, "DS can't start" },
        { kErrorDsInitFailure, "DS init failure" },
        { kErrorDsNoPktPrivacyOnConnection, "DS no pkt privacy on connection" },
        { kErrorDsSourceDomainInForest, "DS source domain in forest" },
        { kErrorDsDestinationDomainNotInForest, "DS destination domain not in forest" },
        { kErrorDsDestinationAuditingNotEnabled, "DS destination auditing not enabled" },
        { kErrorDsCantFindDcForSrcDomain, "DS can't find dc for src domain" },
        { kErrorDsSrcObjNotGroupOrUser, "DS src obj not group or user" },
        { kErrorDsSrcSidExistsInForest, "DS src sid exists in forest" },
        { kErrorDsSrcAndDstObjectClassMismatch, "DS src and dst object class mismatch" },
        { kErrorSamInitFailure, "Sam init failure" },
        { kErrorDsDraSchemaInfoShip, "DS dra schema info ship" },
        { kErrorDsDraSchemaConflict, "DS dra schema conflict" },
        { kErrorDsDraEarlierSchemaConlict, "DS dra earlier schema conflict" },
        { kErrorDsDraObjNcMismatch, "DS dra obj nc mismatch" },
        { kErrorDsNcStillHasDsas, "DS nc still has dsas" },
        { kErrorDsGcRequired, "DS gc required" },
        { kErrorDsLocalMemberOfLocalOnly, "DS local member of local only" },
        { kErrorDsNoFpoInUniversalGroups, "DS no fpo in universal groups" },
        { kErrorDsCantAddToGc, "DS can't add to gc" },
        { kErrorDsNoCheckpointWithPdc, "DS no checkpoint with pdc" },
        { kErrorDsSourceAuditingNotEnabled, "DS source auditing not enabled" },
        { kErrorDsCantCreateInNondomainNc, "DS can't create in nondomain nc" },
        { kErrorDsInvalidNameForSpn, "DS invalid name for spn" },
        { kErrorDsFilterUsesContructedAttrs, "DS filter uses constructed attrs" },
        { kErrorDsUnicodepwdNotInQuotes, "DS unicodepwd not in quotes" },
        { kErrorDsMachineAccountQuotaExceeded, "DS machine account quota exceeded" },
        { kErrorDsMustBeRunOnDstDc, "DS must be run on dst dc" },
        { kErrorDsSrcDcMustBeSp4OrGreater, "DS src dc must be sp4 or greater" },
        { kErrorDsCantTreeDeleteCriticalObj, "DS can't tree delete critical obj" },
        { kErrorDsInitFailureConsole, "DS init failure console" },
        { kErrorDsSamInitFailureConsole, "DS sam init failure console" },
        { kErrorDsForestVersionTooHigh, "DS forest version too high" },
        { kErrorDsDomainVersionTooHigh, "DS domain version too high" },
        { kErrorDsForestVersionTooLow, "DS forest version too low" },
        { kErrorDsDomainVersionTooLow, "DS domain version too low" },
        { kErrorDsIncompatibleVersion, "DS incompatible version" },
        { kErrorDsLowDsaVersion, "DS low dsa version" },
        { kErrorDsNoBehaviorVersionInMixeddomain, "DS no behaviour version in mixeddomain" },
        { kErrorDsNotSupportedSortOrder, "DS not supported sort order" },
        { kErrorDsNameNotUnique, "DS name not unique" },
        { kErrorDsMachineAccountCreatedPrent4, "DS machine account created prent4" },
        { kErrorDsOutOfVersionStore, "DS out of version store" },
        { kErrorDsIncompatibleControlsUsed, "DS incompatible controls used" },
        { kErrorDsNoRefDomain, "DS no ref domain" },
        { kErrorDsReservedLinkId, "DS reserved link ID" },
        { kErrorDsLinkIdNotAvailable, "DS link ID not available" },
        { kErrorDsAgCantHaveUniversalMember, "DS ag can't have universal member" },
        { kErrorDsModifydnDisallowedByInstanceType, "DS modifydn disallowed by instance type" },
        { kErrorDsNoObjectMoveInSchemaNc, "DS no object move in schema nc" },
        { kErrorDsModifydnDisallowedByFlag, "DS modifydn disallowed by flag" },
        { kErrorDsModifydnWrongGrandparent, "DS modifydn wrong grandparent" },
        { kErrorDsNameErrorTrustReferral, "DS name error trust referral" },
        { kErrorNotSupportedOnStandardServer, "Not supported on standard server" },
        { kErrorDsCantAccessRemotePartOfAd, "DS can't access remote part of ad" },
        { kErrorDsCrImpossibleToValidate, "DS cr impossible to validate" },
        { kErrorDsThreadLimitExceeded, "DS thread limit exceeded" },
        { kErrorDsNotClosest, "DS not closest" },
        { kErrorDsCantDeriveSpnWithoutServerRef, "DS can't derive spn without server ref" },
        { kErrorDsSingleUserModeFailed, "DS single user mode failed" },
        { kErrorDsNtdscriptSyntaxError, "DS ntdscript syntax error" },
        { kErrorDsNtdscriptProcessError, "DS ntdscript process error" },
        { kErrorDsDifferentReplEpochs, "DS different repl epochs" },
        { kErrorDsDrsExtensionsChanged, "DS drs extensions changed" },
        { kErrorDsReplicaSetChangeNotAllowedOnDisabledCr, "DS replica set change not allowed on disabled cr" },
        { kErrorDsNoMsdsIntid, "DS no msds intid" },
        { kErrorDsDupMsdsIntid, "DS dup msds intid" },
        { kErrorDsExistsInRdnattid, "DS exists in rdnattid" },
        { kErrorDsAuthorizationFailed, "DS authorisation failed" },
        { kErrorDsInvalidScript, "DS invalid script" },
        { kErrorDsRemoteCrossrefOpFailed, "DS remote crossref op failed" },
        { kDnsErrorRcodeFormatError, "DNS error rcode format error" },
        { kDnsErrorRcodeServerFailure, "DNS error rcode server failure" },
        { kDnsErrorRcodeNameError, "DNS error rcode name error" },
        { kDnsErrorRcodeNotImplemented, "DNS error rcode not implemented" },
        { kDnsErrorRcodeRefused, "DNS error rcode refused" },
        { kDnsErrorRcodeYxdomain, "DNS error rcode yxdomain" },
        { kDnsErrorRcodeYxrrset, "DNS error rcode yxrrset" },
        { kDnsErrorRcodeNxrrset, "DNS error rcode nxrrset" },
        { kDnsErrorRcodeNotauth, "DNS error rcode notauth" },
        { kDnsErrorRcodeNotzone, "DNS error rcode notzone" },
        { kDnsErrorRcodeBadsig, "DNS error rcode badsig" },
        { kDnsErrorRcodeBadkey, "DNS error rcode badkey" },
        { kDnsErrorRcodeBadtime, "DNS error rcode badtime" },
        { kDnsInfoNoRecords, "DNS info no records" },
        { kDnsErrorBadPacket, "DNS error bad packet" },
        { kDnsErrorNoPacket, "DNS error no packet" },
        { kDnsErrorRcode, "DNS error rcode" },
        { kDnsErrorUnsecurePacket, "DNS error unsecure packet" },
        { kDnsErrorInvalidType, "DNS error invalid type" },
        { kDnsErrorInvalidIpAddress, "DNS error invalid IP address" },
        { kDnsErrorInvalidProperty, "DNS error invalid property" },
        { kDnsErrorTryAgainLater, "DNS error try again later" },
        { kDnsErrorNotUnique, "DNS error not unique" },
        { kDnsErrorNonRfcName, "DNS error non RFC name" },
        { kDnsStatusFqdn, "DNS status FQDN" },
        { kDnsStatusDottedName, "DNS status dotted name" },
        { kDnsStatusSinglePartName, "DNS status single part name" },
        { kDnsErrorInvalidNameChar, "DNS error invalid name char" },
        { kDnsErrorNumericName, "DNS error numeric name" },
        { kDnsErrorNotAllowedOnRootServer, "DNS error not allowed on root server" },
        { kDnsErrorZoneDoesNotExist, "DNS error zone does not exist" },
        { kDnsErrorNoZoneInfo, "DNS error not zone info" },
        { kDnsErrorInvalidZoneOperation, "DNS error invalid zone operation" },
        { kDnsErrorZoneConfigurationError, "DNS error zone configuration error" },
        { kDnsErrorZoneHasNoSoaRecord, "DNS error zone has not SOA record" },
        { kDnsErrorZoneHasNoNsRecords, "DNS error zone has no NS records" },
        { kDnsErrorZoneLocked, "DNS error zone locked" },
        { kDnsErrorZoneCreationFailed, "DNS error zone creation failed" },
        { kDnsErrorZoneAlreadyExists, "DNS error zone already exists" },
        { kDnsErrorAutozoneAlreadyExists, "DNS error autozone already exists" },
        { kDnsErrorInvalidZoneType, "DNS error invalid zone type" },
        { kDnsErrorSecondaryRequiresMasterIp, "DNS error secondary requires master IP" },
        { kDnsErrorZoneNotSecondary, "DNS error zone not secondary" },
        { kDnsErrorNeedSecondaryAddresses, "DNS error need secondary addresses" },
        { kDnsErrorWinsInitFailed, "DNS error wins init failed" },
        { kDnsErrorNeedWinsServers, "DNS error need wins servers" },
        { kDnsErrorNbstatInitFailed, "DNS error nbstat init failed" },
        { kDnsErrorSoaDeleteInvalid, "DNS error SOA delete invalid" },
        { kDnsErrorForwarderAlreadyExists, "DNS error forwarder already exists" },
        { kDnsErrorZoneRequiresMasterIp, "DNS error zone requires master IP" },
        { kDnsErrorZoneIsShutdown, "DNS error zone is shutdown" },
        { kDnsErrorPrimaryRequiresDatafile, "DNS error primary requires datafile" },
        { kDnsErrorInvalidDatafileName, "DNS error invalid datafile name" },
        { kDnsErrorDatafileOpenFailure, "DNS error datafile open failure" },
        { kDnsErrorFileWritebackFailed, "DNS error file writeback failed" },
        { kDnsErrorDatafileParsing, "DNS error datafile parsing" },
        { kDnsErrorRecordDoesNotExist, "DNS error record does not exist" },
        { kDnsErrorRecordFormat, "DNS error record format" },
        { kDnsErrorNodeCreationFailed, "DNS error node creation failed" },
        { kDnsErrorUnknownRecordType, "DNS error unknown record type" },
        { kDnsErrorRecordTimedOut, "DNS error record timed out" },
        { kDnsErrorNameNotInZone, "DNS error name not in zone" },
        { kDnsErrorCnameLoop, "DNS error CNAME loop" },
        { kDnsErrorNodeIsCname, "DNS error node is CNAME" },
        { kDnsErrorCnameCollision, "DNS error CNAME collision" },
        { kDnsErrorRecordOnlyAtZoneRoot, "DNS error record only at zone root" },
        { kDnsErrorRecordAlreadyExists, "DNS error record already exists" },
        { kDnsErrorSecondaryData, "DNS error secondary data" },
        { kDnsErrorNoCreateCacheData, "DNS error no create cache data" },
        { kDnsErrorNameDoesNotExist, "DNS error name does not exist" },
        { kDnsWarningPtrCreateFailed, "DNS warning PTR create failed" },
        { kDnsWarningDomainUndeleted, "DNS warning domain undeleted" },
        { kDnsErrorDsUnavailable, "DNS error ds unavailable" },
        { kDnsErrorDsZoneAlreadyExists, "DNS error ds zone already exists" },
        { kDnsErrorNoBootfileIfDsZone, "DNS error no bootfile if ds zone" },
        { kDnsInfoAxfrComplete, "DNS info AXFR complete" },
        { kDnsErrorAxfr, "DNS error AXFR" },
        { kDnsInfoAddedLocalWins, "DNS info added local wins" },
        { kDnsStatusContinueNeeded, "DNS status continue needed" },
        { kDnsErrorNoTcpip, "DNS error no TCPIP" },
        { kDnsErrorNoDnsServers, "DNS error no DNS servers" },
        { kDnsErrorDpDoesNotExist, "DNS error dp does not exist" },
        { kDnsErrorDpAlreadyExists, "DNS error dp already exists" },
        { kDnsErrorDpNotEnlisted, "DNS error dp not enlisted" },
        { kDnsErrorDpAlreadyEnlisted, "DNS error dp already enlisted" },
        { kWSAQosReceivers, "QOS receivers" },
        { kWSAQosSenders, "QOS senders" },
        { kWSAQosNoSenders, "QOS no senders" },
        { kWSAQosNoReceivers, "QOS no receivers" },
        { kWSAQosRequestConfirmed, "QOS request confirmed" },
        { kWSAQosAdmissionFailure, "QOS admission failure" },
        { kWSAQosPolicyFailure, "QOS policy failure" },
        { kWSAQosBadStyle, "QOS bad style" },
        { kWSAQosBadObject, "QOS bad object" },
        { kWSAQosTrafficCtrlError, "QOS traffic ctrl error" },
        { kWSAQosGenericError, "QOS generic error" },
        { kWSAQosEservicetype, "QOS eservicetype" },
        { kWSAQosEflowspec, "QOS eflowspec" },
        { kWSAQosEprovspecbuf, "QOS eprovspecbuf" },
        { kWSAQosEfilterstyle, "QOS efilterstyle" },
        { kWSAQosEfiltertype, "QOS efiltertype" },
        { kWSAQosEfiltercount, "QOS efiltercount" },
        { kWSAQosEobjlength, "QOS eobjlength" },
        { kWSAQosEflowcount, "QOS eflowcount" },
        { kWSAQosEunknownpsobj, "QOS eunknownpsobj" },
        { kWSAQosEpolicyobj, "QOS epolicyobj" },
        { kWSAQosEflowdesc, "QOS eflowdesc" },
        { kWSAQosEpsflowspec, "QOS epsflowspec" },
        { kWSAQosEpsfilterspec, "QOS epsfilterspec" },
        { kWSAQosEsdmodeobj, "QOS esdmodeobj" },
        { kWSAQosEshaperateobj, "QOS eshaperateobj" },
        { kWSAQosReservedPetype, "QOS reserved petype" },
        { kErrorIpsecQmPolicyExists, "IPSEC qm policy exists" },
        { kErrorIpsecQmPolicyNotFound, "IPSEC qm policy not found" },
        { kErrorIpsecQmPolicyInUse, "IPSEC qm policy in use" },
        { kErrorIpsecMmPolicyExists, "IPSEC mm policy exists" },
        { kErrorIpsecMmPolicyNotFound, "IPSEC mm policy not found" },
        { kErrorIpsecMmPolicyInUse, "IPSEC mm policy in use" },
        { kErrorIpsecMmFilterExists, "IPSEC mm filter exists" },
        { kErrorIpsecMmFilterNotFound, "IPSEC mm filter not found" },
        { kErrorIpsecTransportFilterExists, "IPSEC transport filter exists" },
        { kErrorIpsecTransportFilterNotFound, "IPSEC transport filter not found" },
        { kErrorIpsecMmAuthExists, "IPSEC mm auth exists" },
        { kErrorIpsecMmAuthNotFound, "IPSEC mm auth not found" },
        { kErrorIpsecMmAuthInUse, "IPSEC mm auth in use" },
        { kErrorIpsecDefaultMmPolicyNotFound, "IPSEC default mm policy not found" },
        { kErrorIpsecDefaultMmAuthNotFound, "IPSEC default mm auth not found" },
        { kErrorIpsecDefaultQmPolicyNotFound, "IPSEC default qm policy not found" },
        { kErrorIpsecTunnelFilterExists, "IPSEC tunnel filter exists" },
        { kErrorIpsecTunnelFilterNotFound, "IPSEC tunnel filter not found" },
        { kErrorIpsecMmFilterPendingDeletion, "IPSEC mm filter pending deletion" },
        { kErrorIpsecTransportFilterPendingDeletion, "IPSEC transport filter pending deletion" },
        { kErrorIpsecTunnelFilterPendingDeletion, "IPSEC tunnel filter pending deletion" },
        { kErrorIpsecMmPolicyPendingDeletion, "IPSEC mm policy pending deletion" },
        { kErrorIpsecMmAuthPendingDeletion, "IPSEC mm auth pending deletion" },
        { kErrorIpsecQmPolicyPendingDeletion, "IPSEC qm policy pending deletion" },
        { kErrorIpsecIkeAuthFail, "IPSEC IKE auth fail" },
        { kErrorIpsecIkeAttribFail, "IPSEC IKE attrib fail" },
        { kErrorIpsecIkeNegotiationPending, "IPSEC IKE negotiation pending" },
        { kErrorIpsecIkeGeneralProcessingError, "IPSEC IKE general processing error" },
        { kErrorIpsecIkeTimedOut, "IPSEC IKE timed out" },
        { kErrorIpsecIkeNoCert, "IPSEC IKE no cert" },
        { kErrorIpsecIkeSaDeleted, "IPSEC IKE sa deleted" },
        { kErrorIpsecIkeSaReaped, "IPSEC IKE sa reaped" },
        { kErrorIpsecIkeMmAcquireDrop, "IPSEC IKE mm acquire drop" },
        { kErrorIpsecIkeQmAcquireDrop, "IPSEC IKE qm acquire drop" },
        { kErrorIpsecIkeQueueDropMm, "IPSEC IKE queue drop mm" },
        { kErrorIpsecIkeQueueDropNoMm, "IPSEC IKE queue drop no mm" },
        { kErrorIpsecIkeDropNoResponse, "IPSEC IKE drop no response" },
        { kErrorIpsecIkeMmDelayDrop, "IPSEC IKE mm delay drop" },
        { kErrorIpsecIkeQmDelayDrop, "IPSEC IKE qm delay drop" },
        { kErrorIpsecIkeError, "IPSEC IKE error" },
        { kErrorIpsecIkeCrlFailed, "IPSEC IKE crl failed" },
        { kErrorIpsecIkeInvalidKeyUsage, "IPSEC IKE invalid key usage" },
        { kErrorIpsecIkeInvalidCertType, "IPSEC IKE invalid cert type" },
        { kErrorIpsecIkeNoPrivateKey, "IPSEC IKE no private key" },
        { kErrorIpsecIkeDhFail, "IPSEC IKE dh fail" },
        { kErrorIpsecIkeInvalidHeader, "IPSEC IKE invalid header" },
        { kErrorIpsecIkeNoPolicy, "IPSEC IKE no policy" },
        { kErrorIpsecIkeInvalidSignature, "IPSEC IKE invalid signature" },
        { kErrorIpsecIkeKerberosError, "IPSEC IKE kerberos error" },
        { kErrorIpsecIkeNoPublicKey, "IPSEC IKE no public key" },
        { kErrorIpsecIkeProcessErr, "IPSEC IKE process err" },
        { kErrorIpsecIkeProcessErrSa, "IPSEC IKE process err sa" },
        { kErrorIpsecIkeProcessErrProp, "IPSEC IKE process err prop" },
        { kErrorIpsecIkeProcessErrTrans, "IPSEC IKE process err trans" },
        { kErrorIpsecIkeProcessErrKe, "IPSEC IKE process err ke" },
        { kErrorIpsecIkeProcessErrId, "IPSEC IKE process err ID" },
        { kErrorIpsecIkeProcessErrCert, "IPSEC IKE process err cert" },
        { kErrorIpsecIkeProcessErrCertReq, "IPSEC IKE process err cert req" },
        { kErrorIpsecIkeProcessErrHash, "IPSEC IKE process err hash" },
        { kErrorIpsecIkeProcessErrSig, "IPSEC IKE process err sig" },
        { kErrorIpsecIkeProcessErrNonce, "IPSEC IKE process err nonce" },
        { kErrorIpsecIkeProcessErrNotify, "IPSEC IKE process err notify" },
        { kErrorIpsecIkeProcessErrDelete, "IPSEC IKE process err delete" },
        { kErrorIpsecIkeProcessErrVendor, "IPSEC IKE process err vendor" },
        { kErrorIpsecIkeInvalidPayload, "IPSEC IKE invalid payload" },
        { kErrorIpsecIkeLoadSoftSa, "IPSEC IKE load soft sa" },
        { kErrorIpsecIkeSoftSaTornDown, "IPSEC IKE soft sa torn down" },
        { kErrorIpsecIkeInvalidCookie, "IPSEC IKE invalid cookie" },
        { kErrorIpsecIkeNoPeerCert, "IPSEC IKE no peer cert" },
        { kErrorIpsecIkePeerCrlFailed, "IPSEC IKE peer CRL failed" },
        { kErrorIpsecIkePolicyChange, "IPSEC IKE policy change" },
        { kErrorIpsecIkeNoMmPolicy, "IPSEC IKE no mm policy" },
        { kErrorIpsecIkeNotcbpriv, "IPSEC IKE notcbpriv" },
        { kErrorIpsecIkeSecloadfail, "IPSEC IKE secloadfail" },
        { kErrorIpsecIkeFailsspinit, "IPSEC IKE failsspinit" },
        { kErrorIpsecIkeFailqueryssp, "IPSEC IKE failqueryssp" },
        { kErrorIpsecIkeSrvacqfail, "IPSEC IKE srvacqfail" },
        { kErrorIpsecIkeSrvquerycred, "IPSEC IKE srvquerycred" },
        { kErrorIpsecIkeGetspifail, "IPSEC IKE getspifail" },
        { kErrorIpsecIkeInvalidFilter, "IPSEC IKE invalid filter" },
        { kErrorIpsecIkeOutOfMemory, "IPSEC IKE out of memory" },
        { kErrorIpsecIkeAddUpdateKeyFailed, "IPSEC IKE add update key failed" },
        { kErrorIpsecIkeInvalidPolicy, "IPSEC IKE invalid policy" },
        { kErrorIpsecIkeUnknownDoi, "IPSEC IKE unknown doi" },
        { kErrorIpsecIkeInvalidSituation, "IPSEC IKE invalid situation" },
        { kErrorIpsecIkeDhFailure, "IPSEC IKE dh failure" },
        { kErrorIpsecIkeInvalidGroup, "IPSEC IKE invalid group" },
        { kErrorIpsecIkeEncrypt, "IPSEC IKE encrypt" },
        { kErrorIpsecIkeDecrypt, "IPSEC IKE decrypt" },
        { kErrorIpsecIkePolicyMatch, "IPSEC IKE policy match" },
        { kErrorIpsecIkeUnsupportedId, "IPSEC IKE unsupported ID" },
        { kErrorIpsecIkeInvalidHash, "IPSEC IKE invalid hash" },
        { kErrorIpsecIkeInvalidHashAlg, "IPSEC IKE invalid hash alg" },
        { kErrorIpsecIkeInvalidHashSize, "IPSEC IKE invalid hash size" },
        { kErrorIpsecIkeInvalidEncryptAlg, "IPSEC IKE invalid encrypt alg" },
        { kErrorIpsecIkeInvalidAuthAlg, "IPSEC IKE invalid auth alg" },
        { kErrorIpsecIkeInvalidSig, "IPSEC IKE invalid sig" },
        { kErrorIpsecIkeLoadFailed, "IPSEC IKE load failed" },
        { kErrorIpsecIkeRpcDelete, "IPSEC IKE rpc delete" },
        { kErrorIpsecIkeBenignReinit, "IPSEC IKE benign reinit" },
        { kErrorIpsecIkeInvalidResponderLifetimeNotify, "IPSEC IKE invalid responder lifetime notify" },
        { kErrorIpsecIkeInvalidCertKeylen, "IPSEC IKE invalid cert keylen" },
        { kErrorIpsecIkeMmLimit, "IPSEC IKE mm limit" },
        { kErrorIpsecIkeNegotiationDisabled, "IPSEC IKE negotiation disabled" },
        { kErrorIpsecIkeNegStatusEnd, "IPSEC IKE neg status end" },
        { kErrorSxsSectionNotFound, "Sxs section not found" },
        { kErrorSxsCantGenActctx, "Sxs can't gen actctx" },
        { kErrorSxsInvalidActctxdataFormat, "Sxs invalid actctxdata format" },
        { kErrorSxsAssemblyNotFound, "Sxs assembly not found" },
        { kErrorSxsManifestFormatError, "Sxs manifest format error" },
        { kErrorSxsManifestParseError, "Sxs manifest parse error" },
        { kErrorSxsActivationContextDisabled, "Sxs activation context disabled" },
        { kErrorSxsKeyNotFound, "Sxs key not found" },
        { kErrorSxsVersionConflict, "Sxs version conflict" },
        { kErrorSxsWrongSectionType, "Sxs wrong section type" },
        { kErrorSxsThreadQueriesDisabled, "Sxs thread queries disabled" },
        { kErrorSxsProcessDefaultAlreadySet, "Sxs process default already set" },
        { kErrorSxsUnknownEncodingGroup, "Sxs unknown encoding group" },
        { kErrorSxsUnknownEncoding, "Sxs unknown encoding" },
        { kErrorSxsInvalidXmlNamespaceUri, "Sxs invalid XML namespace URI" },
        { kErrorSxsRootManifestDependencyNotInstalled, "Sxs root manifest dependency not installed" },
        { kErrorSxsLeafManifestDependencyNotInstalled, "Sxs leaf manifest dependency not installed" },
        { kErrorSxsInvalidAssemblyIdentityAttribute, "Sxs invalid assembly indentity attribute" },
        { kErrorSxsManifestMissingRequiredDefaultNamespace, "Sxs manifest missing required default namespace" },
        { kErrorSxsManifestInvalidRequiredDefaultNamespace, "Sxs manifest invalid required default namespace" },
        { kErrorSxsPrivateManifestCrossPathWithReparsePoint, "Sxs private manifest cross path with reparse point" },
        { kErrorSxsDuplicateDllName, "Sxs duplicate dll name" },
        { kErrorSxsDuplicateWindowclassName, "Sxs duplicate windowclass name" },
        { kErrorSxsDuplicateClsid, "Sxs duplicate clsid" },
        { kErrorSxsDuplicateIid, "Sxs duplicate iid" },
        { kErrorSxsDuplicateTlbid, "Sxs duplicate tlbid" },
        { kErrorSxsDuplicateProgid, "Sxs duplicate progid" },
        { kErrorSxsDuplicateAssemblyName, "Sxs duplicate assembly name" },
        { kErrorSxsFileHashMismatch, "Sxs file hash mismatch" },
        { kErrorSxsPolicyParseError, "Sxs policy parse error" },
        { kErrorSxsXmlEMissingquote, "Sxs XML e missingquote" },
        { kErrorSxsXmlECommentsyntax, "Sxs XML e commentsyntax" },
        { kErrorSxsXmlEBadstartnamechar, "Sxs XML e badstartnamechar" },
        { kErrorSxsXmlEBadnamechar, "Sxs XML e badnamechar" },
        { kErrorSxsXmlEBadcharinstring, "Sxs XML e badcharinstring" },
        { kErrorSxsXmlEXmldeclsyntax, "Sxs XML e xmldeclsyntax" },
        { kErrorSxsXmlEBadchardata, "Sxs XML e badchardata" },
        { kErrorSxsXmlEMissingwhitespace, "Sxs XML e missingwhitespace" },
        { kErrorSxsXmlEExpectingtagend, "Sxs XML e expectingtagend" },
        { kErrorSxsXmlEMissingsemicolon, "Sxs XML e missingsemicolon" },
        { kErrorSxsXmlEUnbalancedparen, "Sxs XML e unbalancedparen" },
        { kErrorSxsXmlEInternalerror, "Sxs XML e internalerror" },
        { kErrorSxsXmlEUnexpectedWhitespace, "Sxs XML e unexpected whitespace" },
        { kErrorSxsXmlEIncompleteEncoding, "Sxs XML e incomplete encoding" },
        { kErrorSxsXmlEMissingParen, "Sxs XML e missing paren" },
        { kErrorSxsXmlEExpectingclosequote, "Sxs XML e expectingclosequote" },
        { kErrorSxsXmlEMultipleColons, "Sxs XML e multiple colons" },
        { kErrorSxsXmlEInvalidDecimal, "Sxs XML e invalid decimal" },
        { kErrorSxsXmlEInvalidHexidecimal, "Sxs XML e invalid hexidecimal" },
        { kErrorSxsXmlEInvalidUnicode, "Sxs XML e invalid unicode" },
        { kErrorSxsXmlEWhitespaceorquestionmark, "Sxs XML e whitespaceorquestionmark" },
        { kErrorSxsXmlEUnexpectedendtag, "Sxs XML e unexpectedendtag" },
        { kErrorSxsXmlEUnclosedtag, "Sxs XML e unclosedtag" },
        { kErrorSxsXmlEDuplicateattribute, "Sxs XML e duplicateattribute" },
        { kErrorSxsXmlEMultipleroots, "Sxs XML e multipleroots" },
        { kErrorSxsXmlEInvalidatrootlevel, "Sxs XML e invalidatrootlevel" },
        { kErrorSxsXmlEBadxmldecl, "Sxs XML e badxmldecl" },
        { kErrorSxsXmlEMissingroot, "Sxs XML e missingroot" },
        { kErrorSxsXmlEUnexpectedeof, "Sxs XML e unexpectedeof" },
        { kErrorSxsXmlEBadperefinsubset, "Sxs XML e badperefinsubset" },
        { kErrorSxsXmlEUnclosedstarttag, "Sxs XML e unclosedstarttag" },
        { kErrorSxsXmlEUnclosedendtag, "Sxs XML e unclosedendtag" },
        { kErrorSxsXmlEUnclosedstring, "Sxs XML e unclosedstring" },
        { kErrorSxsXmlEUnclosedcomment, "Sxs XML e unclosedcomment" },
        { kErrorSxsXmlEUncloseddecl, "Sxs XML e uncloseddecl" },
        { kErrorSxsXmlEUnclosedcdata, "Sxs XML e unclosedcdata" },
        { kErrorSxsXmlEReservednamespace, "Sxs XML e reservednamespace" },
        { kErrorSxsXmlEInvalidencoding, "Sxs XML e invalidencoding" },
        { kErrorSxsXmlEInvalidswitch, "Sxs XML e invalidswitch" },
        { kErrorSxsXmlEBadxmlcase, "Sxs XML e badxmlcase" },
        { kErrorSxsXmlEInvalidStandalone, "Sxs XML e invalid standalone" },
        { kErrorSxsXmlEUnexpectedStandalone, "Sxs XML e unexpected standalone" },
        { kErrorSxsXmlEInvalidVersion, "Sxs XML e invalid version" },
        { kErrorSxsXmlEMissingequals, "Sxs XML e missingequals" },
        { kErrorSxsProtectionRecoveryFailed, "Sxs protection recovery failed" },
        { kErrorSxsProtectionPublicKeyTooShort, "Sxs protection public key too short" },
        { kErrorSxsProtectionCatalogNotValid, "Sxs protection catalog not valid" },
        { kErrorSxsUntranslatableHresult, "Sxs untranslatable hresult" },
        { kErrorSxsProtectionCatalogFileMissing, "Sxs protection catalog file missing" },
        { kErrorSxsMissingAssemblyIdentityAttribute, "Sxs missing assembly identity attribute" },
        { kErrorSxsInvalidAssemblyIdentityAttributeName, "Sxs invalid assembly identity attribute name" },
    };
#endif /* IL2CPP_DISABLE_FULL_MESSAGES */


    static int32_t compare_message(const void *first, const void *second)
    {
        ErrorDesc *efirst = (ErrorDesc*)first;
        ErrorDesc *esecond = (ErrorDesc*)second;

        return (int32_t)efirst->code - (int32_t)esecond->code;
    }

    static const char *find_message(ErrorCode code, ErrorDesc *list, int32_t count)
    {
        ErrorDesc key = { code, "" };
        ErrorDesc *result = (ErrorDesc*)bsearch(&key, list, count, sizeof(ErrorDesc), compare_message);
        return result ? result->message : NULL;
    }

    static const char *find_message_linear(ErrorCode code, ErrorDesc *list, int32_t count)
    {
        int32_t prev = -1;

        for (int32_t i = 0; i < count; ++i)
        {
            if (list[i].code > prev)
                prev = list[i].code;
            else
            {
                // static int error_shown;
                // if (!error_shown){
                //      error_shown = 1;
                //      fprintf (stderr, "Mono: Incorrect message sorted in io-layer/messages.c at index %d (msg=%s)\n", i, list [i].txt);
                // }
            }

            if (list[i].code == code)
            {
                // static int error_shown;
                // if (!error_shown){
                //      error_shown = 1;
                //      fprintf (stderr, "Mono: Error %d with text %s is improperly sorted in io-layer/messages.c\n", id, list [i].txt);
                // }
                return list[i].message;
            }
        }
        return NULL;
    }

    std::string Messages::FromCode(ErrorCode code)
    {
        const char *message = find_message(code, common_messages, N_ELEMENTS(common_messages));
        if (message != NULL)
            return message;

#ifndef IL2CPP_DISABLE_FULL_MESSAGES
        message = find_message(code, messages, N_ELEMENTS(messages));
        if (message != NULL)
            return message;
#endif

        // Linear search, in case someone adds an error message and does not add it
        // to the list in a sorted position, this will be catched during development.

        message = find_message_linear(code, common_messages, N_ELEMENTS(common_messages));
        if (message != NULL)
            return message;

#ifndef IL2CPP_DISABLE_FULL_MESSAGES
        message = find_message_linear(code, messages, N_ELEMENTS(messages));
        if (message != NULL)
            return message;
#endif

        return std::string();
    }
}
}