[headers 9] Add src/libc64/ and new "z64" rand.h (#2164)

* rand.h -> libc64/qrand.h

* Add rand.h with z64 rand wrappers

* yeet comment

* code/rand.c -> libc64/qrand.c

* fixup

* move libc64 source to src/libc64/

* fix

* bss

* update file splits disasm metadata

9 files changed, 2235 insertions, 0 deletions

diff --git a/src/libc64/__osMalloc_gc.c b/src/libc64/__osMalloc_gc.c
new file mode 100644
index 000000000..45e19532f
--- /dev/null
+++ b/src/libc64/__osMalloc_gc.c
@@ -0,0 +1,895 @@
+#include "global.h"
+#include "fault.h"
+#include "osMalloc.h"
+#include "terminal.h"
+
+#if PLATFORM_GC
+
+#define FILL_ALLOC_BLOCK_FLAG (1 << 0)
+#define FILL_FREE_BLOCK_FLAG (1 << 1)
+#define CHECK_FREE_BLOCK_FLAG (1 << 2)
+
+#define NODE_MAGIC 0x7373
+
+#define BLOCK_UNINIT_MAGIC 0xAB
+#define BLOCK_UNINIT_MAGIC_32 0xABABABAB
+#define BLOCK_ALLOC_MAGIC 0xCD
+#define BLOCK_ALLOC_MAGIC_32 0xCDCDCDCD
+#define BLOCK_FREE_MAGIC 0xEF
+#define BLOCK_FREE_MAGIC_32 0xEFEFEFEF
+
+#define NODE_IS_VALID(node) (((node) != NULL) && ((node)->magic == NODE_MAGIC))
+
+#if OOT_DEBUG
+
+#define NODE_GET_NEXT(node) ArenaImpl_GetNextBlock(node)
+#define NODE_GET_PREV(node) ArenaImpl_GetPrevBlock(node)
+
+#define SET_DEBUG_INFO(node, file, line, arena) ArenaImpl_SetDebugInfo(node, file, line, arena)
+
+#define FILL_UNINIT_BLOCK(arena, node, size) memset(node, BLOCK_UNINIT_MAGIC, size)
+
+#define FILL_ALLOC_BLOCK(arena, alloc, size)   \
+    if ((arena)->flag & FILL_ALLOC_BLOCK_FLAG) \
+    memset(alloc, BLOCK_ALLOC_MAGIC, size)
+
+#define FILL_FREE_BLOCK_HEADER(arena, node)   \
+    if ((arena)->flag & FILL_FREE_BLOCK_FLAG) \
+    memset(node, BLOCK_FREE_MAGIC, sizeof(ArenaNode))
+
+#define FILL_FREE_BLOCK_CONTENTS(arena, node) \
+    if ((arena)->flag & FILL_FREE_BLOCK_FLAG) \
+    memset((void*)((u32)(node) + sizeof(ArenaNode)), BLOCK_FREE_MAGIC, (node)->size)
+
+#define CHECK_FREE_BLOCK(arena, node)          \
+    if ((arena)->flag & CHECK_FREE_BLOCK_FLAG) \
+    __osMalloc_FreeBlockTest(arena, node)
+
+#define CHECK_ALLOC_FAILURE(arena, ptr) (void)0
+
+#else
+
+#define NODE_GET_NEXT(node) (NODE_IS_VALID((node)->next) ? (node)->next : NULL)
+#define NODE_GET_PREV(node) (NODE_IS_VALID((node)->prev) ? (node)->prev : NULL)
+
+#define SET_DEBUG_INFO(node, file, line, arena) (void)0
+#define FILL_UNINIT_BLOCK(arena, node, size) (void)0
+#define FILL_ALLOC_BLOCK(arena, alloc, size) (void)0
+#define FILL_FREE_BLOCK_HEADER(arena, node) (void)0
+#define FILL_FREE_BLOCK_CONTENTS(arena, node) (void)0
+#define CHECK_FREE_BLOCK(arena, node) (void)0
+
+// Number of allocation failures across all arenas.
+u32 gTotalAllocFailures = 0; // "Arena_failcnt"
+
+#define CHECK_ALLOC_FAILURE(arena, ptr) \
+    do {                                \
+        if ((ptr) == NULL) {            \
+            gTotalAllocFailures++;      \
+            (arena)->allocFailures++;   \
+        }                               \
+    } while (0)
+
+#endif
+
+OSMesg sArenaLockMsg;
+
+void __osMallocAddBlock(Arena* arena, void* start, s32 size);
+
+#if OOT_DEBUG
+u32 __osMalloc_FreeBlockTest_Enable;
+
+u32 ArenaImpl_GetFillAllocBlock(Arena* arena) {
+    return (arena->flag & FILL_ALLOC_BLOCK_FLAG) != 0;
+}
+u32 ArenaImpl_GetFillFreeBlock(Arena* arena) {
+    return (arena->flag & FILL_FREE_BLOCK_FLAG) != 0;
+}
+u32 ArenaImpl_GetCheckFreeBlock(Arena* arena) {
+    return (arena->flag & CHECK_FREE_BLOCK_FLAG) != 0;
+}
+
+void ArenaImpl_SetFillAllocBlock(Arena* arena) {
+    arena->flag |= FILL_ALLOC_BLOCK_FLAG;
+}
+void ArenaImpl_SetFillFreeBlock(Arena* arena) {
+    arena->flag |= FILL_FREE_BLOCK_FLAG;
+}
+void ArenaImpl_SetCheckFreeBlock(Arena* arena) {
+    arena->flag |= CHECK_FREE_BLOCK_FLAG;
+}
+
+void ArenaImpl_UnsetFillAllocBlock(Arena* arena) {
+    arena->flag &= ~FILL_ALLOC_BLOCK_FLAG;
+}
+void ArenaImpl_UnsetFillFreeBlock(Arena* arena) {
+    arena->flag &= ~FILL_FREE_BLOCK_FLAG;
+}
+void ArenaImpl_UnsetCheckFreeBlock(Arena* arena) {
+    arena->flag &= ~CHECK_FREE_BLOCK_FLAG;
+}
+
+void ArenaImpl_SetDebugInfo(ArenaNode* node, const char* file, int line, Arena* arena) {
+    node->filename = file;
+    node->line = line;
+    node->threadId = osGetThreadId(NULL);
+    node->arena = arena;
+    node->time = osGetTime();
+}
+#endif
+
+void ArenaImpl_LockInit(Arena* arena) {
+    osCreateMesgQueue(&arena->lockQueue, &sArenaLockMsg, 1);
+}
+
+void ArenaImpl_Lock(Arena* arena) {
+    osSendMesg(&arena->lockQueue, NULL, OS_MESG_BLOCK);
+}
+
+void ArenaImpl_Unlock(Arena* arena) {
+    osRecvMesg(&arena->lockQueue, NULL, OS_MESG_BLOCK);
+}
+
+#if OOT_DEBUG
+ArenaNode* ArenaImpl_GetNextBlock(ArenaNode* node) {
+    ArenaNode* next = node->next;
+
+    if (next != NULL && (next == NULL || (next->magic != NODE_MAGIC))) {
+        osSyncPrintf(VT_COL(RED, WHITE) T("緊急事態！メモリリーク発見！ (block=%08x)\n",
+                                          "Emergency! Memory leak detected! (block=%08x)\n") VT_RST,
+                     next);
+        next = NULL;
+        node->next = NULL;
+    }
+    return next;
+}
+
+ArenaNode* ArenaImpl_GetPrevBlock(ArenaNode* node) {
+    ArenaNode* prev = node->prev;
+
+    if (prev != NULL && (prev == NULL || (prev->magic != NODE_MAGIC))) {
+        osSyncPrintf(VT_COL(RED, WHITE) T("緊急事態！メモリリーク発見！ (block=%08x)\n",
+                                          "Emergency! Memory leak detected! (block=%08x)\n") VT_RST,
+                     prev);
+        prev = NULL;
+        node->prev = NULL;
+    }
+    return prev;
+}
+#endif
+
+ArenaNode* ArenaImpl_GetLastBlock(Arena* arena) {
+    ArenaNode* last = NULL;
+    ArenaNode* iter;
+
+    if (arena != NULL && NODE_IS_VALID(arena->head)) {
+        iter = arena->head;
+        while (iter != NULL) {
+            last = iter;
+            iter = NODE_GET_NEXT(last);
+        }
+    }
+    return last;
+}
+
+void __osMallocInit(Arena* arena, void* start, s32 size) {
+    bzero(arena, sizeof(Arena));
+    ArenaImpl_LockInit(arena);
+    __osMallocAddBlock(arena, start, size);
+    arena->isInit = true;
+}
+
+void __osMallocAddBlock(Arena* arena, void* start, s32 size) {
+    s32 diff;
+    s32 size2;
+    ArenaNode* firstNode;
+    ArenaNode* lastNode;
+
+    if (start != NULL) {
+        firstNode = (ArenaNode*)ALIGN16((u32)start);
+        diff = (s32)firstNode - (s32)start;
+        size2 = (size - diff) & ~0xF;
+
+        if (size2 > (s32)sizeof(ArenaNode)) {
+            FILL_UNINIT_BLOCK(arena, firstNode, size2);
+            firstNode->next = NULL;
+            firstNode->prev = NULL;
+            firstNode->size = size2 - sizeof(ArenaNode);
+            firstNode->isFree = true;
+            firstNode->magic = NODE_MAGIC;
+            ArenaImpl_Lock(arena);
+            lastNode = ArenaImpl_GetLastBlock(arena);
+            if (lastNode == NULL) {
+                arena->head = firstNode;
+                arena->start = start;
+            } else {
+                firstNode->prev = lastNode;
+                lastNode->next = firstNode;
+            }
+            ArenaImpl_Unlock(arena);
+        }
+    }
+}
+
+#if OOT_DEBUG
+void ArenaImpl_RemoveAllBlocks(Arena* arena) {
+    ArenaNode* iter;
+    ArenaNode* next;
+
+    ArenaImpl_Lock(arena);
+
+    iter = arena->head;
+    while (iter != NULL) {
+        next = NODE_GET_NEXT(iter);
+        memset(iter, BLOCK_UNINIT_MAGIC, iter->size + sizeof(ArenaNode));
+        iter = next;
+    }
+
+    ArenaImpl_Unlock(arena);
+}
+#endif
+
+void __osMallocCleanup(Arena* arena) {
+#if OOT_DEBUG
+    ArenaImpl_RemoveAllBlocks(arena);
+#endif
+    bzero(arena, sizeof(*arena));
+}
+
+s32 __osMallocIsInitialized(Arena* arena) {
+    return arena->isInit;
+}
+
+#if OOT_DEBUG
+void __osMalloc_FreeBlockTest(Arena* arena, ArenaNode* node) {
+    ArenaNode* node2 = node;
+    u32* start;
+    u32* end;
+    u32* iter;
+
+    if (__osMalloc_FreeBlockTest_Enable) {
+        start = (u32*)((u32)node + sizeof(ArenaNode));
+        end = (u32*)((u32)start + node2->size);
+        iter = start;
+
+        while (iter < end) {
+            if (*iter != BLOCK_UNINIT_MAGIC_32 && *iter != BLOCK_FREE_MAGIC_32) {
+                osSyncPrintf(VT_COL(RED, WHITE)
+                                 T("緊急事態！メモリリーク検出！ (block=%08x s=%08x e=%08x p=%08x)\n",
+                                   "Emergency! Memory leak detected! (block=%08x s=%08x e=%08x p=%08x)\n") VT_RST,
+                             node, start, end, iter);
+                __osDisplayArena(arena);
+                return;
+            }
+            iter++;
+        }
+    }
+}
+
+void* __osMalloc_NoLockDebug(Arena* arena, u32 size, const char* file, int line) {
+    ArenaNode* iter;
+    u32 blockSize;
+    ArenaNode* newNode;
+    void* alloc = NULL;
+    ArenaNode* next;
+
+    size = ALIGN16(size);
+    blockSize = ALIGN16(size) + sizeof(ArenaNode);
+    iter = arena->head;
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + blockSize);
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = iter->size - blockSize;
+                newNode->isFree = true;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size = size;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, file, line, arena);
+            alloc = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, alloc, size);
+
+            break;
+        }
+
+        iter = NODE_GET_NEXT(iter);
+    }
+
+    return alloc;
+}
+
+void* __osMallocDebug(Arena* arena, u32 size, const char* file, int line) {
+    void* alloc;
+
+    ArenaImpl_Lock(arena);
+    alloc = __osMalloc_NoLockDebug(arena, size, file, line);
+    ArenaImpl_Unlock(arena);
+
+    return alloc;
+}
+
+void* __osMallocRDebug(Arena* arena, u32 size, const char* file, int line) {
+    ArenaNode* iter;
+    ArenaNode* newNode;
+    u32 blockSize;
+    ArenaNode* next;
+    void* allocR = NULL;
+
+    size = ALIGN16(size);
+    ArenaImpl_Lock(arena);
+    iter = ArenaImpl_GetLastBlock(arena);
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            blockSize = ALIGN16(size) + sizeof(ArenaNode);
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + (iter->size - size));
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = size;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size -= blockSize;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+                iter = newNode;
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, file, line, arena);
+            allocR = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, allocR, size);
+
+            break;
+        }
+
+        iter = NODE_GET_PREV(iter);
+    }
+
+    ArenaImpl_Unlock(arena);
+
+    return allocR;
+}
+#endif
+
+void* __osMalloc_NoLock(Arena* arena, u32 size) {
+    ArenaNode* iter;
+    u32 blockSize;
+    ArenaNode* newNode;
+    void* alloc = NULL;
+    ArenaNode* next;
+
+    size = ALIGN16(size);
+    blockSize = ALIGN16(size) + sizeof(ArenaNode);
+    iter = arena->head;
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + blockSize);
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = iter->size - blockSize;
+                newNode->isFree = true;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size = size;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, NULL, 0, arena);
+            alloc = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, alloc, size);
+
+            break;
+        }
+
+        iter = NODE_GET_NEXT(iter);
+    }
+
+    CHECK_ALLOC_FAILURE(arena, alloc);
+
+    return alloc;
+}
+
+void* __osMalloc(Arena* arena, u32 size) {
+    void* alloc;
+
+    ArenaImpl_Lock(arena);
+    alloc = __osMalloc_NoLock(arena, size);
+    ArenaImpl_Unlock(arena);
+
+    return alloc;
+}
+
+void* __osMallocR(Arena* arena, u32 size) {
+    ArenaNode* iter;
+    ArenaNode* allocNode;
+    ArenaNode* newNode;
+    ArenaNode* next;
+    void* alloc = NULL;
+    u32 blockSize;
+
+    size = ALIGN16(size);
+    blockSize = ALIGN16(size) + sizeof(ArenaNode);
+    ArenaImpl_Lock(arena);
+    iter = ArenaImpl_GetLastBlock(arena);
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            if (blockSize < iter->size) {
+                allocNode = (ArenaNode*)((u32)iter + (iter->size - size));
+                allocNode->next = NODE_GET_NEXT(iter);
+
+                newNode = allocNode;
+                newNode->prev = iter;
+                newNode->size = size;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size -= blockSize;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+                iter = newNode;
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, NULL, 0, arena);
+            alloc = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, alloc, size);
+            break;
+        }
+        iter = NODE_GET_PREV(iter);
+    }
+
+    CHECK_ALLOC_FAILURE(arena, alloc);
+
+    ArenaImpl_Unlock(arena);
+
+    return alloc;
+}
+
+void __osFree_NoLock(Arena* arena, void* ptr) {
+    ArenaNode* node;
+    ArenaNode* next;
+    ArenaNode* prev;
+
+    if (ptr == NULL) {
+        return;
+    }
+
+    node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+    if (!NODE_IS_VALID(node)) {
+        PRINTF(VT_COL(RED, WHITE) T("__osFree:不正解放(%08x)\n", "__osFree: Unauthorized release (%08x)\n") VT_RST,
+               ptr);
+        return;
+    }
+    if (node->isFree) {
+        PRINTF(VT_COL(RED, WHITE) T("__osFree:二重解放(%08x)\n", "__osFree: Double release (%08x)\n") VT_RST, ptr);
+        return;
+    }
+#if OOT_DEBUG
+    if (arena != node->arena && arena != NULL) {
+        PRINTF(VT_COL(RED, WHITE)
+                   T("__osFree:確保時と違う方法で解放しようとした (%08x:%08x)\n",
+                     "__osFree:Tried to release in a different way than when it was secured (%08x:%08x)\n") VT_RST,
+               arena, node->arena);
+        return;
+    }
+#endif
+
+    next = NODE_GET_NEXT(node);
+    prev = NODE_GET_PREV(node);
+    node->isFree = true;
+    SET_DEBUG_INFO(node, NULL, 0, arena);
+
+    FILL_FREE_BLOCK_CONTENTS(arena, node);
+
+    if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree) {
+        ArenaNode* newNext = NODE_GET_NEXT(next);
+        if (newNext != NULL) {
+            newNext->prev = node;
+        }
+
+        node->size += next->size + sizeof(ArenaNode);
+        FILL_FREE_BLOCK_HEADER(arena, next);
+        node->next = newNext;
+        next = newNext;
+    }
+
+    if (prev != NULL && prev->isFree && (u32)node == (u32)prev + sizeof(ArenaNode) + prev->size) {
+        if (next) {
+            next->prev = prev;
+        }
+        prev->next = next;
+        prev->size += node->size + sizeof(ArenaNode);
+        FILL_FREE_BLOCK_HEADER(arena, node);
+    }
+}
+
+void __osFree(Arena* arena, void* ptr) {
+    ArenaImpl_Lock(arena);
+    __osFree_NoLock(arena, ptr);
+    ArenaImpl_Unlock(arena);
+}
+
+#if OOT_DEBUG
+void __osFree_NoLockDebug(Arena* arena, void* ptr, const char* file, int line) {
+    ArenaNode* node;
+    ArenaNode* next;
+    ArenaNode* prev;
+    ArenaNode* newNext;
+
+    if (ptr == NULL) {
+        return;
+    }
+
+    node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+    if (!NODE_IS_VALID(node)) {
+        PRINTF(VT_COL(RED, WHITE)
+                   T("__osFree:不正解放(%08x) [%s:%d ]\n", "__osFree: Unauthorized release (%08x) [%s:%d ]\n") VT_RST,
+               ptr, file, line);
+        return;
+    }
+    if (node->isFree) {
+        PRINTF(VT_COL(RED, WHITE) T("__osFree:二重解放(%08x) [%s:%d ]\n", "__osFree: Double release (%08x) [%s:%d ]\n")
+                   VT_RST,
+               ptr, file, line);
+        return;
+    }
+    if (arena != node->arena && arena != NULL) {
+        PRINTF(VT_COL(RED, WHITE)
+                   T("__osFree:確保時と違う方法で解放しようとした (%08x:%08x)\n",
+                     "__osFree:Tried to release in a different way than when it was secured (%08x:%08x)\n") VT_RST,
+               arena, node->arena);
+        return;
+    }
+
+    next = NODE_GET_NEXT(node);
+    prev = NODE_GET_PREV(node);
+    node->isFree = true;
+    SET_DEBUG_INFO(node, file, line, arena);
+
+    FILL_FREE_BLOCK_CONTENTS(arena, node);
+
+    if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree) {
+        newNext = NODE_GET_NEXT(next);
+        if (newNext != NULL) {
+            newNext->prev = node;
+        }
+
+        node->size += next->size + sizeof(ArenaNode);
+        FILL_FREE_BLOCK_HEADER(arena, next);
+        node->next = newNext;
+        next = newNext;
+    }
+
+    if (prev != NULL && prev->isFree && (u32)node == (u32)prev + sizeof(ArenaNode) + prev->size) {
+        if (next != NULL) {
+            next->prev = prev;
+        }
+        prev->next = next;
+        prev->size += node->size + sizeof(ArenaNode);
+        FILL_FREE_BLOCK_HEADER(arena, node);
+    }
+}
+
+void __osFreeDebug(Arena* arena, void* ptr, const char* file, int line) {
+    ArenaImpl_Lock(arena);
+    __osFree_NoLockDebug(arena, ptr, file, line);
+    ArenaImpl_Unlock(arena);
+}
+#endif
+
+void* __osRealloc(Arena* arena, void* ptr, u32 newSize) {
+    ArenaNode* node;
+    void* newAlloc;
+    ArenaNode* next;
+    ArenaNode* newNext;
+    ArenaNode* overNext;
+    ArenaNode* newNext2;
+    ArenaNode* next2;
+    u32 sizeDiff;
+    ArenaNode* overNext2;
+    ArenaNode localCopy;
+    u32 blockSize;
+    s32 pad;
+
+    newSize = ALIGN16(newSize);
+    osSyncPrintf("__osRealloc(%08x, %d)\n", ptr, newSize);
+    ArenaImpl_Lock(arena);
+
+    if (ptr == NULL) {
+        ptr = __osMalloc_NoLock(arena, newSize);
+    } else if (newSize == 0) {
+        __osFree_NoLock(arena, ptr);
+        ptr = NULL;
+    } else {
+        node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+        if (newSize == node->size) {
+            osSyncPrintf(T("メモリブロックサイズが変わらないためなにもしません\n",
+                           "Does nothing because the memory block size does not change\n"));
+        } else if (node->size < newSize) {
+            next = NODE_GET_NEXT(node);
+            sizeDiff = newSize - node->size;
+            if ((u32)next == ((u32)node + node->size + sizeof(ArenaNode)) && next->isFree && next->size >= sizeDiff) {
+                osSyncPrintf(T("現メモリブロックの後ろにフリーブロックがあるので結合します\n",
+                               "Merge because there is a free block after the current memory block\n"));
+                next->size -= sizeDiff;
+                overNext = NODE_GET_NEXT(next);
+                newNext = (ArenaNode*)((u32)next + sizeDiff);
+                if (overNext != NULL) {
+                    overNext->prev = newNext;
+                }
+                node->next = newNext;
+                node->size = newSize;
+                memmove(node->next, next, sizeof(ArenaNode));
+            } else {
+                osSyncPrintf(T("新たにメモリブロックを確保して内容を移動します\n",
+                               "Allocate a new memory block and move the contents\n"));
+                newAlloc = __osMalloc_NoLock(arena, newSize);
+                if (newAlloc != NULL) {
+                    bcopy(ptr, newAlloc, node->size);
+                    __osFree_NoLock(arena, ptr);
+                }
+                ptr = newAlloc;
+            }
+        } else if (newSize < node->size) {
+            next2 = NODE_GET_NEXT(node);
+            if (next2 != NULL && next2->isFree) {
+                blockSize = ALIGN16(newSize) + sizeof(ArenaNode);
+
+                osSyncPrintf(T("現メモリブロックの後ろのフリーブロックを大きくしました\n",
+                               "Increased free block behind current memory block\n"));
+                newNext2 = (ArenaNode*)((u32)node + blockSize);
+                localCopy = *next2;
+                *newNext2 = localCopy;
+                newNext2->size += node->size - newSize;
+                node->next = newNext2;
+                node->size = newSize;
+                overNext2 = NODE_GET_NEXT(newNext2);
+                if (overNext2 != NULL) {
+                    overNext2->prev = newNext2;
+                }
+            } else if (newSize + sizeof(ArenaNode) < node->size) {
+                blockSize = ALIGN16(newSize) + sizeof(ArenaNode);
+
+                osSyncPrintf(T("現メモリブロックの後ろにフリーブロックがないので生成します\n",
+                               "Generated because there is no free block after the current memory block\n"));
+                newNext2 = (ArenaNode*)((u32)node + blockSize);
+                newNext2->next = NODE_GET_NEXT(node);
+                newNext2->prev = node;
+                newNext2->size = node->size - blockSize;
+                newNext2->isFree = true;
+                newNext2->magic = NODE_MAGIC;
+                node->next = newNext2;
+                node->size = newSize;
+                overNext2 = NODE_GET_NEXT(newNext2);
+                if (overNext2 != NULL) {
+                    overNext2->prev = newNext2;
+                }
+            } else {
+                osSyncPrintf(
+                    T("フリーブロック生成するだけの空きがありません\n", "There is no room to generate free blocks\n"));
+                ptr = NULL;
+            }
+        }
+
+        CHECK_ALLOC_FAILURE(arena, ptr);
+    }
+    ArenaImpl_Unlock(arena);
+
+    return ptr;
+}
+
+#if OOT_DEBUG
+void* __osReallocDebug(Arena* arena, void* ptr, u32 newSize, const char* file, int line) {
+    return __osRealloc(arena, ptr, newSize);
+}
+#endif
+
+void ArenaImpl_GetSizes(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAlloc) {
+    ArenaNode* iter;
+
+    ArenaImpl_Lock(arena);
+
+    *outMaxFree = 0;
+    *outFree = 0;
+    *outAlloc = 0;
+
+    iter = arena->head;
+    while (iter != NULL) {
+        if (iter->isFree) {
+            *outFree += iter->size;
+            if (*outMaxFree < iter->size) {
+                *outMaxFree = iter->size;
+            }
+        } else {
+            *outAlloc += iter->size;
+        }
+
+        iter = NODE_GET_NEXT(iter);
+    }
+
+    ArenaImpl_Unlock(arena);
+}
+
+#if OOT_DEBUG
+void __osDisplayArena(Arena* arena) {
+    u32 freeSize;
+    u32 allocatedSize;
+    u32 maxFree;
+    ArenaNode* iter;
+    ArenaNode* next;
+
+    if (!__osMallocIsInitialized(arena)) {
+        osSyncPrintf(T("アリーナは初期化されていません\n", "Arena is not initialized\n"));
+        return;
+    }
+
+    ArenaImpl_Lock(arena);
+
+    maxFree = 0;
+    freeSize = 0;
+    allocatedSize = 0;
+
+    osSyncPrintf(T("アリーナの内容 (0x%08x)\n", "Arena contents (0x%08x)\n"), arena);
+    osSyncPrintf(T("メモリブロック範囲 status サイズ  [時刻  s ms us ns: TID:src:行]\n",
+                   "Memory node range status size [time s ms us ns: TID:src:line]\n"));
+
+    iter = arena->head;
+    while (iter != NULL) {
+        if (iter != NULL && iter->magic == NODE_MAGIC) {
+            next = iter->next;
+            osSyncPrintf("%08x-%08x%c %s %08x", iter, ((u32)iter + sizeof(ArenaNode) + iter->size),
+                         (next == NULL) ? '$' : (iter != next->prev ? '!' : ' '),
+                         iter->isFree ? T("空き", "Free") : T("確保", "Secure"), iter->size);
+
+            if (!iter->isFree) {
+                osSyncPrintf(" [%016llu:%2d:%s:%d]", OS_CYCLES_TO_NSEC(iter->time), iter->threadId,
+                             iter->filename != NULL ? iter->filename : "**NULL**", iter->line);
+            }
+
+            osSyncPrintf("\n");
+
+            if (iter->isFree) {
+                freeSize += iter->size;
+                if (maxFree < iter->size) {
+                    maxFree = iter->size;
+                }
+            } else {
+                allocatedSize += iter->size;
+            }
+        } else {
+            osSyncPrintf("%08x Block Invalid\n", iter);
+            next = NULL;
+        }
+        iter = next;
+    }
+
+    osSyncPrintf(T("確保ブロックサイズの合計 0x%08x バイト\n", "Total reserved node size 0x%08x bytes\n"),
+                 allocatedSize);
+    osSyncPrintf(T("空きブロックサイズの合計 0x%08x バイト\n", "Total free node size 0x%08x bytes\n"), freeSize);
+    osSyncPrintf(T("最大空きブロックサイズ   0x%08x バイト\n", "Maximum free node size 0x%08x bytes\n"), maxFree);
+
+    ArenaImpl_Unlock(arena);
+}
+#endif
+
+void ArenaImpl_FaultClient(Arena* arena) {
+    u32 freeSize;
+    u32 allocatedSize;
+    u32 maxFree;
+    ArenaNode* iter;
+    ArenaNode* next;
+
+    Fault_Printf("ARENA INFO (0x%08x)\n", arena);
+    if (!__osMallocIsInitialized(arena)) {
+        Fault_Printf("Arena is uninitalized\n", arena);
+        return;
+    }
+
+    maxFree = 0;
+    freeSize = 0;
+    allocatedSize = 0;
+
+    Fault_Printf("Memory Block Region status size\n");
+
+    iter = arena->head;
+    while (iter != NULL) {
+        if (iter != NULL && iter->magic == NODE_MAGIC) {
+            next = iter->next;
+            Fault_Printf("%08x-%08x%c %s %08x", iter, ((u32)iter + sizeof(ArenaNode) + iter->size),
+                         (!next) ? '$' : (iter != next->prev ? '!' : ' '), iter->isFree ? "F" : "A", iter->size);
+
+            Fault_Printf("\n");
+
+            if (iter->isFree) {
+                freeSize += iter->size;
+                if (maxFree < iter->size) {
+                    maxFree = iter->size;
+                }
+            } else {
+                allocatedSize += iter->size;
+            }
+        } else {
+            Fault_SetFontColor(0xF801);
+            Fault_Printf("%08x Block Invalid\n", iter);
+            next = NULL;
+        }
+        iter = next;
+    }
+
+    Fault_SetFontColor(0x7F1);
+    Fault_Printf("Total Alloc Block Size  %08x\n", allocatedSize);
+    Fault_Printf("Total Free Block Size   %08x\n", freeSize);
+    Fault_Printf("Largest Free Block Size %08x\n", maxFree);
+}
+
+s32 __osCheckArena(Arena* arena) {
+    ArenaNode* iter;
+    u32 error = 0;
+
+    ArenaImpl_Lock(arena);
+    osSyncPrintf(
+        T("アリーナの内容をチェックしています．．． (%08x)\n", "Checking the contents of the arena... (%08x)\n"),
+        arena);
+    iter = arena->head;
+    while (iter != NULL) {
+        //! @bug: Probably intended to be `!NODE_IS_VALID(iter)`
+        if (NODE_IS_VALID(iter)) {
+#if OOT_DEBUG
+            osSyncPrintf(VT_COL(RED, WHITE) T("おおっと！！ (%08x %08x)\n", "Oops!! (%08x %08x)\n") VT_RST, iter,
+                         iter->magic);
+#else
+            osSyncPrintf(T("おおっと！！ (%08x %08x)\n", "Oops!! (%08x %08x)\n"), iter, iter->magic);
+#endif
+            error = 1;
+            break;
+        }
+        iter = NODE_GET_NEXT(iter);
+    }
+    if (error == 0) {
+        osSyncPrintf(T("アリーナはまだ、いけそうです\n", "The arena is still going well\n"));
+    }
+    ArenaImpl_Unlock(arena);
+
+    return error;
+}
+
+#if OOT_DEBUG
+u8 ArenaImpl_GetAllocFailures(Arena* arena) {
+    return arena->allocFailures;
+}
+#endif
+
+#endif
diff --git a/src/libc64/__osMalloc_n64.c b/src/libc64/__osMalloc_n64.c
new file mode 100644
index 000000000..bd9c358af
--- /dev/null
+++ b/src/libc64/__osMalloc_n64.c
@@ -0,0 +1,474 @@
+#include "global.h"
+#include "fault.h"
+#include "osMalloc.h"
+
+#if PLATFORM_N64
+
+#define NODE_MAGIC 0x7373
+
+#define NODE_IS_VALID(node) ((node)->magic == NODE_MAGIC)
+
+#define NODE_GET_NEXT(node) ((node)->next)
+#define NODE_GET_PREV(node) ((node)->prev)
+
+#define SET_DEBUG_INFO(node, f, l, a)           \
+    {                                           \
+        (node)->filename = (f);                 \
+        (node)->line = (l);                     \
+        (node)->threadId = osGetThreadId(NULL); \
+        (node)->arena = (a);                    \
+        (node)->time = osGetTime();             \
+    }                                           \
+    (void)0
+
+#define FILL_ALLOC_BLOCK(arena, alloc, size) (void)0
+#define FILL_FREE_BLOCK_HEADER(arena, node) (void)0
+#define FILL_FREE_BLOCK_CONTENTS(arena, node) (void)0
+#define CHECK_FREE_BLOCK(arena, node) (void)0
+
+// Number of allocation failures across all arenas.
+u32 gTotalAllocFailures = 0; // "Arena_failcnt"
+
+#define CHECK_ALLOC_FAILURE(arena, ptr) \
+    do {                                \
+        if ((ptr) == NULL) {            \
+            gTotalAllocFailures++;      \
+            (arena)->allocFailures++;   \
+        }                               \
+    } while (0)
+
+void __osMallocInit(Arena* arena, void* start, s32 size) {
+    ArenaNode* firstNode = (ArenaNode*)ALIGN16((u32)start);
+
+    size -= (u8*)firstNode - (u8*)start;
+    size &= ~0xF;
+
+    firstNode->next = NULL;
+    firstNode->prev = NULL;
+    firstNode->size = size - sizeof(ArenaNode);
+    firstNode->isFree = true;
+    firstNode->magic = NODE_MAGIC;
+
+    arena->head = firstNode;
+    arena->start = start;
+    arena->size = size;
+}
+
+void __osMallocCleanup(Arena* arena) {
+    bzero(arena, sizeof(*arena));
+}
+
+s32 __osMallocIsInitialized(Arena* arena) {
+    return arena->start != NULL;
+}
+
+void* __osMallocDebug(Arena* arena, u32 size, const char* file, int line) {
+    ArenaNode* iter;
+    u32 blockSize;
+    ArenaNode* newNode;
+    void* alloc = NULL;
+    ArenaNode* next;
+
+    size = ALIGN16(size);
+    blockSize = ALIGN16(size) + sizeof(ArenaNode);
+    iter = arena->head;
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + blockSize);
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = iter->size - blockSize;
+                newNode->isFree = true;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size = size;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, file, line, arena);
+            alloc = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, alloc, size);
+
+            break;
+        }
+
+        iter = NODE_GET_NEXT(iter);
+    }
+
+    CHECK_ALLOC_FAILURE(arena, alloc);
+
+    return alloc;
+}
+
+void* __osMallocRDebug(Arena* arena, u32 size, const char* file, int line) {
+    ArenaNode* iter;
+    ArenaNode* newNode;
+    u32 blockSize;
+    u32 nodeSize;
+    ArenaNode* next;
+    void* allocR = NULL;
+    ArenaNode* next2;
+
+    size = ALIGN16(size);
+
+    iter = arena->head;
+    next2 = NODE_GET_NEXT(iter);
+    while (next2 != NULL) {
+        iter = next2;
+        next2 = NODE_GET_NEXT(next2);
+    }
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            blockSize = ALIGN16(size) + sizeof(ArenaNode);
+            nodeSize = iter->size;
+            if (blockSize < nodeSize) {
+                newNode = (ArenaNode*)((u32)iter + (iter->size - size));
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = size;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size -= blockSize;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+                iter = newNode;
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, file, line, arena);
+            allocR = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, allocR, size);
+
+            break;
+        }
+
+        iter = NODE_GET_PREV(iter);
+    }
+
+    CHECK_ALLOC_FAILURE(arena, allocR);
+
+    return allocR;
+}
+
+void* __osMalloc(Arena* arena, u32 size) {
+    ArenaNode* iter;
+    u32 blockSize;
+    ArenaNode* newNode;
+    void* alloc = NULL;
+    ArenaNode* next;
+
+    size = ALIGN16(size);
+    blockSize = ALIGN16(size) + sizeof(ArenaNode);
+    iter = arena->head;
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            if (blockSize < iter->size) {
+                newNode = (ArenaNode*)((u32)iter + blockSize);
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = iter->size - blockSize;
+                newNode->isFree = true;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size = size;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, NULL, 0, arena);
+            alloc = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, alloc, size);
+
+            break;
+        }
+
+        iter = NODE_GET_NEXT(iter);
+    }
+
+    CHECK_ALLOC_FAILURE(arena, alloc);
+
+    return alloc;
+}
+
+void* __osMallocR(Arena* arena, u32 size) {
+    ArenaNode* iter;
+    ArenaNode* newNode;
+    u32 blockSize;
+    u32 nodeSize;
+    ArenaNode* next;
+    void* allocR = NULL;
+    ArenaNode* next2;
+
+    size = ALIGN16(size);
+
+    iter = arena->head;
+    next2 = NODE_GET_NEXT(iter);
+    while (next2 != NULL) {
+        iter = next2;
+        next2 = NODE_GET_NEXT(next2);
+    }
+
+    while (iter != NULL) {
+        if (iter->isFree && iter->size >= size) {
+            CHECK_FREE_BLOCK(arena, iter);
+
+            blockSize = ALIGN16(size) + sizeof(ArenaNode);
+            nodeSize = iter->size;
+            if (blockSize < nodeSize) {
+                newNode = (ArenaNode*)((u32)iter + (iter->size - size));
+                newNode->next = NODE_GET_NEXT(iter);
+                newNode->prev = iter;
+                newNode->size = size;
+                newNode->magic = NODE_MAGIC;
+
+                iter->next = newNode;
+                iter->size -= blockSize;
+                next = NODE_GET_NEXT(newNode);
+                if (next) {
+                    next->prev = newNode;
+                }
+                iter = newNode;
+            }
+
+            iter->isFree = false;
+            SET_DEBUG_INFO(iter, NULL, 0, arena);
+            allocR = (void*)((u32)iter + sizeof(ArenaNode));
+            FILL_ALLOC_BLOCK(arena, allocR, size);
+
+            break;
+        }
+        iter = NODE_GET_PREV(iter);
+    }
+
+    CHECK_ALLOC_FAILURE(arena, allocR);
+
+    return allocR;
+}
+
+void __osFree(Arena* arena, void* ptr) {
+    ArenaNode* node;
+    ArenaNode* next;
+    ArenaNode* prev;
+
+    if (ptr == NULL) {
+        return;
+    }
+
+    node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+    if (!NODE_IS_VALID(node)) {
+        (void)T("__osFree:不正解放(%08x)\n", "__osFree: Unauthorized release (%08x)\n");
+        osSetIntMask(OS_IM_ALL);
+        return;
+    }
+    if (node->isFree) {
+        (void)T("__osFree:二重解放(%08x)\n", "__osFree: Double release (%08x)\n");
+        osSetIntMask(OS_IM_ALL);
+        return;
+    }
+    if (arena != node->arena && arena != NULL) {
+        (void)T("__osFree:arena(%08x)が__osMallocのarena(%08x)と一致しない\n",
+                "__osFree:arena(%08x) and __osMalloc:arena(%08x) do not match\n");
+    }
+
+    node->isFree = true;
+    SET_DEBUG_INFO(node, NULL, 0, arena);
+
+    if (node->next != NULL) {
+        next = node->next;
+        if (next->isFree) {
+            if (next->next != NULL) {
+                next->next->prev = node;
+            }
+
+            node->size += next->size + sizeof(ArenaNode);
+            node->next = next->next;
+        }
+    }
+
+    if (node->prev != NULL) {
+        prev = node->prev;
+        if (prev->isFree) {
+            prev->size += node->size + sizeof(ArenaNode);
+            prev->next = NODE_GET_NEXT(node);
+
+            if (node->next != NULL) {
+                node->next->prev = prev;
+            }
+        }
+    }
+}
+
+void __osFreeDebug(Arena* arena, void* ptr, const char* file, int line) {
+    ArenaNode* node;
+    ArenaNode* next;
+    ArenaNode* prev;
+
+    if (ptr == NULL) {
+        return;
+    }
+
+    node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+    if (!NODE_IS_VALID(node)) {
+        (void)T("__osFree:不正解放(%08x)\n", "__osFree: Unauthorized release (%08x)\n");
+        osSetIntMask(OS_IM_ALL);
+        return;
+    }
+    if (node->isFree) {
+        (void)T("__osFree:二重解放(%08x)\n", "__osFree: Double release (%08x)\n");
+        osSetIntMask(OS_IM_ALL);
+        return;
+    }
+    if (arena != node->arena && arena != NULL) {
+        (void)T("__osFree:arena(%08x)が__osMallocのarena(%08x)と一致しない\n",
+                "__osFree:arena(%08x) and __osMalloc:arena(%08x) do not match\n");
+    }
+
+    node->isFree = true;
+    SET_DEBUG_INFO(node, file, line, arena);
+
+    if (node->next != NULL) {
+        next = node->next;
+        if (next->isFree) {
+            if (next->next != NULL) {
+                next->next->prev = node;
+            }
+
+            node->size += next->size + sizeof(ArenaNode);
+            node->next = next->next;
+        }
+    }
+
+    if (node->prev != NULL) {
+        prev = node->prev;
+        if (prev->isFree) {
+            prev->size += node->size + sizeof(ArenaNode);
+            prev->next = NODE_GET_NEXT(node);
+
+            if (node->next != NULL) {
+                node->next->prev = prev;
+            }
+        }
+    }
+}
+
+void* __osRealloc(Arena* arena, void* ptr, u32 newSize) {
+    ArenaNode* node;
+    void* newAlloc;
+    ArenaNode* next;
+    ArenaNode* newNext;
+    u32 sizeDiff;
+
+    (void)"__osRealloc(%08x, %d)\n";
+    osSetIntMask(OS_IM_ALL);
+
+    if (ptr == NULL) {
+        ptr = __osMalloc(arena, newSize);
+    } else if (newSize == 0) {
+        __osFree(arena, ptr);
+        ptr = NULL;
+    } else {
+        newSize = ALIGN16(newSize);
+        node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+        if (newSize == node->size) {
+            // Do nothing
+        } else if (node->size < newSize) {
+            next = NODE_GET_NEXT(node);
+            sizeDiff = newSize - node->size;
+            if (next != NULL && next->isFree && next->size >= sizeDiff) {
+                next->size -= sizeDiff;
+                newNext = (ArenaNode*)((u32)next + sizeDiff);
+                if (NODE_GET_NEXT(next) != NULL) {
+                    NODE_GET_NEXT(next)->prev = newNext;
+                }
+                node->next = newNext;
+                node->size = newSize;
+                memmove(node->next, next, sizeof(ArenaNode));
+            } else {
+                newAlloc = __osMalloc(arena, newSize);
+                if (newAlloc != NULL) {
+                    memcpy(ptr, newAlloc, node->size);
+                    __osFree(arena, ptr);
+                }
+                ptr = newAlloc;
+            }
+        } else if (newSize < node->size) {
+            (void)T("メモリブロックの縮小機能はまだインプリメントしていません\n",
+                    "Memory block shrinking functionality is not yet implemented\n");
+        }
+    }
+
+    CHECK_ALLOC_FAILURE(arena, ptr);
+
+    return ptr;
+}
+
+void* __osReallocDebug(Arena* arena, void* ptr, u32 newSize, const char* file, int line) {
+    return __osRealloc(arena, ptr, newSize);
+}
+
+void ArenaImpl_GetSizes(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAlloc) {
+    ArenaNode* iter;
+
+    *outMaxFree = 0;
+    *outFree = 0;
+    *outAlloc = 0;
+
+    iter = arena->head;
+    while (iter != NULL) {
+        if (iter->isFree) {
+            *outFree += iter->size;
+            if (*outMaxFree < iter->size) {
+                *outMaxFree = iter->size;
+            }
+        } else {
+            *outAlloc += iter->size;
+        }
+
+        iter = NODE_GET_NEXT(iter);
+    }
+}
+
+s32 __osCheckArena(Arena* arena) {
+    ArenaNode* iter;
+
+    (void)T("アリーナの内容をチェックしています．．． (%08x)\n", "Checking the arena contents... (%08x)\n");
+    iter = arena->head;
+    while (iter != NULL) {
+        if (!NODE_IS_VALID(iter)) {
+            (void)T("おおっと！！ (%08x %08x)\n", "Oops!! (%08x %08x)\n");
+            return 1;
+        }
+        iter = NODE_GET_NEXT(iter);
+    }
+
+    (void)T("アリーナはまだ、いけそうです\n", "The arena is still going well\n");
+    return 0;
+}
+
+u8 ArenaImpl_GetAllocFailures(Arena* arena) {
+    return arena->allocFailures;
+}
+
+#endif
diff --git a/src/libc64/aprintf.c b/src/libc64/aprintf.c
new file mode 100644
index 000000000..3fb8cf367
--- /dev/null
+++ b/src/libc64/aprintf.c
@@ -0,0 +1,17 @@
+#include "global.h"
+
+s32 PrintUtils_VPrintf(PrintCallback* pfn, const char* fmt, va_list args) {
+    return _Printf(*pfn, pfn, fmt, args);
+}
+
+s32 PrintUtils_Printf(PrintCallback* pfn, const char* fmt, ...) {
+    s32 ret;
+    va_list args;
+    va_start(args, fmt);
+
+    ret = PrintUtils_VPrintf(pfn, fmt, args);
+
+    va_end(args);
+
+    return ret;
+}
diff --git a/src/libc64/fp.s b/src/libc64/fp.s
new file mode 100644
index 000000000..d5b42094a
--- /dev/null
+++ b/src/libc64/fp.s
@@ -0,0 +1,167 @@
+#include "ultra64/asm.h"
+
+.set noreorder
+
+.section .data
+
+.balign 16
+
+#if !PLATFORM_N64
+DATA(qNaN0x3FFFFF)
+    .word 0x7FBFFFFF
+ENDDATA(qNaN0x3FFFFF)
+
+DATA(qNaN0x10000)
+    .word 0x7F810000
+ENDDATA(qNaN0x10000)
+
+DATA(sNaN0x3FFFFF)
+    .word 0x7FFFFFFF
+ENDDATA(sNaN0x3FFFFF)
+#endif
+
+.section .text
+
+.balign 16
+
+LEAF(floorf)
+    floor.w.s   $f12, $f12
+    jr          $ra
+     cvt.s.w    $f0, $f12
+END(floorf)
+
+LEAF(floor)
+    floor.w.d   $f12, $f12
+    jr          $ra
+     cvt.d.w    $f0, $f12
+END(floor)
+
+LEAF(lfloorf)
+    floor.w.s   $f4, $f12
+    mfc1        $v0, $f4
+    jr          $ra
+     nop
+END(lfloorf)
+
+LEAF(lfloor)
+    floor.w.d   $f4, $f12
+    mfc1        $v0, $f4
+    jr          $ra
+     nop
+END(lfloor)
+
+LEAF(ceilf)
+    ceil.w.s    $f12, $f12
+    jr          $ra
+     cvt.s.w    $f0, $f12
+END(ceilf)
+
+LEAF(ceil)
+    ceil.w.d    $f12, $f12
+    jr          $ra
+     cvt.d.w    $f0, $f12
+END(ceil)
+
+LEAF(lceilf)
+    ceil.w.s    $f4, $f12
+    mfc1        $v0, $f4
+    jr          $ra
+     nop
+END(lceilf)
+
+LEAF(lceil)
+    ceil.w.d    $f4, $f12
+    mfc1        $v0, $f4
+    jr          $ra
+     nop
+END(lceil)
+
+LEAF(truncf)
+    trunc.w.s   $f12, $f12
+    jr          $ra
+     cvt.s.w    $f0, $f12
+END(truncf)
+
+LEAF(trunc)
+    trunc.w.d   $f12, $f12
+    jr          $ra
+     cvt.d.w    $f0, $f12
+END(trunc)
+
+LEAF(ltruncf)
+    trunc.w.s   $f4, $f12
+    mfc1        $v0, $f4
+    jr          $ra
+     nop
+END(ltruncf)
+
+LEAF(ltrunc)
+    trunc.w.d   $f4, $f12
+    mfc1        $v0, $f4
+    jr          $ra
+     nop
+END(ltrunc)
+
+LEAF(nearbyintf)
+    round.w.s   $f12, $f12
+    jr          $ra
+     cvt.s.w    $f0, $f12
+END(nearbyintf)
+
+LEAF(nearbyint)
+    round.w.d   $f12, $f12
+    jr          $ra
+     cvt.d.w    $f0, $f12
+END(nearbyint)
+
+LEAF(lnearbyintf)
+    round.w.s   $f4, $f12
+    mfc1        $v0, $f4
+    jr          $ra
+     nop
+END(lnearbyintf)
+
+LEAF(lnearbyint)
+    round.w.d   $f4, $f12
+    mfc1        $v0, $f4
+    jr          $ra
+     nop
+END(lnearbyint)
+
+LEAF(roundf)
+    li.s        $f4, 0.5
+    nop
+    add.s       $f0, $f12, $f4
+    floor.w.s   $f0, $f0
+    jr          $ra
+     cvt.s.w     $f0, $f0
+END(roundf)
+
+LEAF(round)
+    li.d        $f4, 0.5
+    nop
+    add.d       $f0, $f12, $f4
+    floor.w.d   $f0, $f0
+    jr          $ra
+     cvt.d.w     $f0, $f0
+END(round)
+
+LEAF(lroundf)
+    li.s        $f4, 0.5
+    nop
+    add.s       $f0, $f12, $f4
+    floor.w.s   $f0, $f0
+    mfc1        $v0, $f0
+    jr          $ra
+     nop
+END(lroundf)
+
+LEAF(lround)
+    li.d        $f4, 0.5
+    nop
+    add.d       $f0, $f12, $f4
+    floor.w.d   $f0, $f0
+    mfc1        $v0, $f0
+    jr          $ra
+     nop
+END(lround)
diff --git a/src/libc64/malloc.c b/src/libc64/malloc.c
new file mode 100644
index 000000000..de6a56b30
--- /dev/null
+++ b/src/libc64/malloc.c
@@ -0,0 +1,172 @@
+#include "global.h"
+#include "osMalloc.h"
+
+#define LOG_SEVERITY_NOLOG 0
+#define LOG_SEVERITY_ERROR 2
+#define LOG_SEVERITY_VERBOSE 3
+
+Arena gSystemArena;
+
+#if OOT_DEBUG
+s32 gSystemArenaLogSeverity = LOG_SEVERITY_NOLOG;
+
+void SystemArena_CheckPointer(void* ptr, u32 size, const char* name, const char* action) {
+    if (ptr == NULL) {
+        if (gSystemArenaLogSeverity >= LOG_SEVERITY_ERROR) {
+            PRINTF(T("%s: %u バイトの%sに失敗しました\n", "%s: %u bytes %s failed\n"), name, size, action);
+            __osDisplayArena(&gSystemArena);
+            return;
+        }
+    } else if (gSystemArenaLogSeverity >= LOG_SEVERITY_VERBOSE) {
+        PRINTF(T("%s: %u バイトの%sに成功しました\n", "%s: %u bytes %s succeeded\n"), name, size, action);
+    }
+}
+
+#define SYSTEM_ARENA_CHECK_POINTER(ptr, size, name, action) SystemArena_CheckPointer(ptr, size, name, action)
+#else
+#define SYSTEM_ARENA_CHECK_POINTER(ptr, size, name, action) (void)0
+#endif
+
+void* SystemArena_Malloc(u32 size) {
+    DECLARE_INTERRUPT_MASK
+    void* ptr;
+
+    DISABLE_INTERRUPTS();
+    ptr = __osMalloc(&gSystemArena, size);
+    RESTORE_INTERRUPTS();
+
+    SYSTEM_ARENA_CHECK_POINTER(ptr, size, "malloc", "確保"); // "Secure"
+    return ptr;
+}
+
+#if OOT_DEBUG
+void* SystemArena_MallocDebug(u32 size, const char* file, int line) {
+    DECLARE_INTERRUPT_MASK
+    void* ptr;
+
+    DISABLE_INTERRUPTS();
+    ptr = __osMallocDebug(&gSystemArena, size, file, line);
+    RESTORE_INTERRUPTS();
+
+    SYSTEM_ARENA_CHECK_POINTER(ptr, size, "malloc_DEBUG", "確保"); // "Secure"
+    return ptr;
+}
+#endif
+
+void* SystemArena_MallocR(u32 size) {
+    DECLARE_INTERRUPT_MASK
+    void* ptr;
+
+    DISABLE_INTERRUPTS();
+    ptr = __osMallocR(&gSystemArena, size);
+    RESTORE_INTERRUPTS();
+
+    SYSTEM_ARENA_CHECK_POINTER(ptr, size, "malloc_r", "確保"); // "Secure"
+    return ptr;
+}
+
+#if OOT_DEBUG
+void* SystemArena_MallocRDebug(u32 size, const char* file, int line) {
+    DECLARE_INTERRUPT_MASK
+    void* ptr;
+
+    DISABLE_INTERRUPTS();
+    ptr = __osMallocRDebug(&gSystemArena, size, file, line);
+    RESTORE_INTERRUPTS();
+
+    SYSTEM_ARENA_CHECK_POINTER(ptr, size, "malloc_r_DEBUG", "確保"); // "Secure"
+    return ptr;
+}
+#endif
+
+void* SystemArena_Realloc(void* ptr, u32 newSize) {
+    DECLARE_INTERRUPT_MASK
+
+    DISABLE_INTERRUPTS();
+    ptr = __osRealloc(&gSystemArena, ptr, newSize);
+    RESTORE_INTERRUPTS();
+
+    SYSTEM_ARENA_CHECK_POINTER(ptr, newSize, "realloc", "再確保"); // "Re-securing"
+    return ptr;
+}
+
+#if OOT_DEBUG
+void* SystemArena_ReallocDebug(void* ptr, u32 newSize, const char* file, int line) {
+    DECLARE_INTERRUPT_MASK
+
+    DISABLE_INTERRUPTS();
+    ptr = __osReallocDebug(&gSystemArena, ptr, newSize, file, line);
+    RESTORE_INTERRUPTS();
+
+    SYSTEM_ARENA_CHECK_POINTER(ptr, newSize, "realloc_DEBUG", "再確保"); // "Re-securing"
+    return ptr;
+}
+#endif
+
+void SystemArena_Free(void* ptr) {
+    DECLARE_INTERRUPT_MASK
+
+    DISABLE_INTERRUPTS();
+    __osFree(&gSystemArena, ptr);
+    RESTORE_INTERRUPTS();
+}
+
+#if OOT_DEBUG
+void SystemArena_FreeDebug(void* ptr, const char* file, int line) {
+    DECLARE_INTERRUPT_MASK
+
+    DISABLE_INTERRUPTS();
+    __osFreeDebug(&gSystemArena, ptr, file, line);
+    RESTORE_INTERRUPTS();
+}
+#endif
+
+void* SystemArena_Calloc(u32 num, u32 size) {
+    DECLARE_INTERRUPT_MASK
+    void* ret;
+    u32 n = num * size;
+
+    DISABLE_INTERRUPTS();
+    ret = __osMalloc(&gSystemArena, n);
+    RESTORE_INTERRUPTS();
+
+    if (ret != NULL) {
+        bzero(ret, n);
+    }
+
+    SYSTEM_ARENA_CHECK_POINTER(ret, n, "calloc", "確保");
+    return ret;
+}
+
+#if OOT_DEBUG
+void SystemArena_Display(void) {
+    PRINTF(T("システムヒープ表示\n", "System heap display\n"));
+    __osDisplayArena(&gSystemArena);
+}
+#endif
+
+void SystemArena_GetSizes(u32* outMaxFree, u32* outFree, u32* outAlloc) {
+    ArenaImpl_GetSizes(&gSystemArena, outMaxFree, outFree, outAlloc);
+}
+
+void SystemArena_Check(void) {
+    __osCheckArena(&gSystemArena);
+}
+
+void SystemArena_Init(void* start, u32 size) {
+#if OOT_DEBUG
+    gSystemArenaLogSeverity = LOG_SEVERITY_NOLOG;
+#endif
+    __osMallocInit(&gSystemArena, start, size);
+}
+
+void SystemArena_Cleanup(void) {
+#if OOT_DEBUG
+    gSystemArenaLogSeverity = LOG_SEVERITY_NOLOG;
+#endif
+    __osMallocCleanup(&gSystemArena);
+}
+
+s32 SystemArena_IsInitialized(void) {
+    return __osMallocIsInitialized(&gSystemArena);
+}
diff --git a/src/libc64/math64.c b/src/libc64/math64.c
new file mode 100644
index 000000000..85fb4cedf
--- /dev/null
+++ b/src/libc64/math64.c
@@ -0,0 +1,248 @@
+#include "z64math.h"
+#include "macros.h"
+
+#if !PLATFORM_N64
+s32 gUseAtanContFrac;
+#endif
+
+/**
+ * @param angle radians
+ * @return tan(angle)
+ */
+f32 Math_FTanF(f32 angle) {
+    f32 sin = sinf(angle);
+    f32 cos = cosf(angle);
+
+    return sin / cos;
+}
+
+f32 Math_FFloorF(f32 x) {
+    return floorf(x);
+}
+
+f32 Math_FCeilF(f32 x) {
+    return ceilf(x);
+}
+
+#if PLATFORM_N64
+f64 Math_FAbs(f64 x) {
+    return x < 0.0 ? -x : x;
+}
+
+f32 Math_FAbsF(f32 x) {
+    return x < 0.0f ? -x : x;
+}
+#endif
+
+f32 Math_FRoundF(f32 x) {
+    return roundf(x);
+}
+
+f32 Math_FTruncF(f32 x) {
+    return truncf(x);
+}
+
+f32 Math_FNearbyIntF(f32 x) {
+    return nearbyintf(x);
+}
+
+#if !PLATFORM_N64
+/* Arctangent approximation using a Taylor series (one quadrant) */
+f32 Math_FAtanTaylorQF(f32 x) {
+    static const f32 coeffs[] = {
+        -1.0f / 3, +1.0f / 5, -1.0f / 7, +1.0f / 9, -1.0f / 11, +1.0f / 13, -1.0f / 15, +1.0f / 17, 0.0f,
+    };
+
+    f32 poly = x;
+    f32 sq = SQ(x);
+    f32 exp = x * sq;
+    const f32* c = coeffs;
+    f32 term;
+
+    while (true) {
+        term = *c++ * exp;
+        if (poly + term == poly) {
+            break;
+        }
+        poly += term;
+        exp *= sq;
+    }
+
+    return poly;
+}
+
+/* Ditto for two quadrants */
+f32 Math_FAtanTaylorF(f32 x) {
+    f32 t;
+    f32 q;
+
+    if (x > 0.0f) {
+        t = x;
+    } else if (x < 0.0f) {
+        t = -x;
+    } else if (x == 0.0f) {
+        return 0.0f;
+    } else {
+        return qNaN0x10000;
+    }
+
+    if (t <= M_SQRT2 - 1.0f) {
+        return Math_FAtanTaylorQF(x);
+    }
+
+    if (t >= M_SQRT2 + 1.0f) {
+        q = M_PI / 2 - Math_FAtanTaylorQF(1.0f / t);
+    } else {
+        q = M_PI / 4 - Math_FAtanTaylorQF((1.0f - t) / (1.0f + t));
+    }
+
+    if (x > 0.0f) {
+        return q;
+    } else {
+        return -q;
+    }
+}
+#endif
+
+/* Arctangent approximation using a continued fraction */
+f32 Math_FAtanContFracF(f32 x) {
+    s32 sector;
+    f32 z;
+    f32 conv;
+    f32 sq;
+    s32 i;
+
+#if PLATFORM_N64
+    if (x > 1.0f) {
+        sector = 1;
+        x = 1.0f / x;
+    } else if (x < -1.0f) {
+        sector = -1;
+        x = 1.0f / x;
+    } else {
+        sector = 0;
+    }
+#else
+    if (x >= -1.0f && x <= 1.0f) {
+        sector = 0;
+    } else if (x > 1.0f) {
+        sector = 1;
+        x = 1.0f / x;
+    } else if (x < -1.0f) {
+        sector = -1;
+        x = 1.0f / x;
+    } else {
+        return qNaN0x10000;
+    }
+#endif
+
+    sq = SQ(x);
+    conv = 0.0f;
+
+#if PLATFORM_N64
+    z = 24.0f;
+    i = 24;
+#else
+    z = 8.0f;
+    i = 8;
+#endif
+
+    while (i != 0) {
+        conv = SQ(z) * sq / (2.0f * z + 1.0f + conv);
+        z -= 1.0f;
+        i--;
+    }
+
+#if PLATFORM_N64
+    if (sector > 0) {
+        return M_PI / 2 - (x / (1.0f + conv));
+    } else if (sector < 0) {
+        return -M_PI / 2 - (x / (1.0f + conv));
+    } else {
+        return x / (1.0f + conv);
+    }
+#else
+    conv = x / (1.0f + conv);
+    if (sector == 0) {
+        return conv;
+    } else if (sector > 0) {
+        return M_PI / 2 - conv;
+    } else {
+        return -M_PI / 2 - conv;
+    }
+#endif
+}
+
+#if !PLATFORM_N64
+/**
+ * @return arctan(x) in radians, in (-pi/2,pi/2) range
+ */
+f32 Math_FAtanF(f32 x) {
+    if (!gUseAtanContFrac) {
+        return Math_FAtanTaylorF(x);
+    } else {
+        return Math_FAtanContFracF(x);
+    }
+}
+#endif
+
+/**
+ * @return angle to (x,y) from vector (1,0) around (0,0) in radians, in (-pi,pi] range
+ */
+f32 Math_FAtan2F(f32 y, f32 x) {
+#if PLATFORM_N64
+    if (y == 0.0f && x == 0.0f) {
+        return 0.0f;
+    }
+
+    if (x == 0.0f) {
+        if (y < 0.0f) {
+            return -M_PI / 2;
+        } else {
+            return M_PI / 2;
+        }
+    } else if (x < 0.0f) {
+        if (y < 0.0f) {
+            return -(M_PI - Math_FAtanContFracF(fabs(y / x)));
+        } else {
+            return M_PI - Math_FAtanContFracF(fabs(y / x));
+        }
+    } else { // x > 0.0f
+        return Math_FAtanContFracF(y / x);
+    }
+#else
+    if (x == 0.0f) {
+        if (y == 0.0f) {
+            return 0.0f;
+        } else if (y > 0.0f) {
+            return M_PI / 2;
+        } else if (y < 0.0f) {
+            return -M_PI / 2;
+        } else {
+            return qNaN0x10000;
+        }
+    } else if (x >= 0.0f) {
+        return Math_FAtanF(y / x);
+    } else { // x < 0.0f
+        if (y < 0.0f) {
+            return Math_FAtanF(y / x) - M_PI;
+        } else {
+            return M_PI - Math_FAtanF(-(y / x));
+        }
+    }
+#endif
+}
+
+/**
+ * @return arcsin(x) in radians, in [-pi/2,pi/2] range
+ */
+f32 Math_FAsinF(f32 x) {
+    return Math_FAtan2F(x, sqrtf(1.0f - SQ(x)));
+}
+
+/**
+ * @return arccos(x) in radians, in [0,pi] range
+ */
+f32 Math_FAcosF(f32 x) {
+    return M_PI / 2 - Math_FAsinF(x);
+}
diff --git a/src/libc64/qrand.c b/src/libc64/qrand.c
new file mode 100644
index 000000000..69bfa11d7
--- /dev/null
+++ b/src/libc64/qrand.c
@@ -0,0 +1,197 @@
+/**
+ * @file rand.c
+ *
+ * This file implements the primary random number generator the game relies on. The generator is pseudo-random and
+ * implemented as a Linear Congruential Generator (LCG).
+ *
+ * A LCG computes random numbers sequentially via the relation
+ *      X(n+1) = (a * X(n) + c) mod m
+ * where m is the modulus, a is the multiplier and c is the increment.
+ *
+ * These three parameters (a,c,m) completely specify the LCG and should be chosen such that
+ *  - m > 0
+ *  - 0 < a < m
+ *  - 0 <= c < m
+ *
+ * The period of the LCG (a, c, m) is the smallest period p such that X(n + p) = X(n), past n=p the sequence will repeat
+ * itself in its outputs.
+ * A good LCG should have the maximum possible period, which will be equal to m as there are at most m possible values
+ * for X. This occurs when (Hull, T.E., & Dobell, A.R. (1962). Random Number Generators. Siam Review, 4, 230-254.):
+ *  - m,c are relatively prime, that is the only integer that divides both m and c with no remainder is 1.
+ *  - a - 1 is divisible by all prime factors of m.
+ *  - a - 1 is divisible by 4 if m is divisible by 4.
+ *
+ * Ideally m is chosen to be a large power of 2 so that the modulo operation is inexpensive to compute. In this case the
+ * prime factors of m = 2^k are just k copies of 2. For k > 1 m is divisible by 4, so a - 1 must be divisible by 4. 2^k
+ * and c can easily be made relatively prime by making c an odd number.
+ * If we let k=32 to match the size of an integer, the modulo operation is made implicit by the width of the data type
+ * and becomes free to compute.
+ *
+ * The parameter a should be selected such that a-1 is divisible by 4 (and hence divisible by 2) and c should be any odd
+ * number. The precise values should fare well against the spectral test, a measure of "how random" a particular LCG is.
+ * A pair (a,c) that satisfies these requirements is (1664525, 1013904223), recommended by "Numerical Recipes in C: The
+ * Art of Scientific Computing" (p. 284).
+ *
+ * Therefore, the LCG with parameters (1664525, 1013904223, 2^32) that is implemented in this file has a maximal period
+ * of 2^32 and produces high-quality pseudo-random numbers.
+ *
+ * @note If sampling the LCG for a n-bit number it is important to use the upper n bits instead of the lower n bits of
+ * the LCG output. The lower n bits only have a period of 2^n which may significantly worsen the quality of the
+ * resulting random numbers compared to the quality of the full 32-bit result.
+ *
+ * @note Original name: qrand.c
+ */
+#include "libc64/qrand.h"
+#include "z64math.h"
+
+#define RAND_MULTIPLIER 1664525
+#define RAND_INCREMENT 1013904223
+
+/**
+ * The latest generated random number, used to generate the next number in the sequence.
+ *
+ * @note Original name: __qrand_idum
+ */
+static u32 sRandInt = 1;
+
+#if !PLATFORM_N64
+/**
+ * Space to store a value to be re-interpreted as a float.
+ *
+ * @note Orignal name: __qrand_itemp
+ */
+static FloatInt sRandFloat;
+#endif
+
+/**
+ * Gets the next integer in the sequence of pseudo-random numbers.
+ *
+ * @note Original name: qrand
+ */
+u32 Rand_Next(void) {
+#if PLATFORM_N64
+    u32 next = sRandInt * RAND_MULTIPLIER + RAND_INCREMENT;
+
+    sRandInt = next;
+    return next;
+#else
+    return sRandInt = sRandInt * RAND_MULTIPLIER + RAND_INCREMENT;
+#endif
+}
+
+/**
+ * Seeds the pseudo-random number generator by providing a starting value.
+ *
+ * @note Original name: sqrand
+ */
+void Rand_Seed(u32 seed) {
+    sRandInt = seed;
+}
+
+/**
+ * Returns a pseudo-random floating-point number between 0.0f and 1.0f, by generating the next integer and masking it
+ * to an IEEE-754 compliant floating-point number between 1.0f and 2.0f, returning the result subtract 1.0f.
+ *
+ * @note This technique for generating pseudo-random floats is recommended as a particularly fast but potentially
+ *       non-portable generator in "Numerical Recipes in C: The Art of Scientic Computing", pp. 284-5.
+ *
+ * @note Original name: fqrand
+ */
+f32 Rand_ZeroOne(void) {
+#if PLATFORM_N64
+    fu v;
+    f32 vf;
+
+    // Note this samples the lower 23 bits, effectively reducing the LCG period from 2^32 to 2^23.
+    // This was fixed in Gamecube versions and Majora's Mask.
+    v.i = (Rand_Next() & 0x007FFFFF) | 0x3F800000;
+    vf = v.f - 1.0f;
+    return vf;
+#else
+    sRandInt = sRandInt * RAND_MULTIPLIER + RAND_INCREMENT;
+    // Samples the upper 23 bits to avoid effectively reducing the LCG period.
+    sRandFloat.i = (sRandInt >> 9) | 0x3F800000;
+    return sRandFloat.f - 1.0f;
+#endif
+}
+
+#if !PLATFORM_N64
+/**
+ * Returns a pseudo-random floating-point number between -0.5f and 0.5f by the same manner in which Rand_ZeroOne
+ * generates its result.
+ *
+ * @see Rand_ZeroOne
+ *
+ * @note Original name: fqrand2
+ */
+f32 Rand_Centered(void) {
+    sRandInt = sRandInt * RAND_MULTIPLIER + RAND_INCREMENT;
+    sRandFloat.i = (sRandInt >> 9) | 0x3F800000;
+    return sRandFloat.f - 1.5f;
+}
+#endif
+
+//! All functions below are unused variants of the above four, that use a provided random number variable instead of the
+//! internal `sRandInt`
+
+/**
+ * Seeds a pseudo-random number at rndNum with a provided starting value.
+ *
+ * @see Rand_Seed
+ *
+ * @note Original name: sqrand_r
+ */
+void Rand_Seed_Variable(u32* rndNum, u32 seed) {
+    *rndNum = seed;
+}
+
+/**
+ * Generates the next pseudo-random integer from the provided rndNum.
+ *
+ * @see Rand_Next
+ *
+ * @note Original name: qrand_r
+ */
+u32 Rand_Next_Variable(u32* rndNum) {
+    return *rndNum = (*rndNum) * RAND_MULTIPLIER + RAND_INCREMENT;
+}
+
+/**
+ * Generates the next pseudo-random floating-point number between 0.0f and 1.0f from the provided rndNum.
+ *
+ * @see Rand_ZeroOne
+ *
+ * @note Original name: fqrand_r
+ */
+f32 Rand_ZeroOne_Variable(u32* rndNum) {
+#if PLATFORM_N64
+    fu v;
+    f32 vf;
+    u32 next = Rand_Next_Variable(rndNum);
+
+    v.i = (next & 0x007FFFFF) | 0x3F800000;
+    vf = v.f - 1.0f;
+    return vf;
+#else
+    u32 next = (*rndNum) * RAND_MULTIPLIER + RAND_INCREMENT;
+
+    sRandFloat.i = ((*rndNum = next) >> 9) | 0x3F800000;
+    return sRandFloat.f - 1.0f;
+#endif
+}
+
+#if !PLATFORM_N64
+/**
+ * Generates the next pseudo-random floating-point number between -0.5f and 0.5f from the provided rndNum.
+ *
+ * @see Rand_ZeroOne, Rand_Centered
+ *
+ * @note Original name: fqrand2_r
+ */
+f32 Rand_Centered_Variable(u32* rndNum) {
+    u32 next = (*rndNum) * RAND_MULTIPLIER + RAND_INCREMENT;
+
+    sRandFloat.i = ((*rndNum = next) >> 9) | 0x3F800000;
+    return sRandFloat.f - 1.5f;
+}
+#endif
diff --git a/src/libc64/sleep.c b/src/libc64/sleep.c
new file mode 100644
index 000000000..2b67088a1
--- /dev/null
+++ b/src/libc64/sleep.c
@@ -0,0 +1,28 @@
+#include "global.h"
+
+void Sleep_Cycles(OSTime cycles) {
+    OSMesgQueue mq;
+    OSMesg msg;
+    OSTimer timer;
+
+    osCreateMesgQueue(&mq, &msg, 1);
+    osSetTimer(&timer, cycles, 0, &mq, NULL);
+    osRecvMesg(&mq, NULL, OS_MESG_BLOCK);
+}
+
+void Sleep_Nsec(u32 nsec) {
+    Sleep_Cycles(OS_NSEC_TO_CYCLES(nsec));
+}
+
+void Sleep_Usec(u32 usec) {
+    Sleep_Cycles(OS_USEC_TO_CYCLES(usec));
+}
+
+// originally "msleep"
+void Sleep_Msec(u32 ms) {
+    Sleep_Cycles((ms * OS_CPU_COUNTER) / 1000ull);
+}
+
+void Sleep_Sec(u32 sec) {
+    Sleep_Cycles(sec * OS_CPU_COUNTER);
+}
diff --git a/src/libc64/sprintf.c b/src/libc64/sprintf.c
new file mode 100644
index 000000000..d4af36356
--- /dev/null
+++ b/src/libc64/sprintf.c
@@ -0,0 +1,37 @@
+#include "stdarg.h"
+#include "stdio.h"
+#include "string.h"
+#include "ultra64/xstdio.h"
+
+#if PLATFORM_N64
+// Generated by CVS "$Id$" keyword
+char sSprintfFileInfo[] = "$Id: sprintf.c,v 1.5 1997/03/19 02:28:53 hayakawa Exp $";
+#endif
+
+void* proutSprintf(void* dst, const char* fmt, size_t size) {
+    return (char*)memcpy(dst, fmt, size) + size;
+}
+
+int vsprintf(char* dst, const char* fmt, va_list args) {
+    int ret = _Printf(proutSprintf, dst, fmt, args);
+
+    if (ret > -1) {
+        dst[ret] = '\0';
+    }
+    return ret;
+}
+
+int sprintf(char* dst, const char* fmt, ...) {
+    int ret;
+    va_list args;
+    va_start(args, fmt);
+
+    ret = _Printf(proutSprintf, dst, fmt, args);
+    if (ret > -1) {
+        dst[ret] = '\0';
+    }
+
+    va_end(args);
+
+    return ret;
+}