[ros-diffs] [arty] 13010: Ext2lib import by filip navara for use by usetup.

Ext2lib import by filip navara for use by usetup.
Added: branches/ext2/reactos/lib/fslib/ext2lib/
Added: branches/ext2/reactos/lib/fslib/ext2lib/.cvsignore
Added: branches/ext2/reactos/lib/fslib/ext2lib/Badblock.c
Added: branches/ext2/reactos/lib/fslib/ext2lib/Bitmap.c
Added: branches/ext2/reactos/lib/fslib/ext2lib/Bitmap.h
Added: branches/ext2/reactos/lib/fslib/ext2lib/Disk.c
Added: branches/ext2/reactos/lib/fslib/ext2lib/Disk.h
Added: branches/ext2/reactos/lib/fslib/ext2lib/Group.c
Added: branches/ext2/reactos/lib/fslib/ext2lib/Inode.c
Added: branches/ext2/reactos/lib/fslib/ext2lib/Makefile
Added: branches/ext2/reactos/lib/fslib/ext2lib/Memory.c
Added: branches/ext2/reactos/lib/fslib/ext2lib/Mke2fs.c
Added: branches/ext2/reactos/lib/fslib/ext2lib/Mke2fs.h
Added: branches/ext2/reactos/lib/fslib/ext2lib/Super.c
Added: branches/ext2/reactos/lib/fslib/ext2lib/Uuid.c
Added: branches/ext2/reactos/lib/fslib/ext2lib/ext2_fs.h
Added: branches/ext2/reactos/lib/fslib/ext2lib/types.h
  _____  

Added: branches/ext2/reactos/lib/fslib/ext2lib/.cvsignore
--- branches/ext2/reactos/lib/fslib/ext2lib/.cvsignore	2005-01-13
01:51:33 UTC (rev 13009)
+++ branches/ext2/reactos/lib/fslib/ext2lib/.cvsignore	2005-01-13
01:54:28 UTC (rev 13010)
@@ -0,0 +1,3 @@

+*.d
+*.o
+*.sym
  _____  

Added: branches/ext2/reactos/lib/fslib/ext2lib/Badblock.c
--- branches/ext2/reactos/lib/fslib/ext2lib/Badblock.c	2005-01-13
01:51:33 UTC (rev 13009)
+++ branches/ext2/reactos/lib/fslib/ext2lib/Badblock.c	2005-01-13
01:54:28 UTC (rev 13010)
@@ -0,0 +1,43 @@

+/*
+ * PROJECT:          Mke2fs
+ * FILE:             Badblock.c
+ * PROGRAMMER:       Matt Wu <mattwu(a)163.com>
+ * HOMEPAGE:         http://ext2.yeah.net
+ */
+
+/* INCLUDES
**************************************************************/
+
+#include "Mke2fs.h"
+
+/* DEFINITIONS
***********************************************************/
+
+/* FUNCTIONS
*************************************************************/
+
+bool create_bad_block_inode( PEXT2_FILESYS Ext2Sys,
+                             PEXT2_BADBLK_LIST bb_list)
+{
+    bool            retval;
+    EXT2_INODE      inode;
+    LARGE_INTEGER   SysTime;
+    
+    NtQuerySystemTime(&SysTime);
+
+    ext2_mark_inode_bitmap(Ext2Sys->inode_map, EXT2_BAD_INO);
+
+    Ext2Sys->group_desc[0].bg_free_inodes_count--;
+    Ext2Sys->ext2_sb->s_free_inodes_count--;
+
+    memset(&inode, 0, sizeof(EXT2_INODE));
+    inode.i_mode = (USHORT)((0777 & ~Ext2Sys->umask));
+    inode.i_uid = inode.i_gid = 0;
+    inode.i_blocks = 0;
+    inode.i_block[0] = 0;
+    inode.i_links_count = 2;
+    RtlTimeToSecondsSince1970(&SysTime, &inode.i_mtime);
+    inode.i_ctime = inode.i_atime = inode.i_mtime;
+    inode.i_size = 0;
+
+    retval = ext2_save_inode(Ext2Sys, EXT2_BAD_INO, &inode);
+
+    return retval;
+}
  _____  

Added: branches/ext2/reactos/lib/fslib/ext2lib/Bitmap.c
--- branches/ext2/reactos/lib/fslib/ext2lib/Bitmap.c	2005-01-13
01:51:33 UTC (rev 13009)
+++ branches/ext2/reactos/lib/fslib/ext2lib/Bitmap.c	2005-01-13
01:54:28 UTC (rev 13010)
@@ -0,0 +1,499 @@

+/*
+ * PROJECT:          Mke2fs
+ * FILE:             Bitmap.c
+ * PROGRAMMER:       Matt Wu <mattwu(a)163.com>
+ * HOMEPAGE:         http://ext2.yeah.net
+ */
+
+/* INCLUDES
**************************************************************/
+
+#include "Mke2fs.h"
+
+/* DEFINITIONS
***********************************************************/
+
+/* FUNCTIONS
*************************************************************/
+
+
+bool ext2_set_bit(int nr,void * addr)
+{
+    int     mask;
+    unsigned char *ADDR = (unsigned char *) addr;
+
+    ADDR += nr >> 3;
+    mask = 1 << (nr & 0x07);
+    *ADDR |= mask;
+
+    return true;
+}
+
+bool ext2_clear_bit(int nr, void * addr)
+{
+    int     mask;
+    unsigned char   *ADDR = (unsigned char *) addr;
+
+    ADDR += nr >> 3;
+    mask = 1 << (nr & 0x07);
+    *ADDR &= ~mask;
+    return true;
+}
+
+bool ext2_test_bit(int nr, void * addr)
+{
+    int         mask;
+    const unsigned char *ADDR = (const unsigned char *) addr;
+
+    ADDR += nr >> 3;
+    mask = 1 << (nr & 0x07);
+
+    return ((mask & *ADDR) != 0);
+}
+
+bool ext2_mark_bitmap(PEXT2_BITMAP bitmap, ULONG bitno)
+{
+    if ((bitno < bitmap->start) || (bitno > bitmap->end))
+    {
+        return false;
+    }
+
+    return ext2_set_bit(bitno - bitmap->start, bitmap->bitmap);
+}
+
+bool ext2_unmark_bitmap(PEXT2_BITMAP bitmap, ULONG bitno)
+{
+    if ((bitno < bitmap->start) || (bitno > bitmap->end))
+    {
+        return false;
+    }
+
+    return ext2_clear_bit(bitno - bitmap->start, bitmap->bitmap);
+}
+
+
+bool ext2_test_block_bitmap(PEXT2_BLOCK_BITMAP bitmap,
+                        ULONG block)
+{
+    return ext2_test_bit(block - bitmap->start, bitmap->bitmap);
+}
+
+
+bool ext2_test_block_bitmap_range(PEXT2_BLOCK_BITMAP bitmap,
+                        ULONG block, int num)
+{
+    int i;
+
+    for (i=0; i < num; i++)
+    {
+        if (ext2_test_block_bitmap(bitmap, block+i))
+            return false;
+    }
+    return true;
+}
+
+bool ext2_test_inode_bitmap(PEXT2_BLOCK_BITMAP bitmap,
+                        ULONG inode)
+{
+    return ext2_test_bit(inode - bitmap->start, bitmap->bitmap);
+}
+
+
+bool ext2_allocate_block_bitmap(PEXT2_FILESYS Ext2Sys)
+{
+    ULONG   size = 0;
+
+    PEXT2_SUPER_BLOCK pExt2Sb = Ext2Sys->ext2_sb;
+    Ext2Sys->block_map = (PEXT2_BLOCK_BITMAP)
+        RtlAllocateHeap(GetProcessHeap(), 0,
sizeof(EXT2_BLOCK_BITMAP));
+
+    if (!Ext2Sys->block_map)
+    {
+        KdPrint(("Mke2fs: error allocating block bitmap...\n"));
+        return false;
+    }
+
+    memset(Ext2Sys->block_map, 0, sizeof(EXT2_BLOCK_BITMAP));
+
+    Ext2Sys->block_map->start = pExt2Sb->s_first_data_block;
+    Ext2Sys->block_map->end = pExt2Sb->s_blocks_count-1;
+    Ext2Sys->block_map->real_end = (EXT2_BLOCKS_PER_GROUP(pExt2Sb)
+        * Ext2Sys->group_desc_count) -1 + Ext2Sys->block_map->start;
+
+    size = (((Ext2Sys->block_map->real_end - Ext2Sys->block_map->start)
/ 8) + 1);
+
+    Ext2Sys->block_map->bitmap =
+        (char *)RtlAllocateHeap(GetProcessHeap(), 0, size);
+
+    if (!Ext2Sys->block_map->bitmap)
+    {
+        RtlFreeHeap(GetProcessHeap(), 0, Ext2Sys->block_map);
+        Ext2Sys->block_map = NULL;
+        KdPrint(("Mke2fs: error allocating block bitmap...\n"));
+        return false;
+    }
+
+    memset(Ext2Sys->block_map->bitmap, 0, size);
+
+    return true;
+}
+
+
+bool ext2_allocate_inode_bitmap(PEXT2_FILESYS Ext2Sys)
+{
+    ULONG   size = 0;
+
+    PEXT2_SUPER_BLOCK pExt2Sb = Ext2Sys->ext2_sb;
+
+    Ext2Sys->inode_map = (PEXT2_INODE_BITMAP)
+        RtlAllocateHeap(GetProcessHeap(), 0,
sizeof(EXT2_INODE_BITMAP));
+
+    if (!Ext2Sys->inode_map)
+    {
+        KdPrint(("Mke2fs: error allocating inode bitmap...\n"));
+        return false;
+    }
+
+    memset(Ext2Sys->inode_map, 0, sizeof(EXT2_INODE_BITMAP));
+
+    Ext2Sys->inode_map->start = 1;
+    Ext2Sys->inode_map->end = pExt2Sb->s_inodes_count;
+    Ext2Sys->inode_map->real_end = (EXT2_INODES_PER_GROUP(pExt2Sb)
+        * Ext2Sys->group_desc_count);
+
+    size = (((Ext2Sys->inode_map->real_end - Ext2Sys->inode_map->start)
/ 8) + 1);
+
+    Ext2Sys->inode_map->bitmap =
+        (char *)RtlAllocateHeap(GetProcessHeap(), 0, size);
+
+    if (!Ext2Sys->inode_map->bitmap)
+    {
+        RtlFreeHeap(GetProcessHeap(), 0, Ext2Sys->inode_map);
+        Ext2Sys->inode_map = NULL;
+        KdPrint(("Mke2fs: error allocating block bitmap...\n"));
+        return false;
+    }
+
+    memset(Ext2Sys->inode_map->bitmap, 0, size);
+
+    return true;
+}
+
+void ext2_free_generic_bitmap(PEXT2_GENERIC_BITMAP bitmap)
+{
+    if (!bitmap)
+        return;
+
+    if (bitmap->bitmap)
+    {
+        RtlFreeHeap(GetProcessHeap(), 0, bitmap->bitmap);
+        bitmap->bitmap = 0;
+    }
+
+    RtlFreeHeap(GetProcessHeap(), 0, bitmap);
+}
+
+void ext2_free_inode_bitmap(PEXT2_FILESYS Ext2Sys)
+{
+    PEXT2_INODE_BITMAP bitmap = Ext2Sys->inode_map;
+    if (!bitmap)
+        return;
+
+    ext2_free_generic_bitmap(bitmap);
+
+    Ext2Sys->inode_map = NULL;
+}
+
+void ext2_free_block_bitmap(PEXT2_FILESYS Ext2Sys)
+{
+    PEXT2_BLOCK_BITMAP bitmap = Ext2Sys->block_map;
+    if (!bitmap)
+        return;
+
+    ext2_free_generic_bitmap(bitmap);
+
+    Ext2Sys->block_map = NULL;
+}
+
+bool ext2_write_inode_bitmap(PEXT2_FILESYS fs)
+{
+    ULONG   i;
+    ULONG   nbytes;
+    bool    retval;
+    char    *inode_bitmap = fs->inode_map->bitmap;
+    char    *bitmap_block = NULL;
+    ULONG   blk;
+
+    if (!inode_bitmap)
+        return false;
+
+    nbytes = (size_t) ((EXT2_INODES_PER_GROUP(fs->ext2_sb)+7) / 8);
+    
+    bitmap_block = (char *)RtlAllocateHeap(GetProcessHeap(), 0,
fs->blocksize);
+    if (!bitmap_block) return false;
+
+    memset(bitmap_block, 0xff, fs->blocksize);
+
+    for (i = 0; i < fs->group_desc_count; i++)
+    {
+        memcpy(bitmap_block, inode_bitmap, nbytes);
+        blk = fs->group_desc[i].bg_inode_bitmap;
+
+        if (blk)
+        {
+/*
+#ifdef EXT2_BIG_ENDIAN_BITMAPS
+            if (!((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
+                  (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE)))
+                ext2_swap_bitmap(fs, bitmap_block, nbytes);
+#endif
+*/
+            retval = NT_SUCCESS(Ext2WriteDisk(
+                    fs,
+                    ((ULONGLONG)blk * fs->blocksize),
+                    fs->blocksize, 
+                    (unsigned char *)bitmap_block));
+
+            if (!retval)
+            {
+                RtlFreeHeap(GetProcessHeap(), 0, bitmap_block);
+                return false;
+            }
+        }
+
+        inode_bitmap += nbytes;
+    }
+
+    RtlFreeHeap(GetProcessHeap(), 0, bitmap_block);
+
+    return true;
+}
+
+bool ext2_write_block_bitmap (PEXT2_FILESYS fs)
+{
+    ULONG   i;
+    int     j;
+    int     nbytes;
+    int     nbits;
+    bool    retval;
+    char    *block_bitmap = fs->block_map->bitmap;
+    char    *bitmap_block = NULL;
+    ULONG   blk;
+
+    if (!block_bitmap)
+        return false;
+
+    nbytes = EXT2_BLOCKS_PER_GROUP(fs->ext2_sb) / 8;
+
+    bitmap_block = (char *)RtlAllocateHeap(GetProcessHeap(), 0,
fs->blocksize);
+    if (!bitmap_block)
+        return false;
+
+    memset(bitmap_block, 0xff, fs->blocksize);
+
+    for (i = 0; i < fs->group_desc_count; i++)
+    {
+        memcpy(bitmap_block, block_bitmap, nbytes);
+
+        if (i == fs->group_desc_count - 1)
+        {
+            /* Force bitmap padding for the last group */
+            nbits = (int) ((fs->ext2_sb->s_blocks_count
+                    - fs->ext2_sb->s_first_data_block)
+                       % EXT2_BLOCKS_PER_GROUP(fs->ext2_sb));
+
+            if (nbits)
+            {
+                for (j = nbits; j < fs->blocksize * 8; j++)
+                {
+                    ext2_set_bit(j, bitmap_block);
+                }
+            }
+        }
+
+        blk = fs->group_desc[i].bg_block_bitmap;
+
+        if (blk)
+        {
+#ifdef EXT2_BIG_ENDIAN_BITMAPS
+            if (!((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
+                  (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE)))
+                ext2_swap_bitmap(fs, bitmap_block, nbytes);
+#endif
+            retval = NT_SUCCESS(Ext2WriteDisk(
+                        fs,
+                        ((ULONGLONG)blk * fs->blocksize),
+                        fs->blocksize,
+                        (unsigned char *)bitmap_block));
+
+            if (!retval)
+            {
+                RtlFreeHeap(GetProcessHeap(), 0, bitmap_block);
+                return false;
+            }
+        }
+
+        block_bitmap += nbytes;
+    }
+
+    RtlFreeHeap(GetProcessHeap(), 0, bitmap_block);
+
+    return true;
+}
+
+bool ext2_write_bitmaps(PEXT2_FILESYS fs)
+{
+    bool    retval;
+
+    if (fs->block_map) // && ext2fs_test_bb_dirty(fs))
+    {
+        retval = ext2_write_block_bitmap(fs);
+        if (!retval)
+            return retval;
+    }
+
+    if (fs->inode_map) // && ext2fs_test_ib_dirty(fs))
+    {
+        retval = ext2_write_inode_bitmap(fs);
+        if (!retval)
+            return retval;
+    }
+
+    return true;
+}
+
+
+bool read_bitmaps(PEXT2_FILESYS fs, int do_inode, int do_block)
+{
+    ULONG i;
+    char *block_bitmap = 0, *inode_bitmap = 0;
+    bool retval = false;
+    ULONG block_nbytes = EXT2_BLOCKS_PER_GROUP(fs->ext2_sb) / 8;
+    ULONG inode_nbytes = EXT2_INODES_PER_GROUP(fs->ext2_sb) / 8;
+    ULONG blk;
+
+//  fs->write_bitmaps = ext2_write_bitmaps;
+
+    if (do_block)
+    {
+        if (fs->block_map)
+            ext2_free_block_bitmap(fs);
+
+        retval = ext2_allocate_block_bitmap(fs);
+
+        if (!retval)
+            goto cleanup;
+
+        block_bitmap = fs->block_map->bitmap;
+    }
+
+    if (do_inode)
+    {
+        if (fs->inode_map)
+            ext2_free_inode_bitmap(fs);
+
+        retval = ext2_allocate_inode_bitmap(fs);
+        if (!retval)
+            goto cleanup;
+
+        inode_bitmap = fs->inode_map->bitmap;
+    }
+
+    for (i = 0; i < fs->group_desc_count; i++)
+    {
+        if (block_bitmap)
+        {
+            blk = fs->group_desc[i].bg_block_bitmap;
+
+            if (blk)
+            {
+                retval = NT_SUCCESS(Ext2ReadDisk(
+                            fs,
+                            ((ULONGLONG)blk * fs->blocksize), 
+                            block_nbytes,
+                            (unsigned char *) block_bitmap));
+
+                if (!retval)
+                {
+                    goto cleanup;
+                }
+
+#ifdef EXT2_BIG_ENDIAN_BITMAPS
+                if (!((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
+                      (fs->flags & EXT2_FLAG_SWAP_BYTES_READ)))
+                    ext2_swap_bitmap(fs, block_bitmap, block_nbytes);
+#endif
+            }
+            else
+            {
+                memset(block_bitmap, 0, block_nbytes);
+            }
+
+            block_bitmap += block_nbytes;
+        }
+
+        if (inode_bitmap)
+        {
+            blk = fs->group_desc[i].bg_inode_bitmap;
+            if (blk)
+            {
+                retval = NT_SUCCESS(Ext2ReadDisk(
+                    fs, ((LONGLONG)blk * fs->blocksize), 
+                    inode_nbytes, 
+                    (unsigned char *)inode_bitmap));
+
+                if (!retval)
+                {
+                    goto cleanup;
+                }
+
+#ifdef EXT2_BIG_ENDIAN_BITMAPS
+                if (!((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
+                      (fs->flags & EXT2_FLAG_SWAP_BYTES_READ)))
+                    ext2_swap_bitmap(fs, inode_bitmap, inode_nbytes);
+#endif
+            }
+            else
+            {
+                memset(inode_bitmap, 0, inode_nbytes);
+            }
+
+            inode_bitmap += inode_nbytes;
+        }
+    }
+
+    return true;
+    
+cleanup:
+
+    if (do_block)
+    {
+        RtlFreeHeap(GetProcessHeap(), 0, fs->block_map);
+        fs->block_map = NULL;
+    }
+
+    if (do_inode)
+    {
+        RtlFreeHeap(GetProcessHeap(), 0, fs->inode_map);
+        fs->inode_map = 0;
+    }
+
+    return false;
+}
+
+bool ext2_read_inode_bitmap (PEXT2_FILESYS fs)
+{
+    return read_bitmaps(fs, 1, 0);
+}
+
+bool ext2_read_block_bitmap(PEXT2_FILESYS fs)
+{
+    return read_bitmaps(fs, 0, 1);
+}
+
+bool ext2_read_bitmaps(PEXT2_FILESYS fs)
+{
+
+    if (fs->inode_map && fs->block_map)
+        return 0;
+
+    return read_bitmaps(fs, !fs->inode_map, !fs->block_map);
+}
+
  _____  

Added: branches/ext2/reactos/lib/fslib/ext2lib/Bitmap.h
--- branches/ext2/reactos/lib/fslib/ext2lib/Bitmap.h	2005-01-13
01:51:33 UTC (rev 13009)
+++ branches/ext2/reactos/lib/fslib/ext2lib/Bitmap.h	2005-01-13
01:54:28 UTC (rev 13010)
@@ -0,0 +1,12 @@

+#ifndef _BITMAP_H
+
+#include "time.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include "string.h"
+#include "windows.h"
+
+
+
+
+#endif // _BITMAP_H
  _____  

Added: branches/ext2/reactos/lib/fslib/ext2lib/Disk.c
--- branches/ext2/reactos/lib/fslib/ext2lib/Disk.c	2005-01-13
01:51:33 UTC (rev 13009)
+++ branches/ext2/reactos/lib/fslib/ext2lib/Disk.c	2005-01-13
01:54:28 UTC (rev 13010)
@@ -0,0 +1,1352 @@

+/*
+ * PROJECT:          Mke2fs
+ * FILE:             Disk.c
+ * PROGRAMMER:       Matt Wu &lt;mattwu(a)163.com&gt;
+ * HOMEPAGE:         http://ext2.yeah.net
+ */
+
+/* INCLUDES
**************************************************************/
+
+#include "Mke2fs.h"
+
+/* DEFINITIONS
***********************************************************/
+
+
+
+/* FUNCTIONS
*************************************************************/
+
+PUCHAR
+Ext2StatusToString ( IN NTSTATUS Status )
+{
+    switch (Status)
+    {
+    case 0x00000000: return "STATUS_SUCCESS";
+    case 0x00000001: return "STATUS_WAIT_1";
+    case 0x00000002: return "STATUS_WAIT_2";
+    case 0x00000003: return "STATUS_WAIT_3";
+    case 0x0000003F: return "STATUS_WAIT_63";
+    case 0x00000080: return "STATUS_ABANDONED_WAIT_0";
+    case 0x000000BF: return "STATUS_ABANDONED_WAIT_63";
+    case 0x000000C0: return "STATUS_USER_APC";
+    case 0x00000100: return "STATUS_KERNEL_APC";
+    case 0x00000101: return "STATUS_ALERTED";
+    case 0x00000102: return "STATUS_TIMEOUT";
+    case 0x00000103: return "STATUS_PENDING";
+    case 0x00000104: return "STATUS_REPARSE";
+    case 0x00000105: return "STATUS_MORE_ENTRIES";
+    case 0x00000106: return "STATUS_NOT_ALL_ASSIGNED";
+    case 0x00000107: return "STATUS_SOME_NOT_MAPPED";
+    case 0x00000108: return "STATUS_OPLOCK_BREAK_IN_PROGRESS";
+    case 0x00000109: return "STATUS_VOLUME_MOUNTED";
+    case 0x0000010A: return "STATUS_RXACT_COMMITTED";
+    case 0x0000010B: return "STATUS_NOTIFY_CLEANUP";
+    case 0x0000010C: return "STATUS_NOTIFY_ENUM_DIR";
+    case 0x0000010D: return "STATUS_NO_QUOTAS_FOR_ACCOUNT";
+    case 0x0000010E: return "STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED";
+    case 0x00000110: return "STATUS_PAGE_FAULT_TRANSITION";
+    case 0x00000111: return "STATUS_PAGE_FAULT_DEMAND_ZERO";
+    case 0x00000112: return "STATUS_PAGE_FAULT_COPY_ON_WRITE";
+    case 0x00000113: return "STATUS_PAGE_FAULT_GUARD_PAGE";
+    case 0x00000114: return "STATUS_PAGE_FAULT_PAGING_FILE";
+    case 0x00000115: return "STATUS_CACHE_PAGE_LOCKED";
+    case 0x00000116: return "STATUS_CRASH_DUMP";
+    case 0x00000117: return "STATUS_BUFFER_ALL_ZEROS";
+    case 0x00000118: return "STATUS_REPARSE_OBJECT";
+    case 0x00000119: return "STATUS_RESOURCE_REQUIREMENTS_CHANGED";
+    case 0x00000120: return "STATUS_TRANSLATION_COMPLETE";
+    case 0x00000121: return "STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY";
+    case 0x00010001: return "DBG_EXCEPTION_HANDLED";
+    case 0x00010002: return "DBG_CONTINUE";
+    case 0x40000000: return "STATUS_OBJECT_NAME_EXISTS";
+    case 0x40000001: return "STATUS_THREAD_WAS_SUSPENDED";
+    case 0x40000002: return "STATUS_WORKING_SET_LIMIT_RANGE";
+    case 0x40000003: return "STATUS_IMAGE_NOT_AT_BASE";
+    case 0x40000004: return "STATUS_RXACT_STATE_CREATED";
+    case 0x40000005: return "STATUS_SEGMENT_NOTIFICATION";
+    case 0x40000006: return "STATUS_LOCAL_USER_SESSION_KEY";
+    case 0x40000007: return "STATUS_BAD_CURRENT_DIRECTORY";
+    case 0x40000008: return "STATUS_SERIAL_MORE_WRITES";
+    case 0x40000009: return "STATUS_REGISTRY_RECOVERED";
+    case 0x4000000A: return "STATUS_FT_READ_RECOVERY_FROM_BACKUP";
+    case 0x4000000B: return "STATUS_FT_WRITE_RECOVERY";
+    case 0x4000000C: return "STATUS_SERIAL_COUNTER_TIMEOUT";
+    case 0x4000000D: return "STATUS_NULL_LM_PASSWORD";
+    case 0x4000000E: return "STATUS_IMAGE_MACHINE_TYPE_MISMATCH";
+    case 0x4000000F: return "STATUS_RECEIVE_PARTIAL";
+    case 0x40000010: return "STATUS_RECEIVE_EXPEDITED";
+    case 0x40000011: return "STATUS_RECEIVE_PARTIAL_EXPEDITED";
+    case 0x40000012: return "STATUS_EVENT_DONE";
+    case 0x40000013: return "STATUS_EVENT_PENDING";
+    case 0x40000014: return "STATUS_CHECKING_FILE_SYSTEM";
+    case 0x40000015: return "STATUS_FATAL_APP_EXIT";
+    case 0x40000016: return "STATUS_PREDEFINED_HANDLE";
+    case 0x40000017: return "STATUS_WAS_UNLOCKED";
+    case 0x40000018: return "STATUS_SERVICE_NOTIFICATION";
+    case 0x40000019: return "STATUS_WAS_LOCKED";
+    case 0x4000001A: return "STATUS_LOG_HARD_ERROR";
+    case 0x4000001B: return "STATUS_ALREADY_WIN32";
+    case 0x4000001C: return "STATUS_WX86_UNSIMULATE";
+    case 0x4000001D: return "STATUS_WX86_CONTINUE";
+    case 0x4000001E: return "STATUS_WX86_SINGLE_STEP";
+    case 0x4000001F: return "STATUS_WX86_BREAKPOINT";
+    case 0x40000020: return "STATUS_WX86_EXCEPTION_CONTINUE";
+    case 0x40000021: return "STATUS_WX86_EXCEPTION_LASTCHANCE";
+    case 0x40000022: return "STATUS_WX86_EXCEPTION_CHAIN";
+    case 0x40000023: return "STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE";
+    case 0x40000024: return "STATUS_NO_YIELD_PERFORMED";
+    case 0x40000025: return "STATUS_TIMER_RESUME_IGNORED";
+    case 0x40000026: return "STATUS_ARBITRATION_UNHANDLED";
+    case 0x40000027: return "STATUS_CARDBUS_NOT_SUPPORTED";
+    case 0x40000028: return "STATUS_WX86_CREATEWX86TIB";
+    case 0x40000029: return "STATUS_MP_PROCESSOR_MISMATCH";
+    case 0x40010001: return "DBG_REPLY_LATER";
+    case 0x40010002: return "DBG_UNABLE_TO_PROVIDE_HANDLE";
+    case 0x40010003: return "DBG_TERMINATE_THREAD";
+    case 0x40010004: return "DBG_TERMINATE_PROCESS";
+    case 0x40010005: return "DBG_CONTROL_C";
+    case 0x40010006: return "DBG_PRINTEXCEPTION_C";
+    case 0x40010007: return "DBG_RIPEXCEPTION";
+    case 0x40010008: return "DBG_CONTROL_BREAK";
+    case 0x80000001: return "STATUS_GUARD_PAGE_VIOLATION";
+    case 0x80000002: return "STATUS_DATATYPE_MISALIGNMENT";
+    case 0x80000003: return "STATUS_BREAKPOINT";
+    case 0x80000004: return "STATUS_SINGLE_STEP";
+    case 0x80000005: return "STATUS_BUFFER_OVERFLOW";
+    case 0x80000006: return "STATUS_NO_MORE_FILES";
+    case 0x80000007: return "STATUS_WAKE_SYSTEM_DEBUGGER";
+    case 0x8000000A: return "STATUS_HANDLES_CLOSED";
+    case 0x8000000B: return "STATUS_NO_INHERITANCE";
+    case 0x8000000C: return "STATUS_GUID_SUBSTITUTION_MADE";
+    case 0x8000000D: return "STATUS_PARTIAL_COPY";
+    case 0x8000000E: return "STATUS_DEVICE_PAPER_EMPTY";
+    case 0x8000000F: return "STATUS_DEVICE_POWERED_OFF";
+    case 0x80000010: return "STATUS_DEVICE_OFF_LINE";
+    case 0x80000011: return "STATUS_DEVICE_BUSY";
+    case 0x80000012: return "STATUS_NO_MORE_EAS";
+    case 0x80000013: return "STATUS_INVALID_EA_NAME";
+    case 0x80000014: return "STATUS_EA_LIST_INCONSISTENT";
+    case 0x80000015: return "STATUS_INVALID_EA_FLAG";
+    case 0x80000016: return "STATUS_VERIFY_REQUIRED";
+    case 0x80000017: return "STATUS_EXTRANEOUS_INFORMATION";
+    case 0x80000018: return "STATUS_RXACT_COMMIT_NECESSARY";
+    case 0x8000001A: return "STATUS_NO_MORE_ENTRIES";
+    case 0x8000001B: return "STATUS_FILEMARK_DETECTED";
+    case 0x8000001C: return "STATUS_MEDIA_CHANGED";
+    case 0x8000001D: return "STATUS_BUS_RESET";
+    case 0x8000001E: return "STATUS_END_OF_MEDIA";
+    case 0x8000001F: return "STATUS_BEGINNING_OF_MEDIA";
+    case 0x80000020: return "STATUS_MEDIA_CHECK";
+    case 0x80000021: return "STATUS_SETMARK_DETECTED";
+    case 0x80000022: return "STATUS_NO_DATA_DETECTED";
+    case 0x80000023: return "STATUS_REDIRECTOR_HAS_OPEN_HANDLES";
+    case 0x80000024: return "STATUS_SERVER_HAS_OPEN_HANDLES";
+    case 0x80000025: return "STATUS_ALREADY_DISCONNECTED";
+    case 0x80000026: return "STATUS_LONGJUMP";
+    case 0x80010001: return "DBG_EXCEPTION_NOT_HANDLED";
+    case 0xC0000001: return "STATUS_UNSUCCESSFUL";
+    case 0xC0000002: return "STATUS_NOT_IMPLEMENTED";
+    case 0xC0000003: return "STATUS_INVALID_INFO_CLASS";
+    case 0xC0000004: return "STATUS_INFO_LENGTH_MISMATCH";
+    case 0xC0000005: return "STATUS_ACCESS_VIOLATION";
+    case 0xC0000006: return "STATUS_IN_PAGE_ERROR";
+    case 0xC0000007: return "STATUS_PAGEFILE_QUOTA";
+    case 0xC0000008: return "STATUS_INVALID_HANDLE";
+    case 0xC0000009: return "STATUS_BAD_INITIAL_STACK";
+    case 0xC000000A: return "STATUS_BAD_INITIAL_PC";
+    case 0xC000000B: return "STATUS_INVALID_CID";
+    case 0xC000000C: return "STATUS_TIMER_NOT_CANCELED";
+    case 0xC000000D: return "STATUS_INVALID_PARAMETER";
+    case 0xC000000E: return "STATUS_NO_SUCH_DEVICE";
+    case 0xC000000F: return "STATUS_NO_SUCH_FILE";
+    case 0xC0000010: return "STATUS_INVALID_DEVICE_REQUEST";
+    case 0xC0000011: return "STATUS_END_OF_FILE";
+    case 0xC0000012: return "STATUS_WRONG_VOLUME";
+    case 0xC0000013: return "STATUS_NO_MEDIA_IN_DEVICE";
+    case 0xC0000014: return "STATUS_UNRECOGNIZED_MEDIA";
+    case 0xC0000015: return "STATUS_NONEXISTENT_SECTOR";
+    case 0xC0000016: return "STATUS_MORE_PROCESSING_REQUIRED";
+    case 0xC0000017: return "STATUS_NO_MEMORY";
+    case 0xC0000018: return "STATUS_CONFLICTING_ADDRESSES";
+    case 0xC0000019: return "STATUS_NOT_MAPPED_VIEW";
+    case 0xC000001A: return "STATUS_UNABLE_TO_FREE_VM";
+    case 0xC000001B: return "STATUS_UNABLE_TO_DELETE_SECTION";
+    case 0xC000001C: return "STATUS_INVALID_SYSTEM_SERVICE";
+    case 0xC000001D: return "STATUS_ILLEGAL_INSTRUCTION";
+    case 0xC000001E: return "STATUS_INVALID_LOCK_SEQUENCE";
+    case 0xC000001F: return "STATUS_INVALID_VIEW_SIZE";
+    case 0xC0000020: return "STATUS_INVALID_FILE_FOR_SECTION";
+    case 0xC0000021: return "STATUS_ALREADY_COMMITTED";
+    case 0xC0000022: return "STATUS_ACCESS_DENIED";
+    case 0xC0000023: return "STATUS_BUFFER_TOO_SMALL";
+    case 0xC0000024: return "STATUS_OBJECT_TYPE_MISMATCH";
+    case 0xC0000025: return "STATUS_NONCONTINUABLE_EXCEPTION";
+    case 0xC0000026: return "STATUS_INVALID_DISPOSITION";
+    case 0xC0000027: return "STATUS_UNWIND";
+    case 0xC0000028: return "STATUS_BAD_STACK";
+    case 0xC0000029: return "STATUS_INVALID_UNWIND_TARGET";
+    case 0xC000002A: return "STATUS_NOT_LOCKED";
+    case 0xC000002B: return "STATUS_PARITY_ERROR";
+    case 0xC000002C: return "STATUS_UNABLE_TO_DECOMMIT_VM";
+    case 0xC000002D: return "STATUS_NOT_COMMITTED";
+    case 0xC000002E: return "STATUS_INVALID_PORT_ATTRIBUTES";
+    case 0xC000002F: return "STATUS_PORT_MESSAGE_TOO_LONG";
+    case 0xC0000030: return "STATUS_INVALID_PARAMETER_MIX";
+    case 0xC0000031: return "STATUS_INVALID_QUOTA_LOWER";
+    case 0xC0000032: return "STATUS_DISK_CORRUPT_ERROR";
+    case 0xC0000033: return "STATUS_OBJECT_NAME_INVALID";
+    case 0xC0000034: return "STATUS_OBJECT_NAME_NOT_FOUND";
+    case 0xC0000035: return "STATUS_OBJECT_NAME_COLLISION";
+    case 0xC0000037: return "STATUS_PORT_DISCONNECTED";
+    case 0xC0000038: return "STATUS_DEVICE_ALREADY_ATTACHED";
+    case 0xC0000039: return "STATUS_OBJECT_PATH_INVALID";
+    case 0xC000003A: return "STATUS_OBJECT_PATH_NOT_FOUND";
+    case 0xC000003B: return "STATUS_OBJECT_PATH_SYNTAX_BAD";
+    case 0xC000003C: return "STATUS_DATA_OVERRUN";
+    case 0xC000003D: return "STATUS_DATA_LATE_ERROR";
+    case 0xC000003E: return "STATUS_DATA_ERROR";
+    case 0xC000003F: return "STATUS_CRC_ERROR";
+    case 0xC0000040: return "STATUS_SECTION_TOO_BIG";
+    case 0xC0000041: return "STATUS_PORT_CONNECTION_REFUSED";
+    case 0xC0000042: return "STATUS_INVALID_PORT_HANDLE";
+    case 0xC0000043: return "STATUS_SHARING_VIOLATION";
+    case 0xC0000044: return "STATUS_QUOTA_EXCEEDED";
+    case 0xC0000045: return "STATUS_INVALID_PAGE_PROTECTION";
+    case 0xC0000046: return "STATUS_MUTANT_NOT_OWNED";
+    case 0xC0000047: return "STATUS_SEMAPHORE_LIMIT_EXCEEDED";
+    case 0xC0000048: return "STATUS_PORT_ALREADY_SET";
+    case 0xC0000049: return "STATUS_SECTION_NOT_IMAGE";
+    case 0xC000004A: return "STATUS_SUSPEND_COUNT_EXCEEDED";
+    case 0xC000004B: return "STATUS_THREAD_IS_TERMINATING";
+    case 0xC000004C: return "STATUS_BAD_WORKING_SET_LIMIT";
+    case 0xC000004D: return "STATUS_INCOMPATIBLE_FILE_MAP";
+    case 0xC000004E: return "STATUS_SECTION_PROTECTION";
+    case 0xC000004F: return "STATUS_EAS_NOT_SUPPORTED";
+    case 0xC0000050: return "STATUS_EA_TOO_LARGE";
+    case 0xC0000051: return "STATUS_NONEXISTENT_EA_ENTRY";
+    case 0xC0000052: return "STATUS_NO_EAS_ON_FILE";
+    case 0xC0000053: return "STATUS_EA_CORRUPT_ERROR";
+    case 0xC0000054: return "STATUS_FILE_LOCK_CONFLICT";
+    case 0xC0000055: return "STATUS_LOCK_NOT_GRANTED";
+    case 0xC0000056: return "STATUS_DELETE_PENDING";
+    case 0xC0000057: return "STATUS_CTL_FILE_NOT_SUPPORTED";
+    case 0xC0000058: return "STATUS_UNKNOWN_REVISION";
+    case 0xC0000059: return "STATUS_REVISION_MISMATCH";
+    case 0xC000005A: return "STATUS_INVALID_OWNER";
+    case 0xC000005B: return "STATUS_INVALID_PRIMARY_GROUP";
+    case 0xC000005C: return "STATUS_NO_IMPERSONATION_TOKEN";
+    case 0xC000005D: return "STATUS_CANT_DISABLE_MANDATORY";
+    case 0xC000005E: return "STATUS_NO_LOGON_SERVERS";
+    case 0xC000005F: return "STATUS_NO_SUCH_LOGON_SESSION";
+    case 0xC0000060: return "STATUS_NO_SUCH_PRIVILEGE";
+    case 0xC0000061: return "STATUS_PRIVILEGE_NOT_HELD";
+    case 0xC0000062: return "STATUS_INVALID_ACCOUNT_NAME";
+    case 0xC0000063: return "STATUS_USER_EXISTS";
+    case 0xC0000064: return "STATUS_NO_SUCH_USER";
+    case 0xC0000065: return "STATUS_GROUP_EXISTS";
+    case 0xC0000066: return "STATUS_NO_SUCH_GROUP";
+    case 0xC0000067: return "STATUS_MEMBER_IN_GROUP";
+    case 0xC0000068: return "STATUS_MEMBER_NOT_IN_GROUP";
+    case 0xC0000069: return "STATUS_LAST_ADMIN";
+    case 0xC000006A: return "STATUS_WRONG_PASSWORD";
+    case 0xC000006B: return "STATUS_ILL_FORMED_PASSWORD";
+    case 0xC000006C: return "STATUS_PASSWORD_RESTRICTION";
+    case 0xC000006D: return "STATUS_LOGON_FAILURE";
+    case 0xC000006E: return "STATUS_ACCOUNT_RESTRICTION";
+    case 0xC000006F: return "STATUS_INVALID_LOGON_HOURS";
+    case 0xC0000070: return "STATUS_INVALID_WORKSTATION";
+    case 0xC0000071: return "STATUS_PASSWORD_EXPIRED";
+    case 0xC0000072: return "STATUS_ACCOUNT_DISABLED";
+    case 0xC0000073: return "STATUS_NONE_MAPPED";
+    case 0xC0000074: return "STATUS_TOO_MANY_LUIDS_REQUESTED";
+    case 0xC0000075: return "STATUS_LUIDS_EXHAUSTED";
+    case 0xC0000076: return "STATUS_INVALID_SUB_AUTHORITY";
+    case 0xC0000077: return "STATUS_INVALID_ACL";
+    case 0xC0000078: return "STATUS_INVALID_SID";
+    case 0xC0000079: return "STATUS_INVALID_SECURITY_DESCR";
+    case 0xC000007A: return "STATUS_PROCEDURE_NOT_FOUND";
+    case 0xC000007B: return "STATUS_INVALID_IMAGE_FORMAT";
+    case 0xC000007C: return "STATUS_NO_TOKEN";
+    case 0xC000007D: return "STATUS_BAD_INHERITANCE_ACL";
+    case 0xC000007E: return "STATUS_RANGE_NOT_LOCKED";
+    case 0xC000007F: return "STATUS_DISK_FULL";
+    case 0xC0000080: return "STATUS_SERVER_DISABLED";
+    case 0xC0000081: return "STATUS_SERVER_NOT_DISABLED";
+    case 0xC0000082: return "STATUS_TOO_MANY_GUIDS_REQUESTED";
+    case 0xC0000083: return "STATUS_GUIDS_EXHAUSTED";
+    case 0xC0000084: return "STATUS_INVALID_ID_AUTHORITY";
+    case 0xC0000085: return "STATUS_AGENTS_EXHAUSTED";
+    case 0xC0000086: return "STATUS_INVALID_VOLUME_LABEL";
+    case 0xC0000087: return "STATUS_SECTION_NOT_EXTENDED";
+    case 0xC0000088: return "STATUS_NOT_MAPPED_DATA";
+    case 0xC0000089: return "STATUS_RESOURCE_DATA_NOT_FOUND";
+    case 0xC000008A: return "STATUS_RESOURCE_TYPE_NOT_FOUND";
+    case 0xC000008B: return "STATUS_RESOURCE_NAME_NOT_FOUND";
+    case 0xC000008C: return "STATUS_ARRAY_BOUNDS_EXCEEDED";
+    case 0xC000008D: return "STATUS_FLOAT_DENORMAL_OPERAND";
+    case 0xC000008E: return "STATUS_FLOAT_DIVIDE_BY_ZERO";
+    case 0xC000008F: return "STATUS_FLOAT_INEXACT_RESULT";
+    case 0xC0000090: return "STATUS_FLOAT_INVALID_OPERATION";
+    case 0xC0000091: return "STATUS_FLOAT_OVERFLOW";
+    case 0xC0000092: return "STATUS_FLOAT_STACK_CHECK";
+    case 0xC0000093: return "STATUS_FLOAT_UNDERFLOW";
+    case 0xC0000094: return "STATUS_INTEGER_DIVIDE_BY_ZERO";
+    case 0xC0000095: return "STATUS_INTEGER_OVERFLOW";
+    case 0xC0000096: return "STATUS_PRIVILEGED_INSTRUCTION";
+    case 0xC0000097: return "STATUS_TOO_MANY_PAGING_FILES";
+    case 0xC0000098: return "STATUS_FILE_INVALID";
+    case 0xC0000099: return "STATUS_ALLOTTED_SPACE_EXCEEDED";
+    case 0xC000009A: return "STATUS_INSUFFICIENT_RESOURCES";
+    case 0xC000009B: return "STATUS_DFS_EXIT_PATH_FOUND";
+    case 0xC000009C: return "STATUS_DEVICE_DATA_ERROR";
+    case 0xC000009D: return "STATUS_DEVICE_NOT_CONNECTED";
+    case 0xC000009E: return "STATUS_DEVICE_POWER_FAILURE";
+    case 0xC000009F: return "STATUS_FREE_VM_NOT_AT_BASE";
+    case 0xC00000A0: return "STATUS_MEMORY_NOT_ALLOCATED";
+    case 0xC00000A1: return "STATUS_WORKING_SET_QUOTA";
+    case 0xC00000A2: return "STATUS_MEDIA_WRITE_PROTECTED";
+    case 0xC00000A3: return "STATUS_DEVICE_NOT_READY";
+    case 0xC00000A4: return "STATUS_INVALID_GROUP_ATTRIBUTES";
+    case 0xC00000A5: return "STATUS_BAD_IMPERSONATION_LEVEL";
+    case 0xC00000A6: return "STATUS_CANT_OPEN_ANONYMOUS";
+    case 0xC00000A7: return "STATUS_BAD_VALIDATION_CLASS";
+    case 0xC00000A8: return "STATUS_BAD_TOKEN_TYPE";
+    case 0xC00000A9: return "STATUS_BAD_MASTER_BOOT_RECORD";
+    case 0xC00000AA: return "STATUS_INSTRUCTION_MISALIGNMENT";
+    case 0xC00000AB: return "STATUS_INSTANCE_NOT_AVAILABLE";
+    case 0xC00000AC: return "STATUS_PIPE_NOT_AVAILABLE";
+    case 0xC00000AD: return "STATUS_INVALID_PIPE_STATE";
+    case 0xC00000AE: return "STATUS_PIPE_BUSY";
+    case 0xC00000AF: return "STATUS_ILLEGAL_FUNCTION";
+    case 0xC00000B0: return "STATUS_PIPE_DISCONNECTED";
+    case 0xC00000B1: return "STATUS_PIPE_CLOSING";
+    case 0xC00000B2: return "STATUS_PIPE_CONNECTED";
+    case 0xC00000B3: return "STATUS_PIPE_LISTENING";
+    case 0xC00000B4: return "STATUS_INVALID_READ_MODE";
+    case 0xC00000B5: return "STATUS_IO_TIMEOUT";
+    case 0xC00000B6: return "STATUS_FILE_FORCED_CLOSED";
+    case 0xC00000B7: return "STATUS_PROFILING_NOT_STARTED";
+    case 0xC00000B8: return "STATUS_PROFILING_NOT_STOPPED";
+    case 0xC00000B9: return "STATUS_COULD_NOT_INTERPRET";
+    case 0xC00000BA: return "STATUS_FILE_IS_A_DIRECTORY";
+    case 0xC00000BB: return "STATUS_NOT_SUPPORTED";
+    case 0xC00000BC: return "STATUS_REMOTE_NOT_LISTENING";
+    case 0xC00000BD: return "STATUS_DUPLICATE_NAME";
+    case 0xC00000BE: return "STATUS_BAD_NETWORK_PATH";
+    case 0xC00000BF: return "STATUS_NETWORK_BUSY";
+    case 0xC00000C0: return "STATUS_DEVICE_DOES_NOT_EXIST";
+    case 0xC00000C1: return "STATUS_TOO_MANY_COMMANDS";
+    case 0xC00000C2: return "STATUS_ADAPTER_HARDWARE_ERROR";
+    case 0xC00000C3: return "STATUS_INVALID_NETWORK_RESPONSE";
+    case 0xC00000C4: return "STATUS_UNEXPECTED_NETWORK_ERROR";
+    case 0xC00000C5: return "STATUS_BAD_REMOTE_ADAPTER";
+    case 0xC00000C6: return "STATUS_PRINT_QUEUE_FULL";
+    case 0xC00000C7: return "STATUS_NO_SPOOL_SPACE";
+    case 0xC00000C8: return "STATUS_PRINT_CANCELLED";
+    case 0xC00000C9: return "STATUS_NETWORK_NAME_DELETED";
+    case 0xC00000CA: return "STATUS_NETWORK_ACCESS_DENIED";
+    case 0xC00000CB: return "STATUS_BAD_DEVICE_TYPE";
+    case 0xC00000CC: return "STATUS_BAD_NETWORK_NAME";
+    case 0xC00000CD: return "STATUS_TOO_MANY_NAMES";
+    case 0xC00000CE: return "STATUS_TOO_MANY_SESSIONS";
+    case 0xC00000CF: return "STATUS_SHARING_PAUSED";
+    case 0xC00000D0: return "STATUS_REQUEST_NOT_ACCEPTED";
+    case 0xC00000D1: return "STATUS_REDIRECTOR_PAUSED";
+    case 0xC00000D2: return "STATUS_NET_WRITE_FAULT";
+    case 0xC00000D3: return "STATUS_PROFILING_AT_LIMIT";
+    case 0xC00000D4: return "STATUS_NOT_SAME_DEVICE";
+    case 0xC00000D5: return "STATUS_FILE_RENAMED";
+    case 0xC00000D6: return "STATUS_VIRTUAL_CIRCUIT_CLOSED";
+    case 0xC00000D7: return "STATUS_NO_SECURITY_ON_OBJECT";
+    case 0xC00000D8: return "STATUS_CANT_WAIT";
+    case 0xC00000D9: return "STATUS_PIPE_EMPTY";
+    case 0xC00000DA: return "STATUS_CANT_ACCESS_DOMAIN_INFO";
+    case 0xC00000DB: return "STATUS_CANT_TERMINATE_SELF";
+    case 0xC00000DC: return "STATUS_INVALID_SERVER_STATE";
+    case 0xC00000DD: return "STATUS_INVALID_DOMAIN_STATE";
+    case 0xC00000DE: return "STATUS_INVALID_DOMAIN_ROLE";
+    case 0xC00000DF: return "STATUS_NO_SUCH_DOMAIN";
+    case 0xC00000E0: return "STATUS_DOMAIN_EXISTS";
+    case 0xC00000E1: return "STATUS_DOMAIN_LIMIT_EXCEEDED";
+    case 0xC00000E2: return "STATUS_OPLOCK_NOT_GRANTED";
+    case 0xC00000E3: return "STATUS_INVALID_OPLOCK_PROTOCOL";
+    case 0xC00000E4: return "STATUS_INTERNAL_DB_CORRUPTION";
+    case 0xC00000E5: return "STATUS_INTERNAL_ERROR";
+    case 0xC00000E6: return "STATUS_GENERIC_NOT_MAPPED";
+    case 0xC00000E7: return "STATUS_BAD_DESCRIPTOR_FORMAT";
+    case 0xC00000E8: return "STATUS_INVALID_USER_BUFFER";
+    case 0xC00000E9: return "STATUS_UNEXPECTED_IO_ERROR";
+    case 0xC00000EA: return "STATUS_UNEXPECTED_MM_CREATE_ERR";
+    case 0xC00000EB: return "STATUS_UNEXPECTED_MM_MAP_ERROR";
+    case 0xC00000EC: return "STATUS_UNEXPECTED_MM_EXTEND_ERR";
+    case 0xC00000ED: return "STATUS_NOT_LOGON_PROCESS";
+    case 0xC00000EE: return "STATUS_LOGON_SESSION_EXISTS";
+    case 0xC00000EF: return "STATUS_INVALID_PARAMETER_1";
+    case 0xC00000F0: return "STATUS_INVALID_PARAMETER_2";
+    case 0xC00000F1: return "STATUS_INVALID_PARAMETER_3";
+    case 0xC00000F2: return "STATUS_INVALID_PARAMETER_4";
+    case 0xC00000F3: return "STATUS_INVALID_PARAMETER_5";
+    case 0xC00000F4: return "STATUS_INVALID_PARAMETER_6";
+    case 0xC00000F5: return "STATUS_INVALID_PARAMETER_7";
+    case 0xC00000F6: return "STATUS_INVALID_PARAMETER_8";
+    case 0xC00000F7: return "STATUS_INVALID_PARAMETER_9";
+    case 0xC00000F8: return "STATUS_INVALID_PARAMETER_10";
+    case 0xC00000F9: return "STATUS_INVALID_PARAMETER_11";
+    case 0xC00000FA: return "STATUS_INVALID_PARAMETER_12";
+    case 0xC00000FB: return "STATUS_REDIRECTOR_NOT_STARTED";
+    case 0xC00000FC: return "STATUS_REDIRECTOR_STARTED";
+    case 0xC00000FD: return "STATUS_STACK_OVERFLOW";
+    case 0xC00000FE: return "STATUS_NO_SUCH_PACKAGE";
+    case 0xC00000FF: return "STATUS_BAD_FUNCTION_TABLE";
+    case 0xC0000100: return "STATUS_VARIABLE_NOT_FOUND";
+    case 0xC0000101: return "STATUS_DIRECTORY_NOT_EMPTY";
+    case 0xC0000102: return "STATUS_FILE_CORRUPT_ERROR";
+    case 0xC0000103: return "STATUS_NOT_A_DIRECTORY";
+    case 0xC0000104: return "STATUS_BAD_LOGON_SESSION_STATE";
+    case 0xC0000105: return "STATUS_LOGON_SESSION_COLLISION";
+    case 0xC0000106: return "STATUS_NAME_TOO_LONG";
+    case 0xC0000107: return "STATUS_FILES_OPEN";
+    case 0xC0000108: return "STATUS_CONNECTION_IN_USE";
+    case 0xC0000109: return "STATUS_MESSAGE_NOT_FOUND";
+    case 0xC000010A: return "STATUS_PROCESS_IS_TERMINATING";
+    case 0xC000010B: return "STATUS_INVALID_LOGON_TYPE";
+    case 0xC000010C: return "STATUS_NO_GUID_TRANSLATION";
+    case 0xC000010D: return "STATUS_CANNOT_IMPERSONATE";
+    case 0xC000010E: return "STATUS_IMAGE_ALREADY_LOADED";
+    case 0xC000010F: return "STATUS_ABIOS_NOT_PRESENT";
+    case 0xC0000110: return "STATUS_ABIOS_LID_NOT_EXIST";
+    case 0xC0000111: return "STATUS_ABIOS_LID_ALREADY_OWNED";
+    case 0xC0000112: return "STATUS_ABIOS_NOT_LID_OWNER";
[truncated at 1000 lines; 5088 more skipped]