diff --git a/docs/CMakeLists.txt b/docs/CMakeLists.txt
index 67273c2..2e767fc 100644
--- a/docs/CMakeLists.txt
+++ b/docs/CMakeLists.txt
@@ -23,11 +23,11 @@ if(DOXYGEN_FOUND)
    set(DOXYGEN_EXCLUDE_PATTERNS
       "wut_structsize.h")
    set(DOXYGEN_EXCLUDE_SYMBOLS
-      "UNKNOWN"
-      "CHECK_OFFSET"
-      "CHECK_SIZE"
-      "UNKNOWN_SIZE"
-      "PADDING")
+      "WUT_CHECK_OFFSET"
+      "WUT_CHECK_SIZE"
+      "WUT_PADDING_BYTES"
+      "WUT_UNKNOWN_BYTES"
+      "WUT_UNKNOWN_SIZE")
    set(DOXYGEN_SOURCE_BROWSER YES)
    set(DOXYGEN_ENUM_VALUES_PER_LINE 1)
    set(DOXYGEN_CLASS_DIAGRAMS NO)
diff --git a/include/coreinit/alarm.h b/include/coreinit/alarm.h
index 12426aa..a623c1b 100644
--- a/include/coreinit/alarm.h
+++ b/include/coreinit/alarm.h
@@ -36,27 +36,27 @@ struct OSAlarmQueue
 
    //! Name set by OSInitAlarmQueueEx
    const char *name;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
 
    OSThreadQueue threadQueue;
    OSAlarm *head;
    OSAlarm *tail;
 };
-CHECK_OFFSET(OSAlarmQueue, 0x00, tag);
-CHECK_OFFSET(OSAlarmQueue, 0x04, name);
-CHECK_OFFSET(OSAlarmQueue, 0x0c, threadQueue);
-CHECK_OFFSET(OSAlarmQueue, 0x1c, head);
-CHECK_OFFSET(OSAlarmQueue, 0x20, tail);
-CHECK_SIZE(OSAlarmQueue, 0x24);
+WUT_CHECK_OFFSET(OSAlarmQueue, 0x00, tag);
+WUT_CHECK_OFFSET(OSAlarmQueue, 0x04, name);
+WUT_CHECK_OFFSET(OSAlarmQueue, 0x0c, threadQueue);
+WUT_CHECK_OFFSET(OSAlarmQueue, 0x1c, head);
+WUT_CHECK_OFFSET(OSAlarmQueue, 0x20, tail);
+WUT_CHECK_SIZE(OSAlarmQueue, 0x24);
 
 struct OSAlarmLink
 {
    OSAlarm *prev;
    OSAlarm *next;
 };
-CHECK_OFFSET(OSAlarmLink, 0x00, prev);
-CHECK_OFFSET(OSAlarmLink, 0x04, next);
-CHECK_SIZE(OSAlarmLink, 0x08);
+WUT_CHECK_OFFSET(OSAlarmLink, 0x00, prev);
+WUT_CHECK_OFFSET(OSAlarmLink, 0x04, next);
+WUT_CHECK_SIZE(OSAlarmLink, 0x08);
 
 #define OS_ALARM_TAG 0x614C724Du
 struct OSAlarm
@@ -67,7 +67,7 @@ struct OSAlarm
    //! Name set from OSCreateAlarmEx.
    const char *name;
 
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
 
    //! The callback to execute once the alarm is triggered.
    OSAlarmCallback callback;
@@ -75,7 +75,7 @@ struct OSAlarm
    //! Used with OSCancelAlarms for bulk cancellation of alarms.
    uint32_t group;
 
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
 
    //! The time when the alarm will next be triggered.
    OSTime nextFire;
@@ -104,20 +104,20 @@ struct OSAlarm
    //! The context the alarm was triggered on.
    OSContext *context;
 };
-CHECK_OFFSET(OSAlarm, 0x00, tag);
-CHECK_OFFSET(OSAlarm, 0x04, name);
-CHECK_OFFSET(OSAlarm, 0x0c, callback);
-CHECK_OFFSET(OSAlarm, 0x10, group);
-CHECK_OFFSET(OSAlarm, 0x18, nextFire);
-CHECK_OFFSET(OSAlarm, 0x20, link);
-CHECK_OFFSET(OSAlarm, 0x28, period);
-CHECK_OFFSET(OSAlarm, 0x30, start);
-CHECK_OFFSET(OSAlarm, 0x38, userData);
-CHECK_OFFSET(OSAlarm, 0x3c, state);
-CHECK_OFFSET(OSAlarm, 0x40, threadQueue);
-CHECK_OFFSET(OSAlarm, 0x50, alarmQueue);
-CHECK_OFFSET(OSAlarm, 0x54, context);
-CHECK_SIZE(OSAlarm, 0x58);
+WUT_CHECK_OFFSET(OSAlarm, 0x00, tag);
+WUT_CHECK_OFFSET(OSAlarm, 0x04, name);
+WUT_CHECK_OFFSET(OSAlarm, 0x0c, callback);
+WUT_CHECK_OFFSET(OSAlarm, 0x10, group);
+WUT_CHECK_OFFSET(OSAlarm, 0x18, nextFire);
+WUT_CHECK_OFFSET(OSAlarm, 0x20, link);
+WUT_CHECK_OFFSET(OSAlarm, 0x28, period);
+WUT_CHECK_OFFSET(OSAlarm, 0x30, start);
+WUT_CHECK_OFFSET(OSAlarm, 0x38, userData);
+WUT_CHECK_OFFSET(OSAlarm, 0x3c, state);
+WUT_CHECK_OFFSET(OSAlarm, 0x40, threadQueue);
+WUT_CHECK_OFFSET(OSAlarm, 0x50, alarmQueue);
+WUT_CHECK_OFFSET(OSAlarm, 0x54, context);
+WUT_CHECK_SIZE(OSAlarm, 0x58);
 
 
 /**
diff --git a/include/coreinit/condition.h b/include/coreinit/condition.h
index de2b18c..841db2e 100644
--- a/include/coreinit/condition.h
+++ b/include/coreinit/condition.h
@@ -29,15 +29,15 @@ struct OSCondition
    //! Name set by OSInitCondEx.
    const char *name;
 
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
 
    //! Queue of threads currently waiting on condition with OSWaitCond.
    OSThreadQueue queue;
 };
-CHECK_OFFSET(OSCondition, 0x00, tag);
-CHECK_OFFSET(OSCondition, 0x04, name);
-CHECK_OFFSET(OSCondition, 0x0c, queue);
-CHECK_SIZE(OSCondition, 0x1c);
+WUT_CHECK_OFFSET(OSCondition, 0x00, tag);
+WUT_CHECK_OFFSET(OSCondition, 0x04, name);
+WUT_CHECK_OFFSET(OSCondition, 0x0c, queue);
+WUT_CHECK_SIZE(OSCondition, 0x1c);
 
 
 /**
diff --git a/include/coreinit/context.h b/include/coreinit/context.h
index 9548ada..e718263 100644
--- a/include/coreinit/context.h
+++ b/include/coreinit/context.h
@@ -21,18 +21,18 @@ struct OSContext
    uint32_t xer;
    uint32_t srr0;
    uint32_t srr1;
-   UNKNOWN(0x14);
+   WUT_UNKNOWN_BYTES(0x14);
    uint32_t fpscr;
    double fpr[32];
    uint16_t spinLockCount;
    uint16_t state;
    uint32_t gqr[8];
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
    double psf[32];
    uint64_t coretime[3];
    uint64_t starttime;
    uint32_t error;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
    uint32_t pmc1;
    uint32_t pmc2;
    uint32_t pmc3;
@@ -40,30 +40,30 @@ struct OSContext
    uint32_t mmcr0;
    uint32_t mmcr1;
 };
-CHECK_OFFSET(OSContext, 0x00, tag);
-CHECK_OFFSET(OSContext, 0x08, gpr);
-CHECK_OFFSET(OSContext, 0x88, cr);
-CHECK_OFFSET(OSContext, 0x8c, lr);
-CHECK_OFFSET(OSContext, 0x90, ctr);
-CHECK_OFFSET(OSContext, 0x94, xer);
-CHECK_OFFSET(OSContext, 0x98, srr0);
-CHECK_OFFSET(OSContext, 0x9c, srr1);
-CHECK_OFFSET(OSContext, 0xb4, fpscr);
-CHECK_OFFSET(OSContext, 0xb8, fpr);
-CHECK_OFFSET(OSContext, 0x1b8, spinLockCount);
-CHECK_OFFSET(OSContext, 0x1ba, state);
-CHECK_OFFSET(OSContext, 0x1bc, gqr);
-CHECK_OFFSET(OSContext, 0x1e0, psf);
-CHECK_OFFSET(OSContext, 0x2e0, coretime);
-CHECK_OFFSET(OSContext, 0x2f8, starttime);
-CHECK_OFFSET(OSContext, 0x300, error);
-CHECK_OFFSET(OSContext, 0x308, pmc1);
-CHECK_OFFSET(OSContext, 0x30c, pmc2);
-CHECK_OFFSET(OSContext, 0x310, pmc3);
-CHECK_OFFSET(OSContext, 0x314, pmc4);
-CHECK_OFFSET(OSContext, 0x318, mmcr0);
-CHECK_OFFSET(OSContext, 0x31c, mmcr1);
-CHECK_SIZE(OSContext, 0x320);
+WUT_CHECK_OFFSET(OSContext, 0x00, tag);
+WUT_CHECK_OFFSET(OSContext, 0x08, gpr);
+WUT_CHECK_OFFSET(OSContext, 0x88, cr);
+WUT_CHECK_OFFSET(OSContext, 0x8c, lr);
+WUT_CHECK_OFFSET(OSContext, 0x90, ctr);
+WUT_CHECK_OFFSET(OSContext, 0x94, xer);
+WUT_CHECK_OFFSET(OSContext, 0x98, srr0);
+WUT_CHECK_OFFSET(OSContext, 0x9c, srr1);
+WUT_CHECK_OFFSET(OSContext, 0xb4, fpscr);
+WUT_CHECK_OFFSET(OSContext, 0xb8, fpr);
+WUT_CHECK_OFFSET(OSContext, 0x1b8, spinLockCount);
+WUT_CHECK_OFFSET(OSContext, 0x1ba, state);
+WUT_CHECK_OFFSET(OSContext, 0x1bc, gqr);
+WUT_CHECK_OFFSET(OSContext, 0x1e0, psf);
+WUT_CHECK_OFFSET(OSContext, 0x2e0, coretime);
+WUT_CHECK_OFFSET(OSContext, 0x2f8, starttime);
+WUT_CHECK_OFFSET(OSContext, 0x300, error);
+WUT_CHECK_OFFSET(OSContext, 0x308, pmc1);
+WUT_CHECK_OFFSET(OSContext, 0x30c, pmc2);
+WUT_CHECK_OFFSET(OSContext, 0x310, pmc3);
+WUT_CHECK_OFFSET(OSContext, 0x314, pmc4);
+WUT_CHECK_OFFSET(OSContext, 0x318, mmcr0);
+WUT_CHECK_OFFSET(OSContext, 0x31c, mmcr1);
+WUT_CHECK_SIZE(OSContext, 0x320);
 
 #ifdef __cplusplus
 }
diff --git a/include/coreinit/coroutine.h b/include/coreinit/coroutine.h
index aa4b351..4bd063a 100644
--- a/include/coreinit/coroutine.h
+++ b/include/coreinit/coroutine.h
@@ -25,16 +25,16 @@ struct OSCoroutine
    double fpr[18];
    double psr[18];
 };
-CHECK_OFFSET(OSCoroutine, 0x00, nia);
-CHECK_OFFSET(OSCoroutine, 0x04, cr);
-CHECK_OFFSET(OSCoroutine, 0x08, ugqr1);
-CHECK_OFFSET(OSCoroutine, 0x0C, stack);
-CHECK_OFFSET(OSCoroutine, 0x10, sda2Base);
-CHECK_OFFSET(OSCoroutine, 0x14, sdaBase);
-CHECK_OFFSET(OSCoroutine, 0x18, gpr);
-CHECK_OFFSET(OSCoroutine, 0x60, fpr);
-CHECK_OFFSET(OSCoroutine, 0xF0, psr);
-CHECK_SIZE(OSCoroutine, 0x180);
+WUT_CHECK_OFFSET(OSCoroutine, 0x00, nia);
+WUT_CHECK_OFFSET(OSCoroutine, 0x04, cr);
+WUT_CHECK_OFFSET(OSCoroutine, 0x08, ugqr1);
+WUT_CHECK_OFFSET(OSCoroutine, 0x0C, stack);
+WUT_CHECK_OFFSET(OSCoroutine, 0x10, sda2Base);
+WUT_CHECK_OFFSET(OSCoroutine, 0x14, sdaBase);
+WUT_CHECK_OFFSET(OSCoroutine, 0x18, gpr);
+WUT_CHECK_OFFSET(OSCoroutine, 0x60, fpr);
+WUT_CHECK_OFFSET(OSCoroutine, 0xF0, psr);
+WUT_CHECK_SIZE(OSCoroutine, 0x180);
 
 void
 OSInitCoroutine(OSCoroutine *coroutine,
diff --git a/include/coreinit/event.h b/include/coreinit/event.h
index 91362af..7d94397 100644
--- a/include/coreinit/event.h
+++ b/include/coreinit/event.h
@@ -38,7 +38,7 @@ struct OSEvent
    //! Name set by OSInitEventEx.
    const char *name;
 
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
 
    //! The current value of the event object.
    BOOL value;
@@ -49,12 +49,12 @@ struct OSEvent
    //! The mode of the event object, set by OSInitEvent.
    OSEventMode mode;
 };
-CHECK_OFFSET(OSEvent, 0x0, tag);
-CHECK_OFFSET(OSEvent, 0x4, name);
-CHECK_OFFSET(OSEvent, 0xc, value);
-CHECK_OFFSET(OSEvent, 0x10, queue);
-CHECK_OFFSET(OSEvent, 0x20, mode);
-CHECK_SIZE(OSEvent, 0x24);
+WUT_CHECK_OFFSET(OSEvent, 0x0, tag);
+WUT_CHECK_OFFSET(OSEvent, 0x4, name);
+WUT_CHECK_OFFSET(OSEvent, 0xc, value);
+WUT_CHECK_OFFSET(OSEvent, 0x10, queue);
+WUT_CHECK_OFFSET(OSEvent, 0x20, mode);
+WUT_CHECK_SIZE(OSEvent, 0x24);
 
 
 /**
diff --git a/include/coreinit/fastcondition.h b/include/coreinit/fastcondition.h
index bc2b836..8757ab7 100644
--- a/include/coreinit/fastcondition.h
+++ b/include/coreinit/fastcondition.h
@@ -24,13 +24,13 @@ struct OSFastCondition
 {
    uint32_t tag;
    const char *name;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
    OSThreadQueue queue;
 };
-CHECK_OFFSET(OSFastCondition, 0x00, tag);
-CHECK_OFFSET(OSFastCondition, 0x04, name);
-CHECK_OFFSET(OSFastCondition, 0x0c, queue);
-CHECK_SIZE(OSFastCondition, 0x1c);
+WUT_CHECK_OFFSET(OSFastCondition, 0x00, tag);
+WUT_CHECK_OFFSET(OSFastCondition, 0x04, name);
+WUT_CHECK_OFFSET(OSFastCondition, 0x0c, queue);
+WUT_CHECK_SIZE(OSFastCondition, 0x1c);
 
 void
 OSFastCond_Init(OSFastCondition *condition,
diff --git a/include/coreinit/fastmutex.h b/include/coreinit/fastmutex.h
index 98dd477..d2d8096 100644
--- a/include/coreinit/fastmutex.h
+++ b/include/coreinit/fastmutex.h
@@ -24,9 +24,9 @@ struct OSFastMutexLink
    OSFastMutex *next;
    OSFastMutex *prev;
 };
-CHECK_OFFSET(OSFastMutexLink, 0x00, next);
-CHECK_OFFSET(OSFastMutexLink, 0x04, prev);
-CHECK_SIZE(OSFastMutexLink, 0x08);
+WUT_CHECK_OFFSET(OSFastMutexLink, 0x00, next);
+WUT_CHECK_OFFSET(OSFastMutexLink, 0x04, prev);
+WUT_CHECK_SIZE(OSFastMutexLink, 0x08);
 
 #define OS_FAST_MUTEX_TAG 0x664D7458u
 
@@ -34,16 +34,16 @@ struct OSFastMutex
 {
    uint32_t tag;
    const char *name;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
    OSThreadSimpleQueue queue;
    OSFastMutexLink link;
-   UNKNOWN(16);
+   WUT_UNKNOWN_BYTES(16);
 };
-CHECK_OFFSET(OSFastMutex, 0x00, tag);
-CHECK_OFFSET(OSFastMutex, 0x04, name);
-CHECK_OFFSET(OSFastMutex, 0x0c, queue);
-CHECK_OFFSET(OSFastMutex, 0x14, link);
-CHECK_SIZE(OSFastMutex, 0x2c);
+WUT_CHECK_OFFSET(OSFastMutex, 0x00, tag);
+WUT_CHECK_OFFSET(OSFastMutex, 0x04, name);
+WUT_CHECK_OFFSET(OSFastMutex, 0x0c, queue);
+WUT_CHECK_OFFSET(OSFastMutex, 0x14, link);
+WUT_CHECK_SIZE(OSFastMutex, 0x2c);
 
 void
 OSFastMutex_Init(OSFastMutex *mutex,
diff --git a/include/coreinit/filesystem.h b/include/coreinit/filesystem.h
index 37652b6..e4a0c32 100644
--- a/include/coreinit/filesystem.h
+++ b/include/coreinit/filesystem.h
@@ -140,15 +140,15 @@ typedef void(*FSAsyncCallback)(FSClient *, FSCmdBlock *, FSStatus, uint32_t);
 
 struct FSClient
 {
-   UNKNOWN(0x1700);
+   WUT_UNKNOWN_BYTES(0x1700);
 };
-CHECK_SIZE(FSClient, 0x1700);
+WUT_CHECK_SIZE(FSClient, 0x1700);
 
 struct FSCmdBlock
 {
-   UNKNOWN(0xA80);
+   WUT_UNKNOWN_BYTES(0xA80);
 };
-CHECK_SIZE(FSCmdBlock, 0xA80);
+WUT_CHECK_SIZE(FSCmdBlock, 0xA80);
 
 struct FSStat
 {
@@ -157,41 +157,41 @@ struct FSStat
    uint32_t owner;
    uint32_t group;
    uint32_t size;
-   UNKNOWN(0x50);
+   WUT_UNKNOWN_BYTES(0x50);
 };
-CHECK_OFFSET(FSStat, 0x00, flags);
-CHECK_OFFSET(FSStat, 0x10, size);
-CHECK_SIZE(FSStat, 0x64);
+WUT_CHECK_OFFSET(FSStat, 0x00, flags);
+WUT_CHECK_OFFSET(FSStat, 0x10, size);
+WUT_CHECK_SIZE(FSStat, 0x64);
 
 struct FSStateChangeInfo
 {
-   UNKNOWN(0xC);
+   WUT_UNKNOWN_BYTES(0xC);
 };
-CHECK_SIZE(FSStateChangeInfo, 0xC);
+WUT_CHECK_SIZE(FSStateChangeInfo, 0xC);
 
 struct FSAsyncData
 {
    uint32_t callback;
    uint32_t param;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
 };
-CHECK_OFFSET(FSAsyncData, 0x0, callback);
-CHECK_OFFSET(FSAsyncData, 0x4, param);
-CHECK_SIZE(FSAsyncData, 0xC);
+WUT_CHECK_OFFSET(FSAsyncData, 0x0, callback);
+WUT_CHECK_OFFSET(FSAsyncData, 0x4, param);
+WUT_CHECK_SIZE(FSAsyncData, 0xC);
 
 struct FSDirectoryEntry
 {
    FSStat info;
    char name[256];
 };
-CHECK_OFFSET(FSDirectoryEntry, 0x64, name);
-CHECK_SIZE(FSDirectoryEntry, 0x164);
+WUT_CHECK_OFFSET(FSDirectoryEntry, 0x64, name);
+WUT_CHECK_SIZE(FSDirectoryEntry, 0x164);
 
 struct FSMountSource
 {
-   UNKNOWN(0x300);
+   WUT_UNKNOWN_BYTES(0x300);
 };
-CHECK_SIZE(FSMountSource, 0x300);
+WUT_CHECK_SIZE(FSMountSource, 0x300);
 
 void
 FSInit();
diff --git a/include/coreinit/ios.h b/include/coreinit/ios.h
index c88ca06..3b62ffc 100644
--- a/include/coreinit/ios.h
+++ b/include/coreinit/ios.h
@@ -79,10 +79,10 @@ struct IOSVec
    //! Virtual address of buffer.
    void *vaddr;
 };
-CHECK_OFFSET(IOSVec, 0x00, paddr);
-CHECK_OFFSET(IOSVec, 0x04, len);
-CHECK_OFFSET(IOSVec, 0x08, vaddr);
-CHECK_SIZE(IOSVec, 0x0C);
+WUT_CHECK_OFFSET(IOSVec, 0x00, paddr);
+WUT_CHECK_OFFSET(IOSVec, 0x04, len);
+WUT_CHECK_OFFSET(IOSVec, 0x08, vaddr);
+WUT_CHECK_SIZE(IOSVec, 0x0C);
 
 typedef void (*IOSAsyncCallbackFn)(IOSError, void *);
 
diff --git a/include/coreinit/mcp.h b/include/coreinit/mcp.h
index f54d485..d027a20 100644
--- a/include/coreinit/mcp.h
+++ b/include/coreinit/mcp.h
@@ -32,37 +32,37 @@ struct __attribute__((__packed__)) MCPInstallProgress
    uint32_t contentsTotal;
    uint32_t contentsProgress;
 };
-CHECK_OFFSET(MCPInstallProgress, 0x00, inProgress);
-CHECK_OFFSET(MCPInstallProgress, 0x04, tid);
-CHECK_OFFSET(MCPInstallProgress, 0x0C, sizeTotal);
-CHECK_OFFSET(MCPInstallProgress, 0x14, sizeProgress);
-CHECK_OFFSET(MCPInstallProgress, 0x1C, contentsTotal);
-CHECK_OFFSET(MCPInstallProgress, 0x20, contentsProgress);
-CHECK_SIZE(MCPInstallProgress, 0x24);
+WUT_CHECK_OFFSET(MCPInstallProgress, 0x00, inProgress);
+WUT_CHECK_OFFSET(MCPInstallProgress, 0x04, tid);
+WUT_CHECK_OFFSET(MCPInstallProgress, 0x0C, sizeTotal);
+WUT_CHECK_OFFSET(MCPInstallProgress, 0x14, sizeProgress);
+WUT_CHECK_OFFSET(MCPInstallProgress, 0x1C, contentsTotal);
+WUT_CHECK_OFFSET(MCPInstallProgress, 0x20, contentsProgress);
+WUT_CHECK_SIZE(MCPInstallProgress, 0x24);
 
 struct MCPInstallInfo
 {
-   UNKNOWN(0x27F);
+   WUT_UNKNOWN_BYTES(0x27F);
 };
-CHECK_SIZE(MCPInstallInfo, 0x27F);
+WUT_CHECK_SIZE(MCPInstallInfo, 0x27F);
 
 struct MCPInstallTitleInfo
 {
-   UNKNOWN(0x27F);
+   WUT_UNKNOWN_BYTES(0x27F);
 };
-CHECK_SIZE(MCPInstallTitleInfo, 0x27F);
+WUT_CHECK_SIZE(MCPInstallTitleInfo, 0x27F);
 
 struct MCPDevice
 {
    char name[0x31B];
 };
-CHECK_SIZE(MCPDevice, 0x31B);
+WUT_CHECK_SIZE(MCPDevice, 0x31B);
 
 struct MCPDeviceList
 {
    MCPDevice devices[32];
 };
-CHECK_SIZE(MCPDeviceList, 0x31B*32);
+WUT_CHECK_SIZE(MCPDeviceList, 0x31B*32);
 
 int
 MCP_Open();
diff --git a/include/coreinit/memblockheap.h b/include/coreinit/memblockheap.h
index 6136c0e..6325b40 100644
--- a/include/coreinit/memblockheap.h
+++ b/include/coreinit/memblockheap.h
@@ -18,7 +18,7 @@ typedef struct MEMBlockHeap MEMBlockHeap;
 
 struct MEMBlockHeapTracking
 {
-   UNKNOWN(0x8);
+   WUT_UNKNOWN_BYTES(0x8);
 
    //! Pointer to first memory block
    MEMBlockHeapBlock *blocks;
@@ -26,9 +26,9 @@ struct MEMBlockHeapTracking
    //! Number of blocks in this tracking heap
    uint32_t blockCount;
 };
-CHECK_OFFSET(MEMBlockHeapTracking, 0x08, blocks);
-CHECK_OFFSET(MEMBlockHeapTracking, 0x0C, blockCount);
-CHECK_SIZE(MEMBlockHeapTracking, 0x10);
+WUT_CHECK_OFFSET(MEMBlockHeapTracking, 0x08, blocks);
+WUT_CHECK_OFFSET(MEMBlockHeapTracking, 0x0C, blockCount);
+WUT_CHECK_SIZE(MEMBlockHeapTracking, 0x10);
 
 struct MEMBlockHeapBlock
 {
@@ -47,12 +47,12 @@ struct MEMBlockHeapBlock
    //! Link to next block, always set
    MEMBlockHeapBlock *next;
 };
-CHECK_OFFSET(MEMBlockHeapBlock, 0x00, start);
-CHECK_OFFSET(MEMBlockHeapBlock, 0x04, end);
-CHECK_OFFSET(MEMBlockHeapBlock, 0x08, isFree);
-CHECK_OFFSET(MEMBlockHeapBlock, 0x0c, prev);
-CHECK_OFFSET(MEMBlockHeapBlock, 0x10, next);
-CHECK_SIZE(MEMBlockHeapBlock, 0x14);
+WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x00, start);
+WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x04, end);
+WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x08, isFree);
+WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x0c, prev);
+WUT_CHECK_OFFSET(MEMBlockHeapBlock, 0x10, next);
+WUT_CHECK_SIZE(MEMBlockHeapBlock, 0x14);
 
 struct MEMBlockHeap
 {
@@ -76,14 +76,14 @@ struct MEMBlockHeap
    //! Free block count
    uint32_t numFreeBlocks;
 };
-CHECK_OFFSET(MEMBlockHeap, 0x00, header);
-CHECK_OFFSET(MEMBlockHeap, 0x40, defaultTrack);
-CHECK_OFFSET(MEMBlockHeap, 0x50, defaultBlock);
-CHECK_OFFSET(MEMBlockHeap, 0x64, firstBlock);
-CHECK_OFFSET(MEMBlockHeap, 0x68, lastBlock);
-CHECK_OFFSET(MEMBlockHeap, 0x6C, firstFreeBlock);
-CHECK_OFFSET(MEMBlockHeap, 0x70, numFreeBlocks);
-CHECK_SIZE(MEMBlockHeap, 0x74);
+WUT_CHECK_OFFSET(MEMBlockHeap, 0x00, header);
+WUT_CHECK_OFFSET(MEMBlockHeap, 0x40, defaultTrack);
+WUT_CHECK_OFFSET(MEMBlockHeap, 0x50, defaultBlock);
+WUT_CHECK_OFFSET(MEMBlockHeap, 0x64, firstBlock);
+WUT_CHECK_OFFSET(MEMBlockHeap, 0x68, lastBlock);
+WUT_CHECK_OFFSET(MEMBlockHeap, 0x6C, firstFreeBlock);
+WUT_CHECK_OFFSET(MEMBlockHeap, 0x70, numFreeBlocks);
+WUT_CHECK_SIZE(MEMBlockHeap, 0x74);
 
 MEMHeapHandle
 MEMInitBlockHeap(MEMBlockHeap *heap,
diff --git a/include/coreinit/memexpheap.h b/include/coreinit/memexpheap.h
index 5323f6e..8bbacc9 100644
--- a/include/coreinit/memexpheap.h
+++ b/include/coreinit/memexpheap.h
@@ -38,23 +38,23 @@ struct MEMExpHeapBlock
    MEMExpHeapBlock *prev;
    MEMExpHeapBlock *next;
    uint16_t tag;
-   UNKNOWN(0x02);
+   WUT_UNKNOWN_BYTES(0x02);
 };
-CHECK_OFFSET(MEMExpHeapBlock, 0x00, attribs);
-CHECK_OFFSET(MEMExpHeapBlock, 0x04, blockSize);
-CHECK_OFFSET(MEMExpHeapBlock, 0x08, prev);
-CHECK_OFFSET(MEMExpHeapBlock, 0x0c, next);
-CHECK_OFFSET(MEMExpHeapBlock, 0x10, tag);
-CHECK_SIZE(MEMExpHeapBlock, 0x14);
+WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x00, attribs);
+WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x04, blockSize);
+WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x08, prev);
+WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x0c, next);
+WUT_CHECK_OFFSET(MEMExpHeapBlock, 0x10, tag);
+WUT_CHECK_SIZE(MEMExpHeapBlock, 0x14);
 
 struct MEMExpHeapBlockList
 {
    MEMExpHeapBlock *head;
    MEMExpHeapBlock *tail;
 };
-CHECK_OFFSET(MEMExpHeapBlockList, 0x00, head);
-CHECK_OFFSET(MEMExpHeapBlockList, 0x04, tail);
-CHECK_SIZE(MEMExpHeapBlockList, 0x08);
+WUT_CHECK_OFFSET(MEMExpHeapBlockList, 0x00, head);
+WUT_CHECK_OFFSET(MEMExpHeapBlockList, 0x04, tail);
+WUT_CHECK_SIZE(MEMExpHeapBlockList, 0x08);
 
 struct MEMExpHeap
 {
@@ -64,12 +64,12 @@ struct MEMExpHeap
    uint16_t groupId;
    uint16_t attribs;
 };
-CHECK_OFFSET(MEMExpHeap, 0x00, header);
-CHECK_OFFSET(MEMExpHeap, 0x40, freeList);
-CHECK_OFFSET(MEMExpHeap, 0x48, usedList);
-CHECK_OFFSET(MEMExpHeap, 0x50, groupId);
-CHECK_OFFSET(MEMExpHeap, 0x52, attribs);
-CHECK_SIZE(MEMExpHeap, 0x54);
+WUT_CHECK_OFFSET(MEMExpHeap, 0x00, header);
+WUT_CHECK_OFFSET(MEMExpHeap, 0x40, freeList);
+WUT_CHECK_OFFSET(MEMExpHeap, 0x48, usedList);
+WUT_CHECK_OFFSET(MEMExpHeap, 0x50, groupId);
+WUT_CHECK_OFFSET(MEMExpHeap, 0x52, attribs);
+WUT_CHECK_SIZE(MEMExpHeap, 0x54);
 
 MEMHeapHandle
 MEMCreateExpHeapEx(void *heap,
diff --git a/include/coreinit/memfrmheap.h b/include/coreinit/memfrmheap.h
index cd5f514..e963890 100644
--- a/include/coreinit/memfrmheap.h
+++ b/include/coreinit/memfrmheap.h
@@ -29,11 +29,11 @@ struct MEMFrmHeapState
    void *tail;
    MEMFrmHeapState *previous;
 };
-CHECK_OFFSET(MEMFrmHeapState, 0x00, tag);
-CHECK_OFFSET(MEMFrmHeapState, 0x04, head);
-CHECK_OFFSET(MEMFrmHeapState, 0x08, tail);
-CHECK_OFFSET(MEMFrmHeapState, 0x0C, previous);
-CHECK_SIZE(MEMFrmHeapState, 0x10);
+WUT_CHECK_OFFSET(MEMFrmHeapState, 0x00, tag);
+WUT_CHECK_OFFSET(MEMFrmHeapState, 0x04, head);
+WUT_CHECK_OFFSET(MEMFrmHeapState, 0x08, tail);
+WUT_CHECK_OFFSET(MEMFrmHeapState, 0x0C, previous);
+WUT_CHECK_SIZE(MEMFrmHeapState, 0x10);
 
 struct MEMFrmHeap
 {
@@ -42,11 +42,11 @@ struct MEMFrmHeap
    void *tail;
    MEMFrmHeapState *previousState;
 };
-CHECK_OFFSET(MEMFrmHeap, 0x00, header);
-CHECK_OFFSET(MEMFrmHeap, 0x40, head);
-CHECK_OFFSET(MEMFrmHeap, 0x44, tail);
-CHECK_OFFSET(MEMFrmHeap, 0x48, previousState);
-CHECK_SIZE(MEMFrmHeap, 0x4C);
+WUT_CHECK_OFFSET(MEMFrmHeap, 0x00, header);
+WUT_CHECK_OFFSET(MEMFrmHeap, 0x40, head);
+WUT_CHECK_OFFSET(MEMFrmHeap, 0x44, tail);
+WUT_CHECK_OFFSET(MEMFrmHeap, 0x48, previousState);
+WUT_CHECK_SIZE(MEMFrmHeap, 0x4C);
 
 MEMHeapHandle
 MEMCreateFrmHeapEx(void *heap,
diff --git a/include/coreinit/memheap.h b/include/coreinit/memheap.h
index fccf82b..37f8d14 100644
--- a/include/coreinit/memheap.h
+++ b/include/coreinit/memheap.h
@@ -71,16 +71,16 @@ struct MEMHeapHeader
    //! Flags set during heap creation.
    uint32_t flags;
 
-   UNKNOWN(0x0C);
+   WUT_UNKNOWN_BYTES(0x0C);
 };
-CHECK_OFFSET(MEMHeapHeader, 0x00, tag);
-CHECK_OFFSET(MEMHeapHeader, 0x04, link);
-CHECK_OFFSET(MEMHeapHeader, 0x0C, list);
-CHECK_OFFSET(MEMHeapHeader, 0x18, dataStart);
-CHECK_OFFSET(MEMHeapHeader, 0x1C, dataEnd);
-CHECK_OFFSET(MEMHeapHeader, 0x20, lock);
-CHECK_OFFSET(MEMHeapHeader, 0x30, flags);
-CHECK_SIZE(MEMHeapHeader, 0x40);
+WUT_CHECK_OFFSET(MEMHeapHeader, 0x00, tag);
+WUT_CHECK_OFFSET(MEMHeapHeader, 0x04, link);
+WUT_CHECK_OFFSET(MEMHeapHeader, 0x0C, list);
+WUT_CHECK_OFFSET(MEMHeapHeader, 0x18, dataStart);
+WUT_CHECK_OFFSET(MEMHeapHeader, 0x1C, dataEnd);
+WUT_CHECK_OFFSET(MEMHeapHeader, 0x20, lock);
+WUT_CHECK_OFFSET(MEMHeapHeader, 0x30, flags);
+WUT_CHECK_SIZE(MEMHeapHeader, 0x40);
 
 
 /**
diff --git a/include/coreinit/memlist.h b/include/coreinit/memlist.h
index 4841e0c..b98d024 100644
--- a/include/coreinit/memlist.h
+++ b/include/coreinit/memlist.h
@@ -19,9 +19,9 @@ struct MEMMemoryLink
    void *prev;
    void *next;
 };
-CHECK_OFFSET(MEMMemoryLink, 0x0, prev);
-CHECK_OFFSET(MEMMemoryLink, 0x4, next);
-CHECK_SIZE(MEMMemoryLink, 0x8);
+WUT_CHECK_OFFSET(MEMMemoryLink, 0x0, prev);
+WUT_CHECK_OFFSET(MEMMemoryLink, 0x4, next);
+WUT_CHECK_SIZE(MEMMemoryLink, 0x8);
 
 struct MEMMemoryList
 {
@@ -30,11 +30,11 @@ struct MEMMemoryList
    uint16_t count;
    uint16_t offsetToMemoryLink;
 };
-CHECK_OFFSET(MEMMemoryList, 0x0, head);
-CHECK_OFFSET(MEMMemoryList, 0x4, tail);
-CHECK_OFFSET(MEMMemoryList, 0x8, count);
-CHECK_OFFSET(MEMMemoryList, 0xa, offsetToMemoryLink);
-CHECK_SIZE(MEMMemoryList, 0xc);
+WUT_CHECK_OFFSET(MEMMemoryList, 0x0, head);
+WUT_CHECK_OFFSET(MEMMemoryList, 0x4, tail);
+WUT_CHECK_OFFSET(MEMMemoryList, 0x8, count);
+WUT_CHECK_OFFSET(MEMMemoryList, 0xa, offsetToMemoryLink);
+WUT_CHECK_SIZE(MEMMemoryList, 0xc);
 
 void
 MEMInitList(MEMMemoryList *list,
diff --git a/include/coreinit/memunitheap.h b/include/coreinit/memunitheap.h
index 9b2f8b2..1623bed 100644
--- a/include/coreinit/memunitheap.h
+++ b/include/coreinit/memunitheap.h
@@ -19,8 +19,8 @@ struct MEMUnitHeapFreeBlock
 {
    MEMUnitHeapFreeBlock *next;
 };
-CHECK_OFFSET(MEMUnitHeapFreeBlock, 0x00, next);
-CHECK_SIZE(MEMUnitHeapFreeBlock, 0x04);
+WUT_CHECK_OFFSET(MEMUnitHeapFreeBlock, 0x00, next);
+WUT_CHECK_SIZE(MEMUnitHeapFreeBlock, 0x04);
 
 struct MEMUnitHeap
 {
@@ -28,10 +28,10 @@ struct MEMUnitHeap
    MEMUnitHeapFreeBlock *freeBlocks;
    uint32_t blockSize;
 };
-CHECK_OFFSET(MEMUnitHeap, 0x00, header);
-CHECK_OFFSET(MEMUnitHeap, 0x40, freeBlocks);
-CHECK_OFFSET(MEMUnitHeap, 0x44, blockSize);
-CHECK_SIZE(MEMUnitHeap, 0x48);
+WUT_CHECK_OFFSET(MEMUnitHeap, 0x00, header);
+WUT_CHECK_OFFSET(MEMUnitHeap, 0x40, freeBlocks);
+WUT_CHECK_OFFSET(MEMUnitHeap, 0x44, blockSize);
+WUT_CHECK_SIZE(MEMUnitHeap, 0x48);
 
 MEMHeapHandle
 MEMCreateUnitHeapEx(void *heap,
diff --git a/include/coreinit/messagequeue.h b/include/coreinit/messagequeue.h
index be5e098..9bab844 100644
--- a/include/coreinit/messagequeue.h
+++ b/include/coreinit/messagequeue.h
@@ -27,9 +27,9 @@ struct OSMessage
    void *message;
    uint32_t args[3];
 };
-CHECK_OFFSET(OSMessage, 0x00, message);
-CHECK_OFFSET(OSMessage, 0x04, args);
-CHECK_SIZE(OSMessage, 0x10);
+WUT_CHECK_OFFSET(OSMessage, 0x00, message);
+WUT_CHECK_OFFSET(OSMessage, 0x04, args);
+WUT_CHECK_SIZE(OSMessage, 0x10);
 
 #define OS_MESSAGE_QUEUE_TAG 0x6D536751u
 
@@ -37,7 +37,7 @@ struct OSMessageQueue
 {
    uint32_t tag;
    const char *name;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
    OSThreadQueue sendQueue;
    OSThreadQueue recvQueue;
    OSMessage *messages;
@@ -45,15 +45,15 @@ struct OSMessageQueue
    uint32_t first;
    uint32_t used;
 };
-CHECK_OFFSET(OSMessageQueue, 0x00, tag);
-CHECK_OFFSET(OSMessageQueue, 0x04, name);
-CHECK_OFFSET(OSMessageQueue, 0x0c, sendQueue);
-CHECK_OFFSET(OSMessageQueue, 0x1c, recvQueue);
-CHECK_OFFSET(OSMessageQueue, 0x2c, messages);
-CHECK_OFFSET(OSMessageQueue, 0x30, size);
-CHECK_OFFSET(OSMessageQueue, 0x34, first);
-CHECK_OFFSET(OSMessageQueue, 0x38, used);
-CHECK_SIZE(OSMessageQueue, 0x3c);
+WUT_CHECK_OFFSET(OSMessageQueue, 0x00, tag);
+WUT_CHECK_OFFSET(OSMessageQueue, 0x04, name);
+WUT_CHECK_OFFSET(OSMessageQueue, 0x0c, sendQueue);
+WUT_CHECK_OFFSET(OSMessageQueue, 0x1c, recvQueue);
+WUT_CHECK_OFFSET(OSMessageQueue, 0x2c, messages);
+WUT_CHECK_OFFSET(OSMessageQueue, 0x30, size);
+WUT_CHECK_OFFSET(OSMessageQueue, 0x34, first);
+WUT_CHECK_OFFSET(OSMessageQueue, 0x38, used);
+WUT_CHECK_SIZE(OSMessageQueue, 0x3c);
 
 void
 OSInitMessageQueue(OSMessageQueue *queue,
diff --git a/include/coreinit/mutex.h b/include/coreinit/mutex.h
index 2b7c9e2..043b0a4 100644
--- a/include/coreinit/mutex.h
+++ b/include/coreinit/mutex.h
@@ -26,9 +26,9 @@ struct OSMutexLink
    OSMutex *next;
    OSMutex *prev;
 };
-CHECK_OFFSET(OSMutexLink, 0x00, next);
-CHECK_OFFSET(OSMutexLink, 0x04, prev);
-CHECK_SIZE(OSMutexLink, 0x8);
+WUT_CHECK_OFFSET(OSMutexLink, 0x00, next);
+WUT_CHECK_OFFSET(OSMutexLink, 0x04, prev);
+WUT_CHECK_SIZE(OSMutexLink, 0x8);
 
 #define OS_MUTEX_TAG 0x6D557458u
 
@@ -40,7 +40,7 @@ struct OSMutex
    //! Name set by OSInitMutexEx.
    const char *name;
 
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
 
    //! Queue of threads waiting for this mutex to unlock.
    OSThreadQueue queue;
@@ -54,13 +54,13 @@ struct OSMutex
    //! Link used inside OSThread's mutex queue.
    OSMutexLink link;
 };
-CHECK_OFFSET(OSMutex, 0x00, tag);
-CHECK_OFFSET(OSMutex, 0x04, name);
-CHECK_OFFSET(OSMutex, 0x0c, queue);
-CHECK_OFFSET(OSMutex, 0x1c, owner);
-CHECK_OFFSET(OSMutex, 0x20, count);
-CHECK_OFFSET(OSMutex, 0x24, link);
-CHECK_SIZE(OSMutex, 0x2c);
+WUT_CHECK_OFFSET(OSMutex, 0x00, tag);
+WUT_CHECK_OFFSET(OSMutex, 0x04, name);
+WUT_CHECK_OFFSET(OSMutex, 0x0c, queue);
+WUT_CHECK_OFFSET(OSMutex, 0x1c, owner);
+WUT_CHECK_OFFSET(OSMutex, 0x20, count);
+WUT_CHECK_OFFSET(OSMutex, 0x24, link);
+WUT_CHECK_SIZE(OSMutex, 0x2c);
 
 
 /**
diff --git a/include/coreinit/rendezvous.h b/include/coreinit/rendezvous.h
index edb44f6..87e1a7f 100644
--- a/include/coreinit/rendezvous.h
+++ b/include/coreinit/rendezvous.h
@@ -16,10 +16,10 @@ typedef struct OSRendezvous OSRendezvous;
 struct OSRendezvous
 {
    uint32_t core[3];
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
 };
-CHECK_OFFSET(OSRendezvous, 0x00, core);
-CHECK_SIZE(OSRendezvous, 0x10);
+WUT_CHECK_OFFSET(OSRendezvous, 0x00, core);
+WUT_CHECK_SIZE(OSRendezvous, 0x10);
 
 void
 OSInitRendezvous(OSRendezvous *rendezvous);
diff --git a/include/coreinit/semaphore.h b/include/coreinit/semaphore.h
index 2d1b0f9..29d7bfb 100644
--- a/include/coreinit/semaphore.h
+++ b/include/coreinit/semaphore.h
@@ -26,7 +26,7 @@ struct OSSemaphore
    //! Name set by OSInitMutexEx.
    const char *name;
 
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
 
    //! Current count of semaphore
    int32_t count;
@@ -34,11 +34,11 @@ struct OSSemaphore
    //! Queue of threads waiting on semaphore object with OSWaitSemaphore
    OSThreadQueue queue;
 };
-CHECK_OFFSET(OSSemaphore, 0x00, tag);
-CHECK_OFFSET(OSSemaphore, 0x04, name);
-CHECK_OFFSET(OSSemaphore, 0x0C, count);
-CHECK_OFFSET(OSSemaphore, 0x10, queue);
-CHECK_SIZE(OSSemaphore, 0x20);
+WUT_CHECK_OFFSET(OSSemaphore, 0x00, tag);
+WUT_CHECK_OFFSET(OSSemaphore, 0x04, name);
+WUT_CHECK_OFFSET(OSSemaphore, 0x0C, count);
+WUT_CHECK_OFFSET(OSSemaphore, 0x10, queue);
+WUT_CHECK_SIZE(OSSemaphore, 0x20);
 
 
 /**
diff --git a/include/coreinit/spinlock.h b/include/coreinit/spinlock.h
index 440c815..64923d1 100644
--- a/include/coreinit/spinlock.h
+++ b/include/coreinit/spinlock.h
@@ -17,13 +17,13 @@ typedef struct OSSpinLock OSSpinLock;
 struct OSSpinLock
 {
    uint32_t owner;
-   UNKNOWN(0x4);
+   WUT_UNKNOWN_BYTES(0x4);
    uint32_t recursion;
-   UNKNOWN(0x4);
+   WUT_UNKNOWN_BYTES(0x4);
 };
-CHECK_OFFSET(OSSpinLock, 0x0, owner);
-CHECK_OFFSET(OSSpinLock, 0x8, recursion);
-CHECK_SIZE(OSSpinLock, 0x10);
+WUT_CHECK_OFFSET(OSSpinLock, 0x0, owner);
+WUT_CHECK_OFFSET(OSSpinLock, 0x8, recursion);
+WUT_CHECK_SIZE(OSSpinLock, 0x10);
 
 void
 OSInitSpinLock(OSSpinLock *spinlock);
diff --git a/include/coreinit/systeminfo.h b/include/coreinit/systeminfo.h
index 5d61774..613b247 100644
--- a/include/coreinit/systeminfo.h
+++ b/include/coreinit/systeminfo.h
@@ -18,12 +18,12 @@ struct OSSystemInfo
    uint32_t busClockSpeed;
    uint32_t coreClockSpeed;
    int64_t baseTime;
-   UNKNOWN(0x10);
+   WUT_UNKNOWN_BYTES(0x10);
 };
-CHECK_OFFSET(OSSystemInfo, 0x0, busClockSpeed);
-CHECK_OFFSET(OSSystemInfo, 0x4, coreClockSpeed);
-CHECK_OFFSET(OSSystemInfo, 0x8, baseTime);
-CHECK_SIZE(OSSystemInfo, 0x20);
+WUT_CHECK_OFFSET(OSSystemInfo, 0x0, busClockSpeed);
+WUT_CHECK_OFFSET(OSSystemInfo, 0x4, coreClockSpeed);
+WUT_CHECK_OFFSET(OSSystemInfo, 0x8, baseTime);
+WUT_CHECK_SIZE(OSSystemInfo, 0x20);
 
 OSSystemInfo *
 OSGetSystemInfo();
diff --git a/include/coreinit/taskqueue.h b/include/coreinit/taskqueue.h
index ad7d572..374cfdd 100644
--- a/include/coreinit/taskqueue.h
+++ b/include/coreinit/taskqueue.h
@@ -45,11 +45,11 @@ struct MPTaskInfo
    OSTime duration;
 };
 #pragma pack(pop)
-CHECK_OFFSET(MPTaskInfo, 0x00, state);
-CHECK_OFFSET(MPTaskInfo, 0x04, result);
-CHECK_OFFSET(MPTaskInfo, 0x08, coreID);
-CHECK_OFFSET(MPTaskInfo, 0x0C, duration);
-CHECK_SIZE(MPTaskInfo, 0x14);
+WUT_CHECK_OFFSET(MPTaskInfo, 0x00, state);
+WUT_CHECK_OFFSET(MPTaskInfo, 0x04, result);
+WUT_CHECK_OFFSET(MPTaskInfo, 0x08, coreID);
+WUT_CHECK_OFFSET(MPTaskInfo, 0x0C, duration);
+WUT_CHECK_SIZE(MPTaskInfo, 0x14);
 
 #pragma pack(push, 1)
 struct MPTask
@@ -66,17 +66,17 @@ struct MPTask
    void *userData;
 };
 #pragma pack(pop)
-CHECK_OFFSET(MPTask, 0x00, self);
-CHECK_OFFSET(MPTask, 0x04, queue);
-CHECK_OFFSET(MPTask, 0x08, state);
-CHECK_OFFSET(MPTask, 0x0C, func);
-CHECK_OFFSET(MPTask, 0x10, userArg1);
-CHECK_OFFSET(MPTask, 0x14, userArg2);
-CHECK_OFFSET(MPTask, 0x18, result);
-CHECK_OFFSET(MPTask, 0x1C, coreID);
-CHECK_OFFSET(MPTask, 0x20, duration);
-CHECK_OFFSET(MPTask, 0x28, userData);
-CHECK_SIZE(MPTask, 0x2C);
+WUT_CHECK_OFFSET(MPTask, 0x00, self);
+WUT_CHECK_OFFSET(MPTask, 0x04, queue);
+WUT_CHECK_OFFSET(MPTask, 0x08, state);
+WUT_CHECK_OFFSET(MPTask, 0x0C, func);
+WUT_CHECK_OFFSET(MPTask, 0x10, userArg1);
+WUT_CHECK_OFFSET(MPTask, 0x14, userArg2);
+WUT_CHECK_OFFSET(MPTask, 0x18, result);
+WUT_CHECK_OFFSET(MPTask, 0x1C, coreID);
+WUT_CHECK_OFFSET(MPTask, 0x20, duration);
+WUT_CHECK_OFFSET(MPTask, 0x28, userData);
+WUT_CHECK_SIZE(MPTask, 0x2C);
 
 struct MPTaskQueueInfo
 {
@@ -86,12 +86,12 @@ struct MPTaskQueueInfo
    uint32_t tasksRunning;
    uint32_t tasksFinished;
 };
-CHECK_OFFSET(MPTaskQueueInfo, 0x00, state);
-CHECK_OFFSET(MPTaskQueueInfo, 0x04, tasks);
-CHECK_OFFSET(MPTaskQueueInfo, 0x08, tasksReady);
-CHECK_OFFSET(MPTaskQueueInfo, 0x0C, tasksRunning);
-CHECK_OFFSET(MPTaskQueueInfo, 0x10, tasksFinished);
-CHECK_SIZE(MPTaskQueueInfo, 0x14);
+WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x00, state);
+WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x04, tasks);
+WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x08, tasksReady);
+WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x0C, tasksRunning);
+WUT_CHECK_OFFSET(MPTaskQueueInfo, 0x10, tasksFinished);
+WUT_CHECK_SIZE(MPTaskQueueInfo, 0x14);
 
 struct MPTaskQueue
 {
@@ -100,29 +100,29 @@ struct MPTaskQueue
    uint32_t tasks;
    uint32_t tasksReady;
    uint32_t tasksRunning;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
    uint32_t tasksFinished;
-   UNKNOWN(8);
+   WUT_UNKNOWN_BYTES(8);
    uint32_t queueIndex;
-   UNKNOWN(8);
+   WUT_UNKNOWN_BYTES(8);
    uint32_t queueSize;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
    MPTask **queue;
    uint32_t queueMaxSize;
    OSSpinLock lock;
 };
-CHECK_OFFSET(MPTaskQueue, 0x00, self);
-CHECK_OFFSET(MPTaskQueue, 0x04, state);
-CHECK_OFFSET(MPTaskQueue, 0x08, tasks);
-CHECK_OFFSET(MPTaskQueue, 0x0C, tasksReady);
-CHECK_OFFSET(MPTaskQueue, 0x10, tasksRunning);
-CHECK_OFFSET(MPTaskQueue, 0x18, tasksFinished);
-CHECK_OFFSET(MPTaskQueue, 0x24, queueIndex);
-CHECK_OFFSET(MPTaskQueue, 0x30, queueSize);
-CHECK_OFFSET(MPTaskQueue, 0x38, queue);
-CHECK_OFFSET(MPTaskQueue, 0x3C, queueMaxSize);
-CHECK_OFFSET(MPTaskQueue, 0x40, lock);
-CHECK_SIZE(MPTaskQueue, 0x50);
+WUT_CHECK_OFFSET(MPTaskQueue, 0x00, self);
+WUT_CHECK_OFFSET(MPTaskQueue, 0x04, state);
+WUT_CHECK_OFFSET(MPTaskQueue, 0x08, tasks);
+WUT_CHECK_OFFSET(MPTaskQueue, 0x0C, tasksReady);
+WUT_CHECK_OFFSET(MPTaskQueue, 0x10, tasksRunning);
+WUT_CHECK_OFFSET(MPTaskQueue, 0x18, tasksFinished);
+WUT_CHECK_OFFSET(MPTaskQueue, 0x24, queueIndex);
+WUT_CHECK_OFFSET(MPTaskQueue, 0x30, queueSize);
+WUT_CHECK_OFFSET(MPTaskQueue, 0x38, queue);
+WUT_CHECK_OFFSET(MPTaskQueue, 0x3C, queueMaxSize);
+WUT_CHECK_OFFSET(MPTaskQueue, 0x40, lock);
+WUT_CHECK_SIZE(MPTaskQueue, 0x50);
 
 void
 MPInitTaskQ(MPTaskQueue *queue,
diff --git a/include/coreinit/thread.h b/include/coreinit/thread.h
index cccfcc6..0f43098 100644
--- a/include/coreinit/thread.h
+++ b/include/coreinit/thread.h
@@ -97,21 +97,21 @@ struct OSMutexQueue
    OSMutex *head;
    OSMutex *tail;
    void *parent;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
 };
-CHECK_OFFSET(OSMutexQueue, 0x0, head);
-CHECK_OFFSET(OSMutexQueue, 0x4, tail);
-CHECK_OFFSET(OSMutexQueue, 0x8, parent);
-CHECK_SIZE(OSMutexQueue, 0x10);
+WUT_CHECK_OFFSET(OSMutexQueue, 0x0, head);
+WUT_CHECK_OFFSET(OSMutexQueue, 0x4, tail);
+WUT_CHECK_OFFSET(OSMutexQueue, 0x8, parent);
+WUT_CHECK_SIZE(OSMutexQueue, 0x10);
 
 struct OSFastMutexQueue
 {
    OSFastMutex *head;
    OSFastMutex *tail;
 };
-CHECK_OFFSET(OSFastMutexQueue, 0x00, head);
-CHECK_OFFSET(OSFastMutexQueue, 0x04, tail);
-CHECK_SIZE(OSFastMutexQueue, 0x08);
+WUT_CHECK_OFFSET(OSFastMutexQueue, 0x00, head);
+WUT_CHECK_OFFSET(OSFastMutexQueue, 0x04, tail);
+WUT_CHECK_SIZE(OSFastMutexQueue, 0x08);
 
 #define OS_THREAD_TAG 0x74487244u
 #pragma pack(push, 1)
@@ -143,7 +143,7 @@ struct OSThread
    //! Exit value
    int32_t exitValue;
 
-   UNKNOWN(0x35C - 0x338);
+   WUT_UNKNOWN_BYTES(0x35C - 0x338);
 
    //! Queue the thread is currently waiting on
    OSThreadQueue *queue;
@@ -172,17 +172,17 @@ struct OSThread
    //! Thread entry point
    OSThreadEntryPointFn entryPoint;
 
-   UNKNOWN(0x57c - 0x3a0);
+   WUT_UNKNOWN_BYTES(0x57c - 0x3a0);
 
    //! Thread specific values, accessed with OSSetThreadSpecific and OSGetThreadSpecific.
    void *specific[0x10];
 
-   UNKNOWN(0x5c0 - 0x5bc);
+   WUT_UNKNOWN_BYTES(0x5c0 - 0x5bc);
 
    //! Thread name, accessed with OSSetThreadName and OSGetThreadName.
    const char *name;
 
-   UNKNOWN(0x4);
+   WUT_UNKNOWN_BYTES(0x4);
 
    //! The stack pointer passed in OSCreateThread.
    void *userStackPointer;
@@ -208,37 +208,37 @@ struct OSThread
    //! Queue of threads waiting for a thread to be suspended.
    OSThreadQueue suspendQueue;
 
-   UNKNOWN(0x6a0 - 0x5f4);
+   WUT_UNKNOWN_BYTES(0x6a0 - 0x5f4);
 };
 #pragma pack(pop)
-CHECK_OFFSET(OSThread, 0x320, tag);
-CHECK_OFFSET(OSThread, 0x324, state);
-CHECK_OFFSET(OSThread, 0x325, attr);
-CHECK_OFFSET(OSThread, 0x326, id);
-CHECK_OFFSET(OSThread, 0x328, suspendCounter);
-CHECK_OFFSET(OSThread, 0x32c, priority);
-CHECK_OFFSET(OSThread, 0x330, basePriority);
-CHECK_OFFSET(OSThread, 0x334, exitValue);
-CHECK_OFFSET(OSThread, 0x35c, queue);
-CHECK_OFFSET(OSThread, 0x360, link);
-CHECK_OFFSET(OSThread, 0x368, joinQueue);
-CHECK_OFFSET(OSThread, 0x378, mutex);
-CHECK_OFFSET(OSThread, 0x37c, mutexQueue);
-CHECK_OFFSET(OSThread, 0x38c, activeLink);
-CHECK_OFFSET(OSThread, 0x394, stackStart);
-CHECK_OFFSET(OSThread, 0x398, stackEnd);
-CHECK_OFFSET(OSThread, 0x39c, entryPoint);
-CHECK_OFFSET(OSThread, 0x57c, specific);
-CHECK_OFFSET(OSThread, 0x5c0, name);
-CHECK_OFFSET(OSThread, 0x5c8, userStackPointer);
-CHECK_OFFSET(OSThread, 0x5cc, cleanupCallback);
-CHECK_OFFSET(OSThread, 0x5d0, deallocator);
-CHECK_OFFSET(OSThread, 0x5d4, cancelState);
-CHECK_OFFSET(OSThread, 0x5d8, requestFlag);
-CHECK_OFFSET(OSThread, 0x5dc, needSuspend);
-CHECK_OFFSET(OSThread, 0x5e0, suspendResult);
-CHECK_OFFSET(OSThread, 0x5e4, suspendQueue);
-CHECK_SIZE(OSThread, 0x6a0);
+WUT_CHECK_OFFSET(OSThread, 0x320, tag);
+WUT_CHECK_OFFSET(OSThread, 0x324, state);
+WUT_CHECK_OFFSET(OSThread, 0x325, attr);
+WUT_CHECK_OFFSET(OSThread, 0x326, id);
+WUT_CHECK_OFFSET(OSThread, 0x328, suspendCounter);
+WUT_CHECK_OFFSET(OSThread, 0x32c, priority);
+WUT_CHECK_OFFSET(OSThread, 0x330, basePriority);
+WUT_CHECK_OFFSET(OSThread, 0x334, exitValue);
+WUT_CHECK_OFFSET(OSThread, 0x35c, queue);
+WUT_CHECK_OFFSET(OSThread, 0x360, link);
+WUT_CHECK_OFFSET(OSThread, 0x368, joinQueue);
+WUT_CHECK_OFFSET(OSThread, 0x378, mutex);
+WUT_CHECK_OFFSET(OSThread, 0x37c, mutexQueue);
+WUT_CHECK_OFFSET(OSThread, 0x38c, activeLink);
+WUT_CHECK_OFFSET(OSThread, 0x394, stackStart);
+WUT_CHECK_OFFSET(OSThread, 0x398, stackEnd);
+WUT_CHECK_OFFSET(OSThread, 0x39c, entryPoint);
+WUT_CHECK_OFFSET(OSThread, 0x57c, specific);
+WUT_CHECK_OFFSET(OSThread, 0x5c0, name);
+WUT_CHECK_OFFSET(OSThread, 0x5c8, userStackPointer);
+WUT_CHECK_OFFSET(OSThread, 0x5cc, cleanupCallback);
+WUT_CHECK_OFFSET(OSThread, 0x5d0, deallocator);
+WUT_CHECK_OFFSET(OSThread, 0x5d4, cancelState);
+WUT_CHECK_OFFSET(OSThread, 0x5d8, requestFlag);
+WUT_CHECK_OFFSET(OSThread, 0x5dc, needSuspend);
+WUT_CHECK_OFFSET(OSThread, 0x5e0, suspendResult);
+WUT_CHECK_OFFSET(OSThread, 0x5e4, suspendQueue);
+WUT_CHECK_SIZE(OSThread, 0x6a0);
 
 
 /**
diff --git a/include/coreinit/threadqueue.h b/include/coreinit/threadqueue.h
index 32a70ed..58197af 100644
--- a/include/coreinit/threadqueue.h
+++ b/include/coreinit/threadqueue.h
@@ -22,30 +22,30 @@ struct OSThreadLink
    OSThread *prev;
    OSThread *next;
 };
-CHECK_OFFSET(OSThreadLink, 0x00, prev);
-CHECK_OFFSET(OSThreadLink, 0x04, next);
-CHECK_SIZE(OSThreadLink, 0x8);
+WUT_CHECK_OFFSET(OSThreadLink, 0x00, prev);
+WUT_CHECK_OFFSET(OSThreadLink, 0x04, next);
+WUT_CHECK_SIZE(OSThreadLink, 0x8);
 
 struct OSThreadQueue
 {
    OSThread *head;
    OSThread *tail;
    void *parent;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
 };
-CHECK_OFFSET(OSThreadQueue, 0x00, head);
-CHECK_OFFSET(OSThreadQueue, 0x04, tail);
-CHECK_OFFSET(OSThreadQueue, 0x08, parent);
-CHECK_SIZE(OSThreadQueue, 0x10);
+WUT_CHECK_OFFSET(OSThreadQueue, 0x00, head);
+WUT_CHECK_OFFSET(OSThreadQueue, 0x04, tail);
+WUT_CHECK_OFFSET(OSThreadQueue, 0x08, parent);
+WUT_CHECK_SIZE(OSThreadQueue, 0x10);
 
 struct OSThreadSimpleQueue
 {
    OSThread *head;
    OSThread *tail;
 };
-CHECK_OFFSET(OSThreadSimpleQueue, 0x00, head);
-CHECK_OFFSET(OSThreadSimpleQueue, 0x04, tail);
-CHECK_SIZE(OSThreadSimpleQueue, 0x08);
+WUT_CHECK_OFFSET(OSThreadSimpleQueue, 0x00, head);
+WUT_CHECK_OFFSET(OSThreadSimpleQueue, 0x04, tail);
+WUT_CHECK_SIZE(OSThreadSimpleQueue, 0x08);
 
 void
 OSInitThreadQueue(OSThreadQueue *queue);
diff --git a/include/coreinit/time.h b/include/coreinit/time.h
index 2145575..051d970 100644
--- a/include/coreinit/time.h
+++ b/include/coreinit/time.h
@@ -31,17 +31,17 @@ struct OSCalendarTime
    int32_t tm_msec;
    int32_t tm_usec;
 };
-CHECK_OFFSET(OSCalendarTime, 0x00, tm_sec);
-CHECK_OFFSET(OSCalendarTime, 0x04, tm_min);
-CHECK_OFFSET(OSCalendarTime, 0x08, tm_hour);
-CHECK_OFFSET(OSCalendarTime, 0x0C, tm_mday);
-CHECK_OFFSET(OSCalendarTime, 0x10, tm_mon);
-CHECK_OFFSET(OSCalendarTime, 0x14, tm_year);
-CHECK_OFFSET(OSCalendarTime, 0x18, tm_wday);
-CHECK_OFFSET(OSCalendarTime, 0x1C, tm_yday);
-CHECK_OFFSET(OSCalendarTime, 0x20, tm_msec);
-CHECK_OFFSET(OSCalendarTime, 0x24, tm_usec);
-CHECK_SIZE(OSCalendarTime, 0x28);
+WUT_CHECK_OFFSET(OSCalendarTime, 0x00, tm_sec);
+WUT_CHECK_OFFSET(OSCalendarTime, 0x04, tm_min);
+WUT_CHECK_OFFSET(OSCalendarTime, 0x08, tm_hour);
+WUT_CHECK_OFFSET(OSCalendarTime, 0x0C, tm_mday);
+WUT_CHECK_OFFSET(OSCalendarTime, 0x10, tm_mon);
+WUT_CHECK_OFFSET(OSCalendarTime, 0x14, tm_year);
+WUT_CHECK_OFFSET(OSCalendarTime, 0x18, tm_wday);
+WUT_CHECK_OFFSET(OSCalendarTime, 0x1C, tm_yday);
+WUT_CHECK_OFFSET(OSCalendarTime, 0x20, tm_msec);
+WUT_CHECK_OFFSET(OSCalendarTime, 0x24, tm_usec);
+WUT_CHECK_SIZE(OSCalendarTime, 0x28);
 
 #define OSTimerClockSpeed ((OSGetSystemInfo()->busClockSpeed) / 4)
 
diff --git a/include/gx2/context.h b/include/gx2/context.h
index 2c2ed39..76afcff 100644
--- a/include/gx2/context.h
+++ b/include/gx2/context.h
@@ -20,32 +20,32 @@ struct GX2ShadowState
    uint32_t context[0x400];
    uint32_t alu[0x800];
    uint32_t loop[0x60];
-   PADDING((0x80 - 0x60) * 4);
+   WUT_PADDING_BYTES((0x80 - 0x60) * 4);
    uint32_t resource[0xD9E];
-   PADDING((0xDC0 - 0xD9E) * 4);
+   WUT_PADDING_BYTES((0xDC0 - 0xD9E) * 4);
    uint32_t sampler[0xA2];
-   PADDING((0xC0 - 0xA2) * 4);
+   WUT_PADDING_BYTES((0xC0 - 0xA2) * 4);
 };
-CHECK_OFFSET(GX2ShadowState, 0x0000, config);
-CHECK_OFFSET(GX2ShadowState, 0x2C00, context);
-CHECK_OFFSET(GX2ShadowState, 0x3C00, alu);
-CHECK_OFFSET(GX2ShadowState, 0x5C00, loop);
-CHECK_OFFSET(GX2ShadowState, 0x5E00, resource);
-CHECK_OFFSET(GX2ShadowState, 0x9500, sampler);
-CHECK_SIZE(GX2ShadowState, 0x9800);
+WUT_CHECK_OFFSET(GX2ShadowState, 0x0000, config);
+WUT_CHECK_OFFSET(GX2ShadowState, 0x2C00, context);
+WUT_CHECK_OFFSET(GX2ShadowState, 0x3C00, alu);
+WUT_CHECK_OFFSET(GX2ShadowState, 0x5C00, loop);
+WUT_CHECK_OFFSET(GX2ShadowState, 0x5E00, resource);
+WUT_CHECK_OFFSET(GX2ShadowState, 0x9500, sampler);
+WUT_CHECK_SIZE(GX2ShadowState, 0x9800);
 
 struct GX2ContextState
 {
    GX2ShadowState shadowState;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
    uint32_t shadowDisplayListSize;
-   UNKNOWN(0x9e00 - 0x9808);
+   WUT_UNKNOWN_BYTES(0x9e00 - 0x9808);
    uint32_t shadowDisplayList[192];
 };
-CHECK_OFFSET(GX2ContextState, 0x0000, shadowState);
-CHECK_OFFSET(GX2ContextState, 0x9804, shadowDisplayListSize);
-CHECK_OFFSET(GX2ContextState, 0x9e00, shadowDisplayList);
-CHECK_SIZE(GX2ContextState, 0xa100);
+WUT_CHECK_OFFSET(GX2ContextState, 0x0000, shadowState);
+WUT_CHECK_OFFSET(GX2ContextState, 0x9804, shadowDisplayListSize);
+WUT_CHECK_OFFSET(GX2ContextState, 0x9e00, shadowDisplayList);
+WUT_CHECK_SIZE(GX2ContextState, 0xa100);
 
 void
 GX2SetupContextStateEx(GX2ContextState *state,
diff --git a/include/gx2/event.h b/include/gx2/event.h
index 7810a8c..59f978c 100644
--- a/include/gx2/event.h
+++ b/include/gx2/event.h
@@ -30,13 +30,13 @@ struct GX2DisplayListOverrunData
    //! Size of new display list
    uint32_t newSize;
 
-   UNKNOWN(8);
+   WUT_UNKNOWN_BYTES(8);
 };
-CHECK_OFFSET(GX2DisplayListOverrunData, 0x00, oldList);
-CHECK_OFFSET(GX2DisplayListOverrunData, 0x04, oldSize);
-CHECK_OFFSET(GX2DisplayListOverrunData, 0x08, newList);
-CHECK_OFFSET(GX2DisplayListOverrunData, 0x0C, newSize);
-CHECK_SIZE(GX2DisplayListOverrunData, 0x18);
+WUT_CHECK_OFFSET(GX2DisplayListOverrunData, 0x00, oldList);
+WUT_CHECK_OFFSET(GX2DisplayListOverrunData, 0x04, oldSize);
+WUT_CHECK_OFFSET(GX2DisplayListOverrunData, 0x08, newList);
+WUT_CHECK_OFFSET(GX2DisplayListOverrunData, 0x0C, newSize);
+WUT_CHECK_SIZE(GX2DisplayListOverrunData, 0x18);
 
 BOOL
 GX2DrawDone();
diff --git a/include/gx2/registers.h b/include/gx2/registers.h
index 6181335..01079c7 100644
--- a/include/gx2/registers.h
+++ b/include/gx2/registers.h
@@ -34,33 +34,33 @@ struct GX2AAMaskReg
 {
    uint32_t pa_sc_aa_mask;
 };
-CHECK_OFFSET(GX2AAMaskReg, 0, pa_sc_aa_mask);
-CHECK_SIZE(GX2AAMaskReg, 4);
+WUT_CHECK_OFFSET(GX2AAMaskReg, 0, pa_sc_aa_mask);
+WUT_CHECK_SIZE(GX2AAMaskReg, 4);
 
 struct GX2AlphaTestReg
 {
    uint32_t sx_alpha_test_control;
    uint32_t sx_alpha_ref;
 };
-CHECK_OFFSET(GX2AlphaTestReg, 0, sx_alpha_test_control);
-CHECK_OFFSET(GX2AlphaTestReg, 4, sx_alpha_ref);
-CHECK_SIZE(GX2AlphaTestReg, 8);
+WUT_CHECK_OFFSET(GX2AlphaTestReg, 0, sx_alpha_test_control);
+WUT_CHECK_OFFSET(GX2AlphaTestReg, 4, sx_alpha_ref);
+WUT_CHECK_SIZE(GX2AlphaTestReg, 8);
 
 struct GX2AlphaToMaskReg
 {
    uint32_t db_alpha_to_mask;
 };
-CHECK_OFFSET(GX2AlphaToMaskReg, 0, db_alpha_to_mask);
-CHECK_SIZE(GX2AlphaToMaskReg, 4);
+WUT_CHECK_OFFSET(GX2AlphaToMaskReg, 0, db_alpha_to_mask);
+WUT_CHECK_SIZE(GX2AlphaToMaskReg, 4);
 
 struct GX2BlendControlReg
 {
    GX2RenderTarget target;
    uint32_t cb_blend_control;
 };
-CHECK_OFFSET(GX2BlendControlReg, 0, target);
-CHECK_OFFSET(GX2BlendControlReg, 4, cb_blend_control);
-CHECK_SIZE(GX2BlendControlReg, 8);
+WUT_CHECK_OFFSET(GX2BlendControlReg, 0, target);
+WUT_CHECK_OFFSET(GX2BlendControlReg, 4, cb_blend_control);
+WUT_CHECK_SIZE(GX2BlendControlReg, 8);
 
 struct GX2BlendConstantColorReg
 {
@@ -69,62 +69,62 @@ struct GX2BlendConstantColorReg
    float blue;
    float alpha;
 };
-CHECK_OFFSET(GX2BlendConstantColorReg, 0x00, red);
-CHECK_OFFSET(GX2BlendConstantColorReg, 0x04, green);
-CHECK_OFFSET(GX2BlendConstantColorReg, 0x08, blue);
-CHECK_OFFSET(GX2BlendConstantColorReg, 0x0c, alpha);
-CHECK_SIZE(GX2BlendConstantColorReg, 0x10);
+WUT_CHECK_OFFSET(GX2BlendConstantColorReg, 0x00, red);
+WUT_CHECK_OFFSET(GX2BlendConstantColorReg, 0x04, green);
+WUT_CHECK_OFFSET(GX2BlendConstantColorReg, 0x08, blue);
+WUT_CHECK_OFFSET(GX2BlendConstantColorReg, 0x0c, alpha);
+WUT_CHECK_SIZE(GX2BlendConstantColorReg, 0x10);
 
 struct GX2ColorControlReg
 {
    uint32_t cb_color_control;
 };
-CHECK_OFFSET(GX2ColorControlReg, 0x00, cb_color_control);
-CHECK_SIZE(GX2ColorControlReg, 4);
+WUT_CHECK_OFFSET(GX2ColorControlReg, 0x00, cb_color_control);
+WUT_CHECK_SIZE(GX2ColorControlReg, 4);
 
 struct GX2DepthStencilControlReg
 {
    uint32_t db_depth_control;
 };
-CHECK_OFFSET(GX2DepthStencilControlReg, 0, db_depth_control);
-CHECK_SIZE(GX2DepthStencilControlReg, 4);
+WUT_CHECK_OFFSET(GX2DepthStencilControlReg, 0, db_depth_control);
+WUT_CHECK_SIZE(GX2DepthStencilControlReg, 4);
 
 struct GX2StencilMaskReg
 {
    uint32_t db_stencilrefmask;
    uint32_t db_stencilrefmask_bf;
 };
-CHECK_OFFSET(GX2StencilMaskReg, 0, db_stencilrefmask);
-CHECK_OFFSET(GX2StencilMaskReg, 4, db_stencilrefmask_bf);
-CHECK_SIZE(GX2StencilMaskReg, 8);
+WUT_CHECK_OFFSET(GX2StencilMaskReg, 0, db_stencilrefmask);
+WUT_CHECK_OFFSET(GX2StencilMaskReg, 4, db_stencilrefmask_bf);
+WUT_CHECK_SIZE(GX2StencilMaskReg, 8);
 
 struct GX2LineWidthReg
 {
    uint32_t pa_su_line_cntl;
 };
-CHECK_OFFSET(GX2LineWidthReg, 0, pa_su_line_cntl);
-CHECK_SIZE(GX2LineWidthReg, 4);
+WUT_CHECK_OFFSET(GX2LineWidthReg, 0, pa_su_line_cntl);
+WUT_CHECK_SIZE(GX2LineWidthReg, 4);
 
 struct GX2PointSizeReg
 {
    uint32_t pa_su_point_size;
 };
-CHECK_OFFSET(GX2PointSizeReg, 0, pa_su_point_size);
-CHECK_SIZE(GX2PointSizeReg, 4);
+WUT_CHECK_OFFSET(GX2PointSizeReg, 0, pa_su_point_size);
+WUT_CHECK_SIZE(GX2PointSizeReg, 4);
 
 struct GX2PointLimitsReg
 {
    uint32_t pa_su_point_minmax;
 };
-CHECK_OFFSET(GX2PointLimitsReg, 0, pa_su_point_minmax);
-CHECK_SIZE(GX2PointLimitsReg, 4);
+WUT_CHECK_OFFSET(GX2PointLimitsReg, 0, pa_su_point_minmax);
+WUT_CHECK_SIZE(GX2PointLimitsReg, 4);
 
 struct GX2PolygonControlReg
 {
    uint32_t pa_su_sc_mode_cntl;
 };
-CHECK_OFFSET(GX2PolygonControlReg, 0, pa_su_sc_mode_cntl);
-CHECK_SIZE(GX2PolygonControlReg, 4);
+WUT_CHECK_OFFSET(GX2PolygonControlReg, 0, pa_su_sc_mode_cntl);
+WUT_CHECK_SIZE(GX2PolygonControlReg, 4);
 
 struct GX2PolygonOffsetReg
 {
@@ -134,28 +134,28 @@ struct GX2PolygonOffsetReg
    uint32_t pa_su_poly_offset_back_offset;
    uint32_t pa_su_poly_offset_clamp;
 };
-CHECK_OFFSET(GX2PolygonOffsetReg, 0x00, pa_su_poly_offset_front_scale);
-CHECK_OFFSET(GX2PolygonOffsetReg, 0x04, pa_su_poly_offset_front_offset);
-CHECK_OFFSET(GX2PolygonOffsetReg, 0x08, pa_su_poly_offset_back_scale);
-CHECK_OFFSET(GX2PolygonOffsetReg, 0x0C, pa_su_poly_offset_back_offset);
-CHECK_OFFSET(GX2PolygonOffsetReg, 0x10, pa_su_poly_offset_clamp);
-CHECK_SIZE(GX2PolygonOffsetReg, 20);
+WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x00, pa_su_poly_offset_front_scale);
+WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x04, pa_su_poly_offset_front_offset);
+WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x08, pa_su_poly_offset_back_scale);
+WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x0C, pa_su_poly_offset_back_offset);
+WUT_CHECK_OFFSET(GX2PolygonOffsetReg, 0x10, pa_su_poly_offset_clamp);
+WUT_CHECK_SIZE(GX2PolygonOffsetReg, 20);
 
 struct GX2ScissorReg
 {
    uint32_t pa_sc_generic_scissor_tl;
    uint32_t pa_sc_generic_scissor_br;
 };
-CHECK_OFFSET(GX2ScissorReg, 0x00, pa_sc_generic_scissor_tl);
-CHECK_OFFSET(GX2ScissorReg, 0x04, pa_sc_generic_scissor_br);
-CHECK_SIZE(GX2ScissorReg, 8);
+WUT_CHECK_OFFSET(GX2ScissorReg, 0x00, pa_sc_generic_scissor_tl);
+WUT_CHECK_OFFSET(GX2ScissorReg, 0x04, pa_sc_generic_scissor_br);
+WUT_CHECK_SIZE(GX2ScissorReg, 8);
 
 struct GX2TargetChannelMaskReg
 {
    uint32_t cb_target_mask;
 };
-CHECK_OFFSET(GX2TargetChannelMaskReg, 0x00, cb_target_mask);
-CHECK_SIZE(GX2TargetChannelMaskReg, 4);
+WUT_CHECK_OFFSET(GX2TargetChannelMaskReg, 0x00, cb_target_mask);
+WUT_CHECK_SIZE(GX2TargetChannelMaskReg, 4);
 
 struct GX2ViewportReg
 {
@@ -172,19 +172,19 @@ struct GX2ViewportReg
    uint32_t pa_sc_vport_zmin;
    uint32_t pa_sc_vport_zmax;
 };
-CHECK_OFFSET(GX2ViewportReg, 0x00, pa_cl_vport_xscale);
-CHECK_OFFSET(GX2ViewportReg, 0x04, pa_cl_vport_xoffset);
-CHECK_OFFSET(GX2ViewportReg, 0x08, pa_cl_vport_yscale);
-CHECK_OFFSET(GX2ViewportReg, 0x0C, pa_cl_vport_yoffset);
-CHECK_OFFSET(GX2ViewportReg, 0x10, pa_cl_vport_zscale);
-CHECK_OFFSET(GX2ViewportReg, 0x14, pa_cl_vport_zoffset);
-CHECK_OFFSET(GX2ViewportReg, 0x18, pa_cl_gb_vert_clip_adj);
-CHECK_OFFSET(GX2ViewportReg, 0x1C, pa_cl_gb_vert_disc_adj);
-CHECK_OFFSET(GX2ViewportReg, 0x20, pa_cl_gb_horz_clip_adj);
-CHECK_OFFSET(GX2ViewportReg, 0x24, pa_cl_gb_horz_disc_adj);
-CHECK_OFFSET(GX2ViewportReg, 0x28, pa_sc_vport_zmin);
-CHECK_OFFSET(GX2ViewportReg, 0x2C, pa_sc_vport_zmax);
-CHECK_SIZE(GX2ViewportReg, 48);
+WUT_CHECK_OFFSET(GX2ViewportReg, 0x00, pa_cl_vport_xscale);
+WUT_CHECK_OFFSET(GX2ViewportReg, 0x04, pa_cl_vport_xoffset);
+WUT_CHECK_OFFSET(GX2ViewportReg, 0x08, pa_cl_vport_yscale);
+WUT_CHECK_OFFSET(GX2ViewportReg, 0x0C, pa_cl_vport_yoffset);
+WUT_CHECK_OFFSET(GX2ViewportReg, 0x10, pa_cl_vport_zscale);
+WUT_CHECK_OFFSET(GX2ViewportReg, 0x14, pa_cl_vport_zoffset);
+WUT_CHECK_OFFSET(GX2ViewportReg, 0x18, pa_cl_gb_vert_clip_adj);
+WUT_CHECK_OFFSET(GX2ViewportReg, 0x1C, pa_cl_gb_vert_disc_adj);
+WUT_CHECK_OFFSET(GX2ViewportReg, 0x20, pa_cl_gb_horz_clip_adj);
+WUT_CHECK_OFFSET(GX2ViewportReg, 0x24, pa_cl_gb_horz_disc_adj);
+WUT_CHECK_OFFSET(GX2ViewportReg, 0x28, pa_sc_vport_zmin);
+WUT_CHECK_OFFSET(GX2ViewportReg, 0x2C, pa_sc_vport_zmax);
+WUT_CHECK_SIZE(GX2ViewportReg, 48);
 
 void
 GX2SetAAMask(uint8_t upperLeft,
diff --git a/include/gx2/sampler.h b/include/gx2/sampler.h
index cdb1a1d..1b805fe 100644
--- a/include/gx2/sampler.h
+++ b/include/gx2/sampler.h
@@ -18,7 +18,7 @@ struct GX2Sampler
 {
    uint32_t regs[3];
 };
-CHECK_SIZE(GX2Sampler, 12);
+WUT_CHECK_SIZE(GX2Sampler, 12);
 
 void
 GX2InitSampler(GX2Sampler *sampler,
diff --git a/include/gx2/shaders.h b/include/gx2/shaders.h
index 11598b4..bbca84f 100644
--- a/include/gx2/shaders.h
+++ b/include/gx2/shaders.h
@@ -41,14 +41,14 @@ struct GX2FetchShader
    uint32_t numDivisors;
    uint32_t divisors[2];
 };
-CHECK_OFFSET(GX2FetchShader, 0x0, type);
-CHECK_OFFSET(GX2FetchShader, 0x4, regs.sq_pgm_resources_fs);
-CHECK_OFFSET(GX2FetchShader, 0x8, size);
-CHECK_OFFSET(GX2FetchShader, 0xc, program);
-CHECK_OFFSET(GX2FetchShader, 0x10, attribCount);
-CHECK_OFFSET(GX2FetchShader, 0x14, numDivisors);
-CHECK_OFFSET(GX2FetchShader, 0x18, divisors);
-CHECK_SIZE(GX2FetchShader, 0x20);
+WUT_CHECK_OFFSET(GX2FetchShader, 0x0, type);
+WUT_CHECK_OFFSET(GX2FetchShader, 0x4, regs.sq_pgm_resources_fs);
+WUT_CHECK_OFFSET(GX2FetchShader, 0x8, size);
+WUT_CHECK_OFFSET(GX2FetchShader, 0xc, program);
+WUT_CHECK_OFFSET(GX2FetchShader, 0x10, attribCount);
+WUT_CHECK_OFFSET(GX2FetchShader, 0x14, numDivisors);
+WUT_CHECK_OFFSET(GX2FetchShader, 0x18, divisors);
+WUT_CHECK_SIZE(GX2FetchShader, 0x20);
 
 struct GX2UniformBlock
 {
@@ -56,10 +56,10 @@ struct GX2UniformBlock
    uint32_t offset;
    uint32_t size;
 };
-CHECK_OFFSET(GX2UniformBlock, 0x00, name);
-CHECK_OFFSET(GX2UniformBlock, 0x04, offset);
-CHECK_OFFSET(GX2UniformBlock, 0x08, size);
-CHECK_SIZE(GX2UniformBlock, 0x0C);
+WUT_CHECK_OFFSET(GX2UniformBlock, 0x00, name);
+WUT_CHECK_OFFSET(GX2UniformBlock, 0x04, offset);
+WUT_CHECK_OFFSET(GX2UniformBlock, 0x08, size);
+WUT_CHECK_SIZE(GX2UniformBlock, 0x0C);
 
 struct GX2UniformVar
 {
@@ -69,30 +69,30 @@ struct GX2UniformVar
    uint32_t offset;
    int32_t block;
 };
-CHECK_OFFSET(GX2UniformVar, 0x00, name);
-CHECK_OFFSET(GX2UniformVar, 0x04, type);
-CHECK_OFFSET(GX2UniformVar, 0x08, count);
-CHECK_OFFSET(GX2UniformVar, 0x0C, offset);
-CHECK_OFFSET(GX2UniformVar, 0x10, block);
-CHECK_SIZE(GX2UniformVar, 0x14);
+WUT_CHECK_OFFSET(GX2UniformVar, 0x00, name);
+WUT_CHECK_OFFSET(GX2UniformVar, 0x04, type);
+WUT_CHECK_OFFSET(GX2UniformVar, 0x08, count);
+WUT_CHECK_OFFSET(GX2UniformVar, 0x0C, offset);
+WUT_CHECK_OFFSET(GX2UniformVar, 0x10, block);
+WUT_CHECK_SIZE(GX2UniformVar, 0x14);
 
 struct GX2UniformInitialValue
 {
    float value[4];
    uint32_t offset;
 };
-CHECK_OFFSET(GX2UniformInitialValue, 0x00, value);
-CHECK_OFFSET(GX2UniformInitialValue, 0x10, offset);
-CHECK_SIZE(GX2UniformInitialValue, 0x14);
+WUT_CHECK_OFFSET(GX2UniformInitialValue, 0x00, value);
+WUT_CHECK_OFFSET(GX2UniformInitialValue, 0x10, offset);
+WUT_CHECK_SIZE(GX2UniformInitialValue, 0x14);
 
 struct GX2LoopVar
 {
    uint32_t offset;
    uint32_t value;
 };
-CHECK_OFFSET(GX2LoopVar, 0x00, offset);
-CHECK_OFFSET(GX2LoopVar, 0x04, value);
-CHECK_SIZE(GX2LoopVar, 0x08);
+WUT_CHECK_OFFSET(GX2LoopVar, 0x00, offset);
+WUT_CHECK_OFFSET(GX2LoopVar, 0x04, value);
+WUT_CHECK_SIZE(GX2LoopVar, 0x08);
 
 struct GX2SamplerVar
 {
@@ -100,10 +100,10 @@ struct GX2SamplerVar
    GX2SamplerVarType type;
    uint32_t location;
 };
-CHECK_OFFSET(GX2SamplerVar, 0x00, name);
-CHECK_OFFSET(GX2SamplerVar, 0x04, type);
-CHECK_OFFSET(GX2SamplerVar, 0x08, location);
-CHECK_SIZE(GX2SamplerVar, 0x0C);
+WUT_CHECK_OFFSET(GX2SamplerVar, 0x00, name);
+WUT_CHECK_OFFSET(GX2SamplerVar, 0x04, type);
+WUT_CHECK_OFFSET(GX2SamplerVar, 0x08, location);
+WUT_CHECK_SIZE(GX2SamplerVar, 0x0C);
 
 struct GX2AttribVar
 {
@@ -112,11 +112,11 @@ struct GX2AttribVar
    uint32_t count;
    uint32_t location;
 };
-CHECK_OFFSET(GX2AttribVar, 0x00, name);
-CHECK_OFFSET(GX2AttribVar, 0x04, type);
-CHECK_OFFSET(GX2AttribVar, 0x08, count);
-CHECK_OFFSET(GX2AttribVar, 0x0C, location);
-CHECK_SIZE(GX2AttribVar, 0x10);
+WUT_CHECK_OFFSET(GX2AttribVar, 0x00, name);
+WUT_CHECK_OFFSET(GX2AttribVar, 0x04, type);
+WUT_CHECK_OFFSET(GX2AttribVar, 0x08, count);
+WUT_CHECK_OFFSET(GX2AttribVar, 0x0C, location);
+WUT_CHECK_SIZE(GX2AttribVar, 0x10);
 
 struct GX2VertexShader
 {
@@ -165,38 +165,38 @@ struct GX2VertexShader
 
    GX2RBuffer gx2rBuffer;
 };
-CHECK_OFFSET(GX2VertexShader, 0x00, regs.sq_pgm_resources_vs);
-CHECK_OFFSET(GX2VertexShader, 0x04, regs.vgt_primitiveid_en);
-CHECK_OFFSET(GX2VertexShader, 0x08, regs.spi_vs_out_config);
-CHECK_OFFSET(GX2VertexShader, 0x0C, regs.num_spi_vs_out_id);
-CHECK_OFFSET(GX2VertexShader, 0x10, regs.spi_vs_out_id);
-CHECK_OFFSET(GX2VertexShader, 0x38, regs.pa_cl_vs_out_cntl);
-CHECK_OFFSET(GX2VertexShader, 0x3C, regs.sq_vtx_semantic_clear);
-CHECK_OFFSET(GX2VertexShader, 0x40, regs.num_sq_vtx_semantic);
-CHECK_OFFSET(GX2VertexShader, 0x44, regs.sq_vtx_semantic);
-CHECK_OFFSET(GX2VertexShader, 0xC4, regs.vgt_strmout_buffer_en);
-CHECK_OFFSET(GX2VertexShader, 0xC8, regs.vgt_vertex_reuse_block_cntl);
-CHECK_OFFSET(GX2VertexShader, 0xCC, regs.vgt_hos_reuse_depth);
-CHECK_OFFSET(GX2VertexShader, 0xD0, size);
-CHECK_OFFSET(GX2VertexShader, 0xD4, program);
-CHECK_OFFSET(GX2VertexShader, 0xD8, mode);
-CHECK_OFFSET(GX2VertexShader, 0xDc, uniformBlockCount);
-CHECK_OFFSET(GX2VertexShader, 0xE0, uniformBlocks);
-CHECK_OFFSET(GX2VertexShader, 0xE4, uniformVarCount);
-CHECK_OFFSET(GX2VertexShader, 0xE8, uniformVars);
-CHECK_OFFSET(GX2VertexShader, 0xEc, initialValueCount);
-CHECK_OFFSET(GX2VertexShader, 0xF0, initialValues);
-CHECK_OFFSET(GX2VertexShader, 0xF4, loopVarCount);
-CHECK_OFFSET(GX2VertexShader, 0xF8, loopVars);
-CHECK_OFFSET(GX2VertexShader, 0xFc, samplerVarCount);
-CHECK_OFFSET(GX2VertexShader, 0x100, samplerVars);
-CHECK_OFFSET(GX2VertexShader, 0x104, attribVarCount);
-CHECK_OFFSET(GX2VertexShader, 0x108, attribVars);
-CHECK_OFFSET(GX2VertexShader, 0x10c, ringItemsize);
-CHECK_OFFSET(GX2VertexShader, 0x110, hasStreamOut);
-CHECK_OFFSET(GX2VertexShader, 0x114, streamOutStride);
-CHECK_OFFSET(GX2VertexShader, 0x124, gx2rBuffer);
-CHECK_SIZE(GX2VertexShader, 0x134);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x00, regs.sq_pgm_resources_vs);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x04, regs.vgt_primitiveid_en);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x08, regs.spi_vs_out_config);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x0C, regs.num_spi_vs_out_id);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x10, regs.spi_vs_out_id);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x38, regs.pa_cl_vs_out_cntl);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x3C, regs.sq_vtx_semantic_clear);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x40, regs.num_sq_vtx_semantic);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x44, regs.sq_vtx_semantic);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xC4, regs.vgt_strmout_buffer_en);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xC8, regs.vgt_vertex_reuse_block_cntl);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xCC, regs.vgt_hos_reuse_depth);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xD0, size);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xD4, program);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xD8, mode);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xDc, uniformBlockCount);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xE0, uniformBlocks);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xE4, uniformVarCount);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xE8, uniformVars);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xEc, initialValueCount);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xF0, initialValues);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xF4, loopVarCount);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xF8, loopVars);
+WUT_CHECK_OFFSET(GX2VertexShader, 0xFc, samplerVarCount);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x100, samplerVars);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x104, attribVarCount);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x108, attribVars);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x10c, ringItemsize);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x110, hasStreamOut);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x114, streamOutStride);
+WUT_CHECK_OFFSET(GX2VertexShader, 0x124, gx2rBuffer);
+WUT_CHECK_SIZE(GX2VertexShader, 0x134);
 
 struct GX2PixelShader
 {
@@ -235,31 +235,31 @@ struct GX2PixelShader
 
    GX2RBuffer gx2rBuffer;
 };
-CHECK_OFFSET(GX2PixelShader, 0x00, regs.sq_pgm_resources_ps);
-CHECK_OFFSET(GX2PixelShader, 0x04, regs.sq_pgm_exports_ps);
-CHECK_OFFSET(GX2PixelShader, 0x08, regs.spi_ps_in_control_0);
-CHECK_OFFSET(GX2PixelShader, 0x0C, regs.spi_ps_in_control_1);
-CHECK_OFFSET(GX2PixelShader, 0x10, regs.num_spi_ps_input_cntl);
-CHECK_OFFSET(GX2PixelShader, 0x14, regs.spi_ps_input_cntls);
-CHECK_OFFSET(GX2PixelShader, 0x94, regs.cb_shader_mask);
-CHECK_OFFSET(GX2PixelShader, 0x98, regs.cb_shader_control);
-CHECK_OFFSET(GX2PixelShader, 0x9C, regs.db_shader_control);
-CHECK_OFFSET(GX2PixelShader, 0xA0, regs.spi_input_z);
-CHECK_OFFSET(GX2PixelShader, 0xA4, size);
-CHECK_OFFSET(GX2PixelShader, 0xA8, program);
-CHECK_OFFSET(GX2PixelShader, 0xAC, mode);
-CHECK_OFFSET(GX2PixelShader, 0xB0, uniformBlockCount);
-CHECK_OFFSET(GX2PixelShader, 0xB4, uniformBlocks);
-CHECK_OFFSET(GX2PixelShader, 0xB8, uniformVarCount);
-CHECK_OFFSET(GX2PixelShader, 0xBC, uniformVars);
-CHECK_OFFSET(GX2PixelShader, 0xC0, initialValueCount);
-CHECK_OFFSET(GX2PixelShader, 0xC4, initialValues);
-CHECK_OFFSET(GX2PixelShader, 0xC8, loopVarCount);
-CHECK_OFFSET(GX2PixelShader, 0xCC, loopVars);
-CHECK_OFFSET(GX2PixelShader, 0xD0, samplerVarCount);
-CHECK_OFFSET(GX2PixelShader, 0xD4, samplerVars);
-CHECK_OFFSET(GX2PixelShader, 0xD8, gx2rBuffer);
-CHECK_SIZE(GX2PixelShader, 0xE8);
+WUT_CHECK_OFFSET(GX2PixelShader, 0x00, regs.sq_pgm_resources_ps);
+WUT_CHECK_OFFSET(GX2PixelShader, 0x04, regs.sq_pgm_exports_ps);
+WUT_CHECK_OFFSET(GX2PixelShader, 0x08, regs.spi_ps_in_control_0);
+WUT_CHECK_OFFSET(GX2PixelShader, 0x0C, regs.spi_ps_in_control_1);
+WUT_CHECK_OFFSET(GX2PixelShader, 0x10, regs.num_spi_ps_input_cntl);
+WUT_CHECK_OFFSET(GX2PixelShader, 0x14, regs.spi_ps_input_cntls);
+WUT_CHECK_OFFSET(GX2PixelShader, 0x94, regs.cb_shader_mask);
+WUT_CHECK_OFFSET(GX2PixelShader, 0x98, regs.cb_shader_control);
+WUT_CHECK_OFFSET(GX2PixelShader, 0x9C, regs.db_shader_control);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xA0, regs.spi_input_z);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xA4, size);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xA8, program);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xAC, mode);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xB0, uniformBlockCount);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xB4, uniformBlocks);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xB8, uniformVarCount);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xBC, uniformVars);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xC0, initialValueCount);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xC4, initialValues);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xC8, loopVarCount);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xCC, loopVars);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xD0, samplerVarCount);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xD4, samplerVars);
+WUT_CHECK_OFFSET(GX2PixelShader, 0xD8, gx2rBuffer);
+WUT_CHECK_SIZE(GX2PixelShader, 0xE8);
 
 struct GX2GeometryShader
 {
@@ -304,36 +304,36 @@ struct GX2GeometryShader
 
    GX2RBuffer gx2rBuffer;
 };
-CHECK_OFFSET(GX2GeometryShader, 0x00, regs.sq_pgm_resources_gs);
-CHECK_OFFSET(GX2GeometryShader, 0x04, regs.vgt_gs_out_prim_type);
-CHECK_OFFSET(GX2GeometryShader, 0x08, regs.vgt_gs_mode);
-CHECK_OFFSET(GX2GeometryShader, 0x0C, regs.pa_cl_vs_out_cntl);
-CHECK_OFFSET(GX2GeometryShader, 0x10, regs.sq_pgm_resources_vs);
-CHECK_OFFSET(GX2GeometryShader, 0x14, regs.sq_gs_vert_itemsize);
-CHECK_OFFSET(GX2GeometryShader, 0x18, regs.spi_vs_out_config);
-CHECK_OFFSET(GX2GeometryShader, 0x1C, regs.num_spi_vs_out_id);
-CHECK_OFFSET(GX2GeometryShader, 0x20, regs.spi_vs_out_id);
-CHECK_OFFSET(GX2GeometryShader, 0x48, regs.vgt_strmout_buffer_en);
-CHECK_OFFSET(GX2GeometryShader, 0x4C, size);
-CHECK_OFFSET(GX2GeometryShader, 0x50, program);
-CHECK_OFFSET(GX2GeometryShader, 0x54, vertexProgramSize);
-CHECK_OFFSET(GX2GeometryShader, 0x58, vertexProgram);
-CHECK_OFFSET(GX2GeometryShader, 0x5C, mode);
-CHECK_OFFSET(GX2GeometryShader, 0x60, uniformBlockCount);
-CHECK_OFFSET(GX2GeometryShader, 0x64, uniformBlocks);
-CHECK_OFFSET(GX2GeometryShader, 0x68, uniformVarCount);
-CHECK_OFFSET(GX2GeometryShader, 0x6C, uniformVars);
-CHECK_OFFSET(GX2GeometryShader, 0x70, initialValueCount);
-CHECK_OFFSET(GX2GeometryShader, 0x74, initialValues);
-CHECK_OFFSET(GX2GeometryShader, 0x78, loopVarCount);
-CHECK_OFFSET(GX2GeometryShader, 0x7C, loopVars);
-CHECK_OFFSET(GX2GeometryShader, 0x80, samplerVarCount);
-CHECK_OFFSET(GX2GeometryShader, 0x84, samplerVars);
-CHECK_OFFSET(GX2GeometryShader, 0x88, ringItemSize);
-CHECK_OFFSET(GX2GeometryShader, 0x8C, hasStreamOut);
-CHECK_OFFSET(GX2GeometryShader, 0x90, streamOutStride);
-CHECK_OFFSET(GX2GeometryShader, 0xA0, gx2rBuffer);
-CHECK_SIZE(GX2GeometryShader, 0xB0);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x00, regs.sq_pgm_resources_gs);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x04, regs.vgt_gs_out_prim_type);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x08, regs.vgt_gs_mode);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x0C, regs.pa_cl_vs_out_cntl);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x10, regs.sq_pgm_resources_vs);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x14, regs.sq_gs_vert_itemsize);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x18, regs.spi_vs_out_config);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x1C, regs.num_spi_vs_out_id);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x20, regs.spi_vs_out_id);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x48, regs.vgt_strmout_buffer_en);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x4C, size);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x50, program);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x54, vertexProgramSize);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x58, vertexProgram);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x5C, mode);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x60, uniformBlockCount);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x64, uniformBlocks);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x68, uniformVarCount);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x6C, uniformVars);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x70, initialValueCount);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x74, initialValues);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x78, loopVarCount);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x7C, loopVars);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x80, samplerVarCount);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x84, samplerVars);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x88, ringItemSize);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x8C, hasStreamOut);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0x90, streamOutStride);
+WUT_CHECK_OFFSET(GX2GeometryShader, 0xA0, gx2rBuffer);
+WUT_CHECK_SIZE(GX2GeometryShader, 0xB0);
 
 struct GX2AttribStream
 {
@@ -346,15 +346,15 @@ struct GX2AttribStream
    uint32_t mask;
    GX2EndianSwapMode endianSwap;
 };
-CHECK_OFFSET(GX2AttribStream, 0x0, location);
-CHECK_OFFSET(GX2AttribStream, 0x4, buffer);
-CHECK_OFFSET(GX2AttribStream, 0x8, offset);
-CHECK_OFFSET(GX2AttribStream, 0xc, format);
-CHECK_OFFSET(GX2AttribStream, 0x10, type);
-CHECK_OFFSET(GX2AttribStream, 0x14, aluDivisor);
-CHECK_OFFSET(GX2AttribStream, 0x18, mask);
-CHECK_OFFSET(GX2AttribStream, 0x1c, endianSwap);
-CHECK_SIZE(GX2AttribStream, 0x20);
+WUT_CHECK_OFFSET(GX2AttribStream, 0x0, location);
+WUT_CHECK_OFFSET(GX2AttribStream, 0x4, buffer);
+WUT_CHECK_OFFSET(GX2AttribStream, 0x8, offset);
+WUT_CHECK_OFFSET(GX2AttribStream, 0xc, format);
+WUT_CHECK_OFFSET(GX2AttribStream, 0x10, type);
+WUT_CHECK_OFFSET(GX2AttribStream, 0x14, aluDivisor);
+WUT_CHECK_OFFSET(GX2AttribStream, 0x18, mask);
+WUT_CHECK_OFFSET(GX2AttribStream, 0x1c, endianSwap);
+WUT_CHECK_SIZE(GX2AttribStream, 0x20);
 
 uint32_t
 GX2CalcGeometryShaderInputRingBufferSize(uint32_t ringItemSize);
diff --git a/include/gx2/surface.h b/include/gx2/surface.h
index 93b3418..7930fd2 100644
--- a/include/gx2/surface.h
+++ b/include/gx2/surface.h
@@ -40,25 +40,25 @@ struct GX2Surface
    uint32_t pitch;
    uint32_t mipLevelOffset[13];
 };
-CHECK_OFFSET(GX2Surface, 0x0, dim);
-CHECK_OFFSET(GX2Surface, 0x4, width);
-CHECK_OFFSET(GX2Surface, 0x8, height);
-CHECK_OFFSET(GX2Surface, 0xc, depth);
-CHECK_OFFSET(GX2Surface, 0x10, mipLevels);
-CHECK_OFFSET(GX2Surface, 0x14, format);
-CHECK_OFFSET(GX2Surface, 0x18, aa);
-CHECK_OFFSET(GX2Surface, 0x1c, use);
-CHECK_OFFSET(GX2Surface, 0x1c, resourceFlags);
-CHECK_OFFSET(GX2Surface, 0x20, imageSize);
-CHECK_OFFSET(GX2Surface, 0x24, image);
-CHECK_OFFSET(GX2Surface, 0x28, mipmapSize);
-CHECK_OFFSET(GX2Surface, 0x2c, mipmaps);
-CHECK_OFFSET(GX2Surface, 0x30, tileMode);
-CHECK_OFFSET(GX2Surface, 0x34, swizzle);
-CHECK_OFFSET(GX2Surface, 0x38, alignment);
-CHECK_OFFSET(GX2Surface, 0x3C, pitch);
-CHECK_OFFSET(GX2Surface, 0x40, mipLevelOffset);
-CHECK_SIZE(GX2Surface, 0x74);
+WUT_CHECK_OFFSET(GX2Surface, 0x0, dim);
+WUT_CHECK_OFFSET(GX2Surface, 0x4, width);
+WUT_CHECK_OFFSET(GX2Surface, 0x8, height);
+WUT_CHECK_OFFSET(GX2Surface, 0xc, depth);
+WUT_CHECK_OFFSET(GX2Surface, 0x10, mipLevels);
+WUT_CHECK_OFFSET(GX2Surface, 0x14, format);
+WUT_CHECK_OFFSET(GX2Surface, 0x18, aa);
+WUT_CHECK_OFFSET(GX2Surface, 0x1c, use);
+WUT_CHECK_OFFSET(GX2Surface, 0x1c, resourceFlags);
+WUT_CHECK_OFFSET(GX2Surface, 0x20, imageSize);
+WUT_CHECK_OFFSET(GX2Surface, 0x24, image);
+WUT_CHECK_OFFSET(GX2Surface, 0x28, mipmapSize);
+WUT_CHECK_OFFSET(GX2Surface, 0x2c, mipmaps);
+WUT_CHECK_OFFSET(GX2Surface, 0x30, tileMode);
+WUT_CHECK_OFFSET(GX2Surface, 0x34, swizzle);
+WUT_CHECK_OFFSET(GX2Surface, 0x38, alignment);
+WUT_CHECK_OFFSET(GX2Surface, 0x3C, pitch);
+WUT_CHECK_OFFSET(GX2Surface, 0x40, mipLevelOffset);
+WUT_CHECK_SIZE(GX2Surface, 0x74);
 
 struct GX2DepthBuffer
 {
@@ -74,15 +74,15 @@ struct GX2DepthBuffer
 
    uint32_t regs[7];
 };
-CHECK_OFFSET(GX2DepthBuffer, 0x74, viewMip);
-CHECK_OFFSET(GX2DepthBuffer, 0x78, viewFirstSlice);
-CHECK_OFFSET(GX2DepthBuffer, 0x7C, viewNumSlices);
-CHECK_OFFSET(GX2DepthBuffer, 0x80, hiZPtr);
-CHECK_OFFSET(GX2DepthBuffer, 0x84, hiZSize);
-CHECK_OFFSET(GX2DepthBuffer, 0x88, depthClear);
-CHECK_OFFSET(GX2DepthBuffer, 0x8C, stencilClear);
-CHECK_OFFSET(GX2DepthBuffer, 0x90, regs);
-CHECK_SIZE(GX2DepthBuffer, 0xAC);
+WUT_CHECK_OFFSET(GX2DepthBuffer, 0x74, viewMip);
+WUT_CHECK_OFFSET(GX2DepthBuffer, 0x78, viewFirstSlice);
+WUT_CHECK_OFFSET(GX2DepthBuffer, 0x7C, viewNumSlices);
+WUT_CHECK_OFFSET(GX2DepthBuffer, 0x80, hiZPtr);
+WUT_CHECK_OFFSET(GX2DepthBuffer, 0x84, hiZSize);
+WUT_CHECK_OFFSET(GX2DepthBuffer, 0x88, depthClear);
+WUT_CHECK_OFFSET(GX2DepthBuffer, 0x8C, stencilClear);
+WUT_CHECK_OFFSET(GX2DepthBuffer, 0x90, regs);
+WUT_CHECK_SIZE(GX2DepthBuffer, 0xAC);
 
 struct GX2ColorBuffer
 {
@@ -96,13 +96,13 @@ struct GX2ColorBuffer
 
    uint32_t regs[5];
 };
-CHECK_OFFSET(GX2ColorBuffer, 0x74, viewMip);
-CHECK_OFFSET(GX2ColorBuffer, 0x78, viewFirstSlice);
-CHECK_OFFSET(GX2ColorBuffer, 0x7C, viewNumSlices);
-CHECK_OFFSET(GX2ColorBuffer, 0x80, aaBuffer);
-CHECK_OFFSET(GX2ColorBuffer, 0x84, aaSize);
-CHECK_OFFSET(GX2ColorBuffer, 0x88, regs);
-CHECK_SIZE(GX2ColorBuffer, 0x9C);
+WUT_CHECK_OFFSET(GX2ColorBuffer, 0x74, viewMip);
+WUT_CHECK_OFFSET(GX2ColorBuffer, 0x78, viewFirstSlice);
+WUT_CHECK_OFFSET(GX2ColorBuffer, 0x7C, viewNumSlices);
+WUT_CHECK_OFFSET(GX2ColorBuffer, 0x80, aaBuffer);
+WUT_CHECK_OFFSET(GX2ColorBuffer, 0x84, aaSize);
+WUT_CHECK_OFFSET(GX2ColorBuffer, 0x88, regs);
+WUT_CHECK_SIZE(GX2ColorBuffer, 0x9C);
 
 void
 GX2CalcSurfaceSizeAndAlignment(GX2Surface *surface);
diff --git a/include/gx2/texture.h b/include/gx2/texture.h
index 3f4d8b9..dc522d4 100644
--- a/include/gx2/texture.h
+++ b/include/gx2/texture.h
@@ -25,14 +25,14 @@ struct GX2Texture
 
    uint32_t regs[5];
 };
-CHECK_OFFSET(GX2Texture, 0x0, surface);
-CHECK_OFFSET(GX2Texture, 0x74, viewFirstMip);
-CHECK_OFFSET(GX2Texture, 0x78, viewNumMips);
-CHECK_OFFSET(GX2Texture, 0x7c, viewFirstSlice);
-CHECK_OFFSET(GX2Texture, 0x80, viewNumSlices);
-CHECK_OFFSET(GX2Texture, 0x84, compMap);
-CHECK_OFFSET(GX2Texture, 0x88, regs);
-CHECK_SIZE(GX2Texture, 0x9c);
+WUT_CHECK_OFFSET(GX2Texture, 0x0, surface);
+WUT_CHECK_OFFSET(GX2Texture, 0x74, viewFirstMip);
+WUT_CHECK_OFFSET(GX2Texture, 0x78, viewNumMips);
+WUT_CHECK_OFFSET(GX2Texture, 0x7c, viewFirstSlice);
+WUT_CHECK_OFFSET(GX2Texture, 0x80, viewNumSlices);
+WUT_CHECK_OFFSET(GX2Texture, 0x84, compMap);
+WUT_CHECK_OFFSET(GX2Texture, 0x88, regs);
+WUT_CHECK_SIZE(GX2Texture, 0x9c);
 
 void
 GX2InitTextureRegs(GX2Texture *texture);
diff --git a/include/gx2r/buffer.h b/include/gx2r/buffer.h
index 6bd8e88..a349281 100644
--- a/include/gx2r/buffer.h
+++ b/include/gx2r/buffer.h
@@ -21,11 +21,11 @@ struct GX2RBuffer
    uint32_t elemCount;
    void *buffer;
 };
-CHECK_SIZE(GX2RBuffer, 0x10);
-CHECK_OFFSET(GX2RBuffer, 0x00, flags);
-CHECK_OFFSET(GX2RBuffer, 0x04, elemSize);
-CHECK_OFFSET(GX2RBuffer, 0x08, elemCount);
-CHECK_OFFSET(GX2RBuffer, 0x0C, buffer);
+WUT_CHECK_SIZE(GX2RBuffer, 0x10);
+WUT_CHECK_OFFSET(GX2RBuffer, 0x00, flags);
+WUT_CHECK_OFFSET(GX2RBuffer, 0x04, elemSize);
+WUT_CHECK_OFFSET(GX2RBuffer, 0x08, elemCount);
+WUT_CHECK_OFFSET(GX2RBuffer, 0x0C, buffer);
 
 BOOL
 GX2RBufferExists(GX2RBuffer *buffer);
diff --git a/include/nn/swkbd/swkbd_cpp.h b/include/nn/swkbd/swkbd_cpp.h
index b704fc0..a78b6ea 100644
--- a/include/nn/swkbd/swkbd_cpp.h
+++ b/include/nn/swkbd/swkbd_cpp.h
@@ -62,20 +62,20 @@ struct ConfigArg
    uint32_t unk_0x0C;
    uint32_t unk_0x10;
    int32_t unk_0x14;
-   UNKNOWN(0x9C - 0x18);
+   WUT_UNKNOWN_BYTES(0x9C - 0x18);
    uint32_t unk_0x9C;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
    int32_t unk_0xA4;
 };
-CHECK_OFFSET(ConfigArg, languageType, 0x00);
-CHECK_OFFSET(ConfigArg, unk_0x04, 0x04);
-CHECK_OFFSET(ConfigArg, unk_0x08, 0x08);
-CHECK_OFFSET(ConfigArg, unk_0x0C, 0x0C);
-CHECK_OFFSET(ConfigArg, unk_0x10, 0x10);
-CHECK_OFFSET(ConfigArg, unk_0x14, 0x14);
-CHECK_OFFSET(ConfigArg, unk_0x9C, 0x9C);
-CHECK_OFFSET(ConfigArg, unk_0xA4, 0xA4);
-CHECK_SIZE(ConfigArg, 0xA8);
+WUT_CHECK_OFFSET(ConfigArg, languageType, 0x00);
+WUT_CHECK_OFFSET(ConfigArg, unk_0x04, 0x04);
+WUT_CHECK_OFFSET(ConfigArg, unk_0x08, 0x08);
+WUT_CHECK_OFFSET(ConfigArg, unk_0x0C, 0x0C);
+WUT_CHECK_OFFSET(ConfigArg, unk_0x10, 0x10);
+WUT_CHECK_OFFSET(ConfigArg, unk_0x14, 0x14);
+WUT_CHECK_OFFSET(ConfigArg, unk_0x9C, 0x9C);
+WUT_CHECK_OFFSET(ConfigArg, unk_0xA4, 0xA4);
+WUT_CHECK_SIZE(ConfigArg, 0xA8);
 
 struct ReceiverArg
 {
@@ -86,20 +86,20 @@ struct ReceiverArg
    uint32_t unk_0x10 = 0;
    int32_t unk_0x14 = -1;
 };
-CHECK_OFFSET(ReceiverArg, unk_0x00, 0x00);
-CHECK_OFFSET(ReceiverArg, unk_0x04, 0x04);
-CHECK_OFFSET(ReceiverArg, unk_0x08, 0x08);
-CHECK_OFFSET(ReceiverArg, unk_0x0C, 0x0C);
-CHECK_OFFSET(ReceiverArg, unk_0x10, 0x10);
-CHECK_OFFSET(ReceiverArg, unk_0x14, 0x14);
-CHECK_SIZE(ReceiverArg, 0x18);
+WUT_CHECK_OFFSET(ReceiverArg, unk_0x00, 0x00);
+WUT_CHECK_OFFSET(ReceiverArg, unk_0x04, 0x04);
+WUT_CHECK_OFFSET(ReceiverArg, unk_0x08, 0x08);
+WUT_CHECK_OFFSET(ReceiverArg, unk_0x0C, 0x0C);
+WUT_CHECK_OFFSET(ReceiverArg, unk_0x10, 0x10);
+WUT_CHECK_OFFSET(ReceiverArg, unk_0x14, 0x14);
+WUT_CHECK_SIZE(ReceiverArg, 0x18);
 
 struct KeyboardArg
 {
    ConfigArg configArg;
    ReceiverArg receiverArg;
 };
-CHECK_SIZE(KeyboardArg, 0xC0);
+WUT_CHECK_SIZE(KeyboardArg, 0xC0);
 
 struct InputFormArg
 {
@@ -113,26 +113,26 @@ struct InputFormArg
    bool unk_0x1C = false;
    bool unk_0x1D = false;
    bool unk_0x1E = false;
-   PADDING(1);
+   WUT_PADDING_BYTES(1);
 };
-CHECK_OFFSET(InputFormArg, unk_0x00, 0x00);
-CHECK_OFFSET(InputFormArg, unk_0x04, 0x04);
-CHECK_OFFSET(InputFormArg, unk_0x08, 0x08);
-CHECK_OFFSET(InputFormArg, unk_0x0C, 0x0C);
-CHECK_OFFSET(InputFormArg, maxTextLength, 0x10);
-CHECK_OFFSET(InputFormArg, unk_0x14, 0x14);
-CHECK_OFFSET(InputFormArg, unk_0x18, 0x18);
-CHECK_OFFSET(InputFormArg, unk_0x1C, 0x1C);
-CHECK_OFFSET(InputFormArg, unk_0x1D, 0x1D);
-CHECK_OFFSET(InputFormArg, unk_0x1E, 0x1E);
-CHECK_SIZE(InputFormArg, 0x20);
+WUT_CHECK_OFFSET(InputFormArg, unk_0x00, 0x00);
+WUT_CHECK_OFFSET(InputFormArg, unk_0x04, 0x04);
+WUT_CHECK_OFFSET(InputFormArg, unk_0x08, 0x08);
+WUT_CHECK_OFFSET(InputFormArg, unk_0x0C, 0x0C);
+WUT_CHECK_OFFSET(InputFormArg, maxTextLength, 0x10);
+WUT_CHECK_OFFSET(InputFormArg, unk_0x14, 0x14);
+WUT_CHECK_OFFSET(InputFormArg, unk_0x18, 0x18);
+WUT_CHECK_OFFSET(InputFormArg, unk_0x1C, 0x1C);
+WUT_CHECK_OFFSET(InputFormArg, unk_0x1D, 0x1D);
+WUT_CHECK_OFFSET(InputFormArg, unk_0x1E, 0x1E);
+WUT_CHECK_SIZE(InputFormArg, 0x20);
 
 struct AppearArg
 {
    KeyboardArg keyboardArg;
    InputFormArg inputFormArg;
 };
-CHECK_SIZE(AppearArg, 0xE0);
+WUT_CHECK_SIZE(AppearArg, 0xE0);
 
 struct CreateArg
 {
@@ -141,20 +141,20 @@ struct CreateArg
    uint32_t unk_0x08 = 0;
    FSClient *fsClient = nullptr;
 };
-CHECK_OFFSET(CreateArg, 0x00, workMemory);
-CHECK_OFFSET(CreateArg, 0x04, regionType);
-CHECK_OFFSET(CreateArg, 0x08, unk_0x08);
-CHECK_OFFSET(CreateArg, 0x0C, fsClient);
-CHECK_SIZE(CreateArg, 0x10);
+WUT_CHECK_OFFSET(CreateArg, 0x00, workMemory);
+WUT_CHECK_OFFSET(CreateArg, 0x04, regionType);
+WUT_CHECK_OFFSET(CreateArg, 0x08, unk_0x08);
+WUT_CHECK_OFFSET(CreateArg, 0x0C, fsClient);
+WUT_CHECK_SIZE(CreateArg, 0x10);
 
 struct ControllerInfo
 {
    VPADStatus *vpad = nullptr;
    KPADStatus *kpad[4] = { nullptr, nullptr, nullptr, nullptr };
 };
-CHECK_OFFSET(ControllerInfo, 0x00, vpad);
-CHECK_OFFSET(ControllerInfo, 0x04, kpad);
-CHECK_SIZE(ControllerInfo, 0x14);
+WUT_CHECK_OFFSET(ControllerInfo, 0x00, vpad);
+WUT_CHECK_OFFSET(ControllerInfo, 0x04, kpad);
+WUT_CHECK_SIZE(ControllerInfo, 0x14);
 
 struct DrawStringInfo
 {
@@ -163,18 +163,18 @@ struct DrawStringInfo
       memset(this, 0, sizeof(*this));
    }
 
-   UNKNOWN(0x1C);
+   WUT_UNKNOWN_BYTES(0x1C);
 };
-CHECK_SIZE(DrawStringInfo, 0x1C);
+WUT_CHECK_SIZE(DrawStringInfo, 0x1C);
 
 struct KeyboardCondition
 {
    uint32_t unk_0x00 = 0;
    uint32_t unk_0x04 = 0;
 };
-CHECK_OFFSET(KeyboardCondition, unk_0x00, 0x00);
-CHECK_OFFSET(KeyboardCondition, unk_0x04, 0x04);
-CHECK_SIZE(KeyboardCondition, 0x8);
+WUT_CHECK_OFFSET(KeyboardCondition, unk_0x00, 0x00);
+WUT_CHECK_OFFSET(KeyboardCondition, unk_0x04, 0x04);
+WUT_CHECK_SIZE(KeyboardCondition, 0x8);
 
 struct IEventReceiver;
 struct IControllerEventObj;
diff --git a/include/nsyshid/hid.h b/include/nsyshid/hid.h
index 1507fd1..1e28407 100644
--- a/include/nsyshid/hid.h
+++ b/include/nsyshid/hid.h
@@ -40,29 +40,29 @@ struct HIDDevice
    uint8_t interfaceIndex;
    uint8_t subClass;
    uint8_t protocol;
-   PADDING(1);
+   WUT_PADDING_BYTES(1);
    uint16_t maxPacketSizeRx;
    uint16_t maxPacketSizeTx;
 };
-CHECK_OFFSET(HIDDevice, 0x00, handle);
-CHECK_OFFSET(HIDDevice, 0x04, physicalDeviceInst);
-CHECK_OFFSET(HIDDevice, 0x08, vid);
-CHECK_OFFSET(HIDDevice, 0x0A, pid);
-CHECK_OFFSET(HIDDevice, 0x0C, interfaceIndex);
-CHECK_OFFSET(HIDDevice, 0x0D, subClass);
-CHECK_OFFSET(HIDDevice, 0x0E, protocol);
-CHECK_OFFSET(HIDDevice, 0x10, maxPacketSizeRx);
-CHECK_OFFSET(HIDDevice, 0x12, maxPacketSizeTx);
-CHECK_SIZE(HIDDevice, 0x14);
+WUT_CHECK_OFFSET(HIDDevice, 0x00, handle);
+WUT_CHECK_OFFSET(HIDDevice, 0x04, physicalDeviceInst);
+WUT_CHECK_OFFSET(HIDDevice, 0x08, vid);
+WUT_CHECK_OFFSET(HIDDevice, 0x0A, pid);
+WUT_CHECK_OFFSET(HIDDevice, 0x0C, interfaceIndex);
+WUT_CHECK_OFFSET(HIDDevice, 0x0D, subClass);
+WUT_CHECK_OFFSET(HIDDevice, 0x0E, protocol);
+WUT_CHECK_OFFSET(HIDDevice, 0x10, maxPacketSizeRx);
+WUT_CHECK_OFFSET(HIDDevice, 0x12, maxPacketSizeTx);
+WUT_CHECK_SIZE(HIDDevice, 0x14);
 
 struct HIDClient
 {
    HIDClient *next;
    HIDAttachCallback attachCallback;
 };
-CHECK_OFFSET(HIDClient, 0x00, next);
-CHECK_OFFSET(HIDClient, 0x04, attachCallback);
-CHECK_SIZE(HIDClient, 0x08);
+WUT_CHECK_OFFSET(HIDClient, 0x00, next);
+WUT_CHECK_OFFSET(HIDClient, 0x04, attachCallback);
+WUT_CHECK_SIZE(HIDClient, 0x08);
 
 
 int32_t
diff --git a/include/padscore/kpad.h b/include/padscore/kpad.h
index 7c6dbcd..5f0c587 100644
--- a/include/padscore/kpad.h
+++ b/include/padscore/kpad.h
@@ -28,9 +28,9 @@ struct KPADVec2D
     float x;
     float y;
 };
-CHECK_OFFSET(KPADVec2D, 0x00, x);
-CHECK_OFFSET(KPADVec2D, 0x04, y);
-CHECK_SIZE(KPADVec2D, 0x08);
+WUT_CHECK_OFFSET(KPADVec2D, 0x00, x);
+WUT_CHECK_OFFSET(KPADVec2D, 0x04, y);
+WUT_CHECK_SIZE(KPADVec2D, 0x08);
 
 struct KPADStatus
 {
@@ -43,15 +43,15 @@ struct KPADStatus
    //! Indicates what KPADButtons have been released since last sample
    uint32_t release;
 
-   UNKNOWN(5 * 4);
+   WUT_UNKNOWN_BYTES(5 * 4);
 
    KPADVec2D pos;
 
-   UNKNOWN(3 * 4);
+   WUT_UNKNOWN_BYTES(3 * 4);
 
    KPADVec2D angle;
 
-   UNKNOWN(8 * 4);
+   WUT_UNKNOWN_BYTES(8 * 4);
 
    //! Value from KPADExtensionType
    uint8_t extensionType;
@@ -97,39 +97,39 @@ struct KPADStatus
          int32_t wired;
       } pro;
 
-      UNKNOWN(20 * 4);
+      WUT_UNKNOWN_BYTES(20 * 4);
    };
 
-   UNKNOWN(16 * 4);
+   WUT_UNKNOWN_BYTES(16 * 4);
 };
-CHECK_OFFSET(KPADStatus, 0x00, hold);
-CHECK_OFFSET(KPADStatus, 0x04, trigger);
-CHECK_OFFSET(KPADStatus, 0x08, release);
-CHECK_OFFSET(KPADStatus, 0x20, pos);
-CHECK_OFFSET(KPADStatus, 0x34, angle);
-CHECK_OFFSET(KPADStatus, 0x5C, extensionType);
-CHECK_OFFSET(KPADStatus, 0x5D, error);
-CHECK_OFFSET(KPADStatus, 0x5E, posValid);
-CHECK_OFFSET(KPADStatus, 0x5F, format);
+WUT_CHECK_OFFSET(KPADStatus, 0x00, hold);
+WUT_CHECK_OFFSET(KPADStatus, 0x04, trigger);
+WUT_CHECK_OFFSET(KPADStatus, 0x08, release);
+WUT_CHECK_OFFSET(KPADStatus, 0x20, pos);
+WUT_CHECK_OFFSET(KPADStatus, 0x34, angle);
+WUT_CHECK_OFFSET(KPADStatus, 0x5C, extensionType);
+WUT_CHECK_OFFSET(KPADStatus, 0x5D, error);
+WUT_CHECK_OFFSET(KPADStatus, 0x5E, posValid);
+WUT_CHECK_OFFSET(KPADStatus, 0x5F, format);
 // For WPAD_EXT_NUNCHUK
-CHECK_OFFSET(KPADStatus, 0x60, nunchuck.stick);
+WUT_CHECK_OFFSET(KPADStatus, 0x60, nunchuck.stick);
 // For WPAD_EXT_CLASSIC
-CHECK_OFFSET(KPADStatus, 0x60, classic.hold);
-CHECK_OFFSET(KPADStatus, 0x64, classic.trigger);
-CHECK_OFFSET(KPADStatus, 0x68, classic.release);
-CHECK_OFFSET(KPADStatus, 0x6C, classic.leftStick);
-CHECK_OFFSET(KPADStatus, 0x74, classic.rightStick);
-CHECK_OFFSET(KPADStatus, 0x7C, classic.leftTrigger);
-CHECK_OFFSET(KPADStatus, 0x80, classic.rightTrigger);
+WUT_CHECK_OFFSET(KPADStatus, 0x60, classic.hold);
+WUT_CHECK_OFFSET(KPADStatus, 0x64, classic.trigger);
+WUT_CHECK_OFFSET(KPADStatus, 0x68, classic.release);
+WUT_CHECK_OFFSET(KPADStatus, 0x6C, classic.leftStick);
+WUT_CHECK_OFFSET(KPADStatus, 0x74, classic.rightStick);
+WUT_CHECK_OFFSET(KPADStatus, 0x7C, classic.leftTrigger);
+WUT_CHECK_OFFSET(KPADStatus, 0x80, classic.rightTrigger);
 // For WPAD_EXT_PRO_CONTROLLER
-CHECK_OFFSET(KPADStatus, 0x60, pro.hold);
-CHECK_OFFSET(KPADStatus, 0x64, pro.trigger);
-CHECK_OFFSET(KPADStatus, 0x68, pro.release);
-CHECK_OFFSET(KPADStatus, 0x6C, pro.leftStick);
-CHECK_OFFSET(KPADStatus, 0x74, pro.rightStick);
-CHECK_OFFSET(KPADStatus, 0x7C, pro.charging);
-CHECK_OFFSET(KPADStatus, 0x80, pro.wired);
-CHECK_SIZE(KPADStatus, 0xF0);
+WUT_CHECK_OFFSET(KPADStatus, 0x60, pro.hold);
+WUT_CHECK_OFFSET(KPADStatus, 0x64, pro.trigger);
+WUT_CHECK_OFFSET(KPADStatus, 0x68, pro.release);
+WUT_CHECK_OFFSET(KPADStatus, 0x6C, pro.leftStick);
+WUT_CHECK_OFFSET(KPADStatus, 0x74, pro.rightStick);
+WUT_CHECK_OFFSET(KPADStatus, 0x7C, pro.charging);
+WUT_CHECK_OFFSET(KPADStatus, 0x80, pro.wired);
+WUT_CHECK_SIZE(KPADStatus, 0xF0);
 
 void
 KPADInit();
diff --git a/include/padscore/wpad.h b/include/padscore/wpad.h
index f295a27..5c22f57 100644
--- a/include/padscore/wpad.h
+++ b/include/padscore/wpad.h
@@ -108,32 +108,32 @@ struct WPADVec2D
    int16_t x;
    int16_t y;
 };
-CHECK_OFFSET(WPADVec2D, 0x00, x);
-CHECK_OFFSET(WPADVec2D, 0x02, y);
-CHECK_SIZE(WPADVec2D, 0x04);
+WUT_CHECK_OFFSET(WPADVec2D, 0x00, x);
+WUT_CHECK_OFFSET(WPADVec2D, 0x02, y);
+WUT_CHECK_SIZE(WPADVec2D, 0x04);
 
 struct WPADStatusProController
 {
-   UNKNOWN(0x28);
+   WUT_UNKNOWN_BYTES(0x28);
 
    //! A value from WPADExtensionType
    uint8_t extensionType;
 
    uint8_t err;
-   PADDING(2);
+   WUT_PADDING_BYTES(2);
    uint32_t buttons;
    WPADVec2D leftStick;
    WPADVec2D rightStick;
-   UNKNOWN(8);
+   WUT_UNKNOWN_BYTES(8);
    WPADDataFormat dataFormat;
 };
-CHECK_OFFSET(WPADStatusProController, 0x28, extensionType);
-CHECK_OFFSET(WPADStatusProController, 0x29, err);
-CHECK_OFFSET(WPADStatusProController, 0x2C, buttons);
-CHECK_OFFSET(WPADStatusProController, 0x30, leftStick);
-CHECK_OFFSET(WPADStatusProController, 0x34, rightStick);
-CHECK_OFFSET(WPADStatusProController, 0x40, dataFormat);
-CHECK_SIZE(WPADStatusProController, 0x44);
+WUT_CHECK_OFFSET(WPADStatusProController, 0x28, extensionType);
+WUT_CHECK_OFFSET(WPADStatusProController, 0x29, err);
+WUT_CHECK_OFFSET(WPADStatusProController, 0x2C, buttons);
+WUT_CHECK_OFFSET(WPADStatusProController, 0x30, leftStick);
+WUT_CHECK_OFFSET(WPADStatusProController, 0x34, rightStick);
+WUT_CHECK_OFFSET(WPADStatusProController, 0x40, dataFormat);
+WUT_CHECK_SIZE(WPADStatusProController, 0x44);
 
 typedef void (*WPADSamplingCallback)(WPADChan chan);
 typedef void (*WPADExtensionCallback)(WPADChan chan, int32_t status);
diff --git a/include/sndcore2/core.h b/include/sndcore2/core.h
index 1cfd1bd..c4f1c73 100644
--- a/include/sndcore2/core.h
+++ b/include/sndcore2/core.h
@@ -44,12 +44,12 @@ struct AXProfile
 struct AXInitParams
 {
    AXInitRenderer renderer;
-   UNKNOWN(4);
+   WUT_UNKNOWN_BYTES(4);
    AXInitPipeline pipeline;
 };
-CHECK_OFFSET(AXInitParams, 0x00, renderer);
-CHECK_OFFSET(AXInitParams, 0x08, pipeline);
-CHECK_SIZE(AXInitParams, 0x0C);
+WUT_CHECK_OFFSET(AXInitParams, 0x00, renderer);
+WUT_CHECK_OFFSET(AXInitParams, 0x08, pipeline);
+WUT_CHECK_SIZE(AXInitParams, 0x0C);
 
 void
 AXInit();
diff --git a/include/sndcore2/voice.h b/include/sndcore2/voice.h
index 4eb0def..667b712 100644
--- a/include/sndcore2/voice.h
+++ b/include/sndcore2/voice.h
@@ -101,9 +101,9 @@ struct AXVoiceLink
    AXVoice *next;
    AXVoice *prev;
 };
-CHECK_OFFSET(AXVoiceLink, 0x0, next);
-CHECK_OFFSET(AXVoiceLink, 0x4, prev);
-CHECK_SIZE(AXVoiceLink, 0x8);
+WUT_CHECK_OFFSET(AXVoiceLink, 0x0, next);
+WUT_CHECK_OFFSET(AXVoiceLink, 0x4, prev);
+WUT_CHECK_SIZE(AXVoiceLink, 0x8);
 
 struct AXVoiceOffsets
 {
@@ -114,13 +114,13 @@ struct AXVoiceOffsets
    uint32_t currentOffset;
    const void *data;
 };
-CHECK_OFFSET(AXVoiceOffsets, 0x0, dataType);
-CHECK_OFFSET(AXVoiceOffsets, 0x2, loopingEnabled);
-CHECK_OFFSET(AXVoiceOffsets, 0x4, loopOffset);
-CHECK_OFFSET(AXVoiceOffsets, 0x8, endOffset);
-CHECK_OFFSET(AXVoiceOffsets, 0xc, currentOffset);
-CHECK_OFFSET(AXVoiceOffsets, 0x10, data);
-CHECK_SIZE(AXVoiceOffsets, 0x14);
+WUT_CHECK_OFFSET(AXVoiceOffsets, 0x0, dataType);
+WUT_CHECK_OFFSET(AXVoiceOffsets, 0x2, loopingEnabled);
+WUT_CHECK_OFFSET(AXVoiceOffsets, 0x4, loopOffset);
+WUT_CHECK_OFFSET(AXVoiceOffsets, 0x8, endOffset);
+WUT_CHECK_OFFSET(AXVoiceOffsets, 0xc, currentOffset);
+WUT_CHECK_OFFSET(AXVoiceOffsets, 0x10, data);
+WUT_CHECK_SIZE(AXVoiceOffsets, 0x14);
 
 struct AXVoice
 {
@@ -154,7 +154,7 @@ struct AXVoice
    //! A bitfield representing different things needing to be synced.
    uint32_t syncBits;
 
-   UNKNOWN(0x8);
+   WUT_UNKNOWN_BYTES(0x8);
 
    //! The current offset data!
    AXVoiceOffsets offsets;
@@ -168,56 +168,56 @@ struct AXVoice
    float unk0;
    float unk1;
 };
-CHECK_OFFSET(AXVoice, 0x0, index);
-CHECK_OFFSET(AXVoice, 0x4, state);
-CHECK_OFFSET(AXVoice, 0x8, volume);
-CHECK_OFFSET(AXVoice, 0xc, renderer);
-CHECK_OFFSET(AXVoice, 0x10, link);
-CHECK_OFFSET(AXVoice, 0x18, cbNext);
-CHECK_OFFSET(AXVoice, 0x1c, priority);
-CHECK_OFFSET(AXVoice, 0x20, callback);
-CHECK_OFFSET(AXVoice, 0x24, userContext);
-CHECK_OFFSET(AXVoice, 0x28, syncBits);
-CHECK_OFFSET(AXVoice, 0x34, offsets);
-CHECK_OFFSET(AXVoice, 0x48, callbackEx);
-CHECK_OFFSET(AXVoice, 0x4c, callbackReason);
-CHECK_OFFSET(AXVoice, 0x50, unk0);
-CHECK_OFFSET(AXVoice, 0x54, unk1);
-CHECK_SIZE(AXVoice, 0x58);
+WUT_CHECK_OFFSET(AXVoice, 0x0, index);
+WUT_CHECK_OFFSET(AXVoice, 0x4, state);
+WUT_CHECK_OFFSET(AXVoice, 0x8, volume);
+WUT_CHECK_OFFSET(AXVoice, 0xc, renderer);
+WUT_CHECK_OFFSET(AXVoice, 0x10, link);
+WUT_CHECK_OFFSET(AXVoice, 0x18, cbNext);
+WUT_CHECK_OFFSET(AXVoice, 0x1c, priority);
+WUT_CHECK_OFFSET(AXVoice, 0x20, callback);
+WUT_CHECK_OFFSET(AXVoice, 0x24, userContext);
+WUT_CHECK_OFFSET(AXVoice, 0x28, syncBits);
+WUT_CHECK_OFFSET(AXVoice, 0x34, offsets);
+WUT_CHECK_OFFSET(AXVoice, 0x48, callbackEx);
+WUT_CHECK_OFFSET(AXVoice, 0x4c, callbackReason);
+WUT_CHECK_OFFSET(AXVoice, 0x50, unk0);
+WUT_CHECK_OFFSET(AXVoice, 0x54, unk1);
+WUT_CHECK_SIZE(AXVoice, 0x58);
 
 struct AXVoiceDeviceBusMixData
 {
    uint16_t volume;
    int16_t delta;
 };
-CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x0, volume);
-CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x2, delta);
-CHECK_SIZE(AXVoiceDeviceBusMixData, 0x4);
+WUT_CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x0, volume);
+WUT_CHECK_OFFSET(AXVoiceDeviceBusMixData, 0x2, delta);
+WUT_CHECK_SIZE(AXVoiceDeviceBusMixData, 0x4);
 
 struct AXVoiceDeviceMixData
 {
    AXVoiceDeviceBusMixData bus[4];
 };
-CHECK_OFFSET(AXVoiceDeviceMixData, 0x0, bus);
-CHECK_SIZE(AXVoiceDeviceMixData, 0x10);
+WUT_CHECK_OFFSET(AXVoiceDeviceMixData, 0x0, bus);
+WUT_CHECK_SIZE(AXVoiceDeviceMixData, 0x10);
 
 struct AXVoiceVeData
 {
    uint16_t volume;
    int16_t delta;
 };
-CHECK_OFFSET(AXVoiceVeData, 0x0, volume);
-CHECK_OFFSET(AXVoiceVeData, 0x2, delta);
-CHECK_SIZE(AXVoiceVeData, 0x4);
+WUT_CHECK_OFFSET(AXVoiceVeData, 0x0, volume);
+WUT_CHECK_OFFSET(AXVoiceVeData, 0x2, delta);
+WUT_CHECK_SIZE(AXVoiceVeData, 0x4);
 
 struct AXVoiceAdpcmLoopData
 {
    uint16_t predScale;
    int16_t prevSample[2];
 };
-CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x0, predScale);
-CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x2, prevSample);
-CHECK_SIZE(AXVoiceAdpcmLoopData, 0x6);
+WUT_CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x0, predScale);
+WUT_CHECK_OFFSET(AXVoiceAdpcmLoopData, 0x2, prevSample);
+WUT_CHECK_SIZE(AXVoiceAdpcmLoopData, 0x6);
 
 struct AXVoiceAdpcm
 {
@@ -226,11 +226,11 @@ struct AXVoiceAdpcm
    uint16_t predScale;
    int16_t prevSample[2];
 };
-CHECK_OFFSET(AXVoiceAdpcm, 0x0, coefficients);
-CHECK_OFFSET(AXVoiceAdpcm, 0x20, gain);
-CHECK_OFFSET(AXVoiceAdpcm, 0x22, predScale);
-CHECK_OFFSET(AXVoiceAdpcm, 0x24, prevSample);
-CHECK_SIZE(AXVoiceAdpcm, 0x28);
+WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x0, coefficients);
+WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x20, gain);
+WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x22, predScale);
+WUT_CHECK_OFFSET(AXVoiceAdpcm, 0x24, prevSample);
+WUT_CHECK_SIZE(AXVoiceAdpcm, 0x28);
 
 #pragma pack(push, 1)
 
@@ -246,10 +246,10 @@ struct AXVoiceSrc
    uint16_t currentOffsetFrac;
    int16_t lastSample[4];
 };
-CHECK_OFFSET(AXVoiceSrc, 0x0, ratio);
-CHECK_OFFSET(AXVoiceSrc, 0x4, currentOffsetFrac);
-CHECK_OFFSET(AXVoiceSrc, 0x6, lastSample);
-CHECK_SIZE(AXVoiceSrc, 0xe);
+WUT_CHECK_OFFSET(AXVoiceSrc, 0x0, ratio);
+WUT_CHECK_OFFSET(AXVoiceSrc, 0x4, currentOffsetFrac);
+WUT_CHECK_OFFSET(AXVoiceSrc, 0x6, lastSample);
+WUT_CHECK_SIZE(AXVoiceSrc, 0xe);
 
 #pragma pack(pop)
 
diff --git a/include/vpad/input.h b/include/vpad/input.h
index 7b2294c..22618ab 100644
--- a/include/vpad/input.h
+++ b/include/vpad/input.h
@@ -78,9 +78,9 @@ struct VPADVec2D
    float x;
    float y;
 };
-CHECK_OFFSET(VPADVec2D, 0x00, x);
-CHECK_OFFSET(VPADVec2D, 0x04, y);
-CHECK_SIZE(VPADVec2D, 0x08);
+WUT_CHECK_OFFSET(VPADVec2D, 0x00, x);
+WUT_CHECK_OFFSET(VPADVec2D, 0x04, y);
+WUT_CHECK_SIZE(VPADVec2D, 0x08);
 
 struct VPADVec3D
 {
@@ -88,10 +88,10 @@ struct VPADVec3D
    float y;
    float z;
 };
-CHECK_OFFSET(VPADVec3D, 0x00, x);
-CHECK_OFFSET(VPADVec3D, 0x04, y);
-CHECK_OFFSET(VPADVec3D, 0x08, z);
-CHECK_SIZE(VPADVec3D, 0x0C);
+WUT_CHECK_OFFSET(VPADVec3D, 0x00, x);
+WUT_CHECK_OFFSET(VPADVec3D, 0x04, y);
+WUT_CHECK_OFFSET(VPADVec3D, 0x08, z);
+WUT_CHECK_SIZE(VPADVec3D, 0x0C);
 
 struct VPADTouchData
 {
@@ -104,11 +104,11 @@ struct VPADTouchData
    //! Bitfield of VPADTouchPadValidity to indicate how touch sample accuracy
    uint16_t validity;
 };
-CHECK_OFFSET(VPADTouchData, 0x00, x);
-CHECK_OFFSET(VPADTouchData, 0x02, y);
-CHECK_OFFSET(VPADTouchData, 0x04, touched);
-CHECK_OFFSET(VPADTouchData, 0x06, validity);
-CHECK_SIZE(VPADTouchData, 0x08);
+WUT_CHECK_OFFSET(VPADTouchData, 0x00, x);
+WUT_CHECK_OFFSET(VPADTouchData, 0x02, y);
+WUT_CHECK_OFFSET(VPADTouchData, 0x04, touched);
+WUT_CHECK_OFFSET(VPADTouchData, 0x06, validity);
+WUT_CHECK_SIZE(VPADTouchData, 0x08);
 
 struct VPADAccStatus
 {
@@ -119,8 +119,8 @@ struct VPADAccStatus
    float unk5;
    VPADVec2D vertical;
 };
-CHECK_OFFSET(VPADAccStatus, 0x14, vertical);
-CHECK_SIZE(VPADAccStatus, 0x1c);
+WUT_CHECK_OFFSET(VPADAccStatus, 0x14, vertical);
+WUT_CHECK_SIZE(VPADAccStatus, 0x1c);
 
 struct VPADGyroStatus
 {
@@ -131,7 +131,7 @@ struct VPADGyroStatus
    float unk5;
    float unk6;
 };
-CHECK_SIZE(VPADGyroStatus, 0x18);
+WUT_CHECK_SIZE(VPADGyroStatus, 0x18);
 
 struct VPADStatus
 {
@@ -156,7 +156,7 @@ struct VPADStatus
    //! Status of DRC gyro
    VPADGyroStatus gyro;
 
-   UNKNOWN(2);
+   WUT_UNKNOWN_BYTES(2);
 
    //! Current touch position on DRC
    VPADTouchData tpNormal;
@@ -167,7 +167,7 @@ struct VPADStatus
    //! Filtered touch position, second level of smoothing
    VPADTouchData tpFiltered2;
 
-   UNKNOWN(0x28);
+   WUT_UNKNOWN_BYTES(0x28);
 
    //! Status of DRC magnetometer
    VPADVec3D mag;
@@ -184,24 +184,24 @@ struct VPADStatus
    //! Unknown volume related value
    uint8_t slideVolumeEx;
 
-   UNKNOWN(0x7);
+   WUT_UNKNOWN_BYTES(0x7);
 };
-CHECK_OFFSET(VPADStatus, 0x00, hold);
-CHECK_OFFSET(VPADStatus, 0x04, trigger);
-CHECK_OFFSET(VPADStatus, 0x08, release);
-CHECK_OFFSET(VPADStatus, 0x0C, leftStick);
-CHECK_OFFSET(VPADStatus, 0x14, rightStick);
-CHECK_OFFSET(VPADStatus, 0x1C, accelorometer);
-CHECK_OFFSET(VPADStatus, 0x38, gyro);
-CHECK_OFFSET(VPADStatus, 0x52, tpNormal);
-CHECK_OFFSET(VPADStatus, 0x5A, tpFiltered1);
-CHECK_OFFSET(VPADStatus, 0x62, tpFiltered2);
-CHECK_OFFSET(VPADStatus, 0x94, mag);
-CHECK_OFFSET(VPADStatus, 0xA0, slideVolume);
-CHECK_OFFSET(VPADStatus, 0xA1, battery);
-CHECK_OFFSET(VPADStatus, 0xA2, micStatus);
-CHECK_OFFSET(VPADStatus, 0xA3, slideVolumeEx);
-CHECK_SIZE(VPADStatus, 0xAC);
+WUT_CHECK_OFFSET(VPADStatus, 0x00, hold);
+WUT_CHECK_OFFSET(VPADStatus, 0x04, trigger);
+WUT_CHECK_OFFSET(VPADStatus, 0x08, release);
+WUT_CHECK_OFFSET(VPADStatus, 0x0C, leftStick);
+WUT_CHECK_OFFSET(VPADStatus, 0x14, rightStick);
+WUT_CHECK_OFFSET(VPADStatus, 0x1C, accelorometer);
+WUT_CHECK_OFFSET(VPADStatus, 0x38, gyro);
+WUT_CHECK_OFFSET(VPADStatus, 0x52, tpNormal);
+WUT_CHECK_OFFSET(VPADStatus, 0x5A, tpFiltered1);
+WUT_CHECK_OFFSET(VPADStatus, 0x62, tpFiltered2);
+WUT_CHECK_OFFSET(VPADStatus, 0x94, mag);
+WUT_CHECK_OFFSET(VPADStatus, 0xA0, slideVolume);
+WUT_CHECK_OFFSET(VPADStatus, 0xA1, battery);
+WUT_CHECK_OFFSET(VPADStatus, 0xA2, micStatus);
+WUT_CHECK_OFFSET(VPADStatus, 0xA3, slideVolumeEx);
+WUT_CHECK_SIZE(VPADStatus, 0xAC);
 
 //! Deprecated
 void
diff --git a/include/wut_structsize.h b/include/wut_structsize.h
index ff1611f..f661235 100644
--- a/include/wut_structsize.h
+++ b/include/wut_structsize.h
@@ -4,29 +4,27 @@
 
 // Ensure structs are correct size & offsets
 #if defined(static_assert)
-#  define CHECK_SIZE(Type, Size) \
+#  define WUT_CHECK_SIZE(Type, Size) \
       static_assert(sizeof(Type) == Size, \
                     #Type " must be " #Size " bytes")
 
-#  define CHECK_OFFSET(Type, Offset, Field) \
+#  define WUT_CHECK_OFFSET(Type, Offset, Field) \
       static_assert(offsetof(Type, Field) == Offset, \
                     #Type "::" #Field " must be at offset " #Offset)
 #else
-#  define CHECK_SIZE(Type, Size)
-#  define CHECK_OFFSET(Type, Offset, Field)
+#  define WUT_CHECK_SIZE(Type, Size)
+#  define WUT_CHECK_OFFSET(Type, Offset, Field)
 #endif
 
 // Workaround weird macro concat ## behaviour
-#define PP_CAT(a, b) PP_CAT_I(a, b)
-#define PP_CAT_I(a, b) PP_CAT_II(~, a ## b)
-#define PP_CAT_II(p, res) res
+#define WUT_PP_CAT(a, b) WUT_PP_CAT_I(a, b)
+#define WUT_PP_CAT_I(a, b) WUT_PP_CAT_II(~, a ## b)
+#define WUT_PP_CAT_II(p, res) res
 
 // Allow us to easily add UNKNOWN / PADDING bytes into our structs,
 // generates unique variable names using __COUNTER__
-#define UNKNOWN(Size) char PP_CAT(__unk, __COUNTER__) [Size]
-#define PADDING(Size) UNKNOWN(Size)
+#define WUT_UNKNOWN_BYTES(Size) char WUT_PP_CAT(__unk, __COUNTER__) [Size]
+#define WUT_PADDING_BYTES(Size) WUT_UNKNOWN_BYTES(Size)
 
-// Just some placeholder defines
-#define UNKNOWN_ARG uint32_t
-#define UNKNOWN_ARGS void
-#define UNKNOWN_SIZE(x)
+//! Unknown struct size
+#define WUT_UNKNOWN_SIZE(x)
diff --git a/libraries/libgfd/include/gfd.h b/libraries/libgfd/include/gfd.h
index b0758b2..4610699 100644
--- a/libraries/libgfd/include/gfd.h
+++ b/libraries/libgfd/include/gfd.h
@@ -52,15 +52,15 @@ struct GFDHeader
    uint32_t unk1;
    uint32_t unk2;
 };
-CHECK_OFFSET(GFDHeader, 0x00, magic);
-CHECK_OFFSET(GFDHeader, 0x04, headerSize);
-CHECK_OFFSET(GFDHeader, 0x08, majorVersion);
-CHECK_OFFSET(GFDHeader, 0x0C, minorVersion);
-CHECK_OFFSET(GFDHeader, 0x10, gpuVersion);
-CHECK_OFFSET(GFDHeader, 0x14, align);
-CHECK_OFFSET(GFDHeader, 0x18, unk1);
-CHECK_OFFSET(GFDHeader, 0x1C, unk2);
-CHECK_SIZE(GFDHeader, 0x20);
+WUT_CHECK_OFFSET(GFDHeader, 0x00, magic);
+WUT_CHECK_OFFSET(GFDHeader, 0x04, headerSize);
+WUT_CHECK_OFFSET(GFDHeader, 0x08, majorVersion);
+WUT_CHECK_OFFSET(GFDHeader, 0x0C, minorVersion);
+WUT_CHECK_OFFSET(GFDHeader, 0x10, gpuVersion);
+WUT_CHECK_OFFSET(GFDHeader, 0x14, align);
+WUT_CHECK_OFFSET(GFDHeader, 0x18, unk1);
+WUT_CHECK_OFFSET(GFDHeader, 0x1C, unk2);
+WUT_CHECK_SIZE(GFDHeader, 0x20);
 
 struct GFDBlockHeader
 {
@@ -73,15 +73,15 @@ struct GFDBlockHeader
    uint32_t id;
    uint32_t index;
 };
-CHECK_OFFSET(GFDBlockHeader, 0x00, magic);
-CHECK_OFFSET(GFDBlockHeader, 0x04, headerSize);
-CHECK_OFFSET(GFDBlockHeader, 0x08, majorVersion);
-CHECK_OFFSET(GFDBlockHeader, 0x0C, minorVersion);
-CHECK_OFFSET(GFDBlockHeader, 0x10, type);
-CHECK_OFFSET(GFDBlockHeader, 0x14, dataSize);
-CHECK_OFFSET(GFDBlockHeader, 0x18, id);
-CHECK_OFFSET(GFDBlockHeader, 0x1C, index);
-CHECK_SIZE(GFDHeader, 0x20);
+WUT_CHECK_OFFSET(GFDBlockHeader, 0x00, magic);
+WUT_CHECK_OFFSET(GFDBlockHeader, 0x04, headerSize);
+WUT_CHECK_OFFSET(GFDBlockHeader, 0x08, majorVersion);
+WUT_CHECK_OFFSET(GFDBlockHeader, 0x0C, minorVersion);
+WUT_CHECK_OFFSET(GFDBlockHeader, 0x10, type);
+WUT_CHECK_OFFSET(GFDBlockHeader, 0x14, dataSize);
+WUT_CHECK_OFFSET(GFDBlockHeader, 0x18, id);
+WUT_CHECK_OFFSET(GFDBlockHeader, 0x1C, index);
+WUT_CHECK_SIZE(GFDHeader, 0x20);
 
 struct GFDRelocationHeader
 {
@@ -96,17 +96,17 @@ struct GFDRelocationHeader
    uint32_t patchCount;
    uint32_t patchOffset;
 };
-CHECK_OFFSET(GFDRelocationHeader, 0x00, magic);
-CHECK_OFFSET(GFDRelocationHeader, 0x04, headerSize);
-CHECK_OFFSET(GFDRelocationHeader, 0x08, unk1);
-CHECK_OFFSET(GFDRelocationHeader, 0x0C, dataSize);
-CHECK_OFFSET(GFDRelocationHeader, 0x10, dataOffset);
-CHECK_OFFSET(GFDRelocationHeader, 0x14, textSize);
-CHECK_OFFSET(GFDRelocationHeader, 0x18, textOffset);
-CHECK_OFFSET(GFDRelocationHeader, 0x1C, patchBase);
-CHECK_OFFSET(GFDRelocationHeader, 0x20, patchCount);
-CHECK_OFFSET(GFDRelocationHeader, 0x24, patchOffset);
-CHECK_SIZE(GFDRelocationHeader, 0x28);
+WUT_CHECK_OFFSET(GFDRelocationHeader, 0x00, magic);
+WUT_CHECK_OFFSET(GFDRelocationHeader, 0x04, headerSize);
+WUT_CHECK_OFFSET(GFDRelocationHeader, 0x08, unk1);
+WUT_CHECK_OFFSET(GFDRelocationHeader, 0x0C, dataSize);
+WUT_CHECK_OFFSET(GFDRelocationHeader, 0x10, dataOffset);
+WUT_CHECK_OFFSET(GFDRelocationHeader, 0x14, textSize);
+WUT_CHECK_OFFSET(GFDRelocationHeader, 0x18, textOffset);
+WUT_CHECK_OFFSET(GFDRelocationHeader, 0x1C, patchBase);
+WUT_CHECK_OFFSET(GFDRelocationHeader, 0x20, patchCount);
+WUT_CHECK_OFFSET(GFDRelocationHeader, 0x24, patchOffset);
+WUT_CHECK_SIZE(GFDRelocationHeader, 0x28);
 
 char *
 GFDGetLastErrorString();
diff --git a/libraries/wutdevoptab_sd/devoptab_sd.h b/libraries/wutdevoptab_sd/devoptab_sd.h
index 0defcbf..7a36faa 100644
--- a/libraries/wutdevoptab_sd/devoptab_sd.h
+++ b/libraries/wutdevoptab_sd/devoptab_sd.h
@@ -34,7 +34,7 @@ typedef struct
 typedef struct
 {
    //! Should be set to FS_DIRITER_MAGIC
-   u32 magic;
+   uint32_t magic;
 
    //! FS handle
    FSDirectoryHandle fd;