From 13d9bcb5b4550f877fb2c257c5be3252d2029023 Mon Sep 17 00:00:00 2001
From: Daren Gordon <podunt@live.com>
Date: Tue, 9 Aug 2022 10:47:49 -0400
Subject: [PATCH] This is me learning how to use git i'm running into constant
 errors and having a hard time but hopefully i'll get there in the end okay
 here we go into my local ocdizzle branch we go!

---
 Test.txt                                      |    1 +
 data/dynos.c.h                                |   28 +
 data/dynos.cpp.h                              |  714 ++++++
 data/dynos.h                                  |   40 +
 data/dynos_c.cpp                              |   36 +
 data/dynos_gfx_init.cpp                       |   63 +
 data/dynos_gfx_load.cpp                       |  278 +++
 data/dynos_gfx_read.cpp                       | 1884 ++++++++++++++++
 data/dynos_gfx_texture.cpp                    |  285 +++
 data/dynos_gfx_update.cpp                     |  200 ++
 data/dynos_gfx_write.cpp                      |  318 +++
 data/dynos_level.cpp                          |  826 +++++++
 data/dynos_main.cpp                           |  133 ++
 data/dynos_misc.cpp                           |  509 +++++
 data/dynos_opt.cpp                            |  847 ++++++++
 data/dynos_opt_config.cpp                     |   62 +
 data/dynos_opt_cont.cpp                       |   70 +
 data/dynos_opt_render.cpp                     |  311 +++
 data/dynos_opt_vanilla.cpp                    |  155 ++
 data/dynos_opt_vanilla_c.c                    |   71 +
 data/dynos_sanity.c                           |   34 +
 data/dynos_warps.cpp                          |  475 ++++
 dynos.mk                                      |   27 +
 dynos/cheater_menu.txt                        |   34 +
 enhancements/60fps_ex.patch_installed         |    0
 enhancements/DynOS.1.0.patch_installed        |    0
 .../exit_course_50_coin_fix.patch_installed   |    0
 .../increase_delay_on_credits.patch_installed |    0
 ...rease_delay_on_star_select.patch_installed |    0
 .../leave_ending_screen.patch_installed       |    0
 .../time_trials.2.4.hotfix.patch_installed    |    0
 enhancements/v11.5.ex.patch_installed         |    0
 include/libc/time.h                           |  234 ++
 include/text_cheats_strings.h.in              |  220 ++
 src/game/cheats_menu.h                        |  215 ++
 src/game/mario_cheats.c                       | 1790 +++++++++++++++
 src/game/mario_cheats.h                       |   42 +
 src/game/time_trials.c                        | 1283 +++++++++++
 src/game/time_trials.h                        |   15 +
 src/game/time_trials_ghost_geo.inl            | 1931 +++++++++++++++++
 40 files changed, 13131 insertions(+)
 create mode 100644 Test.txt
 create mode 100644 data/dynos.c.h
 create mode 100644 data/dynos.cpp.h
 create mode 100644 data/dynos.h
 create mode 100644 data/dynos_c.cpp
 create mode 100644 data/dynos_gfx_init.cpp
 create mode 100644 data/dynos_gfx_load.cpp
 create mode 100644 data/dynos_gfx_read.cpp
 create mode 100644 data/dynos_gfx_texture.cpp
 create mode 100644 data/dynos_gfx_update.cpp
 create mode 100644 data/dynos_gfx_write.cpp
 create mode 100644 data/dynos_level.cpp
 create mode 100644 data/dynos_main.cpp
 create mode 100644 data/dynos_misc.cpp
 create mode 100644 data/dynos_opt.cpp
 create mode 100644 data/dynos_opt_config.cpp
 create mode 100644 data/dynos_opt_cont.cpp
 create mode 100644 data/dynos_opt_render.cpp
 create mode 100644 data/dynos_opt_vanilla.cpp
 create mode 100644 data/dynos_opt_vanilla_c.c
 create mode 100644 data/dynos_sanity.c
 create mode 100644 data/dynos_warps.cpp
 create mode 100644 dynos.mk
 create mode 100644 dynos/cheater_menu.txt
 create mode 100644 enhancements/60fps_ex.patch_installed
 create mode 100644 enhancements/DynOS.1.0.patch_installed
 create mode 100644 enhancements/exit_course_50_coin_fix.patch_installed
 create mode 100644 enhancements/increase_delay_on_credits.patch_installed
 create mode 100644 enhancements/increase_delay_on_star_select.patch_installed
 create mode 100644 enhancements/leave_ending_screen.patch_installed
 create mode 100644 enhancements/time_trials.2.4.hotfix.patch_installed
 create mode 100644 enhancements/v11.5.ex.patch_installed
 create mode 100644 include/libc/time.h
 create mode 100644 include/text_cheats_strings.h.in
 create mode 100644 src/game/cheats_menu.h
 create mode 100644 src/game/mario_cheats.c
 create mode 100644 src/game/mario_cheats.h
 create mode 100644 src/game/time_trials.c
 create mode 100644 src/game/time_trials.h
 create mode 100644 src/game/time_trials_ghost_geo.inl

diff --git a/Test.txt b/Test.txt
new file mode 100644
index 00000000..0f3d06ca
--- /dev/null
+++ b/Test.txt
@@ -0,0 +1 @@
+blahblahblah
\ No newline at end of file
diff --git a/data/dynos.c.h b/data/dynos.c.h
new file mode 100644
index 00000000..35a62412
--- /dev/null
+++ b/data/dynos.c.h
@@ -0,0 +1,28 @@
+#ifndef DYNOS_C_H
+#define DYNOS_C_H
+#ifndef __cplusplus
+
+#include "dynos.h"
+
+// The action signature is "bool (*) (const char *)"
+// The input is the button internal name (not label)
+// The output is the result of the action
+#define DYNOS_DEFINE_ACTION(func) \
+DYNOS_AT_STARTUP static void dynos_opt_add_action_##func() { \
+    dynos_opt_add_action(#func, func, false); \
+}
+
+s32     dynos_opt_get_value         (const char *name);
+void    dynos_opt_set_value         (const char *name, s32 value);
+void    dynos_opt_add_action        (const char *funcname, bool (*funcptr)(const char *), bool overwrite);
+
+void   *dynos_update_cmd            (void *cmd);
+void    dynos_update_gfx            ();
+void    dynos_update_opt            (void *pad);
+bool    dynos_sanity_check_geo      (s16 graphNodeType);
+bool    dynos_sanity_check_seq      (u8 loBits);
+s32     dynos_gfx_import_texture    (void **output, void *ptr, s32 tile, void *grapi, void **hashmap, void *pool, s32 *poolpos, s32 poolsize);
+void    dynos_gfx_swap_animations   (void *ptr);
+
+#endif
+#endif
diff --git a/data/dynos.cpp.h b/data/dynos.cpp.h
new file mode 100644
index 00000000..febce95b
--- /dev/null
+++ b/data/dynos.cpp.h
@@ -0,0 +1,714 @@
+#ifndef DYNOS_CPP_H
+#define DYNOS_CPP_H
+#ifdef __cplusplus
+
+#include "dynos.h"
+
+#define FUNCTION_CODE   (u32) 0x434E5546
+#define POINTER_CODE    (u32) 0x52544E50
+
+//
+// Enums
+//
+
+enum {
+    DATA_TYPE_NONE = 0,
+    DATA_TYPE_LIGHT,
+    DATA_TYPE_TEXTURE,
+    DATA_TYPE_VERTEX,
+    DATA_TYPE_DISPLAY_LIST,
+    DATA_TYPE_GEO_LAYOUT,
+    DATA_TYPE_ANIMATION_VALUE,
+    DATA_TYPE_ANIMATION_INDEX,
+    DATA_TYPE_ANIMATION,
+    DATA_TYPE_ANIMATION_TABLE,
+    DATA_TYPE_GFXDYNCMD,
+    DATA_TYPE_UNUSED,
+};
+
+enum {
+    DOPT_NONE = 0,
+
+    DOPT_TOGGLE,
+    DOPT_CHOICE,
+    DOPT_SCROLL,
+    DOPT_BIND,
+    DOPT_BUTTON,
+    DOPT_SUBMENU,
+
+    // These ones are used by the Warp to Level built-in submenu
+    DOPT_CHOICELEVEL,
+    DOPT_CHOICEAREA,
+    DOPT_CHOICESTAR,
+#ifndef DYNOS_COOP
+    DOPT_CHOICEPARAM,
+#endif
+};
+
+#ifdef DYNOS_COOP
+enum {
+    DYNOS_COOP_COMMAND_NONE,
+    DYNOS_COOP_COMMAND_WARP_TO_LEVEL,
+    DYNOS_COOP_COMMAND_WARP_TO_CASTLE,
+    DYNOS_COOP_COMMAND_RESTART_LEVEL,
+    DYNOS_COOP_COMMAND_EXIT_LEVEL,
+};
+#endif
+
+//
+// DynOS Array
+// A vector-like array, implemented to be processed really fast, but cannot handle C++ complex classes like std::string
+//
+
+template <typename T>
+class Array {
+public:
+    inline Array() : mBuffer(NULL), mCount(0), mCapacity(0) {
+    }
+
+    inline Array(const std::initializer_list<T> &aList) : mBuffer(NULL), mCount(0), mCapacity(0) {
+        Resize(aList.size());
+        memcpy(mBuffer, aList.begin(), mCount * sizeof(T));
+    }
+
+    inline Array(const T *aBegin, const T *aEnd) : mBuffer(NULL), mCount(0), mCapacity(0) {
+        Resize(aEnd - aBegin);
+        memcpy(mBuffer, aBegin, mCount * sizeof(T));
+    }
+
+    inline Array(const Array &aOther) : mBuffer(NULL), mCount(0), mCapacity(0) {
+        Resize(aOther.mCount);
+        memcpy(mBuffer, aOther.mBuffer, mCount * sizeof(T));
+    }
+
+    inline void operator=(const Array &aOther) {
+        Resize(aOther.mCount);
+        memcpy(mBuffer, aOther.mBuffer, mCount * sizeof(T));
+    }
+
+    inline ~Array() {
+        Clear();
+    }
+
+public:
+    void Resize(s32 aCount) {
+        if (aCount > mCapacity) {
+            mCapacity = MAX(aCount, MAX(16, mCapacity * 2));
+            T *_Buffer = (T *) calloc(mCapacity, sizeof(T));
+            if (mBuffer) {
+                memcpy(_Buffer, mBuffer, mCount * sizeof(T));
+                free(mBuffer);
+            }
+            mBuffer = _Buffer;
+        }
+        mCount = aCount;
+    }
+
+    void Add(const T& aItem) {
+        Resize(mCount + 1);
+        mBuffer[mCount - 1] = aItem;
+    }
+
+    void Remove(s32 aIndex) {
+        memmove(mBuffer + aIndex, mBuffer + aIndex + 1, (mCount - aIndex - 1) * sizeof(T));
+        mCount--;
+    }
+
+    void Pop() {
+        mCount--;
+    }
+
+    void RemoveAll() {
+        mCount = 0;
+    }
+
+    void Clear() {
+        if (mBuffer) free(mBuffer);
+        mBuffer   = NULL;
+        mCount    = 0;
+        mCapacity = 0;
+    }
+
+    s32 Find(const T& aItem) const {
+        for (s32 i = 0; i != mCount; ++i) {
+            if (mBuffer[i] == aItem) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    template <typename Predicate>
+    s32 FindIf(Predicate aPredicate) const {
+        for (s32 i = 0; i != mCount; ++i) {
+            if (aPredicate(mBuffer[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+public:
+    inline const T *begin() const { return mBuffer; }
+    inline const T *end() const { return mBuffer + mCount; }
+    inline T *begin() { return mBuffer; }
+    inline T *end() { return mBuffer + mCount; }
+
+    inline const T &operator[](s32 aIndex) const { return mBuffer[aIndex]; }
+    inline T &operator[](s32 aIndex) { return mBuffer[aIndex]; }
+
+    inline s32 Count() const { return mCount; }
+    inline bool Empty() const { return mCount == 0; }
+
+public:
+    void Read(FILE *aFile) {
+        s32 _Length = 0; fread(&_Length, sizeof(s32), 1, aFile);
+        Resize(_Length);
+        fread(mBuffer, sizeof(T), _Length, aFile);
+    }
+
+    void Write(FILE *aFile) const {
+        fwrite(&mCount, sizeof(s32), 1, aFile);
+        fwrite(mBuffer, sizeof(T), mCount, aFile);
+    }
+
+private:
+    T *mBuffer;
+    s32 mCount;
+    s32 mCapacity;
+};
+
+//
+// DynOS String
+// A fixed-size string that doesn't require heap memory allocation
+//
+
+#define STRING_SIZE 95
+class String {
+public:
+    inline String() : mCount(0) {
+        mBuffer[0] = 0;
+    }
+
+    inline String(const char *aString) : mCount(0) {
+        if (aString) {
+            u64 _Length = strlen(aString);
+            mCount = MIN(_Length, STRING_SIZE - 1);
+            memcpy(mBuffer, aString, _Length);
+        }
+        mBuffer[mCount] = 0;
+    }
+
+    template <typename... Args>
+    inline String(const char *aFmt, Args... aArgs) : mCount(0) {
+        snprintf(mBuffer, STRING_SIZE, aFmt, aArgs...);
+        mCount = (u8) strlen(mBuffer);
+        mBuffer[mCount] = 0;
+    }
+
+    inline String(const String &aOther) : mCount(0) {
+        mCount = aOther.mCount;
+        memcpy(mBuffer, aOther.mBuffer, mCount);
+        mBuffer[mCount] = 0;
+    }
+
+    inline void operator=(const String &aOther) {
+        mCount = aOther.mCount;
+        memcpy(mBuffer, aOther.mBuffer, mCount);
+        mBuffer[mCount] = 0;
+    }
+
+public:
+    void Add(char aChar) {
+        if (mCount == STRING_SIZE - 1) return;
+        mBuffer[mCount++] = aChar;
+        mBuffer[mCount] = 0;
+    }
+
+    void Remove(s32 aIndex) {
+        memmove(mBuffer + aIndex, mBuffer + aIndex + 1, (mCount-- - aIndex - 1));
+        mBuffer[mCount] = 0;
+    }
+
+    void RemoveAll() {
+        mCount = 0;
+        mBuffer[0] = 0;
+    }
+
+    void Clear() {
+        mCount = 0;
+        mBuffer[0] = 0;
+    }
+
+    s32 Find(char aChar, s32 aStart = 0) const {
+        for (u8 i = (u8) aStart; i < mCount; ++i) {
+            if (mBuffer[i] == aChar) {
+                return (s32) i;
+            }
+        }
+        return -1;
+    }
+
+    s32 Find(const char *aString, s32 aStart = 0) const {
+        const char *_Ptr = strstr(mBuffer + aStart, aString);
+        if (_Ptr) return (s32) (_Ptr - mBuffer);
+        return -1;
+    }
+
+    s32 FindLast(char aChar) const {
+        for (u8 i = mCount; i != 0; --i) {
+            if (mBuffer[i - 1] == aChar) {
+                return (s32) (i - 1);
+            }
+        }
+        return -1;
+    }
+
+    String SubString(s32 aStart, s32 aCount = STRING_SIZE - 1) const {
+        if (aStart >= mCount) return String();
+        if (aCount < 0) aCount = STRING_SIZE - 1;
+        aCount = MIN(aCount, mCount - aStart);
+        String _String;
+        _String.mCount = aCount;
+        memcpy(_String.mBuffer, mBuffer + aStart, aCount);
+        _String.mBuffer[aCount] = 0;
+        return _String;
+    }
+
+public:
+    inline const char *begin() const { return mBuffer; }
+    inline const char *end() const { return mBuffer + mCount; }
+    inline char *begin() { return mBuffer; }
+    inline char *end() { return mBuffer + mCount; }
+
+    inline const char &operator[](s32 aIndex) const { return mBuffer[aIndex]; }
+    inline char &operator[](s32 aIndex) { return mBuffer[aIndex]; }
+
+    inline s32 Length() const { return (s32) mCount; }
+    inline bool Empty() const { return mCount == 0; }
+
+public:
+    bool operator==(const char *aString) const {
+        if (strlen(aString) != mCount) return false;
+        for (u8 i = 0; i != mCount; ++i) {
+            if (aString[i] != mBuffer[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    bool operator==(const String &aOther) const {
+        if (aOther.mCount != mCount) return false;
+        for (u8 i = 0; i != mCount; ++i) {
+            if (aOther.mBuffer[i] != mBuffer[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    bool operator!=(const char *aString) const {
+        if (strlen(aString) != mCount) return true;
+        for (u8 i = 0; i != mCount; ++i) {
+            if (aString[i] != mBuffer[i]) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    bool operator!=(const String &aOther) const {
+        if (aOther.mCount != mCount) return true;
+        for (u8 i = 0; i != mCount; ++i) {
+            if (aOther.mBuffer[i] != mBuffer[i]) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+public:
+    void Read(FILE *aFile) {
+        fread(&mCount, sizeof(u8), 1, aFile);
+        fread(mBuffer, sizeof(char), mCount, aFile);
+        mBuffer[mCount] = 0;
+    }
+
+    void Write(FILE *aFile) const {
+        fwrite(&mCount, sizeof(u8), 1, aFile);
+        fwrite(mBuffer, sizeof(char), mCount, aFile);
+    }
+
+    s32 ParseInt() const {
+        s32 i = 0;
+        if (mBuffer[1] == 'x') {
+            sscanf(mBuffer + 2, "%x", &i);
+        } else {
+            sscanf(mBuffer, "%d", &i);
+        }
+        return i;
+    }
+
+    f32 ParseFloat() const {
+        f32 f = 0.f;
+        sscanf(mBuffer, "%f", &f);
+        return f;
+    }
+
+private:
+    char mBuffer[STRING_SIZE];
+    u8 mCount;
+};
+static_assert(sizeof(String) == (STRING_SIZE + 1), "sizeof(String) must be (STRING_SIZE + 1)");
+
+//
+// Types
+//
+
+template <typename U, typename V>
+using Pair = std::pair<U, V>;
+
+typedef std::string SysPath;
+
+class NoCopy {
+  protected:
+    NoCopy() {}
+    ~NoCopy() {}
+  private:
+    NoCopy(const NoCopy &) = delete;
+    void operator=(const NoCopy &) = delete;
+};
+
+struct TexData : NoCopy {
+    Array<u8> mPngData;
+    Array<u8> mRawData;
+    s32 mRawWidth  = -1;
+    s32 mRawHeight = -1;
+    s32 mRawFormat = -1;
+    s32 mRawSize   = -1;
+    bool mUploaded = false;
+};
+
+struct AnimData : NoCopy {
+    s16 mFlags = 0;
+    s16 mUnk02 = 0;
+    s16 mUnk04 = 0;
+    s16 mUnk06 = 0;
+    s16 mUnk08 = 0;
+    Pair<String, s16> mUnk0A;
+    Pair<String, Array<s16>> mValues;
+    Pair<String, Array<u16>> mIndex;
+    u32 mLength = 0;
+};
+
+template <typename T>
+struct DataNode : NoCopy {
+    String mName;
+    T* mData = NULL;
+    u32 mSize = 0;
+    Array<String> mTokens;
+    u64 mModelIdentifier = 0;
+    u64 mLoadIndex = 0;
+};
+template <typename T>
+using DataNodes = Array<DataNode<T>*>;
+
+struct GfxContext {
+    DataNode<TexData>* mCurrentTexture = NULL;
+    DataNode<TexData>* mCurrentPalette = NULL;
+};
+
+template <typename T>
+using AnimBuffer = Pair<String, Array<T>>;
+struct GfxData : NoCopy {
+
+    // Model data
+    DataNodes<Lights1> mLights;
+    DataNodes<TexData> mTextures;
+    DataNodes<Vtx> mVertices;
+    DataNodes<Gfx> mDisplayLists;
+    DataNodes<GeoLayout> mGeoLayouts;
+
+    // Animation data
+    Array<AnimBuffer<s16> *> mAnimValues;
+    Array<AnimBuffer<u16> *> mAnimIndices;
+    DataNodes<AnimData> mAnimations;
+    Array<Pair<String, void *>> mAnimationTable;
+
+    // Current
+    u64 mLoadIndex = 0;
+    s32 mErrorCount = 0;
+    u32 mModelIdentifier = 0;
+    SysPath mPackFolder;
+    Array<void *> mPointerList;
+    GfxContext mGfxContext;
+    Array<GfxContext> mGeoNodeStack;
+};
+
+struct ActorGfx {
+    GfxData *mGfxData = NULL;
+    GraphNode *mGraphNode = NULL;
+    s32 mPackIndex = 0;
+};
+
+struct PackData {
+    SysPath mPath;
+};
+
+typedef Pair<String, const u8 *> Label;
+struct DynosOption : NoCopy {
+    String mName;
+    String mConfigName; // Name used in the config file
+    Label mLabel;
+    Label mTitle; // Full caps label, displayed with colored font
+    DynosOption *mPrev;
+    DynosOption *mNext;
+    DynosOption *mParent;
+    bool mDynos; // true from create, false from convert
+    u8 mType;
+
+    // TOGGLE
+    struct Toggle : NoCopy {
+        bool *mTog;
+    } mToggle;
+
+    // CHOICE
+    struct Choice : NoCopy {
+        Array<Label> mChoices;
+        s32 *mIndex;
+    } mChoice;
+
+    // SCROLL
+    struct Scroll : NoCopy {
+        s32 mMin;
+        s32 mMax;
+        s32 mStep;
+        s32 *mValue;
+    } mScroll;
+
+    // BIND
+    struct Bind : NoCopy {
+        u32 mMask;
+        u32 *mBinds;
+        s32 mIndex;
+    } mBind;
+
+    // BUTTON
+    struct Button : NoCopy {
+        String mFuncName;
+    } mButton;
+
+    // SUBMENU
+    struct Submenu : NoCopy {
+        DynosOption *mChild;
+        bool mEmpty;
+    } mSubMenu;
+};
+typedef bool (*DynosLoopFunc)(DynosOption *, void *);
+
+//
+// Utils
+//
+
+template <typename T>
+T* New(u64 aCount = 1llu) {
+    T *_Ptr = (T *) calloc(aCount, sizeof(T));
+    for (u64 i = 0; i != aCount; ++i) {
+        new (_Ptr + i) T(); // Calls the constructor of type T at address (_Ptr + i)
+    }
+    return _Ptr;
+}
+
+template <typename T>
+void Delete(T *& aPtr) {
+    if (aPtr) aPtr->~T();
+    free(aPtr);
+    aPtr = NULL;
+}
+
+template <typename T>
+T *CopyBytes(const T *aPtr, u64 aSize) {
+    T *_Ptr = (T *) calloc(1, aSize);
+    memcpy(_Ptr, aPtr, aSize);
+    return _Ptr;
+}
+
+template <typename T = void>
+Array<String> Split(const char *aBuffer, const String &aDelimiters, const String &aEndCharacters = {}, bool aHandleDoubleQuotedStrings = false) {
+    Array<String> _Tokens;
+    String _Token;
+    bool _TreatSpaceAsChar = false;
+    u64 _Length = strlen(aBuffer);
+    for (u64 i = 0; i <= _Length; ++i) {
+        if (i == _Length || aDelimiters.Find(aBuffer[i]) != -1) {
+            if (aBuffer[i] == ' ' && _TreatSpaceAsChar) {
+                _Token.Add(aBuffer[i]);
+            } else {
+                if (!_Token.Empty()) {
+                    _Tokens.Add(_Token);
+                    _Token.Clear();
+                }
+                if (aEndCharacters.Find(aBuffer[i]) != -1) {
+                    break;
+                }
+            }
+        } else {
+            if (aBuffer[i] == '\"' && aHandleDoubleQuotedStrings) {
+                _TreatSpaceAsChar = !_TreatSpaceAsChar;
+            } else {
+                _Token.Add(aBuffer[i]);
+            }
+        }
+    }
+    return _Tokens;
+}
+
+template <typename T>
+T ReadBytes(FILE* aFile) {
+    T _Item = { 0 };
+    fread(&_Item, sizeof(T), 1, aFile);
+    return _Item;
+}
+
+template <typename T>
+void WriteBytes(FILE* aFile, const T& aItem) {
+    fwrite(&aItem, sizeof(T), 1, aFile);
+}
+
+template <typename... Args>
+void PrintNoNewLine(const char *aFmt, Args... aArgs) {
+    printf(aFmt, aArgs...);
+    fflush(stdout);
+}
+
+template <typename... Args>
+void Print(const char *aFmt, Args... aArgs) {
+    printf(aFmt, aArgs...);
+    printf("\r\n");
+    fflush(stdout);
+}
+
+#define PrintError(...) { \
+    if (aGfxData->mErrorCount == 0) Print("  ERROR!"); \
+    Print(__VA_ARGS__); \
+    aGfxData->mErrorCount++; \
+}
+
+template <typename... Args>
+SysPath fstring(const char *aFmt, Args... aArgs) {
+    char buffer[1024];
+    snprintf(buffer, 1024, aFmt, aArgs...);
+    return SysPath(buffer);
+}
+
+// Wraps the static into a function, to call the constructor on first use
+#define STATIC_STORAGE(type, name)  \
+static type &__##name() {           \
+    static type s##name;            \
+    return s##name;                 \
+}
+
+//
+// Main
+//
+
+void DynOS_Init();
+void DynOS_UpdateOpt(void *aPad);
+void *DynOS_UpdateCmd(void *aCmd);
+void DynOS_UpdateGfx();
+bool DynOS_IsTransitionActive();
+#ifndef DYNOS_COOP
+void DynOS_ReturnToMainMenu();
+#endif
+#ifdef DYNOS_COOP
+void DynOS_Coop_SendCommand(s32 aType, s32 aLevel, s32 aArea, s32 aAct);
+#endif
+
+//
+// Opt
+//
+
+s32 DynOS_Opt_GetValue(const String &aName);
+void DynOS_Opt_SetValue(const String &aName, s32 aValue);
+void DynOS_Opt_AddAction(const String &aFuncName, bool (*aFuncPtr)(const char *), bool aOverwrite);
+void DynOS_Opt_Init();
+void DynOS_Opt_InitVanilla(DynosOption *&aOptionsMenu);
+void DynOS_Opt_Update(OSContPad *aPad);
+bool DynOS_Opt_ControllerUpdate(DynosOption *aOpt, void *aData);
+s32 DynOS_Opt_ControllerGetKeyPressed();
+void DynOS_Opt_LoadConfig(DynosOption *aMenu);
+void DynOS_Opt_SaveConfig(DynosOption *aMenu);
+void DynOS_Opt_DrawMenu(DynosOption *aCurrentOption, DynosOption *aCurrentMenu, DynosOption *aOptionsMenu, DynosOption *aDynosMenu);
+void DynOS_Opt_DrawPrompt(DynosOption *aCurrentMenu, DynosOption *aOptionsMenu, DynosOption *aDynosMenu);
+
+//
+// Gfx
+//
+
+u8 *DynOS_Gfx_TextureConvertToRGBA32(const u8 *aData, u64 aLength, s32 aFormat, s32 aSize, const u8 *aPalette);
+bool DynOS_Gfx_ImportTexture(void **aOutput, void *aPtr, s32 aTile, void *aGfxRApi, void **aHashMap, void *aPool, u32 *aPoolPos, u32 aPoolSize);
+Array<ActorGfx> &DynOS_Gfx_GetActorList();
+Array<PackData *> &DynOS_Gfx_GetPacks();
+Array<String> DynOS_Gfx_Init();
+void DynOS_Gfx_Update();
+void DynOS_Gfx_SwapAnimations(void *aPtr);
+bool DynOS_Gfx_WriteBinary(const SysPath &aOutputFilename, GfxData *aGfxData);
+GfxData *DynOS_Gfx_LoadFromBinary(const SysPath &aFilename);
+void DynOS_Gfx_Free(GfxData *aGfxData);
+void DynOS_Gfx_GeneratePack(const SysPath &aPackFolder);
+
+//
+// String
+//
+
+u8 *DynOS_String_Convert(const char *aString, bool aHeapAlloc);
+u8 *DynOS_String_Decapitalize(u8 *aStr64);
+s32 DynOS_String_Length(const u8 *aStr64);
+s32 DynOS_String_WidthChar64(u8 aChar64);
+s32 DynOS_String_Width(const u8 *aStr64);
+
+//
+// Geo
+//
+
+s32 DynOS_Geo_GetActorCount();
+const char *DynOS_Geo_GetActorName(s32 aIndex);
+void *DynOS_Geo_GetActorLayout(s32 aIndex);
+s32 DynOS_Geo_GetActorIndex(const void *aGeoLayout);
+void *DynOS_Geo_GetFunctionPointerFromName(const String &aName);
+void *DynOS_Geo_GetFunctionPointerFromIndex(s32 aIndex);
+s32 DynOS_Geo_GetFunctionIndex(const void *aPtr);
+void *DynOS_Geo_GetGraphNode(const void *aGeoLayout, bool aKeepInMemory);
+
+//
+// Levels
+//
+
+s32 DynOS_Level_GetCount();
+const s32 *DynOS_Level_GetList();
+s32 DynOS_Level_GetCourse(s32 aLevel);
+const void *DynOS_Level_GetScript(s32 aLevel);
+const u8 *DynOS_Level_GetName(s32 aLevel, bool aDecaps, bool aAddCourseNumber);
+const u8 *DynOS_Level_GetActName(s32 aLevel, s32 aAct, bool aDecaps, bool aAddStarNumber);
+const u8 *DynOS_Level_GetAreaName(s32 aLevel, s32 aArea, bool aDecaps);
+s16 *DynOS_Level_GetWarp(s32 aLevel, s32 aArea, u8 aWarpId);
+s16 *DynOS_Level_GetWarpEntry(s32 aLevel, s32 aArea);
+s16 *DynOS_Level_GetWarpDeath(s32 aLevel, s32 aArea);
+
+//
+// Warps
+//
+
+void *DynOS_Warp_Update(void *aCmd, bool aIsLevelInitDone);
+bool DynOS_Warp_ToLevel(s32 aLevel, s32 aArea, s32 aAct);
+bool DynOS_Warp_RestartLevel();
+bool DynOS_Warp_ExitLevel(s32 aDelay);
+bool DynOS_Warp_ToCastle(s32 aLevel);
+#ifndef DYNOS_COOP
+void DynOS_Warp_SetParam(s32 aLevel, s32 aIndex);
+const char *DynOS_Warp_GetParamName(s32 aLevel, s32 aIndex);
+#endif
+
+#endif
+#endif
diff --git a/data/dynos.h b/data/dynos.h
new file mode 100644
index 00000000..aaded6c1
--- /dev/null
+++ b/data/dynos.h
@@ -0,0 +1,40 @@
+#ifndef DYNOS_H
+#define DYNOS_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <math.h>
+#include <limits.h>
+#include <dirent.h>
+#include <SDL2/SDL.h>
+#ifdef __cplusplus
+#include <new>
+#include <utility>
+#include <string>
+extern "C" {
+#endif
+#include "types.h"
+#include "config.h"
+#include "pc/fs/fs.h"
+#include "audio_defines.h"
+#include "engine/math_util.h"
+#undef STB_IMAGE_IMPLEMENTATION
+#include "stb/stb_image.h"
+#ifdef __cplusplus
+}
+#endif
+
+#define DYNOS_VERSION           "1.0"
+#define DYNOS_EXE_FOLDER        sys_exe_path()
+#define DYNOS_USER_FOLDER       sys_user_path()
+#define DYNOS_RES_FOLDER        "dynos"
+#define DYNOS_PACKS_FOLDER      DYNOS_RES_FOLDER "/packs"
+#define DYNOS_CONFIG_FILENAME   "DynOS." DYNOS_VERSION ".config.txt"
+#define DYNOS_AT_STARTUP		__attribute__((constructor))
+#define DYNOS_AT_EXIT			__attribute__((destructor))
+
+#endif
\ No newline at end of file
diff --git a/data/dynos_c.cpp b/data/dynos_c.cpp
new file mode 100644
index 00000000..e16462da
--- /dev/null
+++ b/data/dynos_c.cpp
@@ -0,0 +1,36 @@
+#include "dynos.cpp.h"
+extern "C" {
+
+s32 dynos_opt_get_value(const char *name) {
+    return DynOS_Opt_GetValue(name);
+}
+
+void dynos_opt_set_value(const char *name, s32 value) {
+    return DynOS_Opt_SetValue(name, value);
+}
+
+void dynos_opt_add_action(const char *funcname, bool (*funcptr)(const char *), bool overwrite) {
+    return DynOS_Opt_AddAction(funcname, funcptr, overwrite);
+}
+
+void *dynos_update_cmd(void *cmd) {
+    return DynOS_UpdateCmd(cmd);
+}
+
+void dynos_update_gfx() {
+    return DynOS_UpdateGfx();
+}
+
+void dynos_update_opt(void *pad) {
+    return DynOS_UpdateOpt(pad);
+}
+
+s32 dynos_gfx_import_texture(void **output, void *ptr, s32 tile, void *grapi, void **hashmap, void *pool, s32 *poolpos, s32 poolsize) {
+    return DynOS_Gfx_ImportTexture(output, ptr, tile, grapi, hashmap, pool, (u32 *) poolpos, (u32) poolsize);
+}
+
+void dynos_gfx_swap_animations(void *ptr) {
+    return DynOS_Gfx_SwapAnimations(ptr);
+}
+
+}
diff --git a/data/dynos_gfx_init.cpp b/data/dynos_gfx_init.cpp
new file mode 100644
index 00000000..5c0ea536
--- /dev/null
+++ b/data/dynos_gfx_init.cpp
@@ -0,0 +1,63 @@
+#include "dynos.cpp.h"
+
+Array<ActorGfx> &DynOS_Gfx_GetActorList() {
+    static Array<ActorGfx> sActorGfxList;
+    return sActorGfxList;
+}
+
+Array<PackData *> &DynOS_Gfx_GetPacks() {
+    static Array<PackData *> sPacks;
+    return sPacks;
+}
+
+Array<String> DynOS_Gfx_Init() {
+
+    // Alloc and init the actors gfx list
+    Array<ActorGfx> &pActorGfxList = DynOS_Gfx_GetActorList();
+    pActorGfxList.Resize(DynOS_Geo_GetActorCount());
+    for (s32 i = 0; i != DynOS_Geo_GetActorCount(); ++i) {
+        pActorGfxList[i].mPackIndex = -1;
+        pActorGfxList[i].mGfxData   = NULL;
+        pActorGfxList[i].mGraphNode = (GraphNode *) DynOS_Geo_GetGraphNode(DynOS_Geo_GetActorLayout(i), false);
+    }
+
+    // Scan the DynOS packs folder
+    Array<PackData *> &pDynosPacks = DynOS_Gfx_GetPacks();
+    SysPath _DynosPacksFolder = fstring("%s/%s", DYNOS_EXE_FOLDER, DYNOS_PACKS_FOLDER);
+    DIR *_DynosPacksDir = opendir(_DynosPacksFolder.c_str());
+    if (_DynosPacksDir) {
+        struct dirent *_DynosPacksEnt = NULL;
+        while ((_DynosPacksEnt = readdir(_DynosPacksDir)) != NULL) {
+
+            // Skip . and ..
+            if (SysPath(_DynosPacksEnt->d_name) == ".") continue;
+            if (SysPath(_DynosPacksEnt->d_name) == "..") continue;
+
+            // If pack folder exists, add it to the pack list
+            SysPath _PackFolder = fstring("%s/%s", _DynosPacksFolder.c_str(), _DynosPacksEnt->d_name);
+            if (fs_sys_dir_exists(_PackFolder.c_str())) {
+                PackData *_Pack = New<PackData>();
+
+                // Scan folder for subfolders to convert into .bin files
+                _Pack->mPath = _PackFolder;
+                DynOS_Gfx_GeneratePack(_PackFolder);
+
+                // Add pack to pack list
+                pDynosPacks.Add(_Pack);
+            }
+        }
+        closedir(_DynosPacksDir);
+    }
+
+    // Return a list of pack names
+    Array<String> _PackNames;
+    for (const auto& _Pack : pDynosPacks) {
+        u64 _DirSep1 = _Pack->mPath.find_last_of('\\');
+        u64 _DirSep2 = _Pack->mPath.find_last_of('/');
+        if (_DirSep1++ == SysPath::npos) _DirSep1 = 0;
+        if (_DirSep2++ == SysPath::npos) _DirSep2 = 0;
+        SysPath _DirName = _Pack->mPath.substr(MAX(_DirSep1, _DirSep2));
+        _PackNames.Add(_DirName.c_str());
+    }
+    return _PackNames;
+}
diff --git a/data/dynos_gfx_load.cpp b/data/dynos_gfx_load.cpp
new file mode 100644
index 00000000..0411f5ed
--- /dev/null
+++ b/data/dynos_gfx_load.cpp
@@ -0,0 +1,278 @@
+#include "dynos.cpp.h"
+
+//
+// Pointers
+//
+
+static void *GetPointerFromData(GfxData *aGfxData, const String &aPtrName, u32 aPtrData) {
+
+    // Lights
+    for (auto& _Node : aGfxData->mLights) {
+        if (_Node->mName == aPtrName) {
+            if (aPtrData == 1) {
+                return (void *) &_Node->mData->l[0];
+            }
+            if (aPtrData == 2) {
+                return (void *) &_Node->mData->a;
+            }
+            sys_fatal("Unknown Light type: %u", aPtrData);
+        }
+    }
+
+    // Textures
+    for (auto& _Node : aGfxData->mTextures) {
+        if (_Node->mName == aPtrName) {
+            return (void *) _Node;
+        }
+    }
+
+    // Display lists
+    for (auto &_Node : aGfxData->mDisplayLists) {
+        if (_Node->mName == aPtrName) {
+            return (void *) _Node->mData;
+        }
+    }
+
+    // Geo layouts
+    for (auto &_Node : aGfxData->mGeoLayouts) {
+        if (_Node->mName == aPtrName) {
+            return (void *) _Node->mData;
+        }
+    }
+
+    // Vertices
+    for (auto &_Node : aGfxData->mVertices) {
+        if (_Node->mName == aPtrName) {
+            return (void *) (_Node->mData + aPtrData);
+        }
+    }
+
+    // Error
+    sys_fatal("Pointer not found: %s", aPtrName.begin());
+    return NULL;
+}
+
+static void *ReadPointer(FILE *aFile, GfxData *aGfxData, u32 aValue) {
+
+    // FUNC
+    if (aValue == FUNCTION_CODE) {
+        s32 _GeoFunctionIndex = ReadBytes<s32>(aFile);
+        return DynOS_Geo_GetFunctionPointerFromIndex(_GeoFunctionIndex);
+    }
+
+    // PNTR
+    if (aValue == POINTER_CODE) {
+        String _PtrName; _PtrName.Read(aFile);
+        u32   _PtrData = ReadBytes<u32>(aFile);
+        return GetPointerFromData(aGfxData, _PtrName, _PtrData);
+    }
+
+    // Not a pointer
+    return NULL;
+}
+
+//
+// Read binary
+//
+
+static void LoadLightData(FILE *aFile, GfxData *aGfxData) {
+    DataNode<Lights1> *_Node = New<DataNode<Lights1>>();
+
+    // Name
+    _Node->mName.Read(aFile);
+
+    // Data
+    _Node->mData = New<Lights1>();
+    *_Node->mData = ReadBytes<Lights1>(aFile);
+
+    // Append
+    aGfxData->mLights.Add(_Node);
+}
+
+static void LoadTextureData(FILE *aFile, GfxData *aGfxData) {
+    DataNode<TexData> *_Node = New<DataNode<TexData>>();
+
+    // Name
+    _Node->mName.Read(aFile);
+
+    // Data
+    _Node->mData = New<TexData>();
+    _Node->mData->mUploaded = false;
+    _Node->mData->mPngData.Read(aFile);
+    if (!_Node->mData->mPngData.Empty()) {
+        u8 *_RawData = stbi_load_from_memory(_Node->mData->mPngData.begin(), _Node->mData->mPngData.Count(), &_Node->mData->mRawWidth, &_Node->mData->mRawHeight, NULL, 4);
+        _Node->mData->mRawFormat = G_IM_FMT_RGBA;
+        _Node->mData->mRawSize   = G_IM_SIZ_32b;
+        _Node->mData->mRawData   = Array<u8>(_RawData, _RawData + (_Node->mData->mRawWidth * _Node->mData->mRawHeight * 4));
+        free(_RawData);
+    } else { // Probably a palette
+        _Node->mData->mRawData   = Array<u8>();
+        _Node->mData->mRawWidth  = 0;
+        _Node->mData->mRawHeight = 0;
+        _Node->mData->mRawFormat = 0;
+        _Node->mData->mRawSize   = 0;
+    }
+
+    // Append
+    aGfxData->mTextures.Add(_Node);
+}
+
+static void LoadVertexData(FILE *aFile, GfxData *aGfxData) {
+    DataNode<Vtx> *_Node = New<DataNode<Vtx>>();
+
+    // Name
+    _Node->mName.Read(aFile);
+
+    // Data
+    _Node->mSize = ReadBytes<u32>(aFile);
+    _Node->mData = New<Vtx>(_Node->mSize);
+    for (u32 i = 0; i != _Node->mSize; ++i) {
+        _Node->mData[i].n.ob[0] = ReadBytes<s16>(aFile);
+        _Node->mData[i].n.ob[1] = ReadBytes<s16>(aFile);
+        _Node->mData[i].n.ob[2] = ReadBytes<s16>(aFile);
+        _Node->mData[i].n.flag  = ReadBytes<s16>(aFile);
+        _Node->mData[i].n.tc[0] = ReadBytes<s16>(aFile);
+        _Node->mData[i].n.tc[1] = ReadBytes<s16>(aFile);
+        _Node->mData[i].n.n[0]  = ReadBytes<s8> (aFile);
+        _Node->mData[i].n.n[1]  = ReadBytes<s8> (aFile);
+        _Node->mData[i].n.n[2]  = ReadBytes<s8> (aFile);
+        _Node->mData[i].n.a     = ReadBytes<u8>(aFile);
+    }
+
+    // Append
+    aGfxData->mVertices.Add(_Node);
+}
+
+static void LoadDisplayListData(FILE *aFile, GfxData *aGfxData) {
+    DataNode<Gfx> *_Node = New<DataNode<Gfx>>();
+
+    // Name
+    _Node->mName.Read(aFile);
+
+    // Data
+    _Node->mSize = ReadBytes<u32>(aFile);
+    _Node->mData = New<Gfx>(_Node->mSize);
+    for (u32 i = 0; i != _Node->mSize; ++i) {
+        u32 _WordsW0 = ReadBytes<u32>(aFile);
+        u32 _WordsW1 = ReadBytes<u32>(aFile);
+        void *_Ptr = ReadPointer(aFile, aGfxData, _WordsW1);
+        if (_Ptr) {
+            _Node->mData[i].words.w0 = (uintptr_t) _WordsW0;
+            _Node->mData[i].words.w1 = (uintptr_t) _Ptr;
+        } else {
+            _Node->mData[i].words.w0 = (uintptr_t) _WordsW0;
+            _Node->mData[i].words.w1 = (uintptr_t) _WordsW1;
+        }
+    }
+
+    // Append
+    aGfxData->mDisplayLists.Add(_Node);
+}
+
+static void LoadGeoLayoutData(FILE *aFile, GfxData *aGfxData) {
+    DataNode<GeoLayout> *_Node = New<DataNode<GeoLayout>>();
+
+    // Name
+    _Node->mName.Read(aFile);
+
+    // Data
+    _Node->mSize = ReadBytes<u32>(aFile);
+    _Node->mData = New<GeoLayout>(_Node->mSize);
+    for (u32 i = 0; i != _Node->mSize; ++i) {
+        u32 _Value = ReadBytes<u32>(aFile);
+        void *_Ptr = ReadPointer(aFile, aGfxData, _Value);
+        if (_Ptr) {
+            _Node->mData[i] = (uintptr_t) _Ptr;
+        } else {
+            _Node->mData[i] = (uintptr_t) _Value;
+        }
+    }
+
+    // Append
+    aGfxData->mGeoLayouts.Add(_Node);
+}
+
+// For retro-compatibility
+static void LoadGfxDynCmd(FILE *aFile, GfxData *aGfxData) {
+    Gfx *_Data = NULL;
+    String _DisplayListName; _DisplayListName.Read(aFile);
+    for (auto& _DisplayList : aGfxData->mDisplayLists) {
+        if (_DisplayList->mName == _DisplayListName) {
+            _Data = _DisplayList->mData;
+            break;
+        }
+    }
+    if (!_Data) {
+        sys_fatal("Display list not found: %s", _DisplayListName.begin());
+    }
+    ReadBytes<u32>(aFile);
+    ReadBytes<u8>(aFile);
+}
+
+static void LoadAnimationData(FILE *aFile, GfxData *aGfxData) {
+    DataNode<AnimData> *_Node = New<DataNode<AnimData>>();
+
+    // Name
+    _Node->mName.Read(aFile);
+
+    // Data
+    _Node->mData = New<AnimData>();
+    _Node->mData->mFlags = ReadBytes<s16>(aFile);
+    _Node->mData->mUnk02 = ReadBytes<s16>(aFile);
+    _Node->mData->mUnk04 = ReadBytes<s16>(aFile);
+    _Node->mData->mUnk06 = ReadBytes<s16>(aFile);
+    _Node->mData->mUnk08 = ReadBytes<s16>(aFile);
+    _Node->mData->mUnk0A.second = ReadBytes<s16>(aFile);
+    _Node->mData->mLength = ReadBytes<u32>(aFile);
+    _Node->mData->mValues.second.Read(aFile);
+    _Node->mData->mIndex.second.Read(aFile);
+
+    // Append
+    aGfxData->mAnimations.Add(_Node);
+}
+
+static void LoadAnimationTable(FILE *aFile, GfxData *aGfxData) {
+    void *_AnimationPtr = NULL;
+
+    // Data
+    String _AnimationName; _AnimationName.Read(aFile);
+    if (_AnimationName != "NULL") {
+        for (auto &_AnimData : aGfxData->mAnimations) {
+            if (_AnimData->mName == _AnimationName) {
+                _AnimationPtr = (void *) _AnimData->mData;
+                break;
+            }
+        }
+        if (!_AnimationPtr) {
+            sys_fatal("Animation not found: %s", _AnimationName.begin());
+        }
+    }
+
+    // Append
+    aGfxData->mAnimationTable.Add({ "", _AnimationPtr });
+}
+
+GfxData *DynOS_Gfx_LoadFromBinary(const SysPath &aFilename) {
+    FILE *_File = fopen(aFilename.c_str(), "rb");
+    if (!_File) {
+        return NULL;
+    }
+
+    // Data
+    GfxData *_GfxData = New<GfxData>();
+    for (bool _Done = false; !_Done;) {
+        switch (ReadBytes<u8>(_File)) {
+            case DATA_TYPE_LIGHT:           LoadLightData      (_File, _GfxData); break;
+            case DATA_TYPE_TEXTURE:         LoadTextureData    (_File, _GfxData); break;
+            case DATA_TYPE_VERTEX:          LoadVertexData     (_File, _GfxData); break;
+            case DATA_TYPE_DISPLAY_LIST:    LoadDisplayListData(_File, _GfxData); break;
+            case DATA_TYPE_GEO_LAYOUT:      LoadGeoLayoutData  (_File, _GfxData); break;
+            case DATA_TYPE_ANIMATION:       LoadAnimationData  (_File, _GfxData); break;
+            case DATA_TYPE_ANIMATION_TABLE: LoadAnimationTable (_File, _GfxData); break;
+            case DATA_TYPE_GFXDYNCMD:       LoadGfxDynCmd      (_File, _GfxData); break;
+            default:                        _Done = true;                         break;
+        }
+    }
+    fclose(_File);
+    return _GfxData;
+}
diff --git a/data/dynos_gfx_read.cpp b/data/dynos_gfx_read.cpp
new file mode 100644
index 00000000..928bd9fe
--- /dev/null
+++ b/data/dynos_gfx_read.cpp
@@ -0,0 +1,1884 @@
+#include "dynos.cpp.h"
+extern "C" {
+#include "geo_commands.h"
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb/stb_image_write.h"
+}
+
+#define LAYER_FORCE                     0
+#define LAYER_OPAQUE                    1
+#define LAYER_OPAQUE_DECAL              2
+#define LAYER_OPAQUE_INTER              3
+#define LAYER_ALPHA                     4
+#define LAYER_TRANSPARENT               5
+#define LAYER_TRANSPARENT_DECAL         6
+#define LAYER_TRANSPARENT_INTER         7
+#define DISPLAY_LIST_SIZE_PER_TOKEN     4
+#define GEO_LAYOUT_SIZE_PER_TOKEN       4
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnarrowing"
+
+static DataNode<Gfx>* ParseDisplayListData(GfxData* aGfxData, DataNode<Gfx>* aNode);
+static DataNode<GeoLayout>* ParseGeoLayoutData(GfxData* aGfxData, DataNode<GeoLayout>* aNode, bool aDisplayPercent);
+
+//
+// Model files
+//
+
+enum {
+    COMMENT_NONE = 0,
+    COMMENT_START,       // first slash
+    COMMENT_SINGLE_LINE, // double slash, reset to COMMENT_NONE if \\n is hit
+    COMMENT_BLOCK,       // slash-star, set to comment block end if * is hit
+    COMMENT_BLOCK_END,   // slash-star-star, set to comment none if / is hit, else return to COMMENT_BLOCK
+};
+
+struct IfDefPtr { const char *mPtr; u64 mSize; bool mErase; };
+static IfDefPtr GetNearestIfDefPointer(char *pFileBuffer) {
+    static const IfDefPtr sIfDefs[] = {
+        { "#ifdef VERSION_JP",  17, true  },
+        { "#ifndef VERSION_JP", 18, false },
+        { "#ifdef VERSION_EU",  17, true  },
+        { "#ifdef TEXTURE_FIX", 18, false },
+    };
+    IfDefPtr _Nearest = { NULL, 0, false };
+    for (const auto &_IfDef : sIfDefs) {
+        const char *_Ptr = strstr(pFileBuffer, _IfDef.mPtr);
+        if (_Ptr != NULL && (_Nearest.mPtr == NULL || _Nearest.mPtr > _Ptr)) {
+            _Nearest.mPtr = _Ptr;
+            _Nearest.mSize = _IfDef.mSize;
+            _Nearest.mErase = _IfDef.mErase;
+        }
+    }
+    return _Nearest;
+}
+
+static char *LoadFileBuffer(FILE* aFile, GfxData* aGfxData) {
+    fseek(aFile, 0, SEEK_END);
+    s32 _Length = ftell(aFile);
+    if (aGfxData && aGfxData->mModelIdentifier == 0) {
+        aGfxData->mModelIdentifier = (u32) _Length;
+    }
+
+    // Remove comments
+    rewind(aFile);
+    char *_FileBuffer = New<char>(_Length + 1);
+    char *pFileBuffer = _FileBuffer;
+    char _Previous = 0;
+    char _Current = 0;
+    s32 _CommentType = 0;
+    while (fread(&_Current, 1, 1, aFile)) {
+        if (_CommentType == COMMENT_NONE) {
+            if (_Current == '/') {
+                _CommentType = COMMENT_START;
+            } else {
+                *(pFileBuffer++) = _Current;
+            }
+        } else if (_CommentType == COMMENT_START) {
+            if (_Current == '/') {
+                _CommentType = COMMENT_SINGLE_LINE;
+            } else if (_Current == '*') {
+                _CommentType = COMMENT_BLOCK;
+            } else {
+                _CommentType = COMMENT_NONE;
+                *(pFileBuffer++) = _Previous;
+                *(pFileBuffer++) = _Current;
+            }
+        } else if (_CommentType == COMMENT_SINGLE_LINE) {
+            if (_Current == '\n') {
+                _CommentType = COMMENT_NONE;
+                *(pFileBuffer++) = _Current;
+            }
+        } else if (_CommentType == COMMENT_BLOCK) {
+            if (_Current == '*') {
+                _CommentType = COMMENT_BLOCK_END;
+            }
+        } else if (_CommentType == COMMENT_BLOCK_END) {
+            if (_Current == '/') {
+                _CommentType = COMMENT_NONE;
+            } else {
+                _CommentType = COMMENT_BLOCK;
+            }
+        }
+        _Previous = _Current;
+    }
+    *(pFileBuffer++) = 0;
+
+    // Remove ifdef blocks
+    // Doesn't support nested blocks
+    for (pFileBuffer = _FileBuffer; pFileBuffer != NULL;) {
+        IfDefPtr _IfDefPtr = GetNearestIfDefPointer(pFileBuffer);
+        if (_IfDefPtr.mPtr) {
+            char *pIfDef = (char *) _IfDefPtr.mPtr;
+            char *pElse  = (char *) strstr(_IfDefPtr.mPtr, "#else");
+            char *pEndIf = (char *) strstr(_IfDefPtr.mPtr, "#endif");
+
+            if (pElse && pElse < pEndIf) {
+                if (_IfDefPtr.mErase) memset(pIfDef, ' ', pElse + 5 - pIfDef);
+                else                  memset(pElse,  ' ', pEndIf - pElse);
+            } else {
+                if (_IfDefPtr.mErase) memset(pIfDef, ' ', pEndIf - pIfDef);
+            }
+
+            memset(pIfDef, ' ', _IfDefPtr.mSize);
+            memset(pEndIf, ' ', 6);
+            pFileBuffer = pEndIf;
+        } else {
+            pFileBuffer = NULL;
+        }
+    }
+
+    return _FileBuffer;
+}
+
+template <typename T>
+static void AppendNewNode(GfxData *aGfxData, DataNodes<T> &aNodes, const String &aName, String *&aDataName, Array<String> *&aDataTokens) {
+    DataNode<T> *_Node = New<DataNode<T>>();
+    _Node->mName = aName;
+    _Node->mModelIdentifier = aGfxData->mModelIdentifier;
+    aNodes.Add(_Node);
+    aDataName = &_Node->mName;
+    aDataTokens = &_Node->mTokens;
+}
+
+static void ScanModelFile(GfxData *aGfxData, const SysPath &aFilename) {
+    FILE *_File = fopen(aFilename.c_str(), "rb");
+    if (!_File) return;
+
+    // Load file into a buffer while removing all comments
+    char *_FileBuffer = LoadFileBuffer(_File, aGfxData);
+    fclose(_File);
+
+    // Scanning the loaded data
+    s32 _DataType = DATA_TYPE_NONE;
+    String* pDataName = NULL;
+    Array<String> *pDataTokens = NULL;
+    char *pDataStart = NULL;
+    bool _DataIgnore = false; // Needed to ignore the '#include "file.h"' strings
+    String _Buffer = "";
+    for (char *c = _FileBuffer; *c != 0; ++c) {
+
+        // Scanning data type
+        if (_DataType == DATA_TYPE_NONE) {
+
+            // Reading data type name
+            if ((*c >= 'A' && *c <= 'Z') || (*c >= 'a' && *c <= 'z') || (*c >= '0' && *c <= '9') || (*c == '_') || (*c == '\"')) {
+                if (*c == '\"') {
+                    _DataIgnore = !_DataIgnore;
+                } else if (!_DataIgnore) {
+                    _Buffer.Add(*c);
+                }
+            }
+
+            // Retrieving data type
+            else if (_Buffer.Length() != 0) {
+                if (_Buffer == "static") {
+                    // Ignore static keyword
+                } else if (_Buffer == "const") {
+                    // Ignore const keyword
+                } else if (_Buffer == "inline") {
+                    // Ignore inline keyword
+                } else if (_Buffer == "include") {
+                    // Ignore include keyword
+                } else if (_Buffer == "ALIGNED8") {
+                    // Ignore ALIGNED8 keyword
+                } else if (_Buffer == "UNUSED") {
+                    // Ignore UNUSED keyword
+                } else if (_Buffer == "u64") {
+                    _DataType = DATA_TYPE_UNUSED;
+                } else if (_Buffer == "Lights1") {
+                    _DataType = DATA_TYPE_LIGHT;
+                } else if (_Buffer == "u8") {
+                    _DataType = DATA_TYPE_TEXTURE;
+                } else if (_Buffer == "Texture") {
+                    _DataType = DATA_TYPE_TEXTURE;
+                } else if (_Buffer == "Vtx") {
+                    _DataType = DATA_TYPE_VERTEX;
+                } else if (_Buffer == "Gfx") {
+                    _DataType = DATA_TYPE_DISPLAY_LIST;
+                } else if (_Buffer == "GeoLayout") {
+                    _DataType = DATA_TYPE_GEO_LAYOUT;
+                } else {
+                    PrintError("  ERROR: Unknown type name: %s", _Buffer.begin());
+                }
+                _Buffer.Clear();
+            }
+        }
+
+        // Scanning data identifier
+        else if (!pDataTokens) {
+
+            // Reading data identifier name
+            if ((*c >= 'A' && *c <= 'Z') || (*c >= 'a' && *c <= 'z') || (*c >= '0' && *c <= '9') || (*c == '_')) {
+                _Buffer.Add(*c);
+            }
+
+            // Adding new data node
+            else if (_Buffer.Length() != 0) {
+                switch (_DataType) {
+                    case DATA_TYPE_LIGHT:        AppendNewNode(aGfxData, aGfxData->mLights,       _Buffer, pDataName, pDataTokens); break;
+                    case DATA_TYPE_TEXTURE:      AppendNewNode(aGfxData, aGfxData->mTextures,     _Buffer, pDataName, pDataTokens); break;
+                    case DATA_TYPE_VERTEX:       AppendNewNode(aGfxData, aGfxData->mVertices,     _Buffer, pDataName, pDataTokens); break;
+                    case DATA_TYPE_DISPLAY_LIST: AppendNewNode(aGfxData, aGfxData->mDisplayLists, _Buffer, pDataName, pDataTokens); break;
+                    case DATA_TYPE_GEO_LAYOUT:   AppendNewNode(aGfxData, aGfxData->mGeoLayouts,   _Buffer, pDataName, pDataTokens); break;
+                    case DATA_TYPE_UNUSED:       pDataTokens = (Array<String> *) 1;                                                 break;
+                }
+                _Buffer.Clear();
+            }
+        }
+
+        // Looking for data
+        else if (pDataStart == 0) {
+            if (*c == '=') {
+                pDataStart = c + 1;
+            } else if (*c == ';') {
+                PrintError("  ERROR: %s: Unexpected end of data", pDataName->begin());
+            }
+        }
+
+        // Data end
+        else if (*c == ';') {
+            if (_DataType != DATA_TYPE_UNUSED) {
+                char* pDataEnd = &*c;
+                String _Token = "";
+                for (u8 _Bracket = 0; pDataStart <= pDataEnd; pDataStart++) {
+                    if (*pDataStart == '(') _Bracket++;
+                    if (*pDataStart == ' ' || *pDataStart == '\t' || *pDataStart == '\r' || *pDataStart == '\n') continue;
+                    if (_Bracket <= 1 && (*pDataStart == '(' || *pDataStart == ')' || *pDataStart == ',' || *pDataStart == '{' || *pDataStart == '}' || *pDataStart == ';')) {
+                        if (_Token.Length() != 0) {
+                            pDataTokens->Add(_Token);
+                            _Token.Clear();
+                        }
+                    } else {
+                        _Token.Add(*pDataStart);
+                    }
+                    if (*pDataStart == ')') _Bracket--;
+                }
+            }
+            _DataType   = DATA_TYPE_NONE;
+            pDataName   = NULL;
+            pDataTokens = NULL;
+            pDataStart  = NULL;
+            _DataIgnore = false;
+            _Buffer     = "";
+        }
+    }
+
+    Delete(_FileBuffer);
+    Print("Data read from file \"%s\"", aFilename.c_str());
+}
+
+//
+// Lights
+//
+
+static DataNode<Lights1>* ParseLightData(GfxData* aGfxData, DataNode<Lights1>* aNode) {
+    if (aNode->mData) return aNode;
+
+    // Check tokens count
+    if (aNode->mTokens.Count() < 10) {
+        PrintError("  ERROR: %s: not enough data", aNode->mName.begin());
+        return aNode;
+    }
+
+    // Parse def token
+    if (aNode->mTokens[0] != "gdSPDefLights1") {
+        PrintError("  ERROR: Invalid def token: should be gdSPDefLights1, is %s", aNode->mTokens[0].begin());
+        return aNode;
+    }
+
+    // Parse data tokens
+    u8 ar = (u8) aNode->mTokens[1].ParseInt();
+    u8 ag = (u8) aNode->mTokens[2].ParseInt();
+    u8 ab = (u8) aNode->mTokens[3].ParseInt();
+    u8 r1 = (u8) aNode->mTokens[4].ParseInt();
+    u8 g1 = (u8) aNode->mTokens[5].ParseInt();
+    u8 b1 = (u8) aNode->mTokens[6].ParseInt();
+    s8  x1 = (s8)  aNode->mTokens[7].ParseInt();
+    s8  y1 = (s8)  aNode->mTokens[8].ParseInt();
+    s8  z1 = (s8)  aNode->mTokens[9].ParseInt();
+    aNode->mData = New<Lights1>();
+    *aNode->mData = gdSPDefLights1(ar, ag, ab, r1, g1, b1, x1, y1, z1);
+    aNode->mLoadIndex = aGfxData->mLoadIndex++;
+    return aNode;
+}
+
+//
+// Textures
+//
+
+static TexData* LoadTextureFromFile(GfxData *aGfxData, const String& aFile) {
+
+    // Image file
+    String _TexturePath = aFile.SubString(aFile.Find('/') + 1); // Remove the "actors/"
+    SysPath _Filename = fstring("%s/%s.png", aGfxData->mPackFolder.c_str(), _TexturePath.begin());
+    FILE *_File = fopen(_Filename.c_str(), "rb");
+    if (!_File) {
+        PrintError("  ERROR: Unable to open file \"%s\"", _Filename.c_str());
+        return NULL;
+    }
+
+    // Texture data
+    fseek(_File, 0, SEEK_END);
+    TexData* _Texture = New<TexData>();
+    _Texture->mPngData.Resize(ftell(_File)); rewind(_File);
+    fread(_Texture->mPngData.begin(), sizeof(u8), _Texture->mPngData.Count(), _File);
+    fclose(_File);
+    return _Texture;
+}
+
+static void ConvertTextureDataToPng(GfxData *aGfxData, TexData* aTexture) {
+
+    // Convert to RGBA32
+    const u8 *_Palette = (aGfxData->mGfxContext.mCurrentPalette ? aGfxData->mGfxContext.mCurrentPalette->mData->mRawData.begin() : NULL);
+    u8 *_Buffer = DynOS_Gfx_TextureConvertToRGBA32(aTexture->mRawData.begin(), aTexture->mRawData.Count(), aTexture->mRawFormat, aTexture->mRawSize, _Palette);
+    if (_Buffer == NULL) {
+        PrintError("  ERROR: Unknown texture format");
+        return;
+    }
+
+    // Convert to PNG
+    s32 _PngLength = 0;
+    u8 *_PngData = stbi_write_png_to_mem(_Buffer, 0, aTexture->mRawWidth, aTexture->mRawHeight, 4, &_PngLength);
+    if (!_PngData || !_PngLength) {
+        PrintError("  ERROR: Cannot convert texture to PNG");
+        return;
+    }
+
+    aTexture->mPngData = Array<u8>(_PngData, _PngData + _PngLength);
+    Delete(_PngData);
+}
+
+static DataNode<TexData>* ParseTextureData(GfxData* aGfxData, DataNode<TexData>* aNode) {
+    if (aNode->mData) return aNode;
+
+    // Check tokens Count
+    if (aNode->mTokens.Count() < 1) {
+        PrintError("  ERROR: %s: not enough data", aNode->mName.begin());
+        return aNode;
+    }
+
+    // #include"[texture].inc.c"
+    s32 i0 = aNode->mTokens[0].Find("#include");
+    if (i0 != -1) {
+        s32 i1 = aNode->mTokens[0].Find(".inc.c");
+        if (i1 == -1) {
+            PrintError("  ERROR: %s: missing .inc.c in String %s", aNode->mName.begin(), aNode->mTokens[0].begin());
+            return aNode;
+        }
+
+        // Filename
+        String _Filename  = aNode->mTokens[0].SubString(i0 + 9, i1 - i0 - 9);
+        aNode->mData      = LoadTextureFromFile(aGfxData, _Filename);
+        aNode->mLoadIndex = aGfxData->mLoadIndex++;
+        return aNode;
+    }
+
+    // double quoted String
+    s32 dq0 = aNode->mTokens[0].Find('\"');
+    if (dq0 != -1) {
+        s32 dq1 = aNode->mTokens[0].Find('\"', dq0 + 1);
+        if (dq1 == -1) {
+            PrintError("  ERROR: %s: missing second quote in String %s", aNode->mName.begin(), aNode->mTokens[0].begin());
+            return aNode;
+        }
+
+        // Filename
+        String _Filename  = aNode->mTokens[0].SubString(dq0 + 1, dq1 - dq0 - 1);
+        aNode->mData      = LoadTextureFromFile(aGfxData, _Filename);
+        aNode->mLoadIndex = aGfxData->mLoadIndex++;
+        return aNode;
+    }
+
+    // Stream of bytes
+    aNode->mData              = New<TexData>();
+    aNode->mData->mRawWidth   = -1; // Unknown for now, will be set later
+    aNode->mData->mRawHeight  = -1; // Unknown for now, will be set later
+    aNode->mData->mRawFormat  = -1; // Unknown for now, will be set later
+    aNode->mData->mRawSize    = -1; // Unknown for now, will be set later
+    aNode->mData->mRawData.Resize(aNode->mTokens.Count());
+    for (u64 j = 0; j != aNode->mTokens.Count(); ++j) {
+    aNode->mData->mRawData[j] = aNode->mTokens[j].ParseInt();
+    }
+    aNode->mLoadIndex         = aGfxData->mLoadIndex++;
+    return aNode;
+}
+
+//
+// Vertices
+//
+
+static DataNode<Vtx>* ParseVertexData(GfxData* aGfxData, DataNode<Vtx>* aNode) {
+    if (aNode->mData) return aNode;
+
+    // Vertex data
+    aNode->mSize = (u32) (aNode->mTokens.Count() / 10);
+    aNode->mData = New<Vtx>(aNode->mSize);
+    for (u32 i = 0; i != aNode->mSize; ++i) {
+        f32 px = (f32) aNode->mTokens[10 * i + 0].ParseFloat();
+        f32 py = (f32) aNode->mTokens[10 * i + 1].ParseFloat();
+        f32 pz = (f32) aNode->mTokens[10 * i + 2].ParseFloat();
+        u8 fl = (u8) aNode->mTokens[10 * i + 3].ParseInt();
+        s16 tu = (s16) aNode->mTokens[10 * i + 4].ParseInt();
+        s16 tv = (s16) aNode->mTokens[10 * i + 5].ParseInt();
+        u8 nx = (u8) aNode->mTokens[10 * i + 6].ParseInt();
+        u8 ny = (u8) aNode->mTokens[10 * i + 7].ParseInt();
+        u8 nz = (u8) aNode->mTokens[10 * i + 8].ParseInt();
+        u8 a  = (u8) aNode->mTokens[10 * i + 9].ParseInt();
+        aNode->mData[i] = { { { px, py, pz }, fl, { tu, tv }, { nx, ny, nz, a } } };
+    }
+    aNode->mLoadIndex = aGfxData->mLoadIndex++;
+    return aNode;
+}
+
+//
+// Display lists
+//
+
+#define gfx_constant(x) if (_Arg == #x) { return (s64) (x); }
+static s64 ParseGfxSymbolArg(GfxData* aGfxData, DataNode<Gfx>* aNode, u64* pTokenIndex, const char *aPrefix) {
+    assert(aPrefix != NULL);
+    String _Token = (pTokenIndex != NULL ? aNode->mTokens[(*pTokenIndex)++] : "");
+    String _Arg("%s%s", aPrefix, _Token.begin());
+
+    // Offset
+    s32 _Offset = 0;
+    s32 _Plus = _Arg.Find('+');
+    if (_Plus != -1) {
+        _Offset = _Arg.SubString(_Plus + 1).ParseInt();
+        _Arg = _Arg.SubString(0, _Plus);
+    }
+
+    // Constants
+    gfx_constant(NULL);
+    gfx_constant(G_ON);
+    gfx_constant(G_OFF);
+
+    // Combine modes
+    gfx_constant(G_CCMUX_COMBINED);
+    gfx_constant(G_CCMUX_TEXEL0);
+    gfx_constant(G_CCMUX_TEXEL1);
+    gfx_constant(G_CCMUX_PRIMITIVE);
+    gfx_constant(G_CCMUX_SHADE);
+    gfx_constant(G_CCMUX_ENVIRONMENT);
+    gfx_constant(G_CCMUX_CENTER);
+    gfx_constant(G_CCMUX_SCALE);
+    gfx_constant(G_CCMUX_COMBINED_ALPHA);
+    gfx_constant(G_CCMUX_TEXEL0_ALPHA);
+    gfx_constant(G_CCMUX_TEXEL1_ALPHA);
+    gfx_constant(G_CCMUX_PRIMITIVE_ALPHA);
+    gfx_constant(G_CCMUX_SHADE_ALPHA);
+    gfx_constant(G_CCMUX_ENV_ALPHA);
+    gfx_constant(G_CCMUX_LOD_FRACTION);
+    gfx_constant(G_CCMUX_PRIM_LOD_FRAC);
+    gfx_constant(G_CCMUX_NOISE);
+    gfx_constant(G_CCMUX_K4);
+    gfx_constant(G_CCMUX_K5);
+    gfx_constant(G_CCMUX_1);
+    gfx_constant(G_CCMUX_0);
+    gfx_constant(G_ACMUX_COMBINED);
+    gfx_constant(G_ACMUX_TEXEL0);
+    gfx_constant(G_ACMUX_TEXEL1);
+    gfx_constant(G_ACMUX_PRIMITIVE);
+    gfx_constant(G_ACMUX_SHADE);
+    gfx_constant(G_ACMUX_ENVIRONMENT);
+    gfx_constant(G_ACMUX_LOD_FRACTION);
+    gfx_constant(G_ACMUX_PRIM_LOD_FRAC);
+    gfx_constant(G_ACMUX_1);
+    gfx_constant(G_ACMUX_0);
+
+    // Light constants
+    gfx_constant(NUMLIGHTS_0);
+    gfx_constant(NUMLIGHTS_1);
+    gfx_constant(NUMLIGHTS_2);
+    gfx_constant(NUMLIGHTS_3);
+    gfx_constant(NUMLIGHTS_4);
+    gfx_constant(NUMLIGHTS_5);
+    gfx_constant(NUMLIGHTS_6);
+    gfx_constant(NUMLIGHTS_7);
+
+    // Image formats
+    gfx_constant(G_IM_FMT_RGBA);
+    gfx_constant(G_IM_FMT_YUV);
+    gfx_constant(G_IM_FMT_CI);
+    gfx_constant(G_IM_FMT_IA);
+    gfx_constant(G_IM_FMT_I);
+    gfx_constant(G_IM_SIZ_4b);
+    gfx_constant(G_IM_SIZ_8b);
+    gfx_constant(G_IM_SIZ_16b);
+    gfx_constant(G_IM_SIZ_32b);
+    gfx_constant(G_IM_SIZ_DD);
+
+    // Image constants
+    gfx_constant(G_IM_SIZ_4b_BYTES);
+    gfx_constant(G_IM_SIZ_4b_TILE_BYTES);
+    gfx_constant(G_IM_SIZ_4b_LINE_BYTES);
+    gfx_constant(G_IM_SIZ_8b_BYTES);
+    gfx_constant(G_IM_SIZ_8b_TILE_BYTES);
+    gfx_constant(G_IM_SIZ_8b_LINE_BYTES);
+    gfx_constant(G_IM_SIZ_16b_BYTES);
+    gfx_constant(G_IM_SIZ_16b_TILE_BYTES);
+    gfx_constant(G_IM_SIZ_16b_LINE_BYTES);
+    gfx_constant(G_IM_SIZ_32b_BYTES);
+    gfx_constant(G_IM_SIZ_32b_TILE_BYTES);
+    gfx_constant(G_IM_SIZ_32b_LINE_BYTES);
+    gfx_constant(G_IM_SIZ_4b_LOAD_BLOCK);
+    gfx_constant(G_IM_SIZ_8b_LOAD_BLOCK);
+    gfx_constant(G_IM_SIZ_16b_LOAD_BLOCK);
+    gfx_constant(G_IM_SIZ_32b_LOAD_BLOCK);
+    gfx_constant(G_IM_SIZ_4b_SHIFT);
+    gfx_constant(G_IM_SIZ_8b_SHIFT);
+    gfx_constant(G_IM_SIZ_16b_SHIFT);
+    gfx_constant(G_IM_SIZ_32b_SHIFT);
+    gfx_constant(G_IM_SIZ_4b_INCR);
+    gfx_constant(G_IM_SIZ_8b_INCR);
+    gfx_constant(G_IM_SIZ_16b_INCR);
+    gfx_constant(G_IM_SIZ_32b_INCR);
+
+    // Tile formats
+    gfx_constant(G_TX_RENDERTILE);
+    gfx_constant(G_TX_LOADTILE);
+    gfx_constant(G_TX_NOMIRROR);
+    gfx_constant(G_TX_WRAP);
+    gfx_constant(G_TX_MIRROR);
+    gfx_constant(G_TX_CLAMP);
+    gfx_constant(G_TX_NOMASK);
+    gfx_constant(G_TX_NOLOD);
+    gfx_constant(G_TX_WRAP|G_TX_NOMIRROR);
+    gfx_constant(G_TX_WRAP|G_TX_MIRROR);
+    gfx_constant(G_TX_CLAMP|G_TX_NOMIRROR);
+    gfx_constant(G_TX_CLAMP|G_TX_MIRROR);
+
+    // Render modes
+    gfx_constant(G_RM_AA_ZB_OPA_SURF);
+    gfx_constant(G_RM_AA_ZB_OPA_SURF2);
+    gfx_constant(G_RM_AA_ZB_XLU_SURF);
+    gfx_constant(G_RM_AA_ZB_XLU_SURF2);
+    gfx_constant(G_RM_AA_ZB_OPA_DECAL);
+    gfx_constant(G_RM_AA_ZB_OPA_DECAL2);
+    gfx_constant(G_RM_AA_ZB_XLU_DECAL);
+    gfx_constant(G_RM_AA_ZB_XLU_DECAL2);
+    gfx_constant(G_RM_AA_ZB_OPA_INTER);
+    gfx_constant(G_RM_AA_ZB_OPA_INTER2);
+    gfx_constant(G_RM_AA_ZB_XLU_INTER);
+    gfx_constant(G_RM_AA_ZB_XLU_INTER2);
+    gfx_constant(G_RM_AA_ZB_XLU_LINE);
+    gfx_constant(G_RM_AA_ZB_XLU_LINE2);
+    gfx_constant(G_RM_AA_ZB_DEC_LINE);
+    gfx_constant(G_RM_AA_ZB_DEC_LINE2);
+    gfx_constant(G_RM_AA_ZB_TEX_EDGE);
+    gfx_constant(G_RM_AA_ZB_TEX_EDGE2);
+    gfx_constant(G_RM_AA_ZB_TEX_INTER);
+    gfx_constant(G_RM_AA_ZB_TEX_INTER2);
+    gfx_constant(G_RM_AA_ZB_SUB_SURF);
+    gfx_constant(G_RM_AA_ZB_SUB_SURF2);
+    gfx_constant(G_RM_AA_ZB_PCL_SURF);
+    gfx_constant(G_RM_AA_ZB_PCL_SURF2);
+    gfx_constant(G_RM_AA_ZB_OPA_TERR);
+    gfx_constant(G_RM_AA_ZB_OPA_TERR2);
+    gfx_constant(G_RM_AA_ZB_TEX_TERR);
+    gfx_constant(G_RM_AA_ZB_TEX_TERR2);
+    gfx_constant(G_RM_AA_ZB_SUB_TERR);
+    gfx_constant(G_RM_AA_ZB_SUB_TERR2);
+    gfx_constant(G_RM_RA_ZB_OPA_SURF);
+    gfx_constant(G_RM_RA_ZB_OPA_SURF2);
+    gfx_constant(G_RM_RA_ZB_OPA_DECAL);
+    gfx_constant(G_RM_RA_ZB_OPA_DECAL2);
+    gfx_constant(G_RM_RA_ZB_OPA_INTER);
+    gfx_constant(G_RM_RA_ZB_OPA_INTER2);
+    gfx_constant(G_RM_AA_OPA_SURF);
+    gfx_constant(G_RM_AA_OPA_SURF2);
+    gfx_constant(G_RM_AA_XLU_SURF);
+    gfx_constant(G_RM_AA_XLU_SURF2);
+    gfx_constant(G_RM_AA_XLU_LINE);
+    gfx_constant(G_RM_AA_XLU_LINE2);
+    gfx_constant(G_RM_AA_DEC_LINE);
+    gfx_constant(G_RM_AA_DEC_LINE2);
+    gfx_constant(G_RM_AA_TEX_EDGE);
+    gfx_constant(G_RM_AA_TEX_EDGE2);
+    gfx_constant(G_RM_AA_SUB_SURF);
+    gfx_constant(G_RM_AA_SUB_SURF2);
+    gfx_constant(G_RM_AA_PCL_SURF);
+    gfx_constant(G_RM_AA_PCL_SURF2);
+    gfx_constant(G_RM_AA_OPA_TERR);
+    gfx_constant(G_RM_AA_OPA_TERR2);
+    gfx_constant(G_RM_AA_TEX_TERR);
+    gfx_constant(G_RM_AA_TEX_TERR2);
+    gfx_constant(G_RM_AA_SUB_TERR);
+    gfx_constant(G_RM_AA_SUB_TERR2);
+    gfx_constant(G_RM_RA_OPA_SURF);
+    gfx_constant(G_RM_RA_OPA_SURF2);
+    gfx_constant(G_RM_ZB_OPA_SURF);
+    gfx_constant(G_RM_ZB_OPA_SURF2);
+    gfx_constant(G_RM_ZB_XLU_SURF);
+    gfx_constant(G_RM_ZB_XLU_SURF2);
+    gfx_constant(G_RM_ZB_OPA_DECAL);
+    gfx_constant(G_RM_ZB_OPA_DECAL2);
+    gfx_constant(G_RM_ZB_XLU_DECAL);
+    gfx_constant(G_RM_ZB_XLU_DECAL2);
+    gfx_constant(G_RM_ZB_CLD_SURF);
+    gfx_constant(G_RM_ZB_CLD_SURF2);
+    gfx_constant(G_RM_ZB_OVL_SURF);
+    gfx_constant(G_RM_ZB_OVL_SURF2);
+    gfx_constant(G_RM_ZB_PCL_SURF);
+    gfx_constant(G_RM_ZB_PCL_SURF2);
+    gfx_constant(G_RM_OPA_SURF);
+    gfx_constant(G_RM_OPA_SURF2);
+    gfx_constant(G_RM_XLU_SURF);
+    gfx_constant(G_RM_XLU_SURF2);
+    gfx_constant(G_RM_CLD_SURF);
+    gfx_constant(G_RM_CLD_SURF2);
+    gfx_constant(G_RM_TEX_EDGE);
+    gfx_constant(G_RM_TEX_EDGE2);
+    gfx_constant(G_RM_PCL_SURF);
+    gfx_constant(G_RM_PCL_SURF2);
+    gfx_constant(G_RM_ADD);
+    gfx_constant(G_RM_ADD2);
+    gfx_constant(G_RM_NOOP);
+    gfx_constant(G_RM_NOOP2);
+    gfx_constant(G_RM_VISCVG);
+    gfx_constant(G_RM_VISCVG2);
+    gfx_constant(G_RM_OPA_CI);
+    gfx_constant(G_RM_OPA_CI2);
+    gfx_constant(G_RM_CUSTOM_AA_ZB_XLU_SURF);
+    gfx_constant(G_RM_CUSTOM_AA_ZB_XLU_SURF2);
+    gfx_constant(G_RM_FOG_SHADE_A);
+    gfx_constant(G_RM_FOG_PRIM_A);
+    gfx_constant(G_RM_PASS);
+
+    // Geometry modes
+    gfx_constant(G_ZBUFFER);
+    gfx_constant(G_SHADE);
+    gfx_constant(G_TEXTURE_ENABLE);
+    gfx_constant(G_SHADING_SMOOTH);
+    gfx_constant(G_CULL_FRONT);
+    gfx_constant(G_CULL_BACK);
+    gfx_constant(G_CULL_BOTH);
+    gfx_constant(G_FOG);
+    gfx_constant(G_LIGHTING);
+    gfx_constant(G_TEXTURE_GEN);
+    gfx_constant(G_TEXTURE_GEN_LINEAR);
+    gfx_constant(G_LOD);
+    gfx_constant(G_CLIPPING);
+    gfx_constant(G_FOG|G_TEXTURE_GEN);
+    gfx_constant(G_LIGHTING|G_CULL_BACK);
+    gfx_constant(G_LIGHTING|G_SHADING_SMOOTH);
+    gfx_constant(G_CULL_BACK|G_SHADING_SMOOTH);
+    gfx_constant(G_LIGHTING|G_CULL_BACK|G_SHADING_SMOOTH);
+    gfx_constant(G_TEXTURE_GEN|G_SHADING_SMOOTH);
+    gfx_constant(G_TEXTURE_GEN|G_LIGHTING|G_CULL_BACK);
+    gfx_constant(G_TEXTURE_GEN|G_CULL_BACK|G_SHADING_SMOOTH);
+
+    // Alpha modes
+    gfx_constant(G_AC_NONE);
+    gfx_constant(G_AC_THRESHOLD);
+    gfx_constant(G_AC_DITHER);
+
+    // Other modes
+    gfx_constant(G_MDSFT_ALPHACOMPARE);
+    gfx_constant(G_MDSFT_ZSRCSEL);
+    gfx_constant(G_MDSFT_RENDERMODE);
+    gfx_constant(G_MDSFT_BLENDER);
+    gfx_constant(G_MDSFT_BLENDMASK);
+    gfx_constant(G_MDSFT_ALPHADITHER);
+    gfx_constant(G_MDSFT_RGBDITHER);
+    gfx_constant(G_MDSFT_COMBKEY);
+    gfx_constant(G_MDSFT_TEXTCONV);
+    gfx_constant(G_MDSFT_TEXTFILT);
+    gfx_constant(G_MDSFT_TEXTLUT);
+    gfx_constant(G_MDSFT_TEXTLOD);
+    gfx_constant(G_MDSFT_TEXTDETAIL);
+    gfx_constant(G_MDSFT_TEXTPERSP);
+    gfx_constant(G_MDSFT_CYCLETYPE);
+    gfx_constant(G_MDSFT_COLORDITHER);
+    gfx_constant(G_MDSFT_PIPELINE);
+    gfx_constant(G_PM_1PRIMITIVE);
+    gfx_constant(G_PM_NPRIMITIVE);
+    gfx_constant(G_CYC_1CYCLE);
+    gfx_constant(G_CYC_2CYCLE);
+    gfx_constant(G_CYC_COPY);
+    gfx_constant(G_CYC_FILL);
+    gfx_constant(G_TP_NONE);
+    gfx_constant(G_TP_PERSP);
+    gfx_constant(G_TD_CLAMP);
+    gfx_constant(G_TD_SHARPEN);
+    gfx_constant(G_TD_DETAIL);
+    gfx_constant(G_TL_TILE);
+    gfx_constant(G_TL_LOD);
+    gfx_constant(G_TT_NONE);
+    gfx_constant(G_TT_RGBA16);
+    gfx_constant(G_TT_IA16);
+    gfx_constant(G_TF_POINT);
+    gfx_constant(G_TF_AVERAGE);
+    gfx_constant(G_TF_BILERP);
+    gfx_constant(G_TC_CONV);
+    gfx_constant(G_TC_FILTCONV);
+    gfx_constant(G_TC_FILT);
+    gfx_constant(G_CK_NONE);
+    gfx_constant(G_CK_KEY);
+    gfx_constant(G_CD_MAGICSQ);
+    gfx_constant(G_CD_BAYER);
+    gfx_constant(G_CD_NOISE);
+    gfx_constant(G_CD_DISABLE);
+    gfx_constant(G_CD_ENABLE);
+    gfx_constant(G_AD_PATTERN);
+    gfx_constant(G_AD_NOTPATTERN);
+    gfx_constant(G_AD_NOISE);
+    gfx_constant(G_AD_DISABLE);
+    gfx_constant(G_AC_NONE);
+    gfx_constant(G_AC_THRESHOLD);
+    gfx_constant(G_AC_DITHER);
+    gfx_constant(G_ZS_PIXEL);
+    gfx_constant(G_ZS_PRIM);
+
+    // Common values
+    gfx_constant((4-1)<<G_TEXTURE_IMAGE_FRAC);
+    gfx_constant((8-1)<<G_TEXTURE_IMAGE_FRAC);
+    gfx_constant((16-1)<<G_TEXTURE_IMAGE_FRAC);
+    gfx_constant((32-1)<<G_TEXTURE_IMAGE_FRAC);
+    gfx_constant((64-1)<<G_TEXTURE_IMAGE_FRAC);
+    gfx_constant((128-1)<<G_TEXTURE_IMAGE_FRAC);
+    gfx_constant((256-1)<<G_TEXTURE_IMAGE_FRAC);
+    gfx_constant(CALC_DXT(4,G_IM_SIZ_4b_BYTES));
+    gfx_constant(CALC_DXT(8,G_IM_SIZ_4b_BYTES));
+    gfx_constant(CALC_DXT(16,G_IM_SIZ_4b_BYTES));
+    gfx_constant(CALC_DXT(32,G_IM_SIZ_4b_BYTES));
+    gfx_constant(CALC_DXT(64,G_IM_SIZ_4b_BYTES));
+    gfx_constant(CALC_DXT(128,G_IM_SIZ_4b_BYTES));
+    gfx_constant(CALC_DXT(256,G_IM_SIZ_4b_BYTES));
+    gfx_constant(CALC_DXT(4,G_IM_SIZ_8b_BYTES));
+    gfx_constant(CALC_DXT(8,G_IM_SIZ_8b_BYTES));
+    gfx_constant(CALC_DXT(16,G_IM_SIZ_8b_BYTES));
+    gfx_constant(CALC_DXT(32,G_IM_SIZ_8b_BYTES));
+    gfx_constant(CALC_DXT(64,G_IM_SIZ_8b_BYTES));
+    gfx_constant(CALC_DXT(128,G_IM_SIZ_8b_BYTES));
+    gfx_constant(CALC_DXT(256,G_IM_SIZ_8b_BYTES));
+    gfx_constant(CALC_DXT(4,G_IM_SIZ_16b_BYTES));
+    gfx_constant(CALC_DXT(8,G_IM_SIZ_16b_BYTES));
+    gfx_constant(CALC_DXT(16,G_IM_SIZ_16b_BYTES));
+    gfx_constant(CALC_DXT(32,G_IM_SIZ_16b_BYTES));
+    gfx_constant(CALC_DXT(64,G_IM_SIZ_16b_BYTES));
+    gfx_constant(CALC_DXT(128,G_IM_SIZ_16b_BYTES));
+    gfx_constant(CALC_DXT(256,G_IM_SIZ_16b_BYTES));
+    gfx_constant(CALC_DXT(4,G_IM_SIZ_32b_BYTES));
+    gfx_constant(CALC_DXT(8,G_IM_SIZ_32b_BYTES));
+    gfx_constant(CALC_DXT(16,G_IM_SIZ_32b_BYTES));
+    gfx_constant(CALC_DXT(32,G_IM_SIZ_32b_BYTES));
+    gfx_constant(CALC_DXT(64,G_IM_SIZ_32b_BYTES));
+    gfx_constant(CALC_DXT(128,G_IM_SIZ_32b_BYTES));
+    gfx_constant(CALC_DXT(256,G_IM_SIZ_32b_BYTES));
+
+    // Lights
+    for (auto& _Node : aGfxData->mLights) {
+
+        // Light pointer
+        if (_Arg == _Node->mName) {
+            return (s64) ParseLightData(aGfxData, _Node)->mData;
+        }
+
+        // Ambient pointer
+        String _Ambient("&%s.a", _Node->mName.begin());
+        if (_Arg == _Ambient) {
+            return (s64) &(ParseLightData(aGfxData, _Node)->mData->a);
+        }
+
+        // Diffuse pointer
+        String _Diffuse("&%s.l", _Node->mName.begin());
+        if (_Arg == _Diffuse) {
+            return (s64) &(ParseLightData(aGfxData, _Node)->mData->l[0]);
+        }
+    }
+
+    // Textures
+    for (auto& _Node : aGfxData->mTextures) {
+        if (_Arg == _Node->mName) {
+            return (s64) ParseTextureData(aGfxData, _Node);
+        }
+    }
+
+    // Vertex arrays
+    for (auto& _Node : aGfxData->mVertices) {
+        if (_Arg == _Node->mName) {
+            return (s64) (ParseVertexData(aGfxData, _Node)->mData + _Offset);
+        }
+    }
+
+    // Display lists
+    for (auto& _Node : aGfxData->mDisplayLists) {
+        if (_Arg == _Node->mName) {
+            return (s64) ParseDisplayListData(aGfxData, _Node);
+        }
+    }
+
+    // Integers
+    s32 x;
+    if ((_Arg[1] == 'x' && sscanf(_Arg.begin(), "%x", &x) == 1) || (sscanf(_Arg.begin(), "%d", &x) == 1)) {
+        return (s64) x;
+    }
+
+    // Unknown
+    PrintError("  ERROR: Unknown gfx arg: %s", _Arg.begin());
+    return 0;
+}
+
+#define gfx_symbol_0(symb)                                                                             \
+    if (_Symbol == #symb) {                                                                       \
+        Gfx _Gfx[] = { symb() };                                                                        \
+        memcpy(aHead, _Gfx, sizeof(_Gfx));                                                               \
+        aHead += (sizeof(_Gfx) / sizeof(_Gfx[0]));                                                       \
+        return;                                                                                        \
+    }
+
+#define gfx_symbol_1(symb, ptr)                                                                        \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        if (ptr) { aGfxData->mPointerList.Add(aHead); }                                         \
+        Gfx _Gfx[] = { symb(_Arg0) };                                                                    \
+        memcpy(aHead, _Gfx, sizeof(_Gfx));                                                               \
+        aHead += (sizeof(_Gfx) / sizeof(_Gfx[0]));                                                       \
+        return;                                                                                        \
+    }
+
+#define gfx_symbol_2(symb, ptr)                                                                        \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        if (ptr) { aGfxData->mPointerList.Add(aHead); }                                         \
+        Gfx _Gfx[] = { symb(_Arg0, _Arg1) };                                                              \
+        memcpy(aHead, _Gfx, sizeof(_Gfx));                                                               \
+        aHead += (sizeof(_Gfx) / sizeof(_Gfx[0]));                                                       \
+        return;                                                                                        \
+    }
+
+#define gfx_symbol_3(symb, ptr)                                                                        \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        if (ptr) { aGfxData->mPointerList.Add(aHead); }                                         \
+        Gfx _Gfx[] = { symb(_Arg0, _Arg1, _Arg2) };                                                        \
+        memcpy(aHead, _Gfx, sizeof(_Gfx));                                                               \
+        aHead += (sizeof(_Gfx) / sizeof(_Gfx[0]));                                                       \
+        return;                                                                                        \
+    }
+
+#define gfx_symbol_4(symb)                                                                             \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg3 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        Gfx _Gfx[] = { symb(_Arg0, _Arg1, _Arg2, _Arg3) };                                                  \
+        memcpy(aHead, _Gfx, sizeof(_Gfx));                                                               \
+        aHead += (sizeof(_Gfx) / sizeof(_Gfx[0]));                                                       \
+        return;                                                                                        \
+    }
+
+#define gfx_symbol_5(symb)                                                                             \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg3 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg4 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        Gfx _Gfx[] = { symb(_Arg0, _Arg1, _Arg2, _Arg3, _Arg4) };                                            \
+        memcpy(aHead, _Gfx, sizeof(_Gfx));                                                               \
+        aHead += (sizeof(_Gfx) / sizeof(_Gfx[0]));                                                       \
+        return;                                                                                        \
+    }
+
+#define gfx_symbol_6(symb)                                                                             \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg3 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg4 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg5 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        Gfx _Gfx[] = { symb(_Arg0, _Arg1, _Arg2, _Arg3, _Arg4, _Arg5) };                                      \
+        memcpy(aHead, _Gfx, sizeof(_Gfx));                                                               \
+        aHead += (sizeof(_Gfx) / sizeof(_Gfx[0]));                                                       \
+        return;                                                                                        \
+    }
+
+#define gfx_symbol_7(symb)                                                                             \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg3 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg4 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg5 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg6 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        Gfx _Gfx[] = { symb(_Arg0, _Arg1, _Arg2, _Arg3, _Arg4, _Arg5, _Arg6) };                                \
+        memcpy(aHead, _Gfx, sizeof(_Gfx));                                                               \
+        aHead += (sizeof(_Gfx) / sizeof(_Gfx[0]));                                                       \
+        return;                                                                                        \
+    }
+
+#define gfx_symbol_8(symb)                                                                             \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg3 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg4 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg5 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg6 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        s64 _Arg7 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");                                \
+        Gfx _Gfx[] = { symb(_Arg0, _Arg1, _Arg2, _Arg3, _Arg4, _Arg5, _Arg6, _Arg7) };                          \
+        memcpy(aHead, _Gfx, sizeof(_Gfx));                                                               \
+        aHead += (sizeof(_Gfx) / sizeof(_Gfx[0]));                                                       \
+        return;                                                                                        \
+    }
+
+#define gfx_arg_with_suffix(argname, suffix)                                                           \
+    const String& argname##_token = aNode->mTokens[aTokenIndex];                                    \
+    String _Token##suffix = String("%s%s", argname##_token.begin(), #suffix);                                   \
+    s64 argname = ParseGfxSymbolArg(aGfxData, aNode, NULL, _Token##suffix.begin());                         \
+
+#define STR_VALUE_2(...) #__VA_ARGS__
+#define STR_VALUE(...) STR_VALUE_2(__VA_ARGS__)
+#define gfx_set_combine_mode_arg(x) if (_Arg == #x) { return String("%s", STR_VALUE(x)); }
+static String ConvertSetCombineModeArgToString(GfxData *aGfxData, const String& _Arg) {
+    gfx_set_combine_mode_arg(G_CC_PRIMITIVE);
+    gfx_set_combine_mode_arg(G_CC_SHADE);
+    gfx_set_combine_mode_arg(G_CC_MODULATEI);
+    gfx_set_combine_mode_arg(G_CC_MODULATEIDECALA);
+    gfx_set_combine_mode_arg(G_CC_MODULATEIFADE);
+    gfx_set_combine_mode_arg(G_CC_MODULATERGB);
+    gfx_set_combine_mode_arg(G_CC_MODULATERGBDECALA);
+    gfx_set_combine_mode_arg(G_CC_MODULATERGBFADE);
+    gfx_set_combine_mode_arg(G_CC_MODULATEIA);
+    gfx_set_combine_mode_arg(G_CC_MODULATEIFADEA);
+    gfx_set_combine_mode_arg(G_CC_MODULATEFADE);
+    gfx_set_combine_mode_arg(G_CC_MODULATERGBA);
+    gfx_set_combine_mode_arg(G_CC_MODULATERGBFADEA);
+    gfx_set_combine_mode_arg(G_CC_MODULATEI_PRIM);
+    gfx_set_combine_mode_arg(G_CC_MODULATEIA_PRIM);
+    gfx_set_combine_mode_arg(G_CC_MODULATEIDECALA_PRIM);
+    gfx_set_combine_mode_arg(G_CC_MODULATERGB_PRIM);
+    gfx_set_combine_mode_arg(G_CC_MODULATERGBA_PRIM);
+    gfx_set_combine_mode_arg(G_CC_MODULATERGBDECALA_PRIM);
+    gfx_set_combine_mode_arg(G_CC_FADE);
+    gfx_set_combine_mode_arg(G_CC_FADEA);
+    gfx_set_combine_mode_arg(G_CC_DECALRGB);
+    gfx_set_combine_mode_arg(G_CC_DECALRGBA);
+    gfx_set_combine_mode_arg(G_CC_DECALFADE);
+    gfx_set_combine_mode_arg(G_CC_DECALFADEA);
+    gfx_set_combine_mode_arg(G_CC_BLENDI);
+    gfx_set_combine_mode_arg(G_CC_BLENDIA);
+    gfx_set_combine_mode_arg(G_CC_BLENDIDECALA);
+    gfx_set_combine_mode_arg(G_CC_BLENDRGBA);
+    gfx_set_combine_mode_arg(G_CC_BLENDRGBDECALA);
+    gfx_set_combine_mode_arg(G_CC_BLENDRGBFADEA);
+    gfx_set_combine_mode_arg(G_CC_ADDRGB);
+    gfx_set_combine_mode_arg(G_CC_ADDRGBDECALA);
+    gfx_set_combine_mode_arg(G_CC_ADDRGBFADE);
+    gfx_set_combine_mode_arg(G_CC_REFLECTRGB);
+    gfx_set_combine_mode_arg(G_CC_REFLECTRGBDECALA);
+    gfx_set_combine_mode_arg(G_CC_HILITERGB);
+    gfx_set_combine_mode_arg(G_CC_HILITERGBA);
+    gfx_set_combine_mode_arg(G_CC_HILITERGBDECALA);
+    gfx_set_combine_mode_arg(G_CC_SHADEDECALA);
+    gfx_set_combine_mode_arg(G_CC_SHADEFADEA);
+    gfx_set_combine_mode_arg(G_CC_BLENDPE);
+    gfx_set_combine_mode_arg(G_CC_BLENDPEDECALA);
+    gfx_set_combine_mode_arg(_G_CC_BLENDPE);
+    gfx_set_combine_mode_arg(_G_CC_BLENDPEDECALA);
+    gfx_set_combine_mode_arg(_G_CC_TWOCOLORTEX);
+    gfx_set_combine_mode_arg(_G_CC_SPARSEST);
+    gfx_set_combine_mode_arg(G_CC_TEMPLERP);
+    gfx_set_combine_mode_arg(G_CC_TRILERP);
+    gfx_set_combine_mode_arg(G_CC_INTERFERENCE);
+    gfx_set_combine_mode_arg(G_CC_1CYUV2RGB);
+    gfx_set_combine_mode_arg(G_CC_YUV2RGB);
+    gfx_set_combine_mode_arg(G_CC_PASS2);
+    gfx_set_combine_mode_arg(G_CC_MODULATEI2);
+    gfx_set_combine_mode_arg(G_CC_MODULATEIA2);
+    gfx_set_combine_mode_arg(G_CC_MODULATERGB2);
+    gfx_set_combine_mode_arg(G_CC_MODULATERGBA2);
+    gfx_set_combine_mode_arg(G_CC_MODULATEI_PRIM2);
+    gfx_set_combine_mode_arg(G_CC_MODULATEIA_PRIM2);
+    gfx_set_combine_mode_arg(G_CC_MODULATERGB_PRIM2);
+    gfx_set_combine_mode_arg(G_CC_MODULATERGBA_PRIM2);
+    gfx_set_combine_mode_arg(G_CC_DECALRGB2);
+    gfx_set_combine_mode_arg(G_CC_BLENDI2);
+    gfx_set_combine_mode_arg(G_CC_BLENDIA2);
+    gfx_set_combine_mode_arg(G_CC_CHROMA_KEY2);
+    gfx_set_combine_mode_arg(G_CC_HILITERGB2);
+    gfx_set_combine_mode_arg(G_CC_HILITERGBA2);
+    gfx_set_combine_mode_arg(G_CC_HILITERGBDECALA2);
+    gfx_set_combine_mode_arg(G_CC_HILITERGBPASSA2);
+    PrintError("  ERROR: Unknown gfx gsDPSetCombineMode arg: %s", _Arg.begin());
+    return "";
+}
+
+static Array<s64> ParseGfxSetCombineMode(GfxData* aGfxData, DataNode<Gfx>* aNode, u64* pTokenIndex) {
+    String _Buffer = ConvertSetCombineModeArgToString(aGfxData, aNode->mTokens[(*pTokenIndex)++]);
+    Array<s64> _Args;
+    String _Token;
+    for (u64 i = 0, n = _Buffer.Length(); i <= n; ++i) {
+        if (i == n || _Buffer[i] == ' ' || _Buffer[i] == '\t' || _Buffer[i] == ',') {
+            if (_Token.Length() != 0) {
+                String _Arg("%s%s", (_Args.Count() < 4 ? "G_CCMUX_" : "G_ACMUX_"), _Token.begin());
+                _Args.Add(ParseGfxSymbolArg(aGfxData, aNode, NULL, _Arg.begin()));
+                _Token.Clear();
+            }
+        } else {
+            _Token.Add(_Buffer[i]);
+        }
+    }
+    if (_Args.Count() < 8) {
+        PrintError("  ERROR: gsDPSetCombineMode %s: Not enough arguments", _Buffer.begin());
+    }
+    return _Args;
+}
+
+static void UpdateTextureInfo(GfxData* aGfxData, s64 *aTexPtr, s32 aFormat, s32 aSize, s32 aWidth, s32 aHeight) {
+
+    // Update current texture pointers
+    if (aTexPtr && (*aTexPtr)) {
+        aGfxData->mGfxContext.mCurrentPalette = aGfxData->mGfxContext.mCurrentTexture;
+        aGfxData->mGfxContext.mCurrentTexture = (DataNode<TexData>*) (*aTexPtr);
+    }
+
+    // Update texture info if not loaded from a file
+    if (aGfxData->mGfxContext.mCurrentTexture && aGfxData->mGfxContext.mCurrentTexture->mData && aGfxData->mGfxContext.mCurrentTexture->mData->mPngData.Empty()) {
+        if (aFormat != -1) aGfxData->mGfxContext.mCurrentTexture->mData->mRawFormat = aFormat;
+        if (aSize   != -1) aGfxData->mGfxContext.mCurrentTexture->mData->mRawSize   = aSize;
+        if (aWidth  != -1) aGfxData->mGfxContext.mCurrentTexture->mData->mRawWidth  = aWidth;
+        if (aHeight != -1) aGfxData->mGfxContext.mCurrentTexture->mData->mRawHeight = aHeight;
+    }
+}
+
+static void ParseGfxSymbol(GfxData* aGfxData, DataNode<Gfx>* aNode, Gfx*& aHead, u64& aTokenIndex) {
+    const String& _Symbol = aNode->mTokens[aTokenIndex++];
+
+    // Simple symbols
+    gfx_symbol_0(gsDPFullSync);
+    gfx_symbol_0(gsDPTileSync);
+    gfx_symbol_0(gsDPPipeSync);
+    gfx_symbol_0(gsDPLoadSync);
+    gfx_symbol_0(gsDPNoOp);
+    gfx_symbol_1(gsDPNoOpTag, false);
+    gfx_symbol_1(gsDPSetCycleType, false);
+    gfx_symbol_2(gsSPLight, true);
+    gfx_symbol_3(gsSPVertex, true);
+    gfx_symbol_4(gsSP1Triangle);
+    gfx_symbol_8(gsSP2Triangles);
+    gfx_symbol_1(gsSPNumLights, false);
+    gfx_symbol_1(gsDPSetDepthSource, false);
+    gfx_symbol_1(gsDPSetTextureLUT, false);
+    gfx_symbol_2(gsDPLoadTLUTCmd, false);
+    gfx_symbol_5(gsDPLoadBlock);
+    gfx_symbol_2(gsDPSetRenderMode, false);
+    gfx_symbol_2(gsSPGeometryMode, false);
+    gfx_symbol_6(gsDPSetPrimColor);
+    gfx_symbol_4(gsDPSetEnvColor);
+    gfx_symbol_4(gsDPSetFogColor);
+    gfx_symbol_2(gsSPFogPosition, false);
+    gfx_symbol_1(gsDPSetAlphaCompare, false);
+
+    // Special symbols
+    if (_Symbol == "gsSPTexture") {
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg3 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg4 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        gSPTexture(aHead++, _Arg0, _Arg1, _Arg2, _Arg3, _Arg4);
+        return;
+    }
+    if (_Symbol == "gsSPSetGeometryMode") {
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        gSPSetGeometryMode(aHead++, _Arg0);
+        return;
+    }
+    if (_Symbol == "gsSPClearGeometryMode") {
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        gSPClearGeometryMode(aHead++, _Arg0);
+        return;
+    }
+    if (_Symbol == "gsSPDisplayList") {
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        aGfxData->mPointerList.Add(aHead);
+        gSPDisplayList(aHead++, _Arg0);
+        return;
+    }
+    if (_Symbol == "gsSPBranchList") {
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        aGfxData->mPointerList.Add(aHead);
+        gSPBranchList(aHead++, _Arg0);
+        return;
+    }
+    if (_Symbol == "gsSPEndDisplayList") {
+        gSPEndDisplayList(aHead++);
+
+        // Convert raw texture to PNG if all raw members are set
+        if (aGfxData->mGfxContext.mCurrentTexture                    != NULL &&
+            aGfxData->mGfxContext.mCurrentTexture->mData             != NULL &&
+            aGfxData->mGfxContext.mCurrentTexture->mData->mPngData.Empty()   &&
+            aGfxData->mGfxContext.mCurrentTexture->mData->mRawFormat != -1   &&
+            aGfxData->mGfxContext.mCurrentTexture->mData->mRawSize   != -1   &&
+            aGfxData->mGfxContext.mCurrentTexture->mData->mRawWidth  != -1   &&
+            aGfxData->mGfxContext.mCurrentTexture->mData->mRawHeight != -1) {
+            ConvertTextureDataToPng(aGfxData, aGfxData->mGfxContext.mCurrentTexture->mData);
+        }
+
+        // End the display list parsing after hitting gsSPEndDisplayList
+        aTokenIndex = 0x7FFFFFFF;
+        return;
+    }
+
+    // Complex symbols
+    if (_Symbol == "gsSPSetLights1") {
+        Lights1 *_Light = (Lights1 *) ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        gSPNumLights(aHead++, NUMLIGHTS_1);
+        aGfxData->mPointerList.Add(aHead);
+        gSPLight(aHead++, &_Light->l[0], 1);
+        aGfxData->mPointerList.Add(aHead);
+        gSPLight(aHead++, &_Light->a, 2);
+        return;
+    }
+    if (_Symbol == "gsDPSetCombineMode") {
+        Array<s64> _Args0 = ParseGfxSetCombineMode(aGfxData, aNode, &aTokenIndex);
+        Array<s64> _Args1 = ParseGfxSetCombineMode(aGfxData, aNode, &aTokenIndex);
+        Gfx _Gfx = {{
+            _SHIFTL(G_SETCOMBINE, 24, 8) | _SHIFTL(GCCc0w0(_Args0[0x0], _Args0[0x2], _Args0[0x4], _Args0[0x6]) | GCCc1w0(_Args1[0x0], _Args1[0x2]), 0, 24),
+            (u32) (GCCc0w1(_Args0[0x1], _Args0[0x3], _Args0[0x5], _Args0[0x7]) | GCCc1w1(_Args1[0x1], _Args1[0x4], _Args1[0x6], _Args1[0x3], _Args1[0x5], _Args1[0x7]))
+        }};
+        *(aHead++) = _Gfx;
+        return;
+    }
+    if (_Symbol == "gsDPSetCombineLERP") {
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_CCMUX_");
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_CCMUX_");
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_CCMUX_");
+        s64 _Arg3 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_CCMUX_");
+        s64 _Arg4 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_ACMUX_");
+        s64 _Arg5 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_ACMUX_");
+        s64 _Arg6 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_ACMUX_");
+        s64 _Arg7 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_ACMUX_");
+        s64 _Arg8 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_CCMUX_");
+        s64 _Arg9 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_CCMUX_");
+        s64 _ArgA = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_CCMUX_");
+        s64 _ArgB = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_CCMUX_");
+        s64 _ArgC = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_ACMUX_");
+        s64 _ArgD = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_ACMUX_");
+        s64 _ArgE = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_ACMUX_");
+        s64 _ArgF = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "G_ACMUX_");
+        Gfx _Gfx = {{
+            _SHIFTL(G_SETCOMBINE, 24, 8) | _SHIFTL(GCCc0w0(_Arg0, _Arg2, _Arg4, _Arg6) | GCCc1w0(_Arg8, _ArgA), 0, 24),
+            (u32) (GCCc0w1(_Arg1, _Arg3, _Arg5, _Arg7) | GCCc1w1(_Arg9, _ArgC, _ArgE, _ArgB, _ArgD, _ArgF))
+        }};
+        *(aHead++) = _Gfx;
+        return;
+    }
+
+    // TexData symbols
+    if (_Symbol == "gsDPSetTextureImage") {
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg3 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        UpdateTextureInfo(aGfxData, &_Arg3, (s32) _Arg0, (s32) _Arg1, -1, -1);
+        aGfxData->mPointerList.Add(aHead);
+        gDPSetTextureImage(aHead++, _Arg0, _Arg1, _Arg2, _Arg3);
+        return;
+    }
+    if (_Symbol == "gsDPSetTile") {
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg3 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg4 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg5 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg6 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg7 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg8 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg9 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _ArgA = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _ArgB = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        UpdateTextureInfo(aGfxData, NULL, (s32) _Arg0, (s32) _Arg1, -1, -1);
+        gDPSetTile(aHead++, _Arg0, _Arg1, _Arg2, _Arg3, _Arg4, _Arg5, _Arg6, _Arg7, _Arg8, _Arg9, _ArgA, _ArgB);
+        return;
+    }
+    if (_Symbol == "gsDPLoadTile") {
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg3 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg4 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        UpdateTextureInfo(aGfxData, NULL, -1, -1, (s32) (_Arg3 >> G_TEXTURE_IMAGE_FRAC) + 1, (s32) (_Arg4 >> G_TEXTURE_IMAGE_FRAC) + 1);
+        gDPLoadTile(aHead++, _Arg0, _Arg1, _Arg2, _Arg3, _Arg4);
+        return;
+    }
+    if (_Symbol == "gsDPSetTileSize") {
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg3 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg4 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        UpdateTextureInfo(aGfxData, NULL, -1, -1, (s32) (_Arg3 >> G_TEXTURE_IMAGE_FRAC) + 1, (s32) (_Arg4 >> G_TEXTURE_IMAGE_FRAC) + 1);
+        gDPSetTileSize(aHead++, _Arg0, _Arg1, _Arg2, _Arg3, _Arg4);
+        return;
+    }
+    if (_Symbol == "gsDPLoadTextureBlock") {
+        s64 _Arg0 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg1 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        gfx_arg_with_suffix(arg2_0, _LOAD_BLOCK);
+        gfx_arg_with_suffix(arg2_1, _INCR);
+        gfx_arg_with_suffix(arg2_2, _SHIFT);
+        gfx_arg_with_suffix(arg2_3, _BYTES);
+        gfx_arg_with_suffix(arg2_4, _LINE_BYTES);
+        s64 _Arg2 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg3 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg4 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg5 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg6 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg7 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg8 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _Arg9 = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _ArgA = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        s64 _ArgB = ParseGfxSymbolArg(aGfxData, aNode, &aTokenIndex, "");
+        UpdateTextureInfo(aGfxData, &_Arg0, (s32) _Arg1, (s32) _Arg2, (s32) _Arg3, (s32) _Arg4);
+
+        aGfxData->mPointerList.Add(aHead);
+        gDPSetTextureImage(aHead++, _Arg1, arg2_0, 1, _Arg0);
+        gDPSetTile(aHead++, _Arg1, arg2_0, 0, 0, G_TX_LOADTILE, 0, _Arg7, _Arg9, _ArgB, _Arg6, _Arg8, _ArgA);
+        gDPLoadSync(aHead++);
+        gDPLoadBlock(aHead++, G_TX_LOADTILE, 0, 0, (((_Arg3) * (_Arg4) + arg2_1) >> arg2_2) - 1, CALC_DXT(_Arg3, arg2_3));
+        gDPPipeSync(aHead++);
+        gDPSetTile(aHead++, _Arg1, _Arg2, ((((_Arg3) * arg2_4) + 7) >> 3), 0, G_TX_RENDERTILE, _Arg5, _Arg7, _Arg9, _ArgB, _Arg6, _Arg8, _ArgA);
+        gDPSetTileSize(aHead++, G_TX_RENDERTILE, 0, 0, ((_Arg3) - 1) << G_TEXTURE_IMAGE_FRAC, ((_Arg4) - 1) << G_TEXTURE_IMAGE_FRAC);
+        return;
+    }
+
+    // Unknown
+    PrintError("  ERROR: Unknown gfx symbol: %s", _Symbol.begin());
+}
+
+static DataNode<Gfx>* ParseDisplayListData(GfxData* aGfxData, DataNode<Gfx>* aNode) {
+    if (aNode->mData) return aNode;
+
+    // Display list data
+    aNode->mData = New<Gfx>(aNode->mTokens.Count() * DISPLAY_LIST_SIZE_PER_TOKEN);
+    Gfx* _Head = aNode->mData;
+    for (u64 _TokenIndex = 0; _TokenIndex < aNode->mTokens.Count();) { // Don't increment _TokenIndex here!
+        ParseGfxSymbol(aGfxData, aNode, _Head, _TokenIndex);
+    }
+    aNode->mSize = (u32) (_Head - aNode->mData);
+    aNode->mLoadIndex = aGfxData->mLoadIndex++;
+    return aNode;
+}
+
+//
+// Geo layouts
+//
+
+#define geo_constant(x) if (_Arg == #x) { return (s64) (x); }
+static s64 ParseGeoSymbolArg(GfxData* aGfxData, DataNode<GeoLayout>* aNode, u64& aTokenIndex) {
+    const String& _Arg = aNode->mTokens[aTokenIndex++];
+
+    // Geo functions
+    void *_GeoFunctionPtr = DynOS_Geo_GetFunctionPointerFromName(_Arg);
+    if (_GeoFunctionPtr != NULL) {
+        return (s64) _GeoFunctionPtr;
+    }
+
+    // Layer constants
+    geo_constant(LAYER_FORCE);
+    geo_constant(LAYER_OPAQUE);
+    geo_constant(LAYER_OPAQUE_DECAL);
+    geo_constant(LAYER_OPAQUE_INTER);
+    geo_constant(LAYER_ALPHA);
+    geo_constant(LAYER_TRANSPARENT);
+    geo_constant(LAYER_TRANSPARENT_DECAL);
+    geo_constant(LAYER_TRANSPARENT_INTER);
+
+    // Background constants
+    geo_constant(BACKGROUND_OCEAN_SKY);
+    geo_constant(BACKGROUND_FLAMING_SKY);
+    geo_constant(BACKGROUND_UNDERWATER_CITY);
+    geo_constant(BACKGROUND_BELOW_CLOUDS);
+    geo_constant(BACKGROUND_SNOW_MOUNTAINS);
+    geo_constant(BACKGROUND_DESERT);
+    geo_constant(BACKGROUND_HAUNTED);
+    geo_constant(BACKGROUND_GREEN_SKY);
+    geo_constant(BACKGROUND_ABOVE_CLOUDS);
+    geo_constant(BACKGROUND_PURPLE_SKY);
+
+    // Shadow constants
+    geo_constant(SHADOW_CIRCLE_9_VERTS);
+    geo_constant(SHADOW_CIRCLE_4_VERTS);
+    geo_constant(SHADOW_CIRCLE_4_VERTS_FLAT_UNUSED);
+    geo_constant(SHADOW_SQUARE_PERMANENT);
+    geo_constant(SHADOW_SQUARE_SCALABLE);
+    geo_constant(SHADOW_SQUARE_TOGGLABLE);
+    geo_constant(SHADOW_RECTANGLE_HARDCODED_OFFSET);
+    geo_constant(SHADOW_CIRCLE_PLAYER);
+
+    // Other constants
+    geo_constant(NULL);
+    geo_constant(SCREEN_WIDTH);
+    geo_constant(SCREEN_HEIGHT);
+    geo_constant(SCREEN_WIDTH/2);
+    geo_constant(SCREEN_HEIGHT/2);
+
+    // Display lists
+    for (auto& _Node : aGfxData->mDisplayLists) {
+        if (_Arg == _Node->mName) {
+            return (s64) ParseDisplayListData(aGfxData, _Node);
+        }
+    }
+
+    // Geo layouts
+    for (auto& _Node : aGfxData->mGeoLayouts) {
+        if (_Arg == _Node->mName) {
+            return (s64) ParseGeoLayoutData(aGfxData, _Node, false)->mData;
+        }
+    }
+
+    // Integers
+    s32 x;
+    if ((_Arg[1] == 'x' && sscanf(_Arg.begin(), "%x", &x) == 1) || (sscanf(_Arg.begin(), "%d", &x) == 1)) {
+        return (s64) x;
+    }
+
+    // Unknown
+    PrintError("  ERROR: Unknown geo arg: %s", _Arg.begin());
+    return 0;
+}
+
+#define geo_symbol_0(symb)                                                                             \
+    if (_Symbol == #symb) {                                                                       \
+        GeoLayout _Gl[] = { symb() };                                                                   \
+        memcpy(aHead, _Gl, sizeof(_Gl));                                                                 \
+        aHead += (sizeof(_Gl) / sizeof(_Gl[0]));                                                         \
+        return;                                                                                        \
+    }
+
+#define geo_symbol_1(symb, n)                                                                          \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        if (n != 0) { aGfxData->mPointerList.Add(aHead + n); }                            \
+        GeoLayout _Gl[] = { symb(_Arg0) };                                                               \
+        memcpy(aHead, _Gl, sizeof(_Gl));                                                                 \
+        aHead += (sizeof(_Gl) / sizeof(_Gl[0]));                                                         \
+        return;                                                                                        \
+    }
+
+#define geo_symbol_2(symb, n)                                                                          \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg1 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        if (n != 0) { aGfxData->mPointerList.Add(aHead + n); }                            \
+        GeoLayout _Gl[] = { symb(_Arg0, _Arg1) };                                                         \
+        memcpy(aHead, _Gl, sizeof(_Gl));                                                                 \
+        aHead += (sizeof(_Gl) / sizeof(_Gl[0]));                                                         \
+        return;                                                                                        \
+    }
+
+#define geo_symbol_3(symb, n)                                                                          \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg1 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg2 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        if (n != 0) { aGfxData->mPointerList.Add(aHead + n); }                            \
+        GeoLayout _Gl[] = { symb(_Arg0, _Arg1, _Arg2) };                                                   \
+        memcpy(aHead, _Gl, sizeof(_Gl));                                                                 \
+        aHead += (sizeof(_Gl) / sizeof(_Gl[0]));                                                         \
+        return;                                                                                        \
+    }
+
+#define geo_symbol_4(symb, n)                                                                          \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg1 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg2 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg3 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        if (n != 0) { aGfxData->mPointerList.Add(aHead + n); }                            \
+        GeoLayout _Gl[] = { symb(_Arg0, _Arg1, _Arg2, _Arg3) };                                             \
+        memcpy(aHead, _Gl, sizeof(_Gl));                                                                 \
+        aHead += (sizeof(_Gl) / sizeof(_Gl[0]));                                                         \
+        return;                                                                                        \
+    }
+
+#define geo_symbol_5(symb, n)                                                                          \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg1 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg2 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg3 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg4 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        if (n != 0) { aGfxData->mPointerList.Add(aHead + n); }                            \
+        GeoLayout _Gl[] = { symb(_Arg0, _Arg1, _Arg2, _Arg3, _Arg4) };                                       \
+        memcpy(aHead, _Gl, sizeof(_Gl));                                                                 \
+        aHead += (sizeof(_Gl) / sizeof(_Gl[0]));                                                         \
+        return;                                                                                        \
+    }
+
+#define geo_symbol_6(symb, n)                                                                          \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg1 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg2 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg3 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg4 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg5 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        if (n != 0) { aGfxData->mPointerList.Add(aHead + n); }                            \
+        GeoLayout _Gl[] = { symb(_Arg0, _Arg1, _Arg2, _Arg3, _Arg4, _Arg5) };                                 \
+        memcpy(aHead, _Gl, sizeof(_Gl));                                                                 \
+        aHead += (sizeof(_Gl) / sizeof(_Gl[0]));                                                         \
+        return;                                                                                        \
+    }
+
+#define geo_symbol_7(symb, n)                                                                          \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg1 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg2 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg3 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg4 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg5 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg6 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        if (n != 0) { aGfxData->mPointerList.Add(aHead + n); }                            \
+        GeoLayout _Gl[] = { symb(_Arg0, _Arg1, _Arg2, _Arg3, _Arg4, _Arg5, _Arg6) };                           \
+        memcpy(aHead, _Gl, sizeof(_Gl));                                                                 \
+        aHead += (sizeof(_Gl) / sizeof(_Gl[0]));                                                         \
+        return;                                                                                        \
+    }
+
+#define geo_symbol_8(symb, n)                                                                          \
+    if (_Symbol == #symb) {                                                                       \
+        s64 _Arg0 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg1 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg2 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg3 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg4 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg5 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg6 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        s64 _Arg7 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);                                    \
+        if (n != 0) { aGfxData->mPointerList.Add(aHead + n); }                            \
+        GeoLayout _Gl[] = { symb(_Arg0, _Arg1, _Arg2, _Arg3, _Arg4, _Arg5, _Arg6, _Arg7) };                     \
+        memcpy(aHead, _Gl, sizeof(_Gl));                                                                 \
+        aHead += (sizeof(_Gl) / sizeof(_Gl[0]));                                                         \
+        return;                                                                                        \
+    }
+
+static void ParseGeoSymbol(GfxData* aGfxData, DataNode<GeoLayout>* aNode, GeoLayout*& aHead, u64& aTokenIndex, Array<u64>& aSwitchNodes) {
+    const String& _Symbol = aNode->mTokens[aTokenIndex++];
+
+    // Restore context after each command if inside a switch
+    if (!aSwitchNodes.Empty() && !aGfxData->mGeoNodeStack.Empty()) {
+        aGfxData->mGfxContext = aGfxData->mGeoNodeStack[aGfxData->mGeoNodeStack.Count() - 1];
+    }
+
+    geo_symbol_1(GEO_BRANCH_AND_LINK, 1);
+    geo_symbol_0(GEO_END);
+    geo_symbol_2(GEO_BRANCH, 1);
+    geo_symbol_0(GEO_RETURN);
+    geo_symbol_5(GEO_NODE_SCREEN_AREA, 0);
+    geo_symbol_1(GEO_NODE_ORTHO, 0);
+    geo_symbol_3(GEO_CAMERA_FRUSTUM, 0);
+    geo_symbol_4(GEO_CAMERA_FRUSTUM_WITH_FUNC, 2);
+    geo_symbol_0(GEO_NODE_START);
+    geo_symbol_1(GEO_ZBUFFER, 0);
+    geo_symbol_2(GEO_RENDER_RANGE, 0);
+    geo_symbol_8(GEO_CAMERA, 4);
+    geo_symbol_7(GEO_TRANSLATE_ROTATE, 0);
+    geo_symbol_8(GEO_TRANSLATE_ROTATE_WITH_DL, 4);
+    geo_symbol_4(GEO_TRANSLATE, 0);
+    geo_symbol_5(GEO_TRANSLATE_WITH_DL, 2);
+    geo_symbol_4(GEO_ROTATE, 0);
+    geo_symbol_5(GEO_ROTATE_WITH_DL, 2);
+    geo_symbol_2(GEO_ROTATE_Y, 0);
+    geo_symbol_3(GEO_ROTATE_Y_WITH_DL, 1);
+    geo_symbol_4(GEO_TRANSLATE_NODE, 0);
+    geo_symbol_5(GEO_TRANSLATE_NODE_WITH_DL, 2);
+    geo_symbol_4(GEO_ROTATION_NODE, 0);
+    geo_symbol_5(GEO_ROTATION_NODE_WITH_DL, 2);
+    geo_symbol_5(GEO_ANIMATED_PART, 2);
+    geo_symbol_4(GEO_BILLBOARD_WITH_PARAMS, 0);
+    geo_symbol_5(GEO_BILLBOARD_WITH_PARAMS_AND_DL, 2);
+    geo_symbol_0(GEO_BILLBOARD);
+    geo_symbol_2(GEO_DISPLAY_LIST, 1);
+    geo_symbol_3(GEO_SHADOW, 0);
+    geo_symbol_0(GEO_RENDER_OBJ);
+    geo_symbol_2(GEO_ASM, 1);
+    geo_symbol_2(GEO_BACKGROUND, 1);
+    geo_symbol_1(GEO_BACKGROUND_COLOR, 0);
+    geo_symbol_0(GEO_NOP_1A);
+    geo_symbol_5(GEO_HELD_OBJECT, 2);
+    geo_symbol_2(GEO_SCALE, 0);
+    geo_symbol_3(GEO_SCALE_WITH_DL, 2);
+    geo_symbol_0(GEO_NOP_1E);
+    geo_symbol_0(GEO_NOP_1F);
+    geo_symbol_1(GEO_CULLING_RADIUS, 0);
+
+    // Switch node
+    if (_Symbol == "GEO_SWITCH_CASE") {
+
+        // Start a switch
+        aSwitchNodes.Add(0);
+
+        s64 _Arg0 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);
+        s64 _Arg1 = ParseGeoSymbolArg(aGfxData, aNode, aTokenIndex);
+        aGfxData->mPointerList.Add(aHead + 1);
+        GeoLayout _Gl[] = { GEO_SWITCH_CASE(_Arg0, _Arg1) };
+        memcpy(aHead, _Gl, sizeof(_Gl));
+        aHead += (sizeof(_Gl) / sizeof(_Gl[0]));
+        return;
+    }
+
+    // Open node
+    if (_Symbol == "GEO_OPEN_NODE") {
+
+        // We're inside a switch
+        if (!aSwitchNodes.Empty()) {
+            aSwitchNodes[aSwitchNodes.Count() - 1]++;
+        }
+
+        // Push context
+        aGfxData->mGeoNodeStack.Add(aGfxData->mGfxContext);
+
+        *(aHead++) = GEO_OPEN_NODE();
+        return;
+    }
+
+    // Close node
+    if (_Symbol == "GEO_CLOSE_NODE") {
+
+        // Are we still inside a switch?
+        if (!aSwitchNodes.Empty()) {
+            aSwitchNodes[aSwitchNodes.Count() - 1]--;
+
+            // We're not anymore
+            if (aSwitchNodes[aSwitchNodes.Count() - 1] == 0) {
+                aSwitchNodes.Pop();
+            }
+        }
+
+        // Pop context
+        if (!aGfxData->mGeoNodeStack.Empty()) {
+            aGfxData->mGfxContext = aGfxData->mGeoNodeStack[aGfxData->mGeoNodeStack.Count() - 1];
+            aGfxData->mGeoNodeStack.Pop();
+        }
+
+        *(aHead++) = GEO_CLOSE_NODE();
+        return;
+    }
+
+    // Unknown
+    PrintError("  ERROR: Unknown geo symbol: %s", _Symbol.begin());
+}
+
+static DataNode<GeoLayout>* ParseGeoLayoutData(GfxData* aGfxData, DataNode<GeoLayout>* aNode, bool aDisplayPercent) {
+    if (aNode->mData) return aNode;
+
+    // Geo layout data
+    aNode->mData = New<GeoLayout>(aNode->mTokens.Count() * GEO_LAYOUT_SIZE_PER_TOKEN);
+    GeoLayout* _Head = aNode->mData;
+    Array<u64> _SwitchNodes;
+    for (u64 _TokenIndex = 0; _TokenIndex < aNode->mTokens.Count();) { // Don't increment _TokenIndex here!
+        ParseGeoSymbol(aGfxData, aNode, _Head, _TokenIndex, _SwitchNodes);
+        if (aDisplayPercent && aGfxData->mErrorCount == 0) { PrintNoNewLine("%3d%%\b\b\b\b", (s32) (_TokenIndex * 100) / aNode->mTokens.Count()); }
+    }
+    if (aDisplayPercent && aGfxData->mErrorCount == 0) { Print("100%%"); }
+    aNode->mSize = (u32)(_Head - aNode->mData);
+    aNode->mLoadIndex = aGfxData->mLoadIndex++;
+    return aNode;
+}
+
+//
+// Animation files
+//
+
+static void ScanAnimationDataFile(GfxData *aGfxData, const SysPath &aFilename) {
+    FILE *_File = fopen(aFilename.c_str(), "rb");
+    if (!_File) {
+        PrintError("  ERROR: Unable to open file \"%s\"", aFilename.c_str());
+    }
+
+    // Load file into a buffer while removing all comments
+    char *_FileBuffer = LoadFileBuffer(_File, NULL);
+    fclose(_File);
+
+    // Parse animation data
+    u8 _DataType = DATA_TYPE_NONE;
+    String _DataName;
+    bool _IsData = false;
+    Array<String> _Data;
+    Array<String> _Tokens = Split(_FileBuffer, " []()=&,;\t\r\n\b");
+    for (const auto &_Token : _Tokens) {
+
+        // Data type
+        if (_DataType == DATA_TYPE_NONE) {
+            if (_Token == "s16" || _Token == "u16" || _Token == "s16") {
+                _DataType = DATA_TYPE_ANIMATION_VALUE;
+            } else if (_Token == "Animation") {
+                _DataType = DATA_TYPE_ANIMATION;
+            }
+        }
+
+        // Data name
+        else if (_DataName.Empty()) {
+            _DataName = _Token;
+            if (_DataType == DATA_TYPE_ANIMATION_VALUE && (_DataName.Find("index") != -1 || _DataName.Find("indices") != -1)) {
+                _DataType = DATA_TYPE_ANIMATION_INDEX;
+            }
+        }
+
+        // Is data?
+        else if (!_IsData) {
+            if (_Token == "{") {
+                _IsData = true;
+            }
+        }
+
+        // Data
+        else {
+            if (_Token == "}") {
+                switch (_DataType) {
+                    case DATA_TYPE_ANIMATION_VALUE: {
+                        AnimBuffer<s16> *_AnimValues = New<AnimBuffer<s16>>();
+                        _AnimValues->first = _DataName;
+                        for (const auto &_Value : _Data) {
+                            _AnimValues->second.Add(_Value.ParseInt());
+                        }
+                        aGfxData->mAnimValues.Add(_AnimValues);
+                    } break;
+
+                    case DATA_TYPE_ANIMATION_INDEX: {
+                        AnimBuffer<u16> *_AnimIndices = New<AnimBuffer<u16>>();
+                        _AnimIndices->first = _DataName;
+                        for (const auto &_Index : _Data) {
+                            _AnimIndices->second.Add(_Index.ParseInt());
+                        }
+                        aGfxData->mAnimIndices.Add(_AnimIndices);
+                    } break;
+
+                    case DATA_TYPE_ANIMATION: {
+                        if (_Data.Count() < 10) {
+                            PrintError("  ERROR: %s: Not enough data", _DataName.begin());
+                            break;
+                        }
+
+                        DataNode<AnimData> *_Node = New<DataNode<AnimData>>();
+                        _Node->mName = _DataName;
+                        _Node->mData = New<AnimData>();
+                        _Node->mData->mFlags = (s16) _Data[0].ParseInt();
+                        _Node->mData->mUnk02 = (s16) _Data[1].ParseInt();
+                        _Node->mData->mUnk04 = (s16) _Data[2].ParseInt();
+                        _Node->mData->mUnk06 = (s16) _Data[3].ParseInt();
+                        _Node->mData->mUnk08 = (s16) _Data[4].ParseInt();
+                        _Node->mData->mUnk0A.first = _Data[6]; // 5 is "ANIMINDEX_NUMPARTS"
+                        _Node->mData->mValues.first = _Data[7];
+                        _Node->mData->mIndex.first = _Data[8];
+                        _Node->mData->mLength = (u32) _Data[9].ParseInt();
+                        aGfxData->mAnimations.Add(_Node);
+                    } break;
+                }
+                _DataType = DATA_TYPE_NONE;
+                _DataName.Clear();
+                _IsData = false;
+                _Data.Clear();
+            } else {
+                _Data.Add(_Token);
+            }
+        }
+    }
+    Delete(_FileBuffer);
+}
+
+static void ScanAnimationTableFile(GfxData *aGfxData, const SysPath &aFilename) {
+    FILE *_File = fopen(aFilename.c_str(), "rb");
+    if (!_File) {
+        PrintError("  ERROR: Unable to open file \"%s\"", aFilename.c_str());
+    }
+
+    // Load file into a buffer while removing all comments
+    char *_FileBuffer = LoadFileBuffer(_File, NULL);
+    fclose(_File);
+
+    // Retrieve animation names
+    bool _IsAnimName = false;
+    Array<String> _Tokens = Split(_FileBuffer, " =&,;\t\r\n\b");
+    for (const auto &_Token : _Tokens) {
+        if (_Token == "{") {
+            _IsAnimName = true;
+        } else if (_Token == "}") {
+            _IsAnimName = false;
+        } else if (_IsAnimName) {
+            aGfxData->mAnimationTable.Add({ _Token, NULL });
+        }
+    }
+    Delete(_FileBuffer);
+}
+
+static void ScanAnimationFolder(GfxData *aGfxData, const SysPath &aAnimsFolder) {
+    DIR *_AnimsDir = opendir(aAnimsFolder.c_str());
+    if (!_AnimsDir) return;
+
+    struct dirent *_AnimsEnt = NULL;
+    while ((_AnimsEnt = readdir(_AnimsDir)) != NULL) {
+
+        // Skip
+        if (SysPath(_AnimsEnt->d_name) == ".") continue;
+        if (SysPath(_AnimsEnt->d_name) == "..") continue;
+        if (SysPath(_AnimsEnt->d_name) == "data.inc.c") continue;
+
+        // Animation file
+        SysPath _AnimsFilename = fstring("%s/%s", aAnimsFolder.c_str(), _AnimsEnt->d_name);
+        if (fs_sys_file_exists(_AnimsFilename.c_str())) {
+
+            // Table file
+            if (SysPath(_AnimsEnt->d_name) == "table.inc.c") {
+                ScanAnimationTableFile(aGfxData, _AnimsFilename);
+            }
+
+            // Data file
+            else {
+                ScanAnimationDataFile(aGfxData, _AnimsFilename);
+            }
+        }
+    }
+    closedir(_AnimsDir);
+}
+
+//
+// Read & Generate
+//
+
+// Free data pointers, but keep nodes and tokens intact
+// Delete nodes generated from GfxDynCmds
+template <typename T>
+static void ClearGfxDataNodes(DataNodes<T> &aDataNodes) {
+    for (s32 i = aDataNodes.Count(); i != 0; --i) {
+        Delete(aDataNodes[i - 1]->mData);
+    }
+}
+
+static DataNode<GeoLayout> *GetGeoLayout(GfxData *aGfxData, const String& aGeoRoot) {
+    for (DataNode<GeoLayout> *_Node : aGfxData->mGeoLayouts) {
+        if (_Node->mName == aGeoRoot) {
+            return _Node;
+        }
+    }
+    return NULL;
+}
+
+static String GetActorFolder(const Array<Pair<u64, String>> &aActorsFolders, u64 aModelIdentifier) {
+    for (const auto &_Pair : aActorsFolders) {
+        if (_Pair.first == aModelIdentifier) {
+            return _Pair.second;
+        }
+    }
+    return String();
+}
+
+void DynOS_Gfx_GeneratePack(const SysPath &aPackFolder) {
+    Print("---------- Pack folder: \"%s\" ----------", aPackFolder.c_str());
+    Array<Pair<u64, String>> _ActorsFolders;
+    GfxData *_GfxData = New<GfxData>();
+
+    // Read all the model.inc.c files and geo.inc.c files from the subfolders of the pack folder
+    // Animations are processed separately
+    DIR *aPackDir = opendir(aPackFolder.c_str());
+    if (aPackDir) {
+        struct dirent *_PackEnt = NULL;
+        while ((_PackEnt = readdir(aPackDir)) != NULL) {
+
+            // Skip . and ..
+            if (SysPath(_PackEnt->d_name) == ".") continue;
+            if (SysPath(_PackEnt->d_name) == "..") continue;
+
+            // For each subfolder, read tokens from model.inc.c and geo.inc.c
+            SysPath _Folder = fstring("%s/%s", aPackFolder.c_str(), _PackEnt->d_name);
+            if (fs_sys_dir_exists(_Folder.c_str())) {
+                _GfxData->mModelIdentifier = 0;
+                ScanModelFile(_GfxData, fstring("%s/model.inc.c", _Folder.c_str()));
+                ScanModelFile(_GfxData, fstring("%s/geo.inc.c", _Folder.c_str()));
+                if (_GfxData->mModelIdentifier != 0) {
+                    _ActorsFolders.Add({ _GfxData->mModelIdentifier, String(_PackEnt->d_name) });
+                }
+            }
+        }
+        closedir(aPackDir);
+    }
+
+    // Generate a binary file for each actor found in the GfxData
+    for (s32 i = 0; i != DynOS_Geo_GetActorCount(); ++i) {
+        String _GeoRootName = DynOS_Geo_GetActorName(i);
+        DataNode<GeoLayout> *_GeoRoot = GetGeoLayout(_GfxData, _GeoRootName);
+        if (_GeoRoot != NULL) {
+
+            // If there is an existing binary file for this layout, skip and go to the next actor
+            SysPath _BinFilename = fstring("%s/%s.bin", aPackFolder.c_str(), _GeoRootName.begin());
+            if (fs_sys_file_exists(_BinFilename.c_str())) {
+                continue;
+            }
+
+            // Init
+            _GfxData->mLoadIndex                  = 0;
+            _GfxData->mErrorCount                 = 0;
+            _GfxData->mModelIdentifier            = _GeoRoot->mModelIdentifier;
+            _GfxData->mPackFolder                 = aPackFolder;
+            _GfxData->mPointerList                = { NULL }; // The NULL pointer is needed, so we add it here
+            _GfxData->mGfxContext.mCurrentTexture = NULL;
+            _GfxData->mGfxContext.mCurrentPalette = NULL;
+            _GfxData->mGeoNodeStack.Clear();
+
+            // Parse data
+            PrintNoNewLine("%s.bin: Model identifier: %X - Processing... ", _GeoRootName.begin(), _GfxData->mModelIdentifier);
+            ParseGeoLayoutData(_GfxData, _GeoRoot, true);
+
+            // Init animation data
+            for (auto &_AnimBuffer : _GfxData->mAnimValues) Delete(_AnimBuffer);
+            for (auto &_AnimBuffer : _GfxData->mAnimIndices) Delete(_AnimBuffer);
+            for (auto &_AnimNode : _GfxData->mAnimations) Delete(_AnimNode);
+            _GfxData->mAnimValues.Clear();
+            _GfxData->mAnimIndices.Clear();
+            _GfxData->mAnimations.Clear();
+            _GfxData->mAnimationTable.Clear();
+
+            // Scan anims folder for animation data
+            String _ActorFolder = GetActorFolder(_ActorsFolders, _GfxData->mModelIdentifier);
+            SysPath _AnimsFolder = fstring("%s/%s/anims", aPackFolder.c_str(), _ActorFolder.begin());
+            ScanAnimationFolder(_GfxData, _AnimsFolder);
+
+            // Create table for mario_geo animations or luigi_geo animations
+            if ((_GeoRootName == "mario_geo" || _GeoRootName == "luigi_geo") && !_GfxData->mAnimations.Empty()) {
+                _GfxData->mAnimationTable.Resize(256);
+                for (s32 i = 0; i != 256; ++i) {
+                    String _AnimName("anim_%02X", i);
+                    if (_GfxData->mAnimations.FindIf([&_AnimName](const DataNode<AnimData> *aNode) { return aNode->mName == _AnimName; }) != -1) {
+                        _GfxData->mAnimationTable[i] = { _AnimName, NULL };
+                    } else {
+                        _GfxData->mAnimationTable[i] = { "NULL", NULL };
+                    }
+                }
+            }
+
+            // Write if no error
+            if (_GfxData->mErrorCount == 0) {
+                DynOS_Gfx_WriteBinary(_BinFilename, _GfxData);
+            } else {
+                Print("  %u error(s): Unable to parse data", _GfxData->mErrorCount);
+            }
+
+            // Clear data pointers
+            ClearGfxDataNodes(_GfxData->mLights);
+            ClearGfxDataNodes(_GfxData->mTextures);
+            ClearGfxDataNodes(_GfxData->mVertices);
+            ClearGfxDataNodes(_GfxData->mDisplayLists);
+            ClearGfxDataNodes(_GfxData->mGeoLayouts);
+        }
+    }
+
+    DynOS_Gfx_Free(_GfxData);
+}
+
+#pragma GCC diagnostic pop
diff --git a/data/dynos_gfx_texture.cpp b/data/dynos_gfx_texture.cpp
new file mode 100644
index 00000000..18b8e7f0
--- /dev/null
+++ b/data/dynos_gfx_texture.cpp
@@ -0,0 +1,285 @@
+#include "dynos.cpp.h"
+extern "C" {
+#include "pc/gfx/gfx_rendering_api.h"
+}
+
+//
+// Conversion
+//
+
+#define SCALE_5_8(VAL_) (((VAL_) * 0xFF) / 0x1F)
+#define SCALE_8_5(VAL_) ((((VAL_) + 4) * 0x1F) / 0xFF)
+#define SCALE_4_8(VAL_) ((VAL_) * 0x11)
+#define SCALE_8_4(VAL_) ((VAL_) / 0x11)
+#define SCALE_3_8(VAL_) ((VAL_) * 0x24)
+#define SCALE_8_3(VAL_) ((VAL_) / 0x24)
+
+static u8 *RGBA16_RGBA32(const u8 *aData, u64 aLength) {
+    u8 *_Buffer = New<u8>(aLength * 2);
+    u8 *pBuffer = _Buffer;
+    for (u64 i = 0; i != aLength; i += 2) {
+        u16 _Col  = (aData[i + 0] << 8) | aData[i + 1];
+        u8  _Red  = (_Col >> 11) & 0x1F;
+        u8  _Grn  = (_Col >>  6) & 0x1F;
+        u8  _Blu  = (_Col >>  1) & 0x1F;
+        u8  _Alp  = (_Col >>  0) & 0x01;
+        *(pBuffer++) = (SCALE_5_8(_Red));
+        *(pBuffer++) = (SCALE_5_8(_Grn));
+        *(pBuffer++) = (SCALE_5_8(_Blu));
+        *(pBuffer++) = (0xFF  *  (_Alp));
+    }
+    return _Buffer;
+}
+
+static u8 *RGBA32_RGBA32(const u8 *aData, u64 aLength) {
+    u8 *_Buffer = New<u8>(aLength * 1);
+    memcpy(_Buffer, aData, aLength);
+    return _Buffer;
+}
+
+static u8 *IA4_RGBA32(const u8 *aData, u64 aLength) {
+    u8 *_Buffer = New<u8>(aLength * 8);
+    u8 *pBuffer = _Buffer;
+    for (u64 i = 0; i != aLength; ++i) {
+        u8 _Half0 = (aData[i] >> 4) & 0xF;
+        *(pBuffer++) = (SCALE_3_8(_Half0 >> 1));
+        *(pBuffer++) = (SCALE_3_8(_Half0 >> 1));
+        *(pBuffer++) = (SCALE_3_8(_Half0 >> 1));
+        *(pBuffer++) = (0xFF  *  (_Half0 &  1));
+
+        u8 _Half1 = (aData[i] >> 0) & 0xF;
+        *(pBuffer++) = (SCALE_3_8(_Half1 >> 1));
+        *(pBuffer++) = (SCALE_3_8(_Half1 >> 1));
+        *(pBuffer++) = (SCALE_3_8(_Half1 >> 1));
+        *(pBuffer++) = (0xFF  *  (_Half1 &  1));
+    }
+    return _Buffer;
+}
+
+static u8 *IA8_RGBA32(const u8 *aData, u64 aLength) {
+    u8 *_Buffer = New<u8>(aLength * 4);
+    u8 *pBuffer = _Buffer;
+    for (u64 i = 0; i != aLength; ++i) {
+        u8 _Col   = (aData[i] >> 4) & 0xF;
+        u8 _Alp   = (aData[i] >> 0) & 0xF;
+        *(pBuffer++) = (SCALE_4_8(_Col));
+        *(pBuffer++) = (SCALE_4_8(_Col));
+        *(pBuffer++) = (SCALE_4_8(_Col));
+        *(pBuffer++) = (SCALE_4_8(_Alp));
+    }
+    return _Buffer;
+}
+
+static u8 *IA16_RGBA32(const u8 *aData, u64 aLength) {
+    u8 *_Buffer = New<u8>(aLength * 2);
+    u8 *pBuffer = _Buffer;
+    for (u64 i = 0; i != aLength; i += 2) {
+        u8 _Col   = aData[i + 0];
+        u8 _Alp   = aData[i + 1];
+        *(pBuffer++) = (_Col);
+        *(pBuffer++) = (_Col);
+        *(pBuffer++) = (_Col);
+        *(pBuffer++) = (_Alp);
+    }
+    return _Buffer;
+}
+
+static u8 *CI4_RGBA32(const u8 *aData, u64 aLength, const u8 *aPalette) {
+    u8 *_Buffer = New<u8>(aLength * 8);
+    u8 *pBuffer = _Buffer;
+    for (u64 i = 0; i != aLength; ++i) {
+        u8  _Idx0 = (aData[i] >> 4) & 0xF;
+        u16 _Col0 = (aPalette[_Idx0 * 2 + 0] << 8) | aPalette[_Idx0 * 2 + 1];
+        u8  _Red0 = (_Col0 >> 11) & 0x1F;
+        u8  _Grn0 = (_Col0 >>  6) & 0x1F;
+        u8  _Blu0 = (_Col0 >>  1) & 0x1F;
+        u8  _Alp0 = (_Col0 >>  0) & 0x01;
+        *(pBuffer++) = (SCALE_5_8(_Red0));
+        *(pBuffer++) = (SCALE_5_8(_Grn0));
+        *(pBuffer++) = (SCALE_5_8(_Blu0));
+        *(pBuffer++) = (0xFF  *  (_Alp0));
+
+        u8  _Idx1 = (aData[i] >> 0) & 0xF;
+        u16 _Col1 = (aPalette[_Idx1 * 2 + 0] << 8) | aPalette[_Idx1 * 2 + 1];
+        u8  _Red1 = (_Col1 >> 11) & 0x1F;
+        u8  _Grn1 = (_Col1 >>  6) & 0x1F;
+        u8  _Blu1 = (_Col1 >>  1) & 0x1F;
+        u8  _Alp1 = (_Col1 >>  0) & 0x01;
+        *(pBuffer++) = (SCALE_5_8(_Red1));
+        *(pBuffer++) = (SCALE_5_8(_Grn1));
+        *(pBuffer++) = (SCALE_5_8(_Blu1));
+        *(pBuffer++) = (0xFF  *  (_Alp1));
+    }
+    return _Buffer;
+}
+
+static u8 *CI8_RGBA32(const u8 *aData, u64 aLength, const u8 *aPalette) {
+    u8 *_Buffer = New<u8>(aLength * 4);
+    u8 *pBuffer = _Buffer;
+    for (u64 i = 0; i != aLength; ++i) {
+        u8  _Idx  = aData[i];
+        u16 _Col  = (aPalette[_Idx * 2 + 0] << 8) | aPalette[_Idx * 2 + 1];
+        u8  _Red  = (_Col >> 11) & 0x1F;
+        u8  _Grn  = (_Col >>  6) & 0x1F;
+        u8  _Blu  = (_Col >>  1) & 0x1F;
+        u8  _Alp  = (_Col >>  0) & 0x01;
+        *(pBuffer++) = (SCALE_5_8(_Red));
+        *(pBuffer++) = (SCALE_5_8(_Grn));
+        *(pBuffer++) = (SCALE_5_8(_Blu));
+        *(pBuffer++) = (0xFF  *  (_Alp));
+    }
+    return _Buffer;
+}
+
+static u8 *I4_RGBA32(const u8 *aData, u64 aLength) {
+    u8 *_Buffer = New<u8>(aLength * 8);
+    u8 *pBuffer = _Buffer;
+    for (u64 i = 0; i != aLength; ++i) {
+        u8 _Half0 = (aData[i] >> 4) & 0xF;
+        *(pBuffer++) = (SCALE_4_8(_Half0));
+        *(pBuffer++) = (SCALE_4_8(_Half0));
+        *(pBuffer++) = (SCALE_4_8(_Half0));
+        *(pBuffer++) = (255);
+
+        u8 _Half1 = (aData[i] >> 0) & 0xF;
+        *(pBuffer++) = (SCALE_4_8(_Half1));
+        *(pBuffer++) = (SCALE_4_8(_Half1));
+        *(pBuffer++) = (SCALE_4_8(_Half1));
+        *(pBuffer++) = (255);
+    }
+    return _Buffer;
+}
+
+static u8 *I8_RGBA32(const u8 *aData, u64 aLength) {
+    u8 *_Buffer = New<u8>(aLength * 4);
+    u8 *pBuffer = _Buffer;
+    for (u64 i = 0; i != aLength; ++i) {
+        *(pBuffer++) = (aData[i]);
+        *(pBuffer++) = (aData[i]);
+        *(pBuffer++) = (aData[i]);
+        *(pBuffer++) = (255);
+    }
+    return _Buffer;
+}
+
+u8 *DynOS_Gfx_TextureConvertToRGBA32(const u8 *aData, u64 aLength, s32 aFormat, s32 aSize, const u8 *aPalette) {
+    switch   ((aFormat       << 8) | aSize       ) {
+        case ((G_IM_FMT_RGBA << 8) | G_IM_SIZ_16b): return RGBA16_RGBA32(aData, aLength);
+        case ((G_IM_FMT_RGBA << 8) | G_IM_SIZ_32b): return RGBA32_RGBA32(aData, aLength);
+        case ((G_IM_FMT_IA   << 8) | G_IM_SIZ_4b ): return IA4_RGBA32   (aData, aLength);
+        case ((G_IM_FMT_IA   << 8) | G_IM_SIZ_8b ): return IA8_RGBA32   (aData, aLength);
+        case ((G_IM_FMT_IA   << 8) | G_IM_SIZ_16b): return IA16_RGBA32  (aData, aLength);
+        case ((G_IM_FMT_CI   << 8) | G_IM_SIZ_4b ): return CI4_RGBA32   (aData, aLength, aPalette);
+        case ((G_IM_FMT_CI   << 8) | G_IM_SIZ_8b ): return CI8_RGBA32   (aData, aLength, aPalette);
+        case ((G_IM_FMT_I    << 8) | G_IM_SIZ_4b ): return I4_RGBA32    (aData, aLength);
+        case ((G_IM_FMT_I    << 8) | G_IM_SIZ_8b ): return I8_RGBA32    (aData, aLength);
+    }
+    return NULL;
+}
+
+//
+// Upload
+//
+
+typedef struct GfxRenderingAPI GRAPI;
+static void DynOS_Gfx_UploadTexture(DataNode<TexData> *aNode, GRAPI *aGfxRApi, s32 aTile, s32 aTexId) {
+    aGfxRApi->select_texture(aTile, aTexId);
+    aGfxRApi->upload_texture(aNode->mData->mRawData.begin(), aNode->mData->mRawWidth, aNode->mData->mRawHeight);
+    aNode->mData->mUploaded = true;
+}
+
+//
+// Cache
+//
+
+struct THN {
+    struct THN *mNext;
+    const void *mAddr; // Contains the pointer to the DataNode<TexData> struct, NOT the actual texture data
+    u8 mFmt, mSiz;
+    s32 mTexId;
+    u8 mCms, mCmt;
+    bool mLInf;
+};
+
+static bool DynOS_Gfx_CacheTexture(THN **aOutput, DataNode<TexData> *aNode, s32 aTile, GRAPI *aGfxRApi, THN **aHashMap, THN *aPool, u32 *aPoolPos, u32 aPoolSize) {
+
+    // Find texture in cache
+    uintptr_t _Hash = ((uintptr_t) aNode) & ((aPoolSize * 2) - 1);
+    THN **_Node = &(aHashMap[_Hash]);
+    while ((*_Node) != NULL && ((*_Node) - aPool) < (*aPoolPos)) {
+        if ((*_Node)->mAddr == (const void *) aNode) {
+            aGfxRApi->select_texture(aTile, (*_Node)->mTexId);
+            if (!aNode->mData->mUploaded) {
+                DynOS_Gfx_UploadTexture(aNode, aGfxRApi, aTile, (*_Node)->mTexId);
+            }
+            (*aOutput) = (*_Node);
+            return true;
+        }
+        _Node = &(*_Node)->mNext;
+    }
+
+    // If cache is full, clear cache
+    if ((*aPoolPos) == aPoolSize) {
+        (*aPoolPos) = 0;
+        _Node = &aHashMap[_Hash];
+    }
+
+    // Add new texture to cache
+    (*_Node) = &aPool[(*aPoolPos)++];
+    if (!(*_Node)->mAddr) {
+        (*_Node)->mTexId = aGfxRApi->new_texture();
+    }
+    aGfxRApi->select_texture(aTile, (*_Node)->mTexId);
+    aGfxRApi->set_sampler_parameters(aTile, false, 0, 0);
+    (*_Node)->mCms  = 0;
+    (*_Node)->mCmt  = 0;
+    (*_Node)->mLInf = false;
+    (*_Node)->mNext = NULL;
+    (*_Node)->mAddr = aNode;
+    (*_Node)->mFmt  = G_IM_FMT_RGBA;
+    (*_Node)->mSiz  = G_IM_SIZ_32b;
+    (*aOutput)      = (*_Node);
+    return false;
+}
+
+//
+// Import
+//
+
+static DataNode<TexData> *DynOS_Gfx_RetrieveNode(void *aPtr) {
+    Array<ActorGfx> &pActorGfxList = DynOS_Gfx_GetActorList();
+    for (auto& _ActorGfx : pActorGfxList) {
+        if (_ActorGfx.mGfxData) {
+            for (auto &_Node : _ActorGfx.mGfxData->mTextures) {
+                if ((void*) _Node == aPtr) {
+                    return _Node;
+                }
+            }
+        }
+    }
+    return NULL;
+}
+
+static bool DynOS_Gfx_ImportTexture_Typed(THN **aOutput, void *aPtr, s32 aTile, GRAPI *aGfxRApi, THN **aHashMap, THN *aPool, u32 *aPoolPos, u32 aPoolSize) {
+    DataNode<TexData> *_Node = DynOS_Gfx_RetrieveNode(aPtr);
+    if (_Node) {
+        if (!DynOS_Gfx_CacheTexture(aOutput, _Node, aTile, aGfxRApi, aHashMap, aPool, aPoolPos, aPoolSize)) {
+            DynOS_Gfx_UploadTexture(_Node, aGfxRApi, aTile, (*aOutput)->mTexId);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool DynOS_Gfx_ImportTexture(void **aOutput, void *aPtr, s32 aTile, void *aGfxRApi, void **aHashMap, void *aPool, u32 *aPoolPos, u32 aPoolSize) {
+    return DynOS_Gfx_ImportTexture_Typed(
+        (THN **)  aOutput,
+        (void *)  aPtr,
+        (s32)     aTile,
+        (GRAPI *) aGfxRApi,
+        (THN **)  aHashMap,
+        (THN *)   aPool,
+        (u32 *)   aPoolPos,
+        (u32)     aPoolSize
+    );
+}
diff --git a/data/dynos_gfx_update.cpp b/data/dynos_gfx_update.cpp
new file mode 100644
index 00000000..ce0139ec
--- /dev/null
+++ b/data/dynos_gfx_update.cpp
@@ -0,0 +1,200 @@
+#include "dynos.cpp.h"
+extern "C" {
+#include "object_fields.h"
+#include "game/level_update.h"
+#include "game/object_list_processor.h"
+}
+
+//
+// Free data
+// Must be unloaded the next frame to prevent a crash
+//
+
+STATIC_STORAGE(Array<GfxData *>, GfxDataFreeList);
+#define sGfxDataFreeList __GfxDataFreeList()
+
+STATIC_STORAGE(Array<GraphNode *>, GraphNodeFreeList);
+#define sGraphNodeFreeList __GraphNodeFreeList()
+
+static void DynOS_Gfx_FreeUnloaded() {
+    for (auto &_GfxData : sGfxDataFreeList) DynOS_Gfx_Free(_GfxData);
+    for (auto &_GraphNode : sGraphNodeFreeList) Delete(_GraphNode);
+    sGfxDataFreeList.Clear();
+    sGraphNodeFreeList.Clear();
+}
+
+//
+// Update animations
+//
+
+// Retrieve the current Mario's animation index
+static s32 RetrieveCurrentMarioAnimationIndex() {
+    struct MarioAnimDmaRelatedThing *_AnimDmaTable = gMarioState->animation->animDmaTable;
+    for (s32 i = 0; i != (s32) _AnimDmaTable->count; ++i) {
+        void *_AnimAddr = _AnimDmaTable->srcAddr + _AnimDmaTable->anim[i].offset;
+        if (_AnimAddr == gMarioState->animation->currentAnimAddr) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+// Retrieve the current animation index
+// As we don't know the length of the table, let's hope that we'll always find the animation...
+static s32 RetrieveCurrentAnimationIndex(struct Object *aObject) {
+    if (!aObject->oAnimations || !aObject->header.gfx.unk38.curAnim) {
+        return -1;
+    }
+    for (s32 i = 0; aObject->oAnimations[i] != NULL; ++i) {
+        if (aObject->oAnimations[i] == aObject->header.gfx.unk38.curAnim) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+// Must be called twice, before and after geo_set_animation_globals
+void DynOS_Gfx_SwapAnimations(void *aPtr) {
+    static Animation *pDefaultAnimation = NULL;
+    static Animation  sGfxDataAnimation;
+
+    // Does the object has a model?
+    struct Object *_Object = (struct Object *) aPtr;
+    if (!_Object->header.gfx.sharedChild) {
+        return;
+    }
+
+    // Swap the current animation with the one from the Gfx data
+    if (!pDefaultAnimation) {
+        pDefaultAnimation = _Object->header.gfx.unk38.curAnim;
+
+        // Actor index
+        s32 _ActorIndex = DynOS_Geo_GetActorIndex(_Object->header.gfx.sharedChild->georef);
+        if (_ActorIndex == -1) {
+            return;
+        }
+
+        // Gfx data
+        GfxData *_GfxData = DynOS_Gfx_GetActorList()[_ActorIndex].mGfxData;
+        if (!_GfxData) {
+            return;
+        }
+
+        // Animation table
+        if (_GfxData->mAnimationTable.Empty()) {
+            return;
+        }
+
+        // Animation index
+        s32 _AnimIndex = (_Object == gMarioObject ? RetrieveCurrentMarioAnimationIndex() : RetrieveCurrentAnimationIndex(_Object));
+        if (_AnimIndex == -1) {
+            return;
+        }
+
+        // Animation data
+        const AnimData *_AnimData = (const AnimData *) _GfxData->mAnimationTable[_AnimIndex].second;
+        if (_AnimData) {
+            sGfxDataAnimation.flags = _AnimData->mFlags;
+            sGfxDataAnimation.unk02 = _AnimData->mUnk02;
+            sGfxDataAnimation.unk04 = _AnimData->mUnk04;
+            sGfxDataAnimation.unk06 = _AnimData->mUnk06;
+            sGfxDataAnimation.unk08 = _AnimData->mUnk08;
+            sGfxDataAnimation.unk0A = _AnimData->mUnk0A.second;
+            sGfxDataAnimation.values = _AnimData->mValues.second.begin();
+            sGfxDataAnimation.index = _AnimData->mIndex.second.begin();
+            sGfxDataAnimation.length = _AnimData->mLength;
+            _Object->header.gfx.unk38.curAnim = &sGfxDataAnimation;
+        }
+
+    // Restore the default animation
+    } else {
+        _Object->header.gfx.unk38.curAnim = pDefaultAnimation;
+        pDefaultAnimation = NULL;
+    }
+}
+
+//
+// Update models
+//
+
+static void DynOS_Gfx_UpdateModelData(struct Object *aObject, s32 aActorIndex) {
+    ActorGfx *_ActorGfx = &DynOS_Gfx_GetActorList()[aActorIndex];
+    const Array<PackData *> &pDynosPacks = DynOS_Gfx_GetPacks();
+    for (s32 i = 0; i != pDynosPacks.Count(); ++i) {
+
+        // Pack
+        bool _Enabled = DynOS_Opt_GetValue(String("dynos_pack_%d", i));
+
+        // If enabled and no pack is selected
+        // load the pack's model and replace the default actor's model
+        if (_Enabled && _ActorGfx->mPackIndex == -1) {
+
+            // Load Gfx data from binary
+            SysPath _Filename = fstring("%s/%s.bin", pDynosPacks[i]->mPath.begin(), DynOS_Geo_GetActorName(aActorIndex));
+            GfxData *_GfxData = DynOS_Gfx_LoadFromBinary(_Filename);
+            if (_GfxData == NULL) {
+                continue;
+            }
+
+            // Mark previous model data as unload
+            if (_ActorGfx->mGfxData) sGfxDataFreeList.Add(_ActorGfx->mGfxData);
+            if (_ActorGfx->mGraphNode) sGraphNodeFreeList.Add(_ActorGfx->mGraphNode);
+
+            // Load graph node and animations
+            _ActorGfx->mPackIndex = i;
+            _ActorGfx->mGfxData   = _GfxData;
+            _ActorGfx->mGraphNode = (GraphNode *) DynOS_Geo_GetGraphNode((*(_GfxData->mGeoLayouts.end() - 1))->mData, false);
+            _ActorGfx->mGraphNode->georef = DynOS_Geo_GetActorLayout(aActorIndex);
+            break;
+        }
+
+        // If disabled and this pack is the one selected
+        // unload the pack's model and replace the actor's model by the default one
+        else if (!_Enabled && _ActorGfx->mPackIndex == i) {
+
+            // Mark previous model data as unload
+            if (_ActorGfx->mGfxData) sGfxDataFreeList.Add(_ActorGfx->mGfxData);
+            if (_ActorGfx->mGraphNode) sGraphNodeFreeList.Add(_ActorGfx->mGraphNode);
+
+            // Default
+            _ActorGfx->mPackIndex = -1;
+            _ActorGfx->mGfxData   = NULL;
+            _ActorGfx->mGraphNode = (GraphNode *) DynOS_Geo_GetGraphNode(DynOS_Geo_GetActorLayout(aActorIndex), false);
+        }
+    }
+
+    // Update object
+    aObject->header.gfx.sharedChild = _ActorGfx->mGraphNode;
+}
+
+void DynOS_Gfx_Update() {
+
+    // Don't update until the object lists are loaded
+    if (!gObjectLists) {
+        return;
+    }
+
+    // Free unloaded things
+    DynOS_Gfx_FreeUnloaded();
+
+    // Update per object
+    for (s32 _List = 0; _List != NUM_OBJ_LISTS; ++_List) {
+        struct Object *_Head = (struct Object *) &gObjectLists[_List];
+        for (struct Object *_Object = (struct Object *) _Head->header.next; _Object != _Head; _Object = (struct Object *) _Object->header.next) {
+
+            // Does the object has a model?
+            if (!_Object->header.gfx.sharedChild) {
+                continue;
+            }
+
+            // Actor index
+            s32 _ActorIndex = DynOS_Geo_GetActorIndex(_Object->header.gfx.sharedChild->georef);
+            if (_ActorIndex == -1) {
+                continue;
+            }
+
+            // Replace the object's model and animations
+            DynOS_Gfx_UpdateModelData(_Object, _ActorIndex);
+        }
+    }
+}
diff --git a/data/dynos_gfx_write.cpp b/data/dynos_gfx_write.cpp
new file mode 100644
index 00000000..07ddc253
--- /dev/null
+++ b/data/dynos_gfx_write.cpp
@@ -0,0 +1,318 @@
+#include "dynos.cpp.h"
+
+//
+// Pointers
+//
+
+typedef Pair<String, u32> PointerData;
+static PointerData GetDataFromPointer(const void* aPtr, GfxData* aGfxData) {
+
+    // Lights
+    for (auto& _Node : aGfxData->mLights) {
+        if (&_Node->mData->l[0] == aPtr) { // Light *, not Lights1 *
+            return { _Node->mName, 1 };
+        }
+        if (&_Node->mData->a == aPtr) { // Ambient *, not Lights1 *
+            return { _Node->mName, 2 };
+        }
+    }
+
+    // Textures
+    for (auto& _Node : aGfxData->mTextures) {
+        if (_Node == aPtr) {
+            return { _Node->mName, 0 };
+        }
+    }
+
+    // Display lists
+    for (auto& _Node : aGfxData->mDisplayLists) {
+        if (_Node == aPtr) {
+            return { _Node->mName, 0 };
+        }
+    }
+
+    // Geo layouts
+    for (auto& _Node : aGfxData->mGeoLayouts) {
+        if (_Node->mData == aPtr) {
+            return { _Node->mName, 0 };
+        }
+    }
+
+    // Vertices
+    String _VtxArrayName = "";
+    uintptr_t _VtxArrayStart = 0;
+    for (auto& _Node : aGfxData->mVertices) {
+        if (_Node->mData == aPtr) {
+            return { _Node->mName, 0 };
+        }
+        if ((uintptr_t)_Node->mData <= (uintptr_t)aPtr &&
+            (uintptr_t)_Node->mData >= _VtxArrayStart) {
+            _VtxArrayName = _Node->mName;
+            _VtxArrayStart = (uintptr_t)_Node->mData;
+        }
+    }
+    return { _VtxArrayName, (u32)((const Vtx*)aPtr - (const Vtx*)_VtxArrayStart) };
+}
+
+static void WritePointer(FILE* aFile, const void* aPtr, GfxData* aGfxData) {
+
+    // NULL
+    if (!aPtr) {
+        WriteBytes<u32>(aFile, 0);
+        return;
+    }
+
+    // Geo function
+    s32 _GeoFunctionIndex = DynOS_Geo_GetFunctionIndex(aPtr);
+    if (_GeoFunctionIndex != -1) {
+        WriteBytes<u32>(aFile, FUNCTION_CODE);
+        WriteBytes<s32>(aFile, _GeoFunctionIndex);
+        return;
+    }
+
+    // Pointer
+    PointerData _PtrData = GetDataFromPointer(aPtr, aGfxData);
+    WriteBytes<u32>(aFile, POINTER_CODE);
+    _PtrData.first.Write(aFile);
+    WriteBytes<u32>(aFile, _PtrData.second);
+}
+
+//
+// Lights
+//
+
+static void WriteLightData(FILE* aFile, GfxData* aGfxData, DataNode<Lights1> *aNode) {
+    if (!aNode->mData) return;
+
+    // Header
+    WriteBytes<u8>(aFile, DATA_TYPE_LIGHT);
+    aNode->mName.Write(aFile);
+
+    // Data
+    WriteBytes<Lights1>(aFile, *aNode->mData);
+}
+
+//
+// Textures
+//
+
+static void WriteTextureData(FILE* aFile, GfxData* aGfxData, DataNode<TexData> *aNode) {
+    if (!aNode->mData) return;
+
+    // Header
+    WriteBytes<u8>(aFile, DATA_TYPE_TEXTURE);
+    aNode->mName.Write(aFile);
+
+    // Data
+    aNode->mData->mPngData.Write(aFile);
+}
+
+//
+// Vertices
+//
+
+static void WriteVertexData(FILE* aFile, GfxData* aGfxData, DataNode<Vtx> *aNode) {
+    if (!aNode->mData) return;
+
+    // Header
+    WriteBytes<u8>(aFile, DATA_TYPE_VERTEX);
+    aNode->mName.Write(aFile);
+
+    // Data
+    WriteBytes<u32>(aFile, aNode->mSize);
+    for (u32 i = 0; i != aNode->mSize; ++i) {
+        WriteBytes<s16>(aFile, aNode->mData[i].n.ob[0]);
+        WriteBytes<s16>(aFile, aNode->mData[i].n.ob[1]);
+        WriteBytes<s16>(aFile, aNode->mData[i].n.ob[2]);
+        WriteBytes<s16>(aFile, aNode->mData[i].n.flag);
+        WriteBytes<s16>(aFile, aNode->mData[i].n.tc[0]);
+        WriteBytes<s16>(aFile, aNode->mData[i].n.tc[1]);
+        WriteBytes<s8> (aFile, aNode->mData[i].n.n[0]);
+        WriteBytes<s8> (aFile, aNode->mData[i].n.n[1]);
+        WriteBytes<s8> (aFile, aNode->mData[i].n.n[2]);
+        WriteBytes<u8> (aFile, aNode->mData[i].n.a);
+    }
+}
+
+//
+// Display lists
+//
+
+static void WriteDisplayListData(FILE *aFile, GfxData *aGfxData, DataNode<Gfx> *aNode) {
+    if (!aNode->mData) return;
+
+    // Header
+    WriteBytes<u8>(aFile, DATA_TYPE_DISPLAY_LIST);
+    aNode->mName.Write(aFile);
+
+    // Data
+    WriteBytes<u32>(aFile, aNode->mSize);
+    for (u32 i = 0; i != aNode->mSize; ++i) {
+        Gfx *_Head = &aNode->mData[i];
+        if (aGfxData->mPointerList.Find((void *) _Head) != -1) {
+            WriteBytes<u32>(aFile, _Head->words.w0);
+            WritePointer(aFile, (const void *) _Head->words.w1, aGfxData);
+        } else {
+            WriteBytes<u32>(aFile, _Head->words.w0);
+            WriteBytes<u32>(aFile, _Head->words.w1);
+        }
+    }
+}
+
+//
+// Geo layouts
+//
+
+static void WriteGeoLayoutData(FILE *aFile, GfxData *aGfxData, DataNode<GeoLayout> *aNode) {
+    if (!aNode->mData) return;
+
+    // Header
+    WriteBytes<u8>(aFile, DATA_TYPE_GEO_LAYOUT);
+    aNode->mName.Write(aFile);
+
+    // Data
+    WriteBytes<u32>(aFile, aNode->mSize);
+    for (u32 i = 0; i != aNode->mSize; ++i) {
+        GeoLayout *_Head = &aNode->mData[i];
+        if (aGfxData->mPointerList.Find((void *) _Head) != -1) {
+            WritePointer(aFile, (const void *) (*_Head), aGfxData);
+        } else {
+            WriteBytes<u32>(aFile, *((u32 *) _Head));
+        }
+    }
+}
+
+//
+// Animation data
+//
+
+static void WriteAnimationData(FILE* aFile, GfxData* aGfxData) {
+    for (auto& _Node : aGfxData->mAnimations) {
+
+        // Value buffer
+        s32 _ValueBufferIdx = aGfxData->mAnimValues.FindIf([&_Node](const AnimBuffer<s16> *aAnimBuffer) { return aAnimBuffer->first == _Node->mData->mValues.first; });
+        if (_ValueBufferIdx == -1) {
+            continue;
+        }
+
+        // Index buffer
+        s32 _IndexBufferIdx = aGfxData->mAnimIndices.FindIf([&_Node](const AnimBuffer<u16> *aAnimBuffer) { return aAnimBuffer->first == _Node->mData->mIndex.first; });
+        if (_IndexBufferIdx == -1) {
+            continue;
+        }
+
+        // Unk0A buffer
+        s32 _Unk0ABufferIdx = aGfxData->mAnimIndices.FindIf([&_Node](const AnimBuffer<u16> *aAnimBuffer) { return aAnimBuffer->first == _Node->mData->mUnk0A.first; });
+        if (_Unk0ABufferIdx == -1) {
+            continue;
+        }
+
+        // Header
+        WriteBytes<u8>(aFile, DATA_TYPE_ANIMATION);
+        _Node->mName.Write(aFile);
+
+        // Data
+        WriteBytes<s16>(aFile, _Node->mData->mFlags);
+        WriteBytes<s16>(aFile, _Node->mData->mUnk02);
+        WriteBytes<s16>(aFile, _Node->mData->mUnk04);
+        WriteBytes<s16>(aFile, _Node->mData->mUnk06);
+        WriteBytes<s16>(aFile, _Node->mData->mUnk08);
+        WriteBytes<s16>(aFile, (aGfxData->mAnimIndices[_Unk0ABufferIdx]->second.Count() / 6) - 1);
+        WriteBytes<u32>(aFile, _Node->mData->mLength);
+        aGfxData->mAnimValues[_ValueBufferIdx]->second.Write(aFile);
+        aGfxData->mAnimIndices[_IndexBufferIdx]->second.Write(aFile);
+    }
+}
+
+//
+// Animation table
+//
+
+static void WriteAnimationTable(FILE* aFile, GfxData* aGfxData) {
+    for (auto& _AnimName : aGfxData->mAnimationTable) {
+
+        // Header
+        WriteBytes<u8>(aFile, DATA_TYPE_ANIMATION_TABLE);
+
+        // Data
+        _AnimName.first.Write(aFile);
+    }
+}
+
+//
+// Write
+//
+
+bool DynOS_Gfx_WriteBinary(const SysPath &aOutputFilename, GfxData *aGfxData) {
+    FILE *_File = fopen(aOutputFilename.c_str(), "wb");
+    if (!_File) {
+        PrintError("  ERROR: Unable to create file \"%s\"", aOutputFilename.c_str());
+        return false;
+    }
+
+    for (u64 i = 0; i != aGfxData->mLoadIndex; ++i) {
+        for (auto &_Node : aGfxData->mLights) {
+            if (_Node->mLoadIndex == i) {
+                WriteLightData(_File, aGfxData, _Node);
+            }
+        }
+        for (auto &_Node : aGfxData->mTextures) {
+            if (_Node->mLoadIndex == i) {
+                WriteTextureData(_File, aGfxData, _Node);
+            }
+        }
+        for (auto &_Node : aGfxData->mVertices) {
+            if (_Node->mLoadIndex == i) {
+                WriteVertexData(_File, aGfxData, _Node);
+            }
+        }
+        for (auto &_Node : aGfxData->mDisplayLists) {
+            if (_Node->mLoadIndex == i) {
+                WriteDisplayListData(_File, aGfxData, _Node);
+            }
+        }
+        for (auto &_Node : aGfxData->mGeoLayouts) {
+            if (_Node->mLoadIndex == i) {
+                WriteGeoLayoutData(_File, aGfxData, _Node);
+            }
+        }
+    }
+    WriteAnimationData(_File, aGfxData);
+    WriteAnimationTable(_File, aGfxData);
+    fclose(_File);
+    return true;
+}
+
+//
+// Free
+//
+
+void DynOS_Gfx_Free(GfxData* aGfxData) {
+    if (aGfxData) {
+        for (auto& _Node : aGfxData->mLights) {
+            Delete(_Node->mData);
+            Delete(_Node);
+        }
+        for (auto& _Node : aGfxData->mTextures) {
+            Delete(_Node->mData);
+            Delete(_Node);
+        }
+        for (auto& _Node : aGfxData->mVertices) {
+            Delete(_Node->mData);
+            Delete(_Node);
+        }
+        for (auto& _Node : aGfxData->mDisplayLists) {
+            Delete(_Node->mData);
+            Delete(_Node);
+        }
+        for (auto& _Node : aGfxData->mGeoLayouts) {
+            Delete(_Node->mData);
+            Delete(_Node);
+        }
+        for (auto& _Node : aGfxData->mAnimations) {
+            Delete(_Node->mData);
+            Delete(_Node);
+        }
+        Delete(aGfxData);
+    }
+}
diff --git a/data/dynos_level.cpp b/data/dynos_level.cpp
new file mode 100644
index 00000000..f1a0b8a8
--- /dev/null
+++ b/data/dynos_level.cpp
@@ -0,0 +1,826 @@
+#include "dynos.cpp.h"
+extern "C" {
+#include "game/segment2.h"
+#include "game/save_file.h"
+#include "levels/scripts.h"
+}
+
+//
+// Const
+//
+
+extern "C" {
+extern const BehaviorScript *sWarpBhvSpawnTable[];
+}
+
+#define DYNOS_LEVEL_TEXT_EMPTY              ""
+#define DYNOS_LEVEL_TEXT_CASTLE             "CASTLE"
+#define DYNOS_LEVEL_TEXT_BOWSER_1           "BOWSER 1"
+#define DYNOS_LEVEL_TEXT_BOWSER_2           "BOWSER 2"
+#define DYNOS_LEVEL_TEXT_BOWSER_3           "BOWSER 3"
+#define DYNOS_LEVEL_TEXT_100_COINS_STAR     "100 COINS STAR"
+#define DYNOS_LEVEL_TEXT_RED_COINS_STAR     "RED COINS STAR"
+#define DYNOS_LEVEL_TEXT_ONE_SECRET_STAR    "ONE OF THE CASTLE'S SECRET STARS!"
+
+static void SetConvertedTextToBuffer(u8 *aBuffer, const char *aText) {
+    u8 *_ConvertedText = DynOS_String_Convert(aText, false);
+    memcpy(aBuffer, _ConvertedText, DynOS_String_Length(_ConvertedText) + 1);
+}
+
+//
+// Data
+//
+
+struct DynosWarp {
+/* 0 */ s16 mArea = 0;
+/* 1 */ s16 mId = 0;
+/* 2 */ s16 mType = -1;
+/* 3 */ s16 mPosX = 0;
+/* 4 */ s16 mPosY = 0;
+/* 5 */ s16 mPosZ = 0;
+/* 6 */ s16 mAngle = 0;
+/* 7 */ s16 mDestLevel = 0;
+/* 8 */ s16 mDestArea = 0;
+/* 9 */ s16 mDestId = 0;
+};
+
+static void *sDynosLevelScripts[LEVEL_COUNT] = { NULL };
+static Array<DynosWarp> sDynosLevelWarps[LEVEL_COUNT] = { Array<DynosWarp>() };
+static Array<s32> sDynosLevelList = Array<s32>(); // Ordered by Course Id, COURSE_NONE excluded
+
+static u64 DynOS_Level_CmdGet(void *aCmd, u64 aOffset) {
+    u64 _Offset = (((aOffset) & 3llu) | (((aOffset) & ~3llu) << (sizeof(void *) >> 3llu)));
+    return *((u64 *) (u64(aCmd) + _Offset));
+}
+
+static void *DynOS_Level_CmdNext(void *aCmd, u64 aCmdSize) {
+    u64 _Offset = (((aCmdSize) & 3llu) | (((aCmdSize) & ~3llu) << (sizeof(void *) >> 3llu)));
+    return (void *) (u64(aCmd) + _Offset);
+}
+
+static void DynOS_Level_ParseScript(const void *aScript, s32 (*aPreprocessFunction)(u8, void *));
+
+//
+// Init
+//
+
+static s32 DynOS_Level_PreprocessMasterScript(u8 aType, void *aCmd) {
+    static bool sDynosScriptExecLevelTable = false;
+    static s32 sDynosLevelNum = -1;
+    
+    if (!sDynosScriptExecLevelTable) {
+
+        // JUMP_LINK
+        if (aType == 0x06) {
+            sDynosScriptExecLevelTable = true;
+            return 0;
+        }
+
+    } else {
+
+        // JUMP_IF
+        if (aType == 0x0C) {
+            sDynosLevelNum = (s32) DynOS_Level_CmdGet(aCmd, 0x04);
+            return 0;
+        }
+
+        // EXECUTE
+        if (aType == 0x00) {
+            void *_Script = (void *) DynOS_Level_CmdGet(aCmd, 0x0C);
+            if (sDynosLevelNum >= 0 && sDynosLevelNum < LEVEL_COUNT && !sDynosLevelScripts[sDynosLevelNum]) {
+                sDynosLevelScripts[sDynosLevelNum] = _Script;
+            }
+            sDynosLevelNum = -1;
+            return 2;
+        }
+
+        // EXIT
+        if (aType == 0x02) {
+            return 3;
+        }
+
+        // SLEEP
+        if (aType == 0x03) {
+            return 3;
+        }
+    }
+    return 0;
+}
+
+static s32 sDynosCurrentLevelNum;
+static s32 DynOS_Level_PreprocessScript(u8 aType, void *aCmd) {
+    static u8 sDynosAreaIndex = 0;
+    static auto _GetWarpStruct = [](u8 aArea, u8 aId) -> DynosWarp * {
+        for (s32 i = 0; i != sDynosLevelWarps[sDynosCurrentLevelNum].Count(); ++i) {
+            if (sDynosLevelWarps[sDynosCurrentLevelNum][i].mArea == aArea &&
+                sDynosLevelWarps[sDynosCurrentLevelNum][i].mId == aId) {
+                return &sDynosLevelWarps[sDynosCurrentLevelNum][i];
+            }
+        }
+        DynosWarp _Warp;
+        _Warp.mArea = aArea;
+        _Warp.mId = aId;
+        sDynosLevelWarps[sDynosCurrentLevelNum].Add(_Warp);
+        return &sDynosLevelWarps[sDynosCurrentLevelNum][sDynosLevelWarps[sDynosCurrentLevelNum].Count() - 1];
+    };
+
+    // AREA
+    if (aType == 0x1F) {
+        sDynosAreaIndex = (u8) DynOS_Level_CmdGet(aCmd, 2);
+    }
+
+    // OBJECT
+    else if (aType == 0x24) {
+        const BehaviorScript *bhv = (const BehaviorScript *) DynOS_Level_CmdGet(aCmd, 20);
+        for (s32 i = 0; i < 20; ++i) {
+            if (sWarpBhvSpawnTable[i] == bhv) {
+                DynosWarp *_Warp = _GetWarpStruct(sDynosAreaIndex, ((((u32) DynOS_Level_CmdGet(aCmd, 16)) >> 16) & 0xFF));
+                if (_Warp->mType == -1) {
+                    _Warp->mType = i;
+                    _Warp->mPosX = (s16) DynOS_Level_CmdGet(aCmd, 4);
+                    _Warp->mPosY = (s16) DynOS_Level_CmdGet(aCmd, 6);
+                    _Warp->mPosZ = (s16) DynOS_Level_CmdGet(aCmd, 8);
+                    _Warp->mAngle = (s16)((((s32)((s16) DynOS_Level_CmdGet(aCmd, 12))) * 0x8000) / 180);
+                }
+                break;
+            }
+        }
+    }
+
+    // WARP_NODE
+    else if (aType == 0x26) {
+        DynosWarp *_Warp = _GetWarpStruct(sDynosAreaIndex, (u8) DynOS_Level_CmdGet(aCmd, 2));
+        if (_Warp->mDestLevel == 0) {
+            _Warp->mDestLevel = (u8) DynOS_Level_CmdGet(aCmd, 3);
+            _Warp->mDestArea = (u8) DynOS_Level_CmdGet(aCmd, 4);
+            _Warp->mDestId = (u8) DynOS_Level_CmdGet(aCmd, 5);
+        }
+    }
+
+    // PAINTING_WARP_NODE
+    else if (aType == 0x27) {
+        DynosWarp *_Warp = _GetWarpStruct(sDynosAreaIndex, (u8) DynOS_Level_CmdGet(aCmd, 2));
+        if (_Warp->mDestLevel == 0) {
+            _Warp->mDestLevel = (u8) DynOS_Level_CmdGet(aCmd, 3);
+            _Warp->mDestArea = (u8) DynOS_Level_CmdGet(aCmd, 4);
+            _Warp->mDestId = (u8) DynOS_Level_CmdGet(aCmd, 5);
+        }
+    }
+
+    // SLEEP
+    // SLEEP_BEFORE_EXIT
+    else if (aType == 0x03 || aType == 0x04) {
+        return 3;
+    }
+
+    return 0;
+}
+
+// Runs only once
+static void DynOS_Level_Init() {
+    static bool sInited = false;
+    if (!sInited) {
+
+        // Level scripts
+        DynOS_Level_ParseScript(level_main_scripts_entry, DynOS_Level_PreprocessMasterScript);
+
+        // Level warps
+        for (sDynosCurrentLevelNum = 0; sDynosCurrentLevelNum != LEVEL_COUNT; ++sDynosCurrentLevelNum) {
+            if (sDynosLevelScripts[sDynosCurrentLevelNum]) {
+                DynOS_Level_ParseScript(sDynosLevelScripts[sDynosCurrentLevelNum], DynOS_Level_PreprocessScript);
+            }
+        }
+
+        // Level list ordered by course id
+        for (s32 i = COURSE_MIN; i <= COURSE_MAX; ++i) {
+            if (i == COURSE_CAKE_END) continue;
+            for (s32 j = 1; j != LEVEL_COUNT; ++j) {
+                if (gLevelToCourseNumTable[j - 1] == i) {
+                    sDynosLevelList.Add(j);
+                }
+            }
+        }
+
+        // Done
+        sInited = true;
+    }
+}
+
+//
+// Common
+//
+
+s32 DynOS_Level_GetCount() {
+    DynOS_Level_Init();
+    return sDynosLevelList.Count();
+}
+
+const s32 *DynOS_Level_GetList() {
+    DynOS_Level_Init();
+    return sDynosLevelList.begin();
+}
+
+s32 DynOS_Level_GetCourse(s32 aLevel) {
+    return (s32) gLevelToCourseNumTable[aLevel - 1];
+}
+
+const void *DynOS_Level_GetScript(s32 aLevel) {
+    DynOS_Level_Init();
+    return sDynosLevelScripts[aLevel];
+}
+
+//
+// Course name
+//
+
+const u8 *DynOS_Level_GetName(s32 aLevel, bool aDecaps, bool aAddCourseNumber) {
+    DynOS_Level_Init();
+    static u8 sBuffer[256];
+    memset(sBuffer, 0xFF, 256);
+    s32 _Course = DynOS_Level_GetCourse(aLevel);
+
+    // Level name
+    if (aLevel == LEVEL_BOWSER_1) {
+        SetConvertedTextToBuffer(sBuffer, DYNOS_LEVEL_TEXT_BOWSER_1);
+    } else if (aLevel == LEVEL_BOWSER_2) {
+        SetConvertedTextToBuffer(sBuffer, DYNOS_LEVEL_TEXT_BOWSER_2);
+    } else if (aLevel == LEVEL_BOWSER_3) {
+        SetConvertedTextToBuffer(sBuffer, DYNOS_LEVEL_TEXT_BOWSER_3);
+    } else if (_Course < COURSE_BOB) {
+        SetConvertedTextToBuffer(sBuffer, DYNOS_LEVEL_TEXT_CASTLE);
+    } else if (_Course >= COURSE_CAKE_END) {
+        SetConvertedTextToBuffer(sBuffer, DYNOS_LEVEL_TEXT_CASTLE);
+    } else {
+        const u8 *_CourseName = ((const u8 **) seg2_course_name_table)[_Course - COURSE_BOB] + 3;
+        memcpy(sBuffer, _CourseName, DynOS_String_Length(_CourseName));
+    }
+
+    // Decaps
+    if (aDecaps) {
+        DynOS_String_Decapitalize(sBuffer);
+    }
+
+    // Course number
+    if (aAddCourseNumber && (_Course >= COURSE_BOB) && (_Course <= COURSE_STAGES_MAX)) {
+        memmove(sBuffer + 5, sBuffer, DynOS_String_Length(sBuffer));
+        sBuffer[0] = ((_Course / 10) == 0 ? 158 : (_Course / 10));
+        sBuffer[1] = (_Course % 10);
+        sBuffer[2] = 158;
+        sBuffer[3] = 159;
+        sBuffer[4] = 158;
+    }
+
+    return sBuffer;
+}
+
+//
+// Act/Star name
+//
+
+const u8 *DynOS_Level_GetActName(s32 aLevel, s32 aAct, bool aDecaps, bool aAddStarNumber) {
+    DynOS_Level_Init();
+    static u8 sBuffer[256];
+    memset(sBuffer, 0xFF, 256);
+    s32 _Course = DynOS_Level_GetCourse(aLevel);
+
+    // Star name
+    if (_Course < COURSE_BOB) {
+        SetConvertedTextToBuffer(sBuffer, DYNOS_LEVEL_TEXT_ONE_SECRET_STAR);
+    } else if (aLevel == LEVEL_BITDW) {
+        SetConvertedTextToBuffer(sBuffer, DYNOS_LEVEL_TEXT_RED_COINS_STAR);
+    } else if (aLevel == LEVEL_BITFS) {
+        SetConvertedTextToBuffer(sBuffer, DYNOS_LEVEL_TEXT_RED_COINS_STAR);
+    } else if (aLevel == LEVEL_BITS) {
+        SetConvertedTextToBuffer(sBuffer, DYNOS_LEVEL_TEXT_RED_COINS_STAR);
+    } else if (_Course > COURSE_STAGES_MAX) {
+        SetConvertedTextToBuffer(sBuffer, DYNOS_LEVEL_TEXT_EMPTY);
+    } else if (aAct >= 7) {
+        SetConvertedTextToBuffer(sBuffer, DYNOS_LEVEL_TEXT_100_COINS_STAR);
+    } else {
+        const u8 *_ActName = ((const u8 **) seg2_act_name_table)[(_Course - COURSE_BOB) * 6 + (aAct - 1)];
+        memcpy(sBuffer, _ActName, DynOS_String_Length(_ActName));
+    }
+
+    // Decaps
+    if (aDecaps) {
+        DynOS_String_Decapitalize(sBuffer);
+    }
+
+    // Star number
+    if (aAddStarNumber && (_Course >= COURSE_BOB) && (_Course <= COURSE_STAGES_MAX)) {
+        memmove(sBuffer + 5, sBuffer, DynOS_String_Length(sBuffer));
+        sBuffer[0] = ((aAct / 10) == 0 ? 158 : (aAct / 10));
+        sBuffer[1] = (aAct % 10);
+        sBuffer[2] = 158;
+        sBuffer[3] = 159;
+        sBuffer[4] = 158;
+    }
+
+    return sBuffer;
+}
+
+const u8 *DynOS_Level_GetAreaName(s32 aLevel, s32 aArea, bool aDecaps) {
+    DynOS_Level_Init();
+    static const char *sAreaNamesPerLevel[][4] = {
+        { "", "", "", "" },
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* BoB */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* WF */
+        { "MAIN AREA", "SUNKEN SHIP", "NOT AVAILABLE", "NOT AVAILABLE" }, /* JRB */
+        { "MAIN AREA", "COTTAGE SLIDE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* CCM */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* BBH */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* HMC */
+        { "MAIN AREA", "VOLCANO", "NOT AVAILABLE", "NOT AVAILABLE" }, /* LLL */
+        { "MAIN AREA", "PYRAMID", "EYEROCK'S ROOM", "NOT AVAILABLE" }, /* SSL */
+        { "MAIN AREA", "DOCKS", "NOT AVAILABLE", "NOT AVAILABLE" }, /* DDD */
+        { "MAIN AREA", "IGLOO", "NOT AVAILABLE", "NOT AVAILABLE" }, /* SL */
+        { "MAIN AREA", "DOWNTOWN", "NOT AVAILABLE", "NOT AVAILABLE" }, /* WDW */
+        { "MAIN AREA", "SECRET SLIDE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* TTM */
+        { "HUGE ISLAND", "TINY ISLAND", "WIGGLER'S ROOM", "NOT AVAILABLE" }, /* THI */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* TTC */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* RR */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* BITDW */
+        { "BOWSER BATTLE", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* Bowser 1 */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* BITFS */
+        { "BOWSER BATTLE", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* Bowser 2 */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* BITS */
+        { "BOWSER BATTLE", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* Bowser 3 */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* PSS */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* TOTWC */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* COTMC */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* VCUTM */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* WMOTR */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* SA */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* Castle grounds */
+        { "FIRST FLOOR", "SECOND FLOOR", "BASEMENT", "NOT AVAILABLE" }, /* Castle inside */
+        { "MAIN AREA", "NOT AVAILABLE", "NOT AVAILABLE", "NOT AVAILABLE" }, /* Castle courtyard */
+    };
+    static u8 sBuffer[256];
+    memset(sBuffer, 0xFF, 256);
+
+    // Area name
+    switch (aLevel) {
+        case LEVEL_BOB: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[1][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_WF: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[2][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_JRB: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[3][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_CCM: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[4][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_BBH: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[5][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_HMC: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[6][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_LLL: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[7][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_SSL: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[8][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_DDD: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[9][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_SL: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[10][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_WDW: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[11][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_TTM: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[12][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_THI: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[13][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_TTC: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[14][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_RR: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[15][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_BITDW: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[16][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_BOWSER_1: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[17][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_BITFS: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[18][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_BOWSER_2: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[19][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_BITS: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[20][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_BOWSER_3: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[21][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_PSS: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[22][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_TOTWC: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[23][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_COTMC: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[24][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_VCUTM: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[25][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_WMOTR: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[26][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_SA: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[27][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_CASTLE_GROUNDS: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[28][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_CASTLE: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[29][MIN(MAX(aArea - 1, 0), 3)]); break;
+        case LEVEL_CASTLE_COURTYARD: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[30][MIN(MAX(aArea - 1, 0), 3)]); break;
+        default: SetConvertedTextToBuffer(sBuffer, sAreaNamesPerLevel[0][MIN(MAX(aArea - 1, 0), 3)]); break;
+    }
+
+    // Decaps
+    if (aDecaps) {
+        DynOS_String_Decapitalize(sBuffer);
+    }
+    return sBuffer;
+}
+
+//
+// Level Script Preprocessing
+// By default,
+// - Ifs are always true
+// - Skips are always false
+// - Loops break after the first loop
+//
+
+struct LvlCmd {
+    u8 mType;
+    u8 mSize;
+};
+
+struct Stack {
+    u64 mData[32];
+    s32 mBaseIndex;
+    s32 mTopIndex;
+};
+
+template <typename T>
+static void StackPush(Stack& aStack, const T &aValue) {
+    if (aStack.mTopIndex >= 0) {
+        aStack.mData[aStack.mTopIndex] = u64(aValue);
+        aStack.mTopIndex++;
+    }
+}
+
+template <typename T>
+static T StackPop(Stack& aStack) {
+    if (aStack.mTopIndex <= 0) {
+        return (T) 0;
+    }
+    aStack.mTopIndex--;
+    return (T) aStack.mData[aStack.mTopIndex];
+}
+
+static LvlCmd *DynOS_Level_CmdExecute(Stack &aStack, LvlCmd *aCmd) {
+    StackPush(aStack, DynOS_Level_CmdNext(aCmd, aCmd->mSize));
+    StackPush(aStack, aStack.mBaseIndex);
+    aStack.mBaseIndex = aStack.mTopIndex;
+    return (LvlCmd *) DynOS_Level_CmdGet(aCmd, 12);
+}
+
+static LvlCmd *DynOS_Level_CmdExitAndExecute(Stack &aStack, LvlCmd *aCmd) {
+    aStack.mTopIndex = aStack.mBaseIndex;
+    return (LvlCmd *) DynOS_Level_CmdGet(aCmd, 12);
+}
+
+static LvlCmd *DynOS_Level_CmdExit(Stack &aStack, LvlCmd *aCmd) {
+    aStack.mTopIndex = aStack.mBaseIndex;
+    aStack.mBaseIndex = StackPop<s32>(aStack);
+    return StackPop<LvlCmd *>(aStack);
+}
+
+static LvlCmd *DynOS_Level_CmdSleep(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSleepBeforeExit(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdJump(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdGet(aCmd, 4);
+}
+
+static LvlCmd *DynOS_Level_CmdJumpLink(Stack &aStack, LvlCmd *aCmd) {
+    StackPush(aStack, DynOS_Level_CmdNext(aCmd, aCmd->mSize));
+    return (LvlCmd *) DynOS_Level_CmdGet(aCmd, 4);
+}
+
+static LvlCmd *DynOS_Level_CmdReturn(Stack &aStack, UNUSED LvlCmd *aCmd) {
+    return StackPop<LvlCmd *>(aStack);
+}
+
+static LvlCmd *DynOS_Level_CmdJumpLinkPushArg(Stack &aStack, LvlCmd *aCmd) {
+    StackPush(aStack, DynOS_Level_CmdNext(aCmd, aCmd->mSize));
+    StackPush(aStack, DynOS_Level_CmdGet(aCmd, 2));
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdJumpRepeat(Stack &aStack, LvlCmd *aCmd) {
+    aStack.mTopIndex -= 2;
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdLoopBegin(Stack &aStack, LvlCmd *aCmd) {
+    StackPush(aStack, DynOS_Level_CmdNext(aCmd, aCmd->mSize));
+    StackPush(aStack, 0);
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdLoopUntil(Stack &aStack, LvlCmd *aCmd) {
+    aStack.mTopIndex -= 2;
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdJumpIf(Stack &aStack, LvlCmd *aCmd) {
+    StackPush(aStack, DynOS_Level_CmdNext(aCmd, aCmd->mSize)); /* Not an error, that's intentional */
+    return (LvlCmd *) DynOS_Level_CmdGet(aCmd, 8);
+}
+
+static LvlCmd *DynOS_Level_CmdJumpLinkIf(Stack &aStack, LvlCmd *aCmd) {
+    StackPush(aStack, DynOS_Level_CmdNext(aCmd, aCmd->mSize));
+    return (LvlCmd *) DynOS_Level_CmdGet(aCmd, 8);
+}
+
+static LvlCmd *DynOS_Level_CmdSkipIf(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSkip(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSkipNop(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdCall(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdCallLoop(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSetRegister(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdPushPool(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdPopPool(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdLoadFixed(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdLoadRaw(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdLoadMIO0(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdLoadMarioHead(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdLoadMIO0Texture(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdInitLevel(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdClearLevel(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdAllocLevelPool(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdFreeLevelPool(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdBeginArea(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdEndArea(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdLoadModelFromDL(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdLoadModelFromGeo(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_Cmd23(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdMario(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdObject(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdWarpNode(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdInstantWarp(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSetTerrainType(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdPaintingWarpNode(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_Cmd3A(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSetWhirlpool(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSetBlackout(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSetGamma(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSetTerrain(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSetRooms(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdMacroObjects(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdLoadArea(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdUnloadArea(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSetMarioStartPos(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_Cmd2C(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_Cmd2D(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSetTransition(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdNop(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdShowDialog(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSetBackgroundMusic(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdSetMenuMusic(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdStopMusic(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdGetOrSet(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdAdvanceDemo(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdClearDemoPointer(Stack &aStack, LvlCmd *aCmd) {
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static LvlCmd *DynOS_Level_CmdJumpArea(Stack &aStack, LvlCmd *aCmd, s32 (*aPreprocessFunction)(u8, void *)) {
+    DynOS_Level_ParseScript((const void *) DynOS_Level_CmdGet(aCmd, 8), aPreprocessFunction);
+    return (LvlCmd *) DynOS_Level_CmdNext(aCmd, aCmd->mSize);
+}
+
+static void DynOS_Level_ParseScript(const void *aScript, s32 (*aPreprocessFunction)(u8, void *)) {
+    Stack _Stack;
+    _Stack.mBaseIndex = -1;
+    _Stack.mTopIndex = 0;
+    for (LvlCmd *_Cmd = (LvlCmd *) aScript; _Cmd != NULL;) {
+        u8 _CmdType = (_Cmd->mType & 0x3F);
+        s32 _Action = aPreprocessFunction(_CmdType, (void *) _Cmd);
+        switch (_Action) {
+            case 0:
+                switch (_CmdType) {
+                    case 0x00: _Cmd = DynOS_Level_CmdExecute(_Stack, _Cmd); break;
+                    case 0x01: _Cmd = DynOS_Level_CmdExitAndExecute(_Stack, _Cmd); break;
+                    case 0x02: _Cmd = DynOS_Level_CmdExit(_Stack, _Cmd); break;
+                    case 0x03: _Cmd = DynOS_Level_CmdSleep(_Stack, _Cmd); break;
+                    case 0x04: _Cmd = DynOS_Level_CmdSleepBeforeExit(_Stack, _Cmd); break;
+                    case 0x05: _Cmd = DynOS_Level_CmdJump(_Stack, _Cmd); break;
+                    case 0x06: _Cmd = DynOS_Level_CmdJumpLink(_Stack, _Cmd); break;
+                    case 0x07: _Cmd = DynOS_Level_CmdReturn(_Stack, _Cmd); break;
+                    case 0x08: _Cmd = DynOS_Level_CmdJumpLinkPushArg(_Stack, _Cmd); break;
+                    case 0x09: _Cmd = DynOS_Level_CmdJumpRepeat(_Stack, _Cmd); break;
+                    case 0x0A: _Cmd = DynOS_Level_CmdLoopBegin(_Stack, _Cmd); break;
+                    case 0x0B: _Cmd = DynOS_Level_CmdLoopUntil(_Stack, _Cmd); break;
+                    case 0x0C: _Cmd = DynOS_Level_CmdJumpIf(_Stack, _Cmd); break;
+                    case 0x0D: _Cmd = DynOS_Level_CmdJumpLinkIf(_Stack, _Cmd); break;
+                    case 0x0E: _Cmd = DynOS_Level_CmdSkipIf(_Stack, _Cmd); break;
+                    case 0x0F: _Cmd = DynOS_Level_CmdSkip(_Stack, _Cmd); break;
+                    case 0x10: _Cmd = DynOS_Level_CmdSkipNop(_Stack, _Cmd); break;
+                    case 0x11: _Cmd = DynOS_Level_CmdCall(_Stack, _Cmd); break;
+                    case 0x12: _Cmd = DynOS_Level_CmdCallLoop(_Stack, _Cmd); break;
+                    case 0x13: _Cmd = DynOS_Level_CmdSetRegister(_Stack, _Cmd); break;
+                    case 0x14: _Cmd = DynOS_Level_CmdPushPool(_Stack, _Cmd); break;
+                    case 0x15: _Cmd = DynOS_Level_CmdPopPool(_Stack, _Cmd); break;
+                    case 0x16: _Cmd = DynOS_Level_CmdLoadFixed(_Stack, _Cmd); break;
+                    case 0x17: _Cmd = DynOS_Level_CmdLoadRaw(_Stack, _Cmd); break;
+                    case 0x18: _Cmd = DynOS_Level_CmdLoadMIO0(_Stack, _Cmd); break;
+                    case 0x19: _Cmd = DynOS_Level_CmdLoadMarioHead(_Stack, _Cmd); break;
+                    case 0x1A: _Cmd = DynOS_Level_CmdLoadMIO0Texture(_Stack, _Cmd); break;
+                    case 0x1B: _Cmd = DynOS_Level_CmdInitLevel(_Stack, _Cmd); break;
+                    case 0x1C: _Cmd = DynOS_Level_CmdClearLevel(_Stack, _Cmd); break;
+                    case 0x1D: _Cmd = DynOS_Level_CmdAllocLevelPool(_Stack, _Cmd); break;
+                    case 0x1E: _Cmd = DynOS_Level_CmdFreeLevelPool(_Stack, _Cmd); break;
+                    case 0x1F: _Cmd = DynOS_Level_CmdBeginArea(_Stack, _Cmd); break;
+                    case 0x20: _Cmd = DynOS_Level_CmdEndArea(_Stack, _Cmd); break;
+                    case 0x21: _Cmd = DynOS_Level_CmdLoadModelFromDL(_Stack, _Cmd); break;
+                    case 0x22: _Cmd = DynOS_Level_CmdLoadModelFromGeo(_Stack, _Cmd); break;
+                    case 0x23: _Cmd = DynOS_Level_Cmd23(_Stack, _Cmd); break;
+                    case 0x24: _Cmd = DynOS_Level_CmdObject(_Stack, _Cmd); break;
+                    case 0x25: _Cmd = DynOS_Level_CmdMario(_Stack, _Cmd); break;
+                    case 0x26: _Cmd = DynOS_Level_CmdWarpNode(_Stack, _Cmd); break;
+                    case 0x27: _Cmd = DynOS_Level_CmdPaintingWarpNode(_Stack, _Cmd); break;
+                    case 0x28: _Cmd = DynOS_Level_CmdInstantWarp(_Stack, _Cmd); break;
+                    case 0x29: _Cmd = DynOS_Level_CmdLoadArea(_Stack, _Cmd); break;
+                    case 0x2A: _Cmd = DynOS_Level_CmdUnloadArea(_Stack, _Cmd); break;
+                    case 0x2B: _Cmd = DynOS_Level_CmdSetMarioStartPos(_Stack, _Cmd); break;
+                    case 0x2C: _Cmd = DynOS_Level_Cmd2C(_Stack, _Cmd); break;
+                    case 0x2D: _Cmd = DynOS_Level_Cmd2D(_Stack, _Cmd); break;
+                    case 0x2E: _Cmd = DynOS_Level_CmdSetTerrain(_Stack, _Cmd); break;
+                    case 0x2F: _Cmd = DynOS_Level_CmdSetRooms(_Stack, _Cmd); break;
+                    case 0x30: _Cmd = DynOS_Level_CmdShowDialog(_Stack, _Cmd); break;
+                    case 0x31: _Cmd = DynOS_Level_CmdSetTerrainType(_Stack, _Cmd); break;
+                    case 0x32: _Cmd = DynOS_Level_CmdNop(_Stack, _Cmd); break;
+                    case 0x33: _Cmd = DynOS_Level_CmdSetTransition(_Stack, _Cmd); break;
+                    case 0x34: _Cmd = DynOS_Level_CmdSetBlackout(_Stack, _Cmd); break;
+                    case 0x35: _Cmd = DynOS_Level_CmdSetGamma(_Stack, _Cmd); break;
+                    case 0x36: _Cmd = DynOS_Level_CmdSetBackgroundMusic(_Stack, _Cmd); break;
+                    case 0x37: _Cmd = DynOS_Level_CmdSetMenuMusic(_Stack, _Cmd); break;
+                    case 0x38: _Cmd = DynOS_Level_CmdStopMusic(_Stack, _Cmd); break;
+                    case 0x39: _Cmd = DynOS_Level_CmdMacroObjects(_Stack, _Cmd); break;
+                    case 0x3A: _Cmd = DynOS_Level_Cmd3A(_Stack, _Cmd); break;
+                    case 0x3B: _Cmd = DynOS_Level_CmdSetWhirlpool(_Stack, _Cmd); break;
+                    case 0x3C: _Cmd = DynOS_Level_CmdGetOrSet(_Stack, _Cmd); break;
+                    case 0x3D: _Cmd = DynOS_Level_CmdAdvanceDemo(_Stack, _Cmd); break;
+                    case 0x3E: _Cmd = DynOS_Level_CmdClearDemoPointer(_Stack, _Cmd); break;
+                    case 0x3F: _Cmd = DynOS_Level_CmdJumpArea(_Stack, _Cmd, aPreprocessFunction); break;
+                } break;
+
+            case 1:
+                _Cmd = (LvlCmd *) DynOS_Level_CmdNext(_Cmd, _Cmd->mSize);
+                break;
+
+            case 2:
+                _Cmd = DynOS_Level_CmdReturn(_Stack, _Cmd);
+                break;
+
+            case 3:
+                return;
+        }
+    }
+}
+
+//
+// Level Script Utilities
+//
+
+s16 *DynOS_Level_GetWarp(s32 aLevel, s32 aArea, u8 aWarpId) {
+    DynOS_Level_Init();
+    for (const auto &_Warp : sDynosLevelWarps[aLevel]) {
+        if (_Warp.mArea == aArea && _Warp.mId == aWarpId) {
+            return (s16 *) &_Warp;
+        }
+    }
+    return NULL;
+}
+
+s16 *DynOS_Level_GetWarpEntry(s32 aLevel, s32 aArea) {
+    DynOS_Level_Init();
+    if (aLevel == LEVEL_TTM && aArea > 2) return NULL;
+    return DynOS_Level_GetWarp(aLevel, aArea, 0x0A);
+}
+
+s16 *DynOS_Level_GetWarpDeath(s32 aLevel, s32 aArea) {
+    DynOS_Level_Init();
+    s16 *_Warp = DynOS_Level_GetWarp(aLevel, aArea, 0xF1);
+    if (!_Warp) _Warp = DynOS_Level_GetWarp(aLevel, aArea, 0xF3);
+    return _Warp;
+}
+
diff --git a/data/dynos_main.cpp b/data/dynos_main.cpp
new file mode 100644
index 00000000..9605006b
--- /dev/null
+++ b/data/dynos_main.cpp
@@ -0,0 +1,133 @@
+#include "dynos.cpp.h"
+extern "C" {
+#include "sm64.h"
+#include "level_commands.h"
+#include "game/level_update.h"
+#include "game/options_menu.h"
+#include "game/object_list_processor.h"
+extern s16 gMenuMode;
+extern s8 gDialogBoxState;
+#ifdef OMM_DEFINES_H
+extern void omm_opt_init();
+#endif
+}
+
+#ifdef DYNOS_COOP
+//
+// Network (Coop only)
+//
+
+extern "C" {
+#include "pc/network/network.h"
+}
+
+static struct DynosCoopCommandStruct {
+    s32 mType = DYNOS_COOP_COMMAND_NONE;
+    s32 mLevel = 0;
+    s32 mArea = 0;
+    s32 mAct = 0;
+} sDynosCoopCommand;
+static u8 sDynosCoopCustomPacketId = 0xFF;
+
+static void DynOS_Coop_SendPacket(struct Packet *p, UNUSED void *params) {
+    packet_write(p, &sDynosCoopCommand, sizeof(DynosCoopCommandStruct));
+}
+
+static void DynOS_Coop_ReceivePacket(struct Packet *p) {
+    packet_read(p, &sDynosCoopCommand, sizeof(DynosCoopCommandStruct));
+}
+
+static void DynOS_Coop_Update() {
+    if (sDynosCoopCustomPacketId == 0xFF) {
+        network_register_mod((char *) "DynOS.1.0.coop");
+        sDynosCoopCustomPacketId = network_register_custom_packet(DynOS_Coop_SendPacket, DynOS_Coop_ReceivePacket);
+    }
+
+    // Commands
+    switch (sDynosCoopCommand.mType) {
+        case DYNOS_COOP_COMMAND_WARP_TO_LEVEL: {
+            DynOS_Warp_ToLevel(sDynosCoopCommand.mLevel, sDynosCoopCommand.mArea, sDynosCoopCommand.mAct);
+        } break;
+
+        case DYNOS_COOP_COMMAND_WARP_TO_CASTLE: {
+            DynOS_Warp_ToCastle(sDynosCoopCommand.mLevel);
+        } break;
+
+        case DYNOS_COOP_COMMAND_RESTART_LEVEL: {
+            DynOS_Warp_RestartLevel();
+        } break;
+
+        case DYNOS_COOP_COMMAND_EXIT_LEVEL: {
+            DynOS_Warp_ExitLevel(30);
+        } break;
+    }
+    sDynosCoopCommand.mType = DYNOS_COOP_COMMAND_NONE;
+}
+
+void DynOS_Coop_SendCommand(s32 aType, s32 aLevel, s32 aArea, s32 aAct) {
+    sDynosCoopCommand.mType = aType;
+    sDynosCoopCommand.mLevel = aLevel;
+    sDynosCoopCommand.mArea = aArea;
+    sDynosCoopCommand.mAct = aAct;
+    network_send_custom(sDynosCoopCustomPacketId, true, false, NULL);
+    sDynosCoopCommand.mType = DYNOS_COOP_COMMAND_NONE;
+}
+#endif
+
+//
+// Main Menu
+//
+
+#ifndef DYNOS_COOP
+void DynOS_ReturnToMainMenu() {
+    optmenu_toggle();
+    level_set_transition(0, NULL);
+    gDialogBoxState = 0;
+    gMenuMode = -1;
+    fade_into_special_warp(-2, 0);
+}
+#endif
+
+//
+// Init
+//
+
+DYNOS_AT_STARTUP void DynOS_Init() {
+#ifdef OMM_DEFINES_H
+    omm_opt_init();
+#endif
+    DynOS_Opt_Init();
+}
+
+//
+// Update
+//
+
+static bool sDynosIsLevelEntry = false;
+void DynOS_UpdateOpt(void *aPad) {
+    if (sDynosIsLevelEntry) {
+#ifndef DYNOS_COOP
+        DynOS_Warp_SetParam(gCurrLevelNum, -1);
+#endif
+        sDynosIsLevelEntry = false;
+    }
+    DynOS_Opt_Update((OSContPad *) aPad);
+#ifdef DYNOS_COOP
+    DynOS_Coop_Update();
+#endif
+    gPrevFrameObjectCount = 0;
+}
+
+void *DynOS_UpdateCmd(void *aCmd) {
+    static const uintptr_t sCmdLevelEntry[] = { CALL(0, lvl_init_or_update) };
+    sDynosIsLevelEntry |= (memcmp(aCmd, sCmdLevelEntry, sizeof(sCmdLevelEntry)) == 0);
+    return DynOS_Warp_Update(aCmd, sDynosIsLevelEntry);
+}
+
+void DynOS_UpdateGfx() {
+    DynOS_Gfx_Update();
+}
+
+bool DynOS_IsTransitionActive() {
+    return gWarpTransition.isActive;
+}
diff --git a/data/dynos_misc.cpp b/data/dynos_misc.cpp
new file mode 100644
index 00000000..c9fadd83
--- /dev/null
+++ b/data/dynos_misc.cpp
@@ -0,0 +1,509 @@
+#include "dynos.cpp.h"
+extern "C" {
+#include "object_fields.h"
+#include "game/object_helpers.h"
+#include "game/segment2.h"
+#include "game/level_geo.h"
+#include "game/level_update.h"
+#include "game/moving_texture.h"
+#include "game/paintings.h"
+#include "game/geo_misc.h"
+#include "game/mario_misc.h"
+#include "game/mario_actions_cutscene.h"
+#include "game/screen_transition.h"
+#include "game/object_list_processor.h"
+#include "game/behavior_actions.h"
+#include "game/rendering_graph_node.h"
+#include "actors/common0.h"
+#include "actors/common1.h"
+#include "actors/group0.h"
+#include "actors/group1.h"
+#include "actors/group2.h"
+#include "actors/group3.h"
+#include "actors/group4.h"
+#include "actors/group5.h"
+#include "actors/group6.h"
+#include "actors/group7.h"
+#include "actors/group8.h"
+#include "actors/group9.h"
+#include "actors/group10.h"
+#include "actors/group11.h"
+#include "actors/group12.h"
+#include "actors/group13.h"
+#include "actors/group14.h"
+#include "actors/group15.h"
+#include "actors/group16.h"
+#include "actors/group17.h"
+#ifdef DYNOS_COOP
+extern const GeoLayout luigi_geo[];
+extern const GeoLayout luigis_cap_geo[];
+extern const GeoLayout luigis_metal_cap_geo[];
+extern const GeoLayout luigis_wing_cap_geo[];
+extern const GeoLayout luigis_winged_metal_cap_geo[];
+#endif
+}
+
+//
+// String
+//
+
+static const struct { const char *mStr; u8 mChar64; s32 mWidth; } sSm64CharMap[] = {
+    { "0",   0x00, 7 }, { "1",  0x01,  7 }, { "2",   0x02, 7 }, { "3",   0x03, 7 }, { "4",   0x04,  7 }, { "5",   0x05,  7 },
+    { "6",   0x06, 7 }, { "7",  0x07,  7 }, { "8",   0x08, 7 }, { "9",   0x09, 7 }, { "A",   0x0A,  6 }, { "B",   0x0B,  6 },
+    { "C",   0x0C, 6 }, { "D",  0x0D,  6 }, { "E",   0x0E, 6 }, { "F",   0x0F, 6 }, { "G",   0x10,  6 }, { "H",   0x11,  6 },
+    { "I",   0x12, 5 }, { "J",  0x13,  6 }, { "K",   0x14, 6 }, { "L",   0x15, 5 }, { "M",   0x16,  8 }, { "N",   0x17,  8 },
+    { "O",   0x18, 6 }, { "P",  0x19,  6 }, { "Q",   0x1A, 6 }, { "R",   0x1B, 6 }, { "S",   0x1C,  6 }, { "T",   0x1D,  5 },
+    { "U",   0x1E, 6 }, { "V",  0x1F,  6 }, { "W",   0x20, 8 }, { "X",   0x21, 7 }, { "Y",   0x22,  6 }, { "Z",   0x23,  6 },
+    { "a",   0x24, 6 }, { "b",  0x25,  5 }, { "c",   0x26, 5 }, { "d",   0x27, 6 }, { "e",   0x28,  5 }, { "f",   0x29,  5 },
+    { "g",   0x2A, 6 }, { "h",  0x2B,  5 }, { "i",   0x2C, 4 }, { "j",   0x2D, 5 }, { "k",   0x2E,  5 }, { "l",   0x2F,  3 },
+    { "m",   0x30, 7 }, { "n",  0x31,  5 }, { "o",   0x32, 5 }, { "p",   0x33, 5 }, { "q",   0x34,  6 }, { "r",   0x35,  5 },
+    { "s",   0x36, 5 }, { "t",  0x37,  5 }, { "u",   0x38, 5 }, { "v",   0x39, 5 }, { "w",   0x3A,  7 }, { "x",   0x3B,  7 },
+    { "y",   0x3C, 5 }, { "z",  0x3D,  5 }, { "\'",  0x3E, 4 }, { ".",   0x3F, 4 }, { "^",   0x50,  8 }, { "|",   0x51,  8 },
+    { "<",   0x52, 8 }, { ">",  0x53,  8 }, { "[A]", 0x54, 7 }, { "[B]", 0x55, 7 }, { "[C]", 0x56,  6 }, { "[Z]", 0x57,  7 },
+    { "[R]", 0x58, 7 }, { ",",  0x6F,  4 }, { " ",   0x9E, 5 }, { "-",   0x9F, 6 }, { "/",   0xD0, 10 }, { "[%]", 0xE0,  7 },
+    { "(",   0xE1, 5 }, { ")(", 0xE2, 10 }, { ")",   0xE3, 5 }, { "+",   0xE4, 9 }, { "&",   0xE5,  8 }, { ":",   0xE6,  4 },
+    { "!",   0xF2, 5 }, { "%",  0xF3,  7 }, { "?",   0xF4, 7 }, { "~",   0xF7, 8 }, { "$",   0xF9,  8 }, { "@",   0xFA, 10 },
+    { "*",   0xFB, 6 }, { "=",  0xFD, 10 }, { "\n",  0xFE, 0 },
+};
+
+static const char *DynOS_String_AddChar64(u8 *aStr64, const char *pStr, s32 &aIndex) {
+    for (const auto &c : sSm64CharMap) {
+        if (strstr(pStr, c.mStr) == pStr) {
+            aStr64[aIndex++] = c.mChar64;
+            return pStr + strlen(c.mStr);
+        }
+    }
+
+    // Put a space by default
+    aStr64[aIndex++] = 0x9E;
+    return pStr + 1;
+}
+
+u8 *DynOS_String_Convert(const char *aString, bool aHeapAlloc) {
+
+    // Allocation
+    static u8 sStringBuffer[8][2048];
+    static u32 sStringBufferIndex = 0;
+    u8 *_Str64;
+    if (aHeapAlloc) {
+        _Str64 = New<u8>(2048);
+    } else {
+        _Str64 = sStringBuffer[sStringBufferIndex];
+        sStringBufferIndex = (sStringBufferIndex + 1) % 8;
+    }
+
+    // Conversion
+    memset(_Str64, 0xFF, 2048);
+    const char *pStr = aString;
+    for (s32 i = 0; *pStr != 0 && i < 2047;) {
+        pStr = DynOS_String_AddChar64(_Str64, pStr, i);
+    }
+    return _Str64;
+}
+
+u8 *DynOS_String_Decapitalize(u8 *aStr64) {
+    bool _WasSpace = true;
+    for (u8 *pStr64 = aStr64; *pStr64 != 0xFF; pStr64++) {
+        if (*pStr64 >= 10 && *pStr64 <= 35) {
+            if (_WasSpace) _WasSpace = false;
+            else *pStr64 += 26;
+        } else if (*pStr64 >= 63) {
+            _WasSpace = true;
+        }
+    }
+    return aStr64;
+}
+
+s32 DynOS_String_Length(const u8 *aStr64) {
+    s32 _Length = 0;
+    for (; aStr64 && *aStr64 != 255; aStr64++, _Length++);
+    return _Length;
+}
+
+s32 DynOS_String_WidthChar64(u8 aChar64) {
+    for (const auto &c : sSm64CharMap) {
+        if (c.mChar64 == aChar64) {
+            return c.mWidth;
+        }
+    }
+    return 0;
+}
+
+s32 DynOS_String_Width(const u8 *aStr64) {
+    s32 _Width = 0;
+    for (; *aStr64 != 0xFF; aStr64++) {
+        _Width += DynOS_String_WidthChar64(*aStr64);
+    }
+    return _Width;
+}
+
+//
+// Geo
+//
+
+static void *geo_rotate_3d_coin(s32 callContext, void *node, UNUSED void *c) {
+    if (callContext == GEO_CONTEXT_RENDER) {
+        struct Object *obj = (struct Object *) gCurGraphNodeObject;
+        struct GraphNodeRotation *rotNode = (struct GraphNodeRotation *) ((struct GraphNode *) node)->next;
+        rotNode->rotation[0] = 0;
+        rotNode->rotation[1] = obj->oAnimState;
+        rotNode->rotation[2] = 0;
+        obj->oAnimState += 0x0800;
+    }
+    return NULL;
+}
+
+//
+// Actors
+//
+
+static const Array<Pair<const char *, void *>> &__Actors() {
+#define define_actor(geo) { #geo, (void *) geo }
+static const Array<Pair<const char *, void *>> sActors = {
+    define_actor(amp_geo),
+
+    define_actor(birds_geo),
+    define_actor(blargg_geo),
+    define_actor(blue_coin_switch_geo),
+    define_actor(black_bobomb_geo),
+    define_actor(bobomb_buddy_geo),
+    define_actor(boo_geo),
+    define_actor(boo_castle_geo),
+    define_actor(bookend_geo),
+    define_actor(bookend_part_geo),
+    define_actor(bowling_ball_geo),
+    define_actor(bowling_ball_track_geo),
+    define_actor(bowser_geo),
+    define_actor(bowser2_geo),
+    define_actor(bowser_bomb_geo),
+    define_actor(bowser_flames_geo),
+    define_actor(bowser_impact_smoke_geo),
+    define_actor(bowser_1_yellow_sphere_geo),
+    define_actor(invisible_bowser_accessory_geo),
+    define_actor(bowser_key_geo),
+    define_actor(bowser_key_cutscene_geo),
+    define_actor(breakable_box_geo),
+    define_actor(breakable_box_small_geo),
+    define_actor(bub_geo),
+    define_actor(bubba_geo),
+    define_actor(bubble_geo),
+    define_actor(bullet_bill_geo),
+    define_actor(bully_geo),
+    define_actor(bully_boss_geo),
+    define_actor(burn_smoke_geo),
+    define_actor(butterfly_geo),
+
+    define_actor(cannon_barrel_geo),
+    define_actor(cannon_base_geo),
+    define_actor(cap_switch_geo),
+    define_actor(cartoon_star_geo),
+    define_actor(chain_chomp_geo),
+    define_actor(checkerboard_platform_geo),
+    define_actor(chilly_chief_geo),
+    define_actor(chilly_chief_big_geo),
+    define_actor(chuckya_geo),
+    define_actor(clam_shell_geo),
+    define_actor(yellow_coin_geo),
+    define_actor(yellow_coin_no_shadow_geo),
+    define_actor(blue_coin_geo),
+    define_actor(blue_coin_no_shadow_geo),
+    define_actor(red_coin_geo),
+    define_actor(red_coin_no_shadow_geo),
+
+    define_actor(dirt_animation_geo),
+    define_actor(dorrie_geo),
+    define_actor(cabin_door_geo),
+    define_actor(castle_door_geo),
+    define_actor(castle_door_0_star_geo),
+    define_actor(castle_door_1_star_geo),
+    define_actor(castle_door_3_stars_geo),
+    define_actor(haunted_door_geo),
+    define_actor(hazy_maze_door_geo),
+    define_actor(metal_door_geo),
+    define_actor(key_door_geo),
+    define_actor(wooden_door_geo),
+
+    define_actor(enemy_lakitu_geo),
+    define_actor(exclamation_box_geo),
+    define_actor(exclamation_box_outline_geo),
+    define_actor(explosion_geo),
+    define_actor(eyerok_left_hand_geo),
+    define_actor(eyerok_right_hand_geo),
+
+    define_actor(fish_geo),
+    define_actor(cyan_fish_geo),
+    define_actor(flyguy_geo),
+    define_actor(red_flame_geo),
+    define_actor(red_flame_shadow_geo),
+    define_actor(blue_flame_geo),
+    define_actor(fwoosh_geo),
+
+    define_actor(goomba_geo),
+
+    define_actor(haunted_cage_geo),
+    define_actor(haunted_chair_geo),
+    define_actor(heart_geo),
+    define_actor(heave_ho_geo),
+    define_actor(hoot_geo),
+
+    define_actor(king_bobomb_geo),
+    define_actor(klepto_geo),
+    define_actor(koopa_with_shell_geo),
+    define_actor(koopa_without_shell_geo),
+    define_actor(koopa_flag_geo),
+    define_actor(koopa_shell_geo),
+
+    define_actor(lakitu_geo),
+#ifdef DYNOS_COOP
+    define_actor(luigi_geo),
+    define_actor(luigis_cap_geo),
+    define_actor(luigis_metal_cap_geo),
+    define_actor(luigis_wing_cap_geo),
+    define_actor(luigis_winged_metal_cap_geo),
+#endif
+
+    define_actor(mad_piano_geo),
+    define_actor(manta_seg5_geo_05008D14),
+    define_actor(mario_geo),
+    define_actor(marios_cap_geo),
+    define_actor(marios_metal_cap_geo),
+    define_actor(marios_wing_cap_geo),
+    define_actor(marios_winged_metal_cap_geo),
+    define_actor(metal_box_geo),
+    define_actor(metallic_ball_geo),
+    define_actor(mips_geo),
+    define_actor(mist_geo),
+    define_actor(moneybag_geo),
+    define_actor(monty_mole_geo),
+    define_actor(mr_blizzard_geo),
+    define_actor(mr_blizzard_hidden_geo),
+    define_actor(mr_i_geo),
+    define_actor(mr_i_iris_geo),
+    define_actor(mushroom_1up_geo),
+
+    define_actor(number_geo),
+
+    define_actor(peach_geo),
+    define_actor(penguin_geo),
+    define_actor(piranha_plant_geo),
+    define_actor(pokey_head_geo),
+    define_actor(pokey_body_part_geo),
+    define_actor(purple_marble_geo),
+    define_actor(purple_switch_geo),
+
+    define_actor(scuttlebug_geo),
+    define_actor(seaweed_geo),
+    define_actor(skeeter_geo),
+    define_actor(small_key_geo),
+    define_actor(small_water_splash_geo),
+    define_actor(smoke_geo),
+    define_actor(snufit_geo),
+    define_actor(sparkles_geo),
+    define_actor(sparkles_animation_geo),
+    define_actor(spindrift_geo),
+    define_actor(spiny_geo),
+    define_actor(spiny_ball_geo),
+    define_actor(star_geo),
+    define_actor(transparent_star_geo),
+    define_actor(sushi_geo),
+    define_actor(swoop_geo),
+
+    define_actor(thwomp_geo),
+    define_actor(toad_geo),
+    define_actor(treasure_chest_base_geo),
+    define_actor(treasure_chest_lid_geo),
+    define_actor(bubbly_tree_geo),
+    define_actor(spiky_tree_geo),
+    define_actor(snow_tree_geo),
+    define_actor(palm_tree_geo),
+    define_actor(leaves_geo),
+    define_actor(tweester_geo),
+
+    define_actor(ukiki_geo),
+    define_actor(unagi_geo),
+
+    define_actor(warp_pipe_geo),
+    define_actor(water_bomb_geo),
+    define_actor(water_bomb_shadow_geo),
+    define_actor(water_ring_geo),
+    define_actor(water_splash_geo),
+    define_actor(idle_water_wave_geo),
+    define_actor(wave_trail_geo),
+    define_actor(white_particle_geo),
+    define_actor(white_puff_geo),
+    define_actor(whomp_geo),
+    define_actor(wiggler_head_geo),
+    define_actor(wiggler_body_geo),
+    define_actor(wooden_post_geo),
+    define_actor(wooden_signpost_geo),
+
+    define_actor(yellow_sphere_geo),
+    define_actor(yoshi_geo),
+    define_actor(yoshi_egg_geo),
+};
+#undef define_actor
+return sActors;
+}
+#define sActors __Actors()
+
+s32 DynOS_Geo_GetActorCount() {
+    return sActors.Count();
+}
+
+const char *DynOS_Geo_GetActorName(s32 aIndex) {
+    return sActors[aIndex].first;
+}
+
+void *DynOS_Geo_GetActorLayout(s32 aIndex) {
+    return sActors[aIndex].second;
+}
+
+s32 DynOS_Geo_GetActorIndex(const void *aGeoLayout) {
+    for (const auto &_Actor : sActors) {
+        if (_Actor.second == aGeoLayout) {
+            return (s32) (&_Actor - sActors.begin());
+        }
+    }
+    return -1;
+}
+
+//
+// Geo Functions
+//
+
+static const Array<Pair<const char *, void *>> &__GeoFunctions() {
+#define define_geo_function(name) { #name, (void *) name }
+static const Array<Pair<const char *, void *>> sGeoFunctions = {
+    define_geo_function(geo_mirror_mario_set_alpha),
+    define_geo_function(geo_switch_mario_stand_run),
+    define_geo_function(geo_switch_mario_eyes),
+    define_geo_function(geo_mario_tilt_torso),
+    define_geo_function(geo_mario_head_rotation),
+    define_geo_function(geo_switch_mario_hand),
+    define_geo_function(geo_mario_hand_foot_scaler),
+    define_geo_function(geo_switch_mario_cap_effect),
+    define_geo_function(geo_switch_mario_cap_on_off),
+    define_geo_function(geo_mario_rotate_wing_cap_wings),
+    define_geo_function(geo_switch_mario_hand_grab_pos),
+    define_geo_function(geo_render_mirror_mario),
+    define_geo_function(geo_mirror_mario_backface_culling),
+    define_geo_function(geo_update_projectile_pos_from_parent),
+    define_geo_function(geo_update_layer_transparency),
+    define_geo_function(geo_switch_anim_state),
+    define_geo_function(geo_switch_area),
+    define_geo_function(geo_camera_main),
+    define_geo_function(geo_camera_fov),
+    define_geo_function(geo_envfx_main),
+    define_geo_function(geo_skybox_main),
+    define_geo_function(geo_wdw_set_initial_water_level),
+    define_geo_function(geo_movtex_pause_control),
+    define_geo_function(geo_movtex_draw_water_regions),
+    define_geo_function(geo_movtex_draw_nocolor),
+    define_geo_function(geo_movtex_draw_colored),
+    define_geo_function(geo_movtex_draw_colored_no_update),
+    define_geo_function(geo_movtex_draw_colored_2_no_update),
+    define_geo_function(geo_movtex_update_horizontal),
+    define_geo_function(geo_movtex_draw_colored_no_update),
+    define_geo_function(geo_painting_draw),
+    define_geo_function(geo_painting_update),
+    define_geo_function(geo_exec_inside_castle_light),
+    define_geo_function(geo_exec_flying_carpet_timer_update),
+    define_geo_function(geo_exec_flying_carpet_create),
+    define_geo_function(geo_exec_cake_end_screen),
+    define_geo_function(geo_cannon_circle_base),
+    define_geo_function(geo_move_mario_part_from_parent),
+    define_geo_function(geo_bits_bowser_coloring),
+    define_geo_function(geo_update_body_rot_from_parent),
+    define_geo_function(geo_switch_bowser_eyes),
+    define_geo_function(geo_switch_tuxie_mother_eyes),
+    define_geo_function(geo_update_held_mario_pos),
+    define_geo_function(geo_snufit_move_mask),
+    define_geo_function(geo_snufit_scale_body),
+    define_geo_function(geo_scale_bowser_key),
+    { "geo_rotate_coin", (void *) geo_rotate_3d_coin },
+    define_geo_function(geo_offset_klepto_held_object),
+    define_geo_function(geo_switch_peach_eyes),
+};
+#undef define_geo_function
+return sGeoFunctions;
+}
+#define sGeoFunctions __GeoFunctions()
+
+void *DynOS_Geo_GetFunctionPointerFromName(const String &aName) {
+    for (const auto &_GeoFunction : sGeoFunctions) {
+        if (aName == _GeoFunction.first) {
+            return _GeoFunction.second;
+        }
+    };
+    return NULL;
+}
+
+void *DynOS_Geo_GetFunctionPointerFromIndex(s32 aIndex) {
+    return sGeoFunctions[aIndex].second;
+}
+
+s32 DynOS_Geo_GetFunctionIndex(const void *aPtr) {
+    for (const auto &_GeoFunction : sGeoFunctions) {
+        if (_GeoFunction.second == aPtr) {
+            return (s32) (&_GeoFunction - sGeoFunctions.begin());
+        }
+    }
+    return -1;
+}
+
+static void _RelocateGraphNodePointers(struct GraphNode *aHead, u64 aOffset) {
+    struct GraphNode *_Node = aHead;
+    do {
+        if (_Node->prev) {
+            _Node->prev = (struct GraphNode *) ((u64) _Node->prev + aOffset);
+        }
+        if (_Node->next) {
+            _Node->next = (struct GraphNode *) ((u64) _Node->next + aOffset);
+        }
+        if (_Node->parent) {
+            _Node->parent = (struct GraphNode *) ((u64) _Node->parent + aOffset);
+        }
+        if (_Node->children) {
+            _Node->children = (struct GraphNode *) ((u64) _Node->children + aOffset);
+            _RelocateGraphNodePointers(_Node->children, aOffset);
+        }
+        _Node = _Node->next;
+    } while (_Node != aHead);
+}
+
+void *DynOS_Geo_GetGraphNode(const void *aGeoLayout, bool aKeepInMemory) {
+    static Array<Pair<void *, void *>> sLoadedGraphNodes;
+    if (aKeepInMemory) {
+        s32 _LoadedGraphNodeIndex = sLoadedGraphNodes.FindIf([&aGeoLayout](const Pair<void *, void *> &aLoadedGraphNode) { return aLoadedGraphNode.first == aGeoLayout; });
+        if (_LoadedGraphNodeIndex != -1) {
+            return sLoadedGraphNodes[_LoadedGraphNodeIndex].second;
+        }
+    }
+
+    // Process the geo layout on a large pool of memory (16 MB)
+    struct AllocOnlyPool *_Pool = (struct AllocOnlyPool *) calloc(1, 0x1000000);
+    _Pool->totalSpace = 0x1000000    - sizeof(struct AllocOnlyPool);
+    _Pool->usedSpace  = 0;
+    _Pool->startPtr   = (u8 *) _Pool + sizeof(struct AllocOnlyPool);
+    _Pool->freePtr    = (u8 *) _Pool + sizeof(struct AllocOnlyPool);
+    void *_Processed  = process_geo_layout(_Pool, (void *) aGeoLayout);
+
+    // Copy the graph node data to the minimum amount of memory needed
+    if (_Processed && _Pool->usedSpace != 0) {
+        struct GraphNode *_Node = (struct GraphNode *) calloc(1, _Pool->usedSpace);
+        memcpy(_Node, _Pool->startPtr, _Pool->usedSpace);
+
+        // Relocate all graph pointers
+        u64 _Offset = (u64) _Node - (u64) _Pool->startPtr;
+        _RelocateGraphNodePointers(_Node, _Offset);
+
+        // Add it to loaded graph nodes
+        if (aKeepInMemory) {
+            sLoadedGraphNodes.Add({ (void *) aGeoLayout, (void *) _Node });
+        }
+        free(_Pool);
+        return _Node;
+    }
+    free(_Pool);
+    return NULL;
+}
diff --git a/data/dynos_opt.cpp b/data/dynos_opt.cpp
new file mode 100644
index 00000000..4ef1b04d
--- /dev/null
+++ b/data/dynos_opt.cpp
@@ -0,0 +1,847 @@
+#include "dynos.cpp.h"
+extern "C" {
+#include "pc/configfile.h"
+#include "audio/external.h"
+#include "game/game_init.h"
+#include "pc/controller/controller_keyboard.h"
+#ifdef BETTERCAMERA
+#include "game/bettercamera.h"
+#endif
+}
+
+//
+// Data
+//
+
+static DynosOption *sPrevOpt     = NULL;
+static DynosOption *sDynosMenu   = NULL;
+static DynosOption *sOptionsMenu = NULL;
+static DynosOption *sCurrentMenu = NULL;
+static DynosOption *sCurrentOpt  = NULL;
+extern s32 sBindingState;
+
+//
+// Action list
+//
+
+typedef bool (*DynosActionFunction)(const char *);
+struct DynosAction : NoCopy {
+    String mFuncName;
+    DynosActionFunction mAction;
+};
+
+STATIC_STORAGE(Array<DynosAction *>, DynosActions);
+#define sDynosActions __DynosActions()
+
+static DynosActionFunction DynOS_Opt_GetAction(const String& aFuncName) {
+    for (auto &_DynosAction : sDynosActions) {
+        if (_DynosAction->mFuncName == aFuncName) {
+            return _DynosAction->mAction;
+        }
+    }
+    return NULL;
+}
+
+void DynOS_Opt_AddAction(const String& aFuncName, bool (*aFuncPtr)(const char *), bool aOverwrite) {
+    for (auto &_DynosAction : sDynosActions) {
+        if (_DynosAction->mFuncName == aFuncName) {
+            if (aOverwrite) {
+                _DynosAction->mAction = aFuncPtr;
+            }
+            return;
+        }
+    }
+    DynosAction *_DynosAction = New<DynosAction>();
+    _DynosAction->mFuncName = aFuncName;
+    _DynosAction->mAction = aFuncPtr;
+    sDynosActions.Add(_DynosAction);
+}
+
+//
+// Constructors
+//
+
+static DynosOption *DynOS_Opt_GetExistingOption(DynosOption *aOpt, const String &aName) {
+    while (aOpt) {
+        if (aOpt->mName == aName) {
+            return aOpt;
+        }
+        if (aOpt->mType == DOPT_SUBMENU) {
+            DynosOption *_Opt = DynOS_Opt_GetExistingOption(aOpt->mSubMenu.mChild, aName);
+            if (_Opt) {
+                return _Opt;
+            }
+        }
+        aOpt = aOpt->mNext;
+    }
+    return NULL;
+}
+
+static DynosOption *DynOS_Opt_NewOption(const String &aName, const String &aConfigName, const String &aLabel, const String &aTitle) {
+
+    // Check if the option already exists
+    static DynosOption sDummyOpt;
+    if (DynOS_Opt_GetExistingOption(sDynosMenu, aName)) {
+        return &sDummyOpt;
+    }
+
+    // Create a new option
+    DynosOption *_Opt = New<DynosOption>();
+    _Opt->mName       = aName;
+    _Opt->mConfigName = aConfigName;
+    _Opt->mLabel      = { aLabel, NULL };
+    _Opt->mTitle      = { aTitle, NULL };
+    _Opt->mDynos      = true;
+    if (sPrevOpt == NULL) { // The very first option
+        _Opt->mPrev   = NULL;
+        _Opt->mNext   = NULL;
+        _Opt->mParent = NULL;
+        sDynosMenu    = _Opt;
+    } else {
+    if (sPrevOpt->mType == DOPT_SUBMENU && sPrevOpt->mSubMenu.mEmpty) { // First option of a sub-menu
+        _Opt->mPrev   = NULL;
+        _Opt->mNext   = NULL;
+        _Opt->mParent = sPrevOpt;
+        sPrevOpt->mSubMenu.mChild = _Opt;
+        sPrevOpt->mSubMenu.mEmpty = false;
+    } else {
+        _Opt->mPrev   = sPrevOpt;
+        _Opt->mNext   = NULL;
+        _Opt->mParent = sPrevOpt->mParent;
+        sPrevOpt->mNext = _Opt;
+    }
+    }
+    sPrevOpt = _Opt;
+    return _Opt;
+}
+
+static void DynOS_Opt_EndSubMenu() {
+    if (sPrevOpt && sPrevOpt->mParent) {
+        if (sPrevOpt->mType == DOPT_SUBMENU && sPrevOpt->mSubMenu.mEmpty) { // ENDMENU command following a SUBMENU command
+            sPrevOpt->mSubMenu.mEmpty = false;
+        } else {
+            sPrevOpt = sPrevOpt->mParent;
+        }
+    }
+}
+
+static void DynOS_Opt_CreateSubMenu(const String &aName, const String &aLabel, const String &aTitle) {
+    DynosOption *_Opt     = DynOS_Opt_NewOption(aName, "", aLabel, aTitle);
+    _Opt->mType           = DOPT_SUBMENU;
+    _Opt->mSubMenu.mChild = NULL;
+    _Opt->mSubMenu.mEmpty = true;
+}
+
+static void DynOS_Opt_CreateToggle(const String &aName, const String &aConfigName, const String &aLabel, s32 aValue) {
+    DynosOption *_Opt   = DynOS_Opt_NewOption(aName, aConfigName, aLabel, aLabel);
+    _Opt->mType         = DOPT_TOGGLE;
+    _Opt->mToggle.mTog  = New<bool>();
+    *_Opt->mToggle.mTog = (bool) aValue;
+}
+
+static void DynOS_Opt_CreateScroll(const String &aName, const String &aConfigName, const String &aLabel, s32 aMin, s32 aMax, s32 aStep, s32 aValue) {
+    DynosOption *_Opt     = DynOS_Opt_NewOption(aName, aConfigName, aLabel, aLabel);
+    _Opt->mType           = DOPT_SCROLL;
+    _Opt->mScroll.mMin    = aMin;
+    _Opt->mScroll.mMax    = aMax;
+    _Opt->mScroll.mStep   = aStep;
+    _Opt->mScroll.mValue  = New<s32>();
+    *_Opt->mScroll.mValue = aValue;
+}
+
+static void DynOS_Opt_CreateChoice(const String &aName, const String &aConfigName, const String &aLabel, const Array<String>& aChoices, s32 aValue) {
+    DynosOption *_Opt      = DynOS_Opt_NewOption(aName, aConfigName, aLabel, aLabel);
+    _Opt->mType            = DOPT_CHOICE;
+    _Opt->mChoice.mIndex   = New<s32>();
+    *_Opt->mChoice.mIndex  = aValue;
+    for (const auto &_Choice : aChoices) {
+        _Opt->mChoice.mChoices.Add({ _Choice, NULL });
+    }
+}
+
+static void DynOS_Opt_CreateButton(const String &aName, const String &aLabel, const String& aFuncName) {
+    DynosOption *_Opt       = DynOS_Opt_NewOption(aName, "", aLabel, aLabel);
+    _Opt->mType             = DOPT_BUTTON;
+    _Opt->mButton.mFuncName = aFuncName;
+}
+
+static void DynOS_Opt_CreateBind(const String &aName, const String &aConfigName, const String &aLabel, u32 aMask, u32 aBind0, u32 aBind1, u32 aBind2) {
+    DynosOption *_Opt     = DynOS_Opt_NewOption(aName, aConfigName, aLabel, aLabel);
+    _Opt->mType           = DOPT_BIND;
+    _Opt->mBind.mMask     = aMask;
+    _Opt->mBind.mBinds    = New<u32>(3);
+    _Opt->mBind.mBinds[0] = aBind0;
+    _Opt->mBind.mBinds[1] = aBind1;
+    _Opt->mBind.mBinds[2] = aBind2;
+    _Opt->mBind.mIndex    = 0;
+}
+
+static void DynOS_Opt_ReadFile(const SysPath &aFolder, const SysPath &aFilename) {
+
+    // Open file
+    SysPath _FullFilename = fstring("%s/%s", aFolder.c_str(), aFilename.c_str());
+    FILE *_File = fopen(_FullFilename.c_str(), "rt");
+    if (_File == NULL) {
+        return;
+    }
+
+    // Read file and create options
+    char _Buffer[4096];
+    while (fgets(_Buffer, 4096, _File) != NULL) {
+        Array<String> _Tokens = Split(_Buffer, " #\t\r\n\b", "#", true);
+
+        // Empty line
+        if (_Tokens.Empty()) {
+            continue;
+        }
+
+        // SUBMENU [Name] [Label] [Title]
+        if (_Tokens[0] == "SUBMENU" && _Tokens.Count() >= 4) {
+            DynOS_Opt_CreateSubMenu(_Tokens[1], _Tokens[2], _Tokens[3]);
+            continue;
+        }
+
+        // TOGGLE  [Name] [Label] [ConfigName] [InitialValue]
+        if (_Tokens[0] == "TOGGLE" && _Tokens.Count() >= 5) {
+            DynOS_Opt_CreateToggle(_Tokens[1], _Tokens[3], _Tokens[2], _Tokens[4].ParseInt());
+            continue;
+        }
+
+        // SCROLL  [Name] [Label] [ConfigName] [InitialValue] [Min] [Max] [Step]
+        if (_Tokens[0] == "SCROLL" && _Tokens.Count() >= 8) {
+            DynOS_Opt_CreateScroll(_Tokens[1], _Tokens[3], _Tokens[2], _Tokens[5].ParseInt(), _Tokens[6].ParseInt(), _Tokens[7].ParseInt(), _Tokens[4].ParseInt());
+            continue;
+        }
+
+        // CHOICE  [Name] [Label] [ConfigName] [InitialValue] [ChoiceStrings...]
+        if (_Tokens[0] == "CHOICE" && _Tokens.Count() >= 6) {
+            DynOS_Opt_CreateChoice(_Tokens[1], _Tokens[3], _Tokens[2], Array<String>(_Tokens.begin() + 5, _Tokens.end()), _Tokens[4].ParseInt());
+            continue;
+        }
+
+        // BUTTON  [Name] [Label] [FuncName]
+        if (_Tokens[0] == "BUTTON" && _Tokens.Count() >= 4) {
+            DynOS_Opt_CreateButton(_Tokens[1], _Tokens[2], _Tokens[3]);
+            continue;
+        }
+
+        // BIND    [Name] [Label] [ConfigName] [Mask] [DefaultValues]
+        if (_Tokens[0] == "BIND" && _Tokens.Count() >= 8) {
+            DynOS_Opt_CreateBind(_Tokens[1], _Tokens[3], _Tokens[2], _Tokens[4].ParseInt(), _Tokens[5].ParseInt(), _Tokens[6].ParseInt(), _Tokens[7].ParseInt());
+            continue;
+        }
+
+        // ENDMENU
+        if (_Tokens[0] == "ENDMENU") {
+            DynOS_Opt_EndSubMenu();
+            continue;
+        }
+    }
+    fclose(_File);
+}
+
+static void DynOS_Opt_LoadOptions() {
+    SysPath _DynosFolder = fstring("%s/%s", DYNOS_EXE_FOLDER, DYNOS_RES_FOLDER);
+    DIR *_DynosDir = opendir(_DynosFolder.c_str());
+    sPrevOpt = NULL;
+    if (_DynosDir) {
+        struct dirent *_DynosEnt = NULL;
+        while ((_DynosEnt = readdir(_DynosDir)) != NULL) {
+            SysPath _Filename = SysPath(_DynosEnt->d_name);
+            if (_Filename.find(".txt") == _Filename.length() - 4) {
+                DynOS_Opt_ReadFile(_DynosFolder, _Filename);
+            }
+        }
+        closedir(_DynosDir);
+    }
+}
+
+//
+// Loop through DynosOptions
+//
+
+DynosOption *DynOS_Opt_Loop(DynosOption *aOpt, DynosLoopFunc aFunc, void *aData) {
+    while (aOpt) {
+        if (aFunc(aOpt, aData)) {
+            return aOpt;
+        } else if (aOpt->mType == DOPT_SUBMENU) {
+            DynosOption *_Opt = DynOS_Opt_Loop(aOpt->mSubMenu.mChild, aFunc, aData);
+            if (_Opt) {
+                return _Opt;
+            }
+        }
+        aOpt = aOpt->mNext;
+    }
+    return NULL;
+}
+
+//
+// Get/Set values
+//
+
+static bool DynOS_Opt_Get(DynosOption *aOpt, void *aData) {
+    return aOpt->mName == (const char *) aData;
+}
+
+s32 DynOS_Opt_GetValue(const String &aName) {
+    DynosOption *_Opt = DynOS_Opt_Loop(sDynosMenu, DynOS_Opt_Get, (void *) aName.begin());
+    if (_Opt) {
+        switch (_Opt->mType) {
+            case DOPT_TOGGLE:      return *_Opt->mToggle.mTog;
+            case DOPT_CHOICE:      return *_Opt->mChoice.mIndex;
+            case DOPT_CHOICELEVEL: return *_Opt->mChoice.mIndex;
+            case DOPT_CHOICEAREA:  return *_Opt->mChoice.mIndex;
+            case DOPT_CHOICESTAR:  return *_Opt->mChoice.mIndex;
+#ifndef DYNOS_COOP
+            case DOPT_CHOICEPARAM: return *_Opt->mChoice.mIndex;
+#endif
+            case DOPT_SCROLL:      return *_Opt->mScroll.mValue;
+            default:               break;
+        }
+    }
+    return 0;
+}
+
+void DynOS_Opt_SetValue(const String &aName, s32 aValue) {
+    DynosOption *_Opt = DynOS_Opt_Loop(sDynosMenu, DynOS_Opt_Get, (void *) aName.begin());
+    if (_Opt) {
+        switch (_Opt->mType) {
+            case DOPT_TOGGLE:      *_Opt->mToggle.mTog   = aValue; break;
+            case DOPT_CHOICE:      *_Opt->mChoice.mIndex = aValue; break;
+            case DOPT_CHOICELEVEL: *_Opt->mChoice.mIndex = aValue; break;
+            case DOPT_CHOICEAREA:  *_Opt->mChoice.mIndex = aValue; break;
+            case DOPT_CHOICESTAR:  *_Opt->mChoice.mIndex = aValue; break;
+#ifndef DYNOS_COOP
+            case DOPT_CHOICEPARAM: *_Opt->mChoice.mIndex = aValue; break;
+#endif
+            case DOPT_SCROLL:      *_Opt->mScroll.mValue = aValue; break;
+            default:               break;
+        }
+    }
+}
+
+//
+// Processing
+//
+
+#define SOUND_DYNOS_SAVED   (SOUND_MENU_MARIO_CASTLE_WARP2  | (0xFF << 8))
+#define SOUND_DYNOS_SELECT  (SOUND_MENU_CHANGE_SELECT       | (0xF8 << 8))
+#define SOUND_DYNOS_OK      (SOUND_MENU_CHANGE_SELECT       | (0xF8 << 8))
+#define SOUND_DYNOS_CANCEL  (SOUND_MENU_CAMERA_BUZZ         | (0xFC << 8))
+
+enum {
+    INPUT_LEFT,
+    INPUT_RIGHT,
+    INPUT_A,
+    INPUT_Z
+};
+
+enum {
+    RESULT_NONE,
+    RESULT_OK,
+    RESULT_CANCEL
+};
+
+static s32 DynOS_Opt_ProcessInput(DynosOption *aOpt, s32 input) {
+    switch (aOpt->mType) {
+        case DOPT_TOGGLE:
+            if (input == INPUT_LEFT) {
+                *aOpt->mToggle.mTog = false;
+                return RESULT_OK;
+            }
+            if (input == INPUT_RIGHT) {
+                *aOpt->mToggle.mTog = true;
+                return RESULT_OK;
+            }
+            if (input == INPUT_A) {
+                *aOpt->mToggle.mTog = !(*aOpt->mToggle.mTog);
+                return RESULT_OK;
+            }
+            break;
+
+        case DOPT_CHOICE:
+            if (input == INPUT_LEFT) {
+                *aOpt->mChoice.mIndex = (*aOpt->mChoice.mIndex + aOpt->mChoice.mChoices.Count() - 1) % (aOpt->mChoice.mChoices.Count());
+                return RESULT_OK;
+            }
+            if (input == INPUT_RIGHT || input == INPUT_A) {
+                *aOpt->mChoice.mIndex = (*aOpt->mChoice.mIndex + 1) % (aOpt->mChoice.mChoices.Count());
+                return RESULT_OK;
+            }
+            break;
+
+        case DOPT_CHOICELEVEL:
+            if (input == INPUT_LEFT) {
+                *aOpt->mChoice.mIndex = (*aOpt->mChoice.mIndex + DynOS_Level_GetCount() - 1) % (DynOS_Level_GetCount());
+                return RESULT_OK;
+            }
+            if (input == INPUT_RIGHT || input == INPUT_A) {
+                *aOpt->mChoice.mIndex = (*aOpt->mChoice.mIndex + 1) % (DynOS_Level_GetCount());
+                return RESULT_OK;
+            }
+            break;
+
+        case DOPT_CHOICEAREA:
+            if (input == INPUT_LEFT) {
+                *aOpt->mChoice.mIndex = (*aOpt->mChoice.mIndex + 3) % (4);
+                return RESULT_OK;
+            }
+            if (input == INPUT_RIGHT || input == INPUT_A) {
+                *aOpt->mChoice.mIndex = (*aOpt->mChoice.mIndex + 1) % (4);
+                return RESULT_OK;
+            }
+            break;
+
+        case DOPT_CHOICESTAR:
+            if (input == INPUT_LEFT) {
+                *aOpt->mChoice.mIndex = (*aOpt->mChoice.mIndex + 5) % (6);
+                return RESULT_OK;
+            }
+            if (input == INPUT_RIGHT || input == INPUT_A) {
+                *aOpt->mChoice.mIndex = (*aOpt->mChoice.mIndex + 1) % (6);
+                return RESULT_OK;
+            }
+            break;
+
+#ifndef DYNOS_COOP
+        case DOPT_CHOICEPARAM:
+            if (input == INPUT_LEFT) {
+                *aOpt->mChoice.mIndex = (*aOpt->mChoice.mIndex + 4) % (5);
+                return RESULT_OK;
+            }
+            if (input == INPUT_RIGHT || input == INPUT_A) {
+                *aOpt->mChoice.mIndex = (*aOpt->mChoice.mIndex + 1) % (5);
+                return RESULT_OK;
+            }
+            break;
+#endif
+
+        case DOPT_SCROLL:
+            if (input == INPUT_LEFT) {
+                *aOpt->mScroll.mValue = MAX(aOpt->mScroll.mMin, *aOpt->mScroll.mValue - aOpt->mScroll.mStep * (gPlayer1Controller->buttonDown & A_BUTTON ? 5 : 1));
+                return RESULT_OK;
+            }
+            if (input == INPUT_RIGHT) {
+                *aOpt->mScroll.mValue = MIN(aOpt->mScroll.mMax, *aOpt->mScroll.mValue + aOpt->mScroll.mStep * (gPlayer1Controller->buttonDown & A_BUTTON ? 5 : 1));
+                return RESULT_OK;
+            }
+            break;
+
+        case DOPT_BIND:
+            if (input == INPUT_LEFT) {
+                aOpt->mBind.mIndex = MAX(0, aOpt->mBind.mIndex - 1);
+                return RESULT_OK;
+            }
+            if (input == INPUT_RIGHT) {
+                aOpt->mBind.mIndex = MIN(2, aOpt->mBind.mIndex + 1);
+                return RESULT_OK;
+            }
+            if (input == INPUT_Z) {
+                aOpt->mBind.mBinds[aOpt->mBind.mIndex] = VK_INVALID;
+                return RESULT_OK;
+            }
+            if (input == INPUT_A) {
+                aOpt->mBind.mBinds[aOpt->mBind.mIndex] = VK_INVALID;
+                sBindingState = 1;
+                controller_get_raw_key();
+                return RESULT_OK;
+            }
+            break;
+
+        case DOPT_BUTTON:
+            if (input == INPUT_A) {
+                DynosActionFunction _Action = DynOS_Opt_GetAction(aOpt->mButton.mFuncName);
+                if (_Action != NULL && _Action(aOpt->mName.begin())) {
+                    return RESULT_OK;
+                }
+                return RESULT_CANCEL;
+            }
+            break;
+
+        case DOPT_SUBMENU:
+            if (input == INPUT_A) {
+                if (aOpt->mSubMenu.mChild != NULL) {
+                    sCurrentOpt = aOpt->mSubMenu.mChild;
+                    return RESULT_OK;
+                }
+                return RESULT_CANCEL;
+            }
+            break;
+    }
+    return RESULT_NONE;
+}
+
+static void DynOS_Opt_Open(DynosOption *aMenu) {
+    play_sound(SOUND_DYNOS_SELECT, gDefaultSoundArgs);
+    sCurrentMenu = aMenu;
+    sCurrentOpt = aMenu;
+}
+
+static void DynOS_Opt_Close(bool aPlaySavedSfx) {
+    if (sCurrentMenu != NULL) {
+        if (aPlaySavedSfx) {
+            play_sound(SOUND_DYNOS_SAVED, gDefaultSoundArgs);
+        }
+#ifdef BETTERCAMERA
+        newcam_init_settings();
+#endif
+        controller_reconfigure();
+        configfile_save(configfile_name());
+        DynOS_Opt_SaveConfig(sDynosMenu);
+        sCurrentMenu = NULL;
+    }
+}
+
+static void DynOS_Opt_ProcessInputs() {
+    static s32 sStickTimer = 0;
+    static bool sPrevStick = 0;
+
+    // Stick values
+    f32 _StickX = gPlayer1Controller->stickX;
+    f32 _StickY = gPlayer1Controller->stickY;
+    if (absx(_StickX) > 60 || absx(_StickY) > 60) {
+        if (sStickTimer == 0) {
+            sStickTimer = (sPrevStick ? 2 : 9);
+        } else {
+            _StickX = 0;
+            _StickY = 0;
+            sStickTimer--;
+        }
+        sPrevStick = true;
+    } else {
+        sStickTimer = 0;
+        sPrevStick = false;
+    }
+
+    // Key binding
+    if (sBindingState != 0) {
+        u32 _Key = (sCurrentOpt->mDynos ? (u32) DynOS_Opt_ControllerGetKeyPressed() : controller_get_raw_key());
+        if (_Key != VK_INVALID) {
+            play_sound(SOUND_DYNOS_SELECT, gDefaultSoundArgs);
+            sCurrentOpt->mBind.mBinds[sCurrentOpt->mBind.mIndex] = _Key;
+            sBindingState = false;
+        }
+        return;
+    }
+
+    if (sCurrentMenu != NULL) {
+
+        // Up
+        if (_StickY > +60) {
+            if (sCurrentOpt->mPrev != NULL) {
+                sCurrentOpt = sCurrentOpt->mPrev;
+            } else {
+                while (sCurrentOpt->mNext) sCurrentOpt = sCurrentOpt->mNext;
+            }
+            play_sound(SOUND_DYNOS_SELECT, gDefaultSoundArgs);
+            return;
+        }
+
+        // Down
+        if (_StickY < -60) {
+            if (sCurrentOpt->mNext != NULL) {
+                sCurrentOpt = sCurrentOpt->mNext;
+            } else {
+                while (sCurrentOpt->mPrev) sCurrentOpt = sCurrentOpt->mPrev;
+            }
+            play_sound(SOUND_DYNOS_SELECT, gDefaultSoundArgs);
+            return;
+        }
+
+        // Left
+        if (_StickX < -60) {
+            switch (DynOS_Opt_ProcessInput(sCurrentOpt, INPUT_LEFT)) {
+                case RESULT_OK:     play_sound(SOUND_DYNOS_OK, gDefaultSoundArgs); break;
+                case RESULT_CANCEL: play_sound(SOUND_DYNOS_CANCEL, gDefaultSoundArgs); break;
+                case RESULT_NONE:   break;
+            }
+            return;
+        }
+
+        // Right
+        if (_StickX > +60) {
+            switch (DynOS_Opt_ProcessInput(sCurrentOpt, INPUT_RIGHT)) {
+                case RESULT_OK:     play_sound(SOUND_DYNOS_OK, gDefaultSoundArgs); break;
+                case RESULT_CANCEL: play_sound(SOUND_DYNOS_CANCEL, gDefaultSoundArgs); break;
+                case RESULT_NONE:   break;
+            }
+            return;
+        }
+
+        // A
+        if (gPlayer1Controller->buttonPressed & A_BUTTON) {
+            switch (DynOS_Opt_ProcessInput(sCurrentOpt, INPUT_A)) {
+                case RESULT_OK:     play_sound(SOUND_DYNOS_OK, gDefaultSoundArgs); break;
+                case RESULT_CANCEL: play_sound(SOUND_DYNOS_CANCEL, gDefaultSoundArgs); break;
+                case RESULT_NONE:   break;
+            }
+            return;
+        }
+
+        // B
+        if (gPlayer1Controller->buttonPressed & B_BUTTON) {
+            if (sCurrentOpt->mParent != NULL) {
+                sCurrentOpt = sCurrentOpt->mParent;
+                play_sound(SOUND_DYNOS_SELECT, gDefaultSoundArgs);
+            } else {
+                DynOS_Opt_Close(true);
+            }
+            return;
+        }
+
+        // Z
+        if (gPlayer1Controller->buttonPressed & Z_TRIG) {
+            switch (DynOS_Opt_ProcessInput(sCurrentOpt, INPUT_Z)) {
+                case RESULT_OK:     play_sound(SOUND_DYNOS_OK, gDefaultSoundArgs); break;
+                case RESULT_CANCEL: play_sound(SOUND_DYNOS_CANCEL, gDefaultSoundArgs); break;
+                case RESULT_NONE:
+                    if (sCurrentMenu == sDynosMenu) {
+                        DynOS_Opt_Close(true);
+                    } else {
+                        DynOS_Opt_Open(sDynosMenu);
+                    } break;
+            }
+            return;
+        }
+
+        // R
+        if (gPlayer1Controller->buttonPressed & R_TRIG) {
+            if (sCurrentMenu == sOptionsMenu) {
+                DynOS_Opt_Close(true);
+            } else {
+                DynOS_Opt_Open(sOptionsMenu);
+            }
+            return;
+        }
+
+        // Start
+        if (gPlayer1Controller->buttonPressed & START_BUTTON) {
+            DynOS_Opt_Close(true);
+            return;
+        }
+    } else if (gPlayer1Controller->buttonPressed & R_TRIG) {
+        DynOS_Opt_Open(sOptionsMenu);
+    } else if (gPlayer1Controller->buttonPressed & Z_TRIG) {
+        DynOS_Opt_Open(sDynosMenu);
+    }
+}
+
+//
+// Init
+//
+
+static void DynOS_Opt_CreateWarpToLevelSubMenu() {
+    DynOS_Opt_CreateSubMenu("dynos_warp_to_level_submenu", "Warp to Level", "WARP TO LEUEL");
+
+    // Level select
+    {
+    DynosOption *aOpt     = DynOS_Opt_NewOption("dynos_warp_level", "", "Level Select", "");
+    aOpt->mType           = DOPT_CHOICELEVEL;
+    aOpt->mChoice.mIndex  = New<s32>();
+    *aOpt->mChoice.mIndex = 0;
+    }
+
+    // Area select
+    {
+    DynosOption *aOpt     = DynOS_Opt_NewOption("dynos_warp_area", "", "Area Select", "");
+    aOpt->mType           = DOPT_CHOICEAREA;
+    aOpt->mChoice.mIndex  = New<s32>();
+    *aOpt->mChoice.mIndex = 0;
+    }
+
+    // Star select
+    {
+    DynosOption *aOpt     = DynOS_Opt_NewOption("dynos_warp_act", "", "Star Select", "");
+    aOpt->mType           = DOPT_CHOICESTAR;
+    aOpt->mChoice.mIndex  = New<s32>();
+    *aOpt->mChoice.mIndex = 0;
+    }
+
+#ifndef DYNOS_COOP
+    // Param select
+    {
+    DynosOption *aOpt = DynOS_Opt_NewOption("dynos_warp_param", "", "Param Select", "");
+    aOpt->mType           = DOPT_CHOICEPARAM;
+    aOpt->mChoice.mIndex  = New<s32>();
+    *aOpt->mChoice.mIndex = 0;
+    }
+#endif
+
+    DynOS_Opt_CreateButton("dynos_warp_to_level", "Warp", "DynOS_Opt_WarpToLevel");
+    DynOS_Opt_EndSubMenu();
+}
+
+static void DynOS_Opt_CreateWarpToCastleSubMenu() {
+    DynOS_Opt_CreateSubMenu("dynos_warp_to_castle_submenu", "Warp to Castle", "WARP TO CASTLE");
+
+    // Level select
+    {
+    DynosOption *aOpt     = DynOS_Opt_NewOption("dynos_warp_castle", "", "Level Exit", "");
+    aOpt->mType           = DOPT_CHOICELEVEL;
+    aOpt->mChoice.mIndex  = New<s32>();
+    *aOpt->mChoice.mIndex = 0;
+    }
+
+    DynOS_Opt_CreateButton("dynos_warp_to_castle", "Warp", "DynOS_Opt_WarpToCastle");
+    DynOS_Opt_EndSubMenu();
+}
+
+static u32 DynOS_Opt_GetHash(const String& aStr) {
+    u32 _Hash = 5381u;
+    for (char c : aStr) { _Hash += c + (_Hash << 5); }
+    return _Hash;
+}
+
+static void DynOS_Opt_CreateModelPacksSubMenu() {
+    Array<String> _Packs = DynOS_Gfx_Init();
+    if (_Packs.Count() == 0) {
+        return;
+    }
+
+    DynOS_Opt_CreateSubMenu("dynos_model_loader_submenu", "Model Packs", "MODEL PACKS");
+    for (s32 i = 0; i != _Packs.Count(); ++i) {
+        DynOS_Opt_CreateToggle(String("dynos_pack_%d", i), String("dynos_pack_%08X", DynOS_Opt_GetHash(_Packs[i])), _Packs[i], false);
+    }
+    DynOS_Opt_CreateButton("dynos_packs_disable_all", "Disable all packs", "DynOS_Opt_DisableAllPacks");
+    DynOS_Opt_EndSubMenu();
+}
+
+void DynOS_Opt_Init() {
+
+    // Convert options menu
+    DynOS_Opt_InitVanilla(sOptionsMenu);
+
+    // Create DynOS menu
+    DynOS_Opt_LoadOptions();
+
+    // Warp to level
+    DynOS_Opt_CreateWarpToLevelSubMenu();
+
+    // Warp to castle
+    DynOS_Opt_CreateWarpToCastleSubMenu();
+
+    // Restart level
+    DynOS_Opt_CreateButton("dynos_restart_level", "Restart Level", "DynOS_Opt_RestartLevel");
+
+    // Exit level
+    DynOS_Opt_CreateButton("dynos_exit_level", "Exit Level", "DynOS_Opt_ExitLevel");
+
+#ifndef DYNOS_COOP
+    // Return to main menu
+    DynOS_Opt_CreateButton("dynos_return_to_main_menu", "Return to Main Menu", "DynOS_Opt_ReturnToMainMenu");
+#endif
+
+    // Model loader
+    DynOS_Opt_CreateModelPacksSubMenu();
+
+    // Init config
+    DynOS_Opt_LoadConfig(sDynosMenu);
+}
+
+//
+// Update
+//
+
+void DynOS_Opt_Update(OSContPad *aPad) {
+    DynOS_Opt_Loop(sDynosMenu, DynOS_Opt_ControllerUpdate, (void *) aPad);
+    if (DynOS_IsTransitionActive()) {
+        aPad->button = 0;
+        aPad->stick_x = 0;
+        aPad->stick_y = 0;
+        aPad->ext_stick_x = 0;
+        aPad->ext_stick_y = 0;
+    }
+}
+
+//
+// Hijack
+// This is C code
+//
+
+extern "C" {
+
+u8 optmenu_open = 0;
+
+void optmenu_toggle(void) {
+    DynOS_Opt_Close(false);
+    optmenu_open = 0;
+}
+
+void optmenu_draw(void) {
+    DynOS_Opt_DrawMenu(sCurrentOpt, sCurrentMenu, sOptionsMenu, sDynosMenu);
+}
+
+void optmenu_draw_prompt(void) {
+    DynOS_Opt_DrawPrompt(sCurrentMenu, sOptionsMenu, sDynosMenu);
+    DynOS_Opt_ProcessInputs();
+    optmenu_open = (sCurrentMenu != NULL);
+}
+
+void optmenu_check_buttons(void) {
+}
+
+}
+
+//
+// Built-in options
+//
+
+#define DYNOS_DEFINE_ACTION(func) \
+DYNOS_AT_STARTUP static void DynOS_Opt_AddAction_##func() { \
+    DynOS_Opt_AddAction(#func, func, false); \
+}
+
+#ifndef DYNOS_COOP
+static bool DynOS_Opt_ReturnToMainMenu(UNUSED const char *optName) {
+    DynOS_ReturnToMainMenu();
+    return true;
+}
+DYNOS_DEFINE_ACTION(DynOS_Opt_ReturnToMainMenu);
+#endif
+
+static bool DynOS_Opt_WarpToLevel(UNUSED const char *optName) {
+    s32 _Level = DynOS_Level_GetList()[DynOS_Opt_GetValue("dynos_warp_level")];
+    s32 _Area = DynOS_Opt_GetValue("dynos_warp_area") + 1;
+    s32 _Act = DynOS_Opt_GetValue("dynos_warp_act") + 1;
+#ifdef DYNOS_COOP
+    DynOS_Coop_SendCommand(DYNOS_COOP_COMMAND_WARP_TO_LEVEL, _Level, _Area, _Act);
+#endif
+    return DynOS_Warp_ToLevel(_Level, _Area, _Act);
+}
+DYNOS_DEFINE_ACTION(DynOS_Opt_WarpToLevel);
+
+static bool DynOS_Opt_WarpToCastle(UNUSED const char *optName) {
+    s32 _Level = DynOS_Level_GetList()[DynOS_Opt_GetValue("dynos_warp_castle")];
+#ifdef DYNOS_COOP
+    DynOS_Coop_SendCommand(DYNOS_COOP_COMMAND_WARP_TO_CASTLE, _Level, 0, 0);
+#endif
+    return DynOS_Warp_ToCastle(_Level);
+}
+DYNOS_DEFINE_ACTION(DynOS_Opt_WarpToCastle);
+
+static bool DynOS_Opt_RestartLevel(UNUSED const char *optName) {
+#ifdef DYNOS_COOP
+    DynOS_Coop_SendCommand(DYNOS_COOP_COMMAND_RESTART_LEVEL, 0, 0, 0);
+#endif
+    return DynOS_Warp_RestartLevel();
+}
+DYNOS_DEFINE_ACTION(DynOS_Opt_RestartLevel);
+
+static bool DynOS_Opt_ExitLevel(UNUSED const char *optName) {
+#ifdef DYNOS_COOP
+    DynOS_Coop_SendCommand(DYNOS_COOP_COMMAND_EXIT_LEVEL, 0, 0, 0);
+#endif
+    return DynOS_Warp_ExitLevel(30);
+}
+DYNOS_DEFINE_ACTION(DynOS_Opt_ExitLevel);
+
+static bool DynOS_Opt_DisableAllPacks(UNUSED const char *optName) {
+    const Array<PackData *> &pDynosPacks = DynOS_Gfx_GetPacks();
+    for (s32 i = 0; i != pDynosPacks.Count(); ++i) {
+        DynOS_Opt_SetValue(String("dynos_pack_%d", i), false);
+    }
+    return true;
+}
+DYNOS_DEFINE_ACTION(DynOS_Opt_DisableAllPacks);
+
+#undef DYNOS_DEFINE_ACTION
diff --git a/data/dynos_opt_config.cpp b/data/dynos_opt_config.cpp
new file mode 100644
index 00000000..ed26b07c
--- /dev/null
+++ b/data/dynos_opt_config.cpp
@@ -0,0 +1,62 @@
+#include "dynos.cpp.h"
+
+extern DynosOption *DynOS_Opt_Loop(DynosOption *aOpt, DynosLoopFunc aFunc, void *aData);
+
+static bool DynOS_Opt_ReadConfig(DynosOption *aOpt, void *aData) {
+    return (aOpt->mConfigName == (const char *) aData);
+}
+
+void DynOS_Opt_LoadConfig(DynosOption *aMenu) {
+    SysPath _Filename = fstring("%s/%s", DYNOS_USER_FOLDER, DYNOS_CONFIG_FILENAME);
+    FILE *_File = fopen(_Filename.c_str(), "r");
+    if (_File) {
+        char _Buffer[1024];
+        while (fgets(_Buffer, 1024, _File)) {
+            
+            // Option strings
+            char *_NameBegin = _Buffer;
+            char *_DataBegin = strchr(_NameBegin, '=');
+            if (_NameBegin && _DataBegin) {
+                *(_DataBegin++) = 0;
+
+                // Option name
+                String _OptName = String(_NameBegin);
+                DynosOption *_Opt = DynOS_Opt_Loop(aMenu, DynOS_Opt_ReadConfig, (void *) _OptName.begin());
+                if (_Opt) {
+
+                    // Option values
+                    switch (_Opt->mType) {
+                        case DOPT_TOGGLE: sscanf(_DataBegin, "%hhu\n",           &_Opt->mToggle.mTog[0]); break;
+                        case DOPT_CHOICE: sscanf(_DataBegin, "%d\n",             &_Opt->mChoice.mIndex[0]); break;
+                        case DOPT_SCROLL: sscanf(_DataBegin, "%d\n",             &_Opt->mScroll.mValue[0]); break;
+                        case DOPT_BIND:   sscanf(_DataBegin, "%04X;%04X;%04X\n", &_Opt->mBind.mBinds[0], &_Opt->mBind.mBinds[1], &_Opt->mBind.mBinds[2]); break;
+                    }
+                }
+            }
+        }
+        fclose(_File);
+    }
+}
+
+static bool DynOS_Opt_WriteConfig(DynosOption *aOpt, void *aData) {
+    if (aOpt->mConfigName.Length() != 0 &&
+        aOpt->mConfigName          != "null" &&
+        aOpt->mConfigName          != "NULL") {
+        switch (aOpt->mType) {
+            case DOPT_TOGGLE: fprintf((FILE *) aData, "%s=%hhu\n",           aOpt->mConfigName.begin(), aOpt->mToggle.mTog[0]); break;
+            case DOPT_CHOICE: fprintf((FILE *) aData, "%s=%d\n",             aOpt->mConfigName.begin(), aOpt->mChoice.mIndex[0]); break;
+            case DOPT_SCROLL: fprintf((FILE *) aData, "%s=%d\n",             aOpt->mConfigName.begin(), aOpt->mScroll.mValue[0]); break;
+            case DOPT_BIND:   fprintf((FILE *) aData, "%s=%04X;%04X;%04X\n", aOpt->mConfigName.begin(), aOpt->mBind.mBinds[0], aOpt->mBind.mBinds[1], aOpt->mBind.mBinds[2]); break;
+        }
+    }
+    return false;
+}
+
+void DynOS_Opt_SaveConfig(DynosOption *aMenu) {
+    SysPath _Filename = fstring("%s/%s", DYNOS_USER_FOLDER, DYNOS_CONFIG_FILENAME);
+    FILE *_File = fopen(_Filename.c_str(), "w");
+    if (_File) {
+        DynOS_Opt_Loop(aMenu, DynOS_Opt_WriteConfig, (void *) _File);
+        fclose(_File);
+    }
+}
diff --git a/data/dynos_opt_cont.cpp b/data/dynos_opt_cont.cpp
new file mode 100644
index 00000000..f88f57dc
--- /dev/null
+++ b/data/dynos_opt_cont.cpp
@@ -0,0 +1,70 @@
+#include "dynos.cpp.h"
+extern "C" {
+#include "pc/controller/controller_api.h"
+}
+
+static bool DynOS_Opt_ControllerIsKeyDown(s32 aCont, s32 aKey) {
+
+    // Keyboard
+    if (aCont == 0 && aKey >= 0 && aKey < SDL_NUM_SCANCODES) {
+        return SDL_GetKeyboardState(NULL)[aKey];
+    }
+
+    // Game Controller
+    else if (aKey >= 0x1000) {
+
+        // Button
+        s32 _Button = (aKey - 0x1000);
+        if (_Button < SDL_CONTROLLER_BUTTON_MAX) {
+            return SDL_GameControllerGetButton(SDL_GameControllerOpen(aCont - 1), SDL_GameControllerButton(_Button));
+        }
+
+        // Axis
+        s32 _Axis = (aKey - 0x1000 - SDL_CONTROLLER_BUTTON_MAX);
+        if (_Axis < SDL_CONTROLLER_AXIS_MAX * 2) {
+            s32 _AxisValue = SDL_GameControllerGetAxis(SDL_GameControllerOpen(aCont - 1), SDL_GameControllerAxis(_Axis / 2));
+            if (_Axis & 1) return (_AxisValue < (SHRT_MIN / 2));
+            else           return (_AxisValue > (SHRT_MAX / 2));
+        }
+    }
+    // Invalid
+    return false;
+}
+
+#define MAX_CONTS 8
+bool DynOS_Opt_ControllerUpdate(DynosOption *aOpt, void *aData) {
+    if (aOpt->mType == DOPT_BIND) {
+        OSContPad *pad = (OSContPad *) aData;
+        for (s32 _Cont = 0; _Cont < MAX_CONTS; ++_Cont)
+        for (s32 _Bind = 0; _Bind < 3; ++_Bind) {
+            pad->button |= aOpt->mBind.mMask * DynOS_Opt_ControllerIsKeyDown(_Cont, aOpt->mBind.mBinds[_Bind]);
+        }
+    }
+    return false;
+}
+
+#define MAX_GKEYS (SDL_CONTROLLER_BUTTON_MAX + SDL_CONTROLLER_AXIS_MAX * 2)
+s32 sBindingState = 0; // 0 = No bind, 1 = Wait for all keys released, 2 = Return first pressed key
+s32 DynOS_Opt_ControllerGetKeyPressed() {
+
+    // Keyboard
+    for (s32 _Key = 0; _Key < SDL_NUM_SCANCODES; ++_Key) {
+        if (DynOS_Opt_ControllerIsKeyDown(0, _Key)) {
+            if (sBindingState == 1) return VK_INVALID;
+            return _Key;
+        }
+    }
+
+    // Game Controller
+    for (s32 _Cont = 1; _Cont < MAX_CONTS; ++_Cont)
+    for (s32 _Key = 0; _Key < MAX_GKEYS; ++_Key) {
+        if (DynOS_Opt_ControllerIsKeyDown(_Cont, _Key + 0x1000)) {
+            if (sBindingState == 1) return VK_INVALID;
+            return _Key + 0x1000;
+        }
+    }
+
+    // No key
+    sBindingState = 2;
+    return VK_INVALID;
+}
diff --git a/data/dynos_opt_render.cpp b/data/dynos_opt_render.cpp
new file mode 100644
index 00000000..c221737d
--- /dev/null
+++ b/data/dynos_opt_render.cpp
@@ -0,0 +1,311 @@
+#include "dynos.cpp.h"
+extern "C" {
+#include "course_table.h"
+#include "game/game_init.h"
+#include "game/ingame_menu.h"
+#include "game/segment2.h"
+#include "pc/controller/controller_api.h"
+#include "gfx_dimensions.h"
+}
+
+extern s32 sBindingState;
+
+#define DYNOS_TEXT_DYNOS_MENU   { "DYNOS MENU",  NULL }
+#define DYNOS_TEXT_A            { "([A]) >",     NULL }
+#define DYNOS_TEXT_OPEN_LEFT    { "[Z] DynOS",   NULL }
+#define DYNOS_TEXT_CLOSE_LEFT   { "[Z] Return",  NULL }
+#define DYNOS_TEXT_OPTIONS_MENU { "OPTIONS",     NULL }
+#define DYNOS_TEXT_DISABLED     { "Disabled",    NULL }
+#define DYNOS_TEXT_ENABLED      { "Enabled",     NULL }
+#define DYNOS_TEXT_NONE         { "NONE",        NULL }
+#define DYNOS_TEXT_DOT_DOT_DOT  { "...",         NULL }
+#define DYNOS_TEXT_OPEN_RIGHT   { "[R] Options", NULL }
+#define DYNOS_TEXT_CLOSE_RIGHT  { "[R] Return",  NULL }
+
+static void RenderString(const u8 *aStr64, s32 aX, s32 aY) {
+    create_dl_translation_matrix(MENU_MTX_PUSH, aX, aY, 0);
+    for (; *aStr64 != DIALOG_CHAR_TERMINATOR; ++aStr64) {
+        if (*aStr64 != DIALOG_CHAR_SPACE) {
+            void **fontLUT = (void **) segmented_to_virtual(main_font_lut);
+            void *packedTexture = segmented_to_virtual(fontLUT[*aStr64]);
+            gDPPipeSync(gDisplayListHead++);
+            gDPSetTextureImage(gDisplayListHead++, G_IM_FMT_IA, G_IM_SIZ_16b, 1, VIRTUAL_TO_PHYSICAL(packedTexture));
+            gSPDisplayList(gDisplayListHead++, dl_ia_text_tex_settings);
+        }
+        create_dl_translation_matrix(MENU_MTX_NOPUSH, DynOS_String_WidthChar64(*aStr64), 0, 0);
+    }
+    gSPPopMatrix(gDisplayListHead++, G_MTX_MODELVIEW);
+}
+
+static void PrintString(const Label& aLabel, s32 aX, s32 aY, u32 aFrontColorRGBA, u32 aBackColorRGBA, bool aAlignLeft) {
+    const u8 *_Str64 = (aLabel.second ? aLabel.second : DynOS_String_Convert(aLabel.first.begin(), false));
+
+    gSPDisplayList(gDisplayListHead++, dl_ia_text_begin);
+    if ((aBackColorRGBA & 0xFF) != 0) {
+        gDPSetEnvColor(gDisplayListHead++, ((aBackColorRGBA >> 24) & 0xFF), ((aBackColorRGBA >> 16) & 0xFF), ((aBackColorRGBA >> 8) & 0xFF), ((aBackColorRGBA >> 0) & 0xFF));
+        if (aAlignLeft) {
+            RenderString(_Str64, GFX_DIMENSIONS_FROM_LEFT_EDGE(aX) + 1, aY - 1);
+        } else {
+            RenderString(_Str64, GFX_DIMENSIONS_FROM_RIGHT_EDGE(aX + DynOS_String_Width(_Str64) - 1), aY - 1);
+        }
+    }
+    if ((aFrontColorRGBA & 0xFF) != 0) {
+        gDPSetEnvColor(gDisplayListHead++, ((aFrontColorRGBA >> 24) & 0xFF), ((aFrontColorRGBA >> 16) & 0xFF), ((aFrontColorRGBA >> 8) & 0xFF), ((aFrontColorRGBA >> 0) & 0xFF));
+        if (aAlignLeft) {
+            RenderString(_Str64, GFX_DIMENSIONS_FROM_LEFT_EDGE(aX), aY);
+        } else {
+            RenderString(_Str64, GFX_DIMENSIONS_FROM_RIGHT_EDGE(aX + DynOS_String_Width(_Str64)), aY);
+        }
+    }
+    gSPDisplayList(gDisplayListHead++, dl_ia_text_end);
+    gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 255);
+}
+
+static void PrintBox(s32 aX, s32 aY, s32 aWidth, s32 aHeight, u32 aColorRGBA, bool aAlignLeft) {
+    if ((aColorRGBA && 0xFF) != 0) {
+        Mtx *_Matrix = (Mtx *) alloc_display_list(sizeof(Mtx));
+        if (!_Matrix) return;
+        if (aAlignLeft) {
+            create_dl_translation_matrix(MENU_MTX_PUSH, GFX_DIMENSIONS_FROM_LEFT_EDGE(aX), aY + aHeight, 0);
+        } else {
+            create_dl_translation_matrix(MENU_MTX_PUSH, GFX_DIMENSIONS_FROM_RIGHT_EDGE(aX + aWidth), aY + aHeight, 0);
+        }
+        guScale(_Matrix, (f32) aWidth / 130.f, (f32) aHeight / 80.f, 1.f);
+        gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(_Matrix), G_MTX_MODELVIEW | G_MTX_MUL | G_MTX_NOPUSH);
+        gDPSetEnvColor(gDisplayListHead++, ((aColorRGBA >> 24) & 0xFF), ((aColorRGBA >> 16) & 0xFF), ((aColorRGBA >> 8) & 0xFF), ((aColorRGBA >> 0) & 0xFF));
+        gSPDisplayList(gDisplayListHead++, dl_draw_text_bg_box);
+        gSPPopMatrix(gDisplayListHead++, G_MTX_MODELVIEW);
+        gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 255);
+    }
+}
+
+static const char *IntToString(const char *fmt, s32 x) {
+    static char sBuffer[16];
+    snprintf(sBuffer, 16, fmt, x);
+    return sBuffer;
+}
+
+#define get_label(opt)      (opt->mLabel)
+#define get_title(opt)      (opt->mTitle)
+#define get_choice(opt)     (opt->mChoice.mChoices[*opt->mChoice.mIndex])
+#define get_dec_number(n)   { "", DynOS_String_Convert(IntToString("%d", n), false) }
+#define get_hex_number(n)   { "", DynOS_String_Convert(IntToString("%04X", n), false) }
+#define get_level(opt)      { "", DynOS_Level_GetName(DynOS_Level_GetList()[*opt->mChoice.mIndex], true, true) }
+#define get_star(opt)       { "", DynOS_Level_GetActName(DynOS_Level_GetList()[DynOS_Opt_GetValue("dynos_warp_level")], *opt->mChoice.mIndex + 1, true, true) }
+#define get_param(opt)      { DynOS_Warp_GetParamName(DynOS_Level_GetList()[DynOS_Opt_GetValue("dynos_warp_level")], *opt->mChoice.mIndex), NULL }
+
+static s32 GetCurrentOptionCount(DynosOption *aCurrentOpt) {
+    s32 _Count = 0;
+    while (aCurrentOpt->mPrev) { aCurrentOpt = aCurrentOpt->mPrev; }
+    while (aCurrentOpt) { aCurrentOpt = aCurrentOpt->mNext; _Count++; }
+    return _Count;
+}
+
+static s32 GetCurrentOptionIndex(DynosOption *aCurrentOpt) {
+    s32 _Index = 0;
+    while (aCurrentOpt->mPrev) { aCurrentOpt = aCurrentOpt->mPrev; _Index++; }
+    return _Index;
+}
+
+#define PREV(opt) (opt == NULL ? NULL : opt->mPrev)
+#define NEXT(opt) (opt == NULL ? NULL : opt->mNext)
+static DynosOption **GetCurrentOptions(DynosOption *aCurrentOpt) {
+    static DynosOption *sOptionList[13];
+
+    sOptionList[6]  = aCurrentOpt;
+    sOptionList[5]  = PREV(sOptionList[6]);
+    sOptionList[4]  = PREV(sOptionList[5]);
+    sOptionList[3]  = PREV(sOptionList[4]);
+    sOptionList[2]  = PREV(sOptionList[3]);
+    sOptionList[1]  = PREV(sOptionList[2]);
+    sOptionList[0]  = PREV(sOptionList[1]);
+    sOptionList[7]  = NEXT(sOptionList[6]);
+    sOptionList[8]  = NEXT(sOptionList[7]);
+    sOptionList[9]  = NEXT(sOptionList[8]);
+    sOptionList[10] = NEXT(sOptionList[9]);
+    sOptionList[11] = NEXT(sOptionList[10]);
+    sOptionList[12] = NEXT(sOptionList[11]);
+
+    s32 _StartIndex = 12, _EndIndex = 0;
+    for (s32 i = 0; i != 13; ++i) {
+        if (sOptionList[i] != NULL) {
+            _StartIndex = MIN(_StartIndex, i);
+            _EndIndex = MAX(_EndIndex, i);
+        }
+    }
+
+    if (_EndIndex - _StartIndex < 7) {
+        return &sOptionList[_StartIndex];
+    }
+    if (_EndIndex <= 9) {
+        return &sOptionList[_EndIndex - 6];
+    }
+    if (_StartIndex >= 3) {
+        return &sOptionList[_StartIndex];
+    }
+    return &sOptionList[3];
+}
+#undef PREV
+#undef NEXT
+
+#define COLOR_WHITE             0xFFFFFFFF
+#define COLOR_BLACK             0x000000FF
+#define COLOR_GRAY              0xA0A0A0FF
+#define COLOR_DARK_GRAY         0x808080FF
+#define COLOR_SELECT            0x80E0FFFF
+#define COLOR_SELECT_BOX        0x00FFFF20
+#define COLOR_ENABLED           0x20E020FF
+#define COLOR_DISABLED          0xFF2020FF
+#define OFFSET_FROM_LEFT_EDGE   (20.f * sqr(GFX_DIMENSIONS_ASPECT_RATIO))
+#define OFFSET_FROM_RIGHT_EDGE  (20.f * sqr(GFX_DIMENSIONS_ASPECT_RATIO))
+#define SCROLL_BAR_SIZE         ((s32) (45.f * GFX_DIMENSIONS_ASPECT_RATIO))
+
+static void DynOS_Opt_DrawOption(DynosOption *aOpt, DynosOption *aCurrentOpt, s32 aY) {
+    if (aOpt == NULL) {
+        return;
+    }
+
+    // Selected box
+    if (aOpt == aCurrentOpt) {
+        u8 _Alpha = (u8) ((coss(gGlobalTimer * 0x800) + 1.f) * 0x20);
+        PrintBox(OFFSET_FROM_LEFT_EDGE - 4, aY - 2, GFX_DIMENSIONS_FROM_RIGHT_EDGE(OFFSET_FROM_RIGHT_EDGE) - GFX_DIMENSIONS_FROM_LEFT_EDGE(OFFSET_FROM_LEFT_EDGE) + 8, 20, COLOR_SELECT_BOX + _Alpha, 1);
+    }
+
+    // Label
+    if (aOpt == aCurrentOpt) {
+        PrintString(get_label(aOpt), OFFSET_FROM_LEFT_EDGE, aY, COLOR_SELECT, COLOR_BLACK, 1);
+    } else {
+        PrintString(get_label(aOpt), OFFSET_FROM_LEFT_EDGE, aY, COLOR_WHITE, COLOR_BLACK, 1);
+    }
+
+    // Values
+    switch (aOpt->mType) {
+        case DOPT_TOGGLE: {
+            if (*aOpt->mToggle.mTog) {
+                PrintString(DYNOS_TEXT_ENABLED, OFFSET_FROM_RIGHT_EDGE, aY, COLOR_ENABLED, COLOR_BLACK, 0);
+            } else {
+                PrintString(DYNOS_TEXT_DISABLED, OFFSET_FROM_RIGHT_EDGE, aY, COLOR_DISABLED, COLOR_BLACK, 0);
+            }
+        } break;
+
+        case DOPT_CHOICE: {
+            PrintString(get_choice(aOpt), OFFSET_FROM_RIGHT_EDGE, aY, aOpt == aCurrentOpt ? COLOR_SELECT : COLOR_WHITE, COLOR_BLACK, 0);
+        } break;
+
+        case DOPT_CHOICELEVEL: {
+            PrintString(get_level(aOpt), OFFSET_FROM_RIGHT_EDGE, aY, aOpt == aCurrentOpt ? COLOR_SELECT : COLOR_WHITE, COLOR_BLACK, 0);
+        } break;
+
+        case DOPT_CHOICEAREA: {
+            s32 _Level = DynOS_Level_GetList()[DynOS_Opt_GetValue("dynos_warp_level")];
+            s32 _Area = *aOpt->mChoice.mIndex + 1;
+            const u8 *_Name = DynOS_Level_GetAreaName(_Level, _Area, true);
+            if (DynOS_Level_GetWarpEntry(_Level, _Area)) {
+                PrintString({ "", _Name }, OFFSET_FROM_RIGHT_EDGE, aY, aOpt == aCurrentOpt ? COLOR_SELECT : COLOR_WHITE, COLOR_BLACK, 0);
+            } else {
+                PrintString({ "", _Name }, OFFSET_FROM_RIGHT_EDGE, aY, COLOR_GRAY, COLOR_BLACK, 0);
+            }
+        } break;
+
+        case DOPT_CHOICESTAR: {
+            s32 _Course = DynOS_Level_GetCourse(DynOS_Level_GetList()[DynOS_Opt_GetValue("dynos_warp_level")]);
+            if (_Course >= COURSE_MIN && _Course <= COURSE_STAGES_MAX) {
+                PrintString(get_star(aOpt), OFFSET_FROM_RIGHT_EDGE, aY, aOpt == aCurrentOpt ? COLOR_SELECT : COLOR_WHITE, COLOR_BLACK, 0);
+            }
+        } break;
+
+#ifndef DYNOS_COOP
+        case DOPT_CHOICEPARAM: {
+            PrintString(get_param(aOpt), OFFSET_FROM_RIGHT_EDGE, aY, aOpt == aCurrentOpt ? COLOR_SELECT : COLOR_WHITE, COLOR_BLACK, 0);
+        } break;
+#endif
+
+        case DOPT_SCROLL: {
+            s32 _Width = (s32) (SCROLL_BAR_SIZE * (f32) (*aOpt->mScroll.mValue - aOpt->mScroll.mMin) / (f32) (aOpt->mScroll.mMax - aOpt->mScroll.mMin));
+            PrintString(get_dec_number(*aOpt->mScroll.mValue), OFFSET_FROM_RIGHT_EDGE, aY, aOpt == aCurrentOpt ? COLOR_SELECT : COLOR_WHITE, COLOR_BLACK, 0);
+            PrintBox(OFFSET_FROM_RIGHT_EDGE + 28, aY + 4, SCROLL_BAR_SIZE + 2, 8, COLOR_DARK_GRAY, 0);
+            PrintBox(OFFSET_FROM_RIGHT_EDGE + 29 + SCROLL_BAR_SIZE - _Width, aY + 5, _Width, 6, aOpt == aCurrentOpt ? COLOR_SELECT : COLOR_WHITE, 0);
+        } break;
+
+        case DOPT_BIND: {
+            for (s32 i = 0; i != 3; ++i) {
+                u32 _Bind = aOpt->mBind.mBinds[i];
+                if (aOpt == aCurrentOpt && i == aOpt->mBind.mIndex) {
+                    if (sBindingState != 0) {
+                        PrintString(DYNOS_TEXT_DOT_DOT_DOT, OFFSET_FROM_RIGHT_EDGE + (2 - i) * 36, aY, COLOR_SELECT, COLOR_BLACK, 0);
+                    } else if (_Bind == VK_INVALID) {
+                        PrintString(DYNOS_TEXT_NONE, OFFSET_FROM_RIGHT_EDGE + (2 - i) * 36, aY, COLOR_SELECT, COLOR_BLACK, 0);
+                    } else {
+                        PrintString(get_hex_number(_Bind), OFFSET_FROM_RIGHT_EDGE + (2 - i) * 36, aY, COLOR_SELECT, COLOR_BLACK, 0);
+                    }
+                } else {
+                    if (_Bind == VK_INVALID) {
+                        PrintString(DYNOS_TEXT_NONE, OFFSET_FROM_RIGHT_EDGE + (2 - i) * 36, aY, COLOR_GRAY, COLOR_BLACK, 0);
+                    } else {
+                        PrintString(get_hex_number(_Bind), OFFSET_FROM_RIGHT_EDGE + (2 - i) * 36, aY, COLOR_WHITE, COLOR_BLACK, 0);
+                    }
+                }
+            }
+        } break;
+
+        case DOPT_BUTTON: {
+        } break;
+
+        case DOPT_SUBMENU: {
+            if (aOpt == aCurrentOpt) {
+                PrintString(DYNOS_TEXT_A, OFFSET_FROM_RIGHT_EDGE, aY, COLOR_SELECT, COLOR_BLACK, 0);
+            }
+        } break;
+    }
+}
+
+void DynOS_Opt_DrawMenu(DynosOption *aCurrentOption, DynosOption *aCurrentMenu, DynosOption *aOptionsMenu, DynosOption *aDynosMenu) {
+    if (aCurrentMenu == NULL) {
+        return;
+    }
+
+    // Colorful label
+    Label _Title;
+    if (aCurrentOption->mParent) {
+        _Title = get_title(aCurrentOption->mParent);
+    } else if (aCurrentMenu == aDynosMenu) {
+        _Title = DYNOS_TEXT_DYNOS_MENU;
+    } else if (aCurrentMenu == aOptionsMenu) {
+        _Title = DYNOS_TEXT_OPTIONS_MENU;
+    }
+    gSPDisplayList(gDisplayListHead++, dl_rgba16_text_begin);
+    gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 255);
+    if (!_Title.second) _Title.second = DynOS_String_Convert(_Title.first.begin(), false);
+    print_hud_lut_string(HUD_LUT_GLOBAL, (SCREEN_WIDTH / 2 - DynOS_String_Length(_Title.second) * 6), 40, _Title.second);
+    gSPDisplayList(gDisplayListHead++, dl_rgba16_text_end);
+
+    // Display options
+    DynosOption **_Options = GetCurrentOptions(aCurrentOption);
+    for (s32 i = 0; i != 7; ++i) {
+        DynOS_Opt_DrawOption(_Options[i], aCurrentOption, 156 - 20 * i);
+    }
+
+    // Scroll bar
+    s32 _OptCount = GetCurrentOptionCount(aCurrentOption);
+    s32 _OptIndex = GetCurrentOptionIndex(aCurrentOption);
+    if (_OptCount > 7) {
+        s32 _Height = (s32) (134.f * sqrtf(1.f / (_OptCount - 6)));
+        s32 _Y = 37 + (134 - _Height) * (1.f - MAX(0.f, MIN(1.f, (f32)(_OptIndex - 3) / (f32)(_OptCount - 6))));
+        PrintBox(OFFSET_FROM_RIGHT_EDGE - 16, 36, 8, 136, COLOR_DARK_GRAY, 0);
+        PrintBox(OFFSET_FROM_RIGHT_EDGE - 15, _Y, 6, _Height, COLOR_WHITE, 0);
+    }
+}
+
+#define PROMPT_OFFSET (56.25f * GFX_DIMENSIONS_ASPECT_RATIO)
+void DynOS_Opt_DrawPrompt(DynosOption *aCurrentMenu, DynosOption *aOptionsMenu, DynosOption *aDynosMenu) {
+    if (aCurrentMenu == aOptionsMenu) {
+        PrintString(DYNOS_TEXT_OPEN_LEFT,   PROMPT_OFFSET, 212, COLOR_WHITE, COLOR_BLACK, 1);
+        PrintString(DYNOS_TEXT_CLOSE_RIGHT, PROMPT_OFFSET, 212, COLOR_WHITE, COLOR_BLACK, 0);
+    } else if (aCurrentMenu == aDynosMenu) {
+        PrintString(DYNOS_TEXT_CLOSE_LEFT,  PROMPT_OFFSET, 212, COLOR_WHITE, COLOR_BLACK, 1);
+        PrintString(DYNOS_TEXT_OPEN_RIGHT,  PROMPT_OFFSET, 212, COLOR_WHITE, COLOR_BLACK, 0);
+    } else {
+        PrintString(DYNOS_TEXT_OPEN_LEFT,   PROMPT_OFFSET, 212, COLOR_WHITE, COLOR_BLACK, 1);
+        PrintString(DYNOS_TEXT_OPEN_RIGHT,  PROMPT_OFFSET, 212, COLOR_WHITE, COLOR_BLACK, 0);
+    }
+}
diff --git a/data/dynos_opt_vanilla.cpp b/data/dynos_opt_vanilla.cpp
new file mode 100644
index 00000000..7d45582f
--- /dev/null
+++ b/data/dynos_opt_vanilla.cpp
@@ -0,0 +1,155 @@
+#include "dynos.cpp.h"
+
+static DynosOption *sPrevOpt = NULL;
+static DynosOption *sOptionsMenu = NULL;
+
+//
+// Vanilla actions
+//
+
+typedef void (*VanillaActionFunction)(struct Option *, s32);
+typedef struct VanillaAction {
+    String mFuncName;
+    VanillaActionFunction mAction;
+} VanillaAction;
+
+STATIC_STORAGE(Array<VanillaAction *>, VanillaActions);
+#define sVanillaActions __VanillaActions()
+
+static VanillaActionFunction DynOS_Opt_GetVanillaAction(const String& aFuncName) {
+    for (auto &_DynosAction : sVanillaActions) {
+        if (_DynosAction->mFuncName == aFuncName) {
+            return _DynosAction->mAction;
+        }
+    }
+    return NULL;
+}
+
+static void DynOS_Opt_AddVanillaAction(const String& aFuncName, void (*aFuncPtr)(struct Option *, s32)) {
+    for (auto &_DynosAction : sVanillaActions) {
+        if (_DynosAction->mFuncName == aFuncName) {
+            return;
+        }
+    }
+    VanillaAction *_DynosAction = New<VanillaAction>();
+    _DynosAction->mFuncName = aFuncName;
+    _DynosAction->mAction = aFuncPtr;
+    sVanillaActions.Add(_DynosAction);
+}
+
+static bool DynOS_Opt_CallVanillaAction(const char *aOptName) {
+    VanillaActionFunction _Func = DynOS_Opt_GetVanillaAction(aOptName);
+    if (_Func) {
+        _Func(NULL, 0);
+        return true;
+    }
+    return false;
+}
+
+//
+// Convert classic options menu into DynOS menu
+//
+
+static DynosOption *DynOS_Opt_ConvertOption(const u8 *aLabel, const u8 *aTitle) {
+    static u32 sOptIdx = 0;
+    DynosOption *_Opt   = New<DynosOption>();
+    _Opt->mName         = String("vanilla_opt_%08X", sOptIdx++);
+    _Opt->mConfigName   = "";
+    _Opt->mLabel        = { "", aLabel };
+    _Opt->mTitle        = { "", aTitle };
+    _Opt->mDynos        = false;
+    if (sPrevOpt == NULL) { // The very first option
+        _Opt->mPrev     = NULL;
+        _Opt->mNext     = NULL;
+        _Opt->mParent   = NULL;
+        sOptionsMenu    = _Opt;
+    } else {
+    if (sPrevOpt->mType == DOPT_SUBMENU && sPrevOpt->mSubMenu.mEmpty) { // First option of a sub-menu
+        _Opt->mPrev     = NULL;
+        _Opt->mNext     = NULL;
+        _Opt->mParent   = sPrevOpt;
+        sPrevOpt->mSubMenu.mChild = _Opt;
+        sPrevOpt->mSubMenu.mEmpty = false;
+    } else {
+        _Opt->mPrev     = sPrevOpt;
+        _Opt->mNext     = NULL;
+        _Opt->mParent   = sPrevOpt->mParent;
+        sPrevOpt->mNext = _Opt;
+    }
+    }
+    sPrevOpt = _Opt;
+    return _Opt;
+}
+
+static void DynOS_Opt_EndSubMenu() {
+    if (sPrevOpt) {
+        if (sPrevOpt->mType == DOPT_SUBMENU && sPrevOpt->mSubMenu.mEmpty) { // ENDMENU command following a SUBMENU command
+            sPrevOpt->mSubMenu.mEmpty = false;
+        } else {
+            sPrevOpt = sPrevOpt->mParent;
+        }
+    }
+}
+
+static void DynOS_Opt_ConvertSubMenu(const u8 *aLabel, const u8 *aTitle) {
+    DynosOption *_Opt     = DynOS_Opt_ConvertOption(aLabel, aTitle);
+    _Opt->mType           = DOPT_SUBMENU;
+    _Opt->mSubMenu.mChild = NULL;
+    _Opt->mSubMenu.mEmpty = true;
+}
+
+static void DynOS_Opt_ConvertToggle(const u8 *aLabel, bool *pValue) {
+    DynosOption *_Opt  = DynOS_Opt_ConvertOption(aLabel, aLabel);
+    _Opt->mType        = DOPT_TOGGLE;
+    _Opt->mToggle.mTog = (bool *) pValue;
+}
+
+static void DynOS_Opt_ConvertScroll(const u8 *aLabel, s32 aMin, s32 aMax, s32 aStep, u32 *pValue) {
+    DynosOption *_Opt    = DynOS_Opt_ConvertOption(aLabel, aLabel);
+    _Opt->mType          = DOPT_SCROLL;
+    _Opt->mScroll.mMin   = aMin;
+    _Opt->mScroll.mMax   = aMax;
+    _Opt->mScroll.mStep  = aStep;
+    _Opt->mScroll.mValue = (s32 *) pValue;
+}
+
+static void DynOS_Opt_ConvertChoice(const u8 *aLabel, const u8 **aChoices, s32 aCount, u32 *pValue) {
+    DynosOption *_Opt    = DynOS_Opt_ConvertOption(aLabel, aLabel);
+    _Opt->mType          = DOPT_CHOICE;
+    _Opt->mChoice.mIndex = (s32 *) pValue;
+    for (s32 i = 0; i != aCount; ++i) {
+    _Opt->mChoice.mChoices.Add({ "", aChoices[i] });
+    }
+}
+
+static void DynOS_Opt_ConvertButton(const u8 *aLabel, VanillaActionFunction aAction) {
+    DynosOption *_Opt       = DynOS_Opt_ConvertOption(aLabel, aLabel);
+    _Opt->mType             = DOPT_BUTTON;
+    _Opt->mButton.mFuncName = "DynOS_Opt_CallVanillaAction";
+    DynOS_Opt_AddVanillaAction(_Opt->mName, aAction);
+}
+
+static void DynOS_Opt_ConvertBind(const u8 *aLabel, u32 *pBinds) {
+    DynosOption *_Opt  = DynOS_Opt_ConvertOption(aLabel, aLabel);
+    _Opt->mType        = DOPT_BIND;
+    _Opt->mBind.mMask  = 0;
+    _Opt->mBind.mBinds = pBinds;
+    _Opt->mBind.mIndex = 0;
+}
+
+extern "C" {
+extern void dynos_opt_convert_vanilla_main_menu();
+void dynos_opt_end_submenu() { return DynOS_Opt_EndSubMenu(); }
+void dynos_opt_convert_submenu(const u8 *label, const u8 *title) { return DynOS_Opt_ConvertSubMenu(label, title); }
+void dynos_opt_convert_toggle(const u8 *label, bool *bval) { return DynOS_Opt_ConvertToggle(label, bval); }
+void dynos_opt_convert_scroll(const u8 *label, s32 min, s32 max, s32 step, u32 *uval) { return DynOS_Opt_ConvertScroll(label, min, max, step, uval); }
+void dynos_opt_convert_choice(const u8 *label, const u8 **choices, s32 numChoices, u32 *uval) { return DynOS_Opt_ConvertChoice(label, choices, numChoices, uval); }
+void dynos_opt_convert_button(const u8 *label, void *action) { return DynOS_Opt_ConvertButton(label, (VanillaActionFunction) action); }
+void dynos_opt_convert_bind(const u8 *label, u32 *uval) { return DynOS_Opt_ConvertBind(label, uval); }
+}
+void DynOS_Opt_InitVanilla(DynosOption *&aOptionsMenu) {
+    sPrevOpt = NULL;
+    dynos_opt_convert_vanilla_main_menu();
+    DynOS_Opt_AddAction("DynOS_Opt_CallVanillaAction", DynOS_Opt_CallVanillaAction, true);
+    aOptionsMenu = sOptionsMenu;
+}
diff --git a/data/dynos_opt_vanilla_c.c b/data/dynos_opt_vanilla_c.c
new file mode 100644
index 00000000..e286d1a2
--- /dev/null
+++ b/data/dynos_opt_vanilla_c.c
@@ -0,0 +1,71 @@
+#include "dynos.c.h"
+
+// Not my problem
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsizeof-pointer-div"
+#pragma GCC diagnostic ignored "-Wdiscarded-qualifiers"
+#pragma GCC diagnostic ignored "-Wpointer-sign"
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#define optmenu_toggle optmenu_toggle_unused
+#define optmenu_draw optmenu_draw_unused
+#define optmenu_draw_prompt optmenu_draw_prompt_unused
+#define optmenu_check_buttons optmenu_check_buttons_unused
+#define optmenu_open optmenu_open_unused
+#define DYNOS_INL
+#include "game/options_menu.c"
+#undef DYNOS_INL
+#undef optmenu_toggle
+#undef optmenu_draw
+#undef optmenu_draw_prompt
+#undef optmenu_check_buttons
+#undef optmenu_open
+#pragma GCC diagnostic pop
+// Now, that's my problem
+
+extern void dynos_opt_end_submenu();
+extern void dynos_opt_convert_submenu(const u8 *label, const u8 *title);
+extern void dynos_opt_convert_toggle(const u8 *label, bool *bval);
+extern void dynos_opt_convert_scroll(const u8 *label, s32 min, s32 max, s32 step, u32 *uval);
+extern void dynos_opt_convert_choice(const u8 *label, const u8 **choices, s32 numChoices, u32 *uval);
+extern void dynos_opt_convert_button(const u8 *label, void *action);
+extern void dynos_opt_convert_bind(const u8 *label, u32 *uval);
+
+static void dynos_opt_convert_menu(struct SubMenu *submenu) {
+    for (s32 i = 0; i != submenu->numOpts; ++i) {
+        struct Option *opt = &submenu->opts[i];
+        switch (opt->type) {
+            case OPT_TOGGLE:
+                dynos_opt_convert_toggle(opt->label, opt->bval);
+                break;
+
+            case OPT_CHOICE:
+                dynos_opt_convert_choice(opt->label, opt->choices, opt->numChoices, opt->uval);
+                break;
+
+            case OPT_SCROLL:
+                dynos_opt_convert_scroll(opt->label, opt->scrMin, opt->scrMax, opt->scrStep, opt->uval);
+                break;
+
+            case OPT_SUBMENU:
+                dynos_opt_convert_submenu(opt->label, opt->nextMenu->label);
+                dynos_opt_convert_menu(opt->nextMenu);
+                dynos_opt_end_submenu();
+                break;
+
+            case OPT_BIND:
+                dynos_opt_convert_bind(opt->label, opt->uval);
+                break;
+
+            case OPT_BUTTON:
+                dynos_opt_convert_button(opt->label, opt->actionFn);
+                break;
+
+            default:
+                break;
+        }
+    }
+}
+
+void dynos_opt_convert_vanilla_main_menu() {
+    dynos_opt_convert_menu(&menuMain);
+}
diff --git a/data/dynos_sanity.c b/data/dynos_sanity.c
new file mode 100644
index 00000000..530c6a76
--- /dev/null
+++ b/data/dynos_sanity.c
@@ -0,0 +1,34 @@
+#include "dynos.c.h"
+#include "audio/internal.h"
+#include "engine/graph_node.h"
+
+bool dynos_sanity_check_geo(s16 graphNodeType) {
+    return
+        (graphNodeType == GRAPH_NODE_TYPE_ROOT) ||
+        (graphNodeType == GRAPH_NODE_TYPE_ORTHO_PROJECTION) ||
+        (graphNodeType == GRAPH_NODE_TYPE_PERSPECTIVE) ||
+        (graphNodeType == GRAPH_NODE_TYPE_MASTER_LIST) ||
+        (graphNodeType == GRAPH_NODE_TYPE_START) ||
+        (graphNodeType == GRAPH_NODE_TYPE_LEVEL_OF_DETAIL) ||
+        (graphNodeType == GRAPH_NODE_TYPE_SWITCH_CASE) ||
+        (graphNodeType == GRAPH_NODE_TYPE_CAMERA) ||
+        (graphNodeType == GRAPH_NODE_TYPE_TRANSLATION_ROTATION) ||
+        (graphNodeType == GRAPH_NODE_TYPE_TRANSLATION) ||
+        (graphNodeType == GRAPH_NODE_TYPE_ROTATION) ||
+        (graphNodeType == GRAPH_NODE_TYPE_OBJECT) ||
+        (graphNodeType == GRAPH_NODE_TYPE_ANIMATED_PART) ||
+        (graphNodeType == GRAPH_NODE_TYPE_BILLBOARD) ||
+        (graphNodeType == GRAPH_NODE_TYPE_DISPLAY_LIST) ||
+        (graphNodeType == GRAPH_NODE_TYPE_SCALE) ||
+        (graphNodeType == GRAPH_NODE_TYPE_SHADOW) ||
+        (graphNodeType == GRAPH_NODE_TYPE_OBJECT_PARENT) ||
+        (graphNodeType == GRAPH_NODE_TYPE_GENERATED_LIST) ||
+        (graphNodeType == GRAPH_NODE_TYPE_BACKGROUND) ||
+        (graphNodeType == GRAPH_NODE_TYPE_HELD_OBJ) ||
+        (graphNodeType == GRAPH_NODE_TYPE_CULLING_RADIUS);
+}
+
+bool dynos_sanity_check_seq(u8 loBits) {
+    return
+        (loBits < LAYERS_MAX);
+}
diff --git a/data/dynos_warps.cpp b/data/dynos_warps.cpp
new file mode 100644
index 00000000..f7be85d6
--- /dev/null
+++ b/data/dynos_warps.cpp
@@ -0,0 +1,475 @@
+#include "dynos.cpp.h"
+extern "C" {
+#include "sm64.h"
+#include "seq_ids.h"
+#include "course_table.h"
+#include "audio/external.h"
+#include "engine/surface_collision.h"
+#include "game/mario.h"
+#include "game/ingame_menu.h"
+#include "game/level_update.h"
+#include "game/sound_init.h"
+#include "game/object_list_processor.h"
+#include "game/options_menu.h"
+extern s8 gDialogBoxState;
+extern s16 gMenuMode;
+extern s32 gWdwWaterLevelSet;
+extern const u8 sSpawnTypeFromWarpBhv[];
+extern void set_mario_initial_action(struct MarioState *, u32, u32);
+extern void set_play_mode(s16);
+}
+
+//
+// Data
+//
+
+#ifndef DYNOS_COOP
+       s32 gDDDBowsersSub     = -1;
+       s32 gDDDPoles          = -1;
+#endif
+static s32 sDynosWarpLevelNum = -1;
+static s32 sDynosWarpAreaNum  = -1;
+static s32 sDynosWarpActNum   = -1;
+static s32 sDynosExitLevelNum = -1;
+static s32 sDynosExitAreaNum  = -1;
+
+//
+// Level Entry
+//
+
+bool DynOS_Warp_ToLevel(s32 aLevel, s32 aArea, s32 aAct) {
+    if (DynOS_Level_GetCourse(aLevel) == COURSE_NONE || !DynOS_Level_GetWarpEntry(aLevel, aArea)) {
+        return false;
+    }
+
+    sDynosWarpLevelNum = aLevel;
+    sDynosWarpAreaNum  = aArea;
+    sDynosWarpActNum   = aAct;
+    return true;
+}
+
+bool DynOS_Warp_RestartLevel() {
+    return DynOS_Warp_ToLevel(gCurrLevelNum, 1, gCurrActNum);
+}
+
+//
+// Level Exit
+//
+
+bool DynOS_Warp_ExitLevel(s32 aDelay) {
+    if (DynOS_Level_GetCourse(gCurrLevelNum) == COURSE_NONE) {
+        return false;
+    }
+
+    // Close the pause menu if it was open
+    optmenu_toggle();
+    level_set_transition(0, NULL);
+    gDialogBoxState = 0;
+    gMenuMode = -1;
+
+    // Cancel out every music/sound/sequence
+    for (u16 seqid = 0; seqid != SEQ_COUNT; ++seqid) {
+    stop_background_music(seqid);
+    }
+    play_shell_music();
+    stop_shell_music();
+    stop_cap_music();
+    func_80321080(0);
+    fadeout_music(0);
+    fadeout_level_music(0);
+
+    // Play Mario head transition, and change play mode to avoid getting stuck on the pause menu
+    aDelay = MAX(1, aDelay);
+    gMarioState->invincTimer = -1;
+    play_transition(WARP_TRANSITION_FADE_INTO_MARIO, aDelay, 0x00, 0x00, 0x00);
+    set_play_mode(0);
+    sDynosExitLevelNum = gCurrLevelNum;
+    sDynosExitAreaNum = gCurrAreaIndex;
+    return true;
+}
+
+bool DynOS_Warp_ToCastle(s32 aLevel) {
+    if (DynOS_Level_GetCourse(aLevel) == COURSE_NONE) {
+        return false;
+    }
+
+    // Close the pause menu if it was open
+    optmenu_toggle();
+    level_set_transition(0, NULL);
+    gDialogBoxState = 0;
+    gMenuMode = -1;
+
+    // Cancel out every music/sound/sequence
+    for (u16 seqid = 0; seqid != SEQ_COUNT; ++seqid) {
+    stop_background_music(seqid);
+    }
+    play_shell_music();
+    stop_shell_music();
+    stop_cap_music();
+    func_80321080(0);
+    fadeout_music(0);
+    fadeout_level_music(0);
+
+    // Change play mode to avoid getting stuck on the pause menu
+    set_play_mode(0);
+    sDynosExitLevelNum = aLevel;
+    sDynosExitAreaNum = 1;
+    return true;
+}
+
+//
+// Params
+//
+
+#ifndef DYNOS_COOP
+const char *DynOS_Warp_GetParamName(s32 aLevel, s32 aIndex) {
+    static const char *sLevelParams[][5] = {
+        { "", "", "", "", "" },
+        { "None", "No Submarine, No Poles", "Submarine Only", "Poles Only", "Submarine And Poles" },
+        { "None", "Water Level: Lowest", "Water Level: Low", "Water Level: High", "Water Level: Highest" },
+        { "None", "Top Flooded", "Top Drained", "Top Flooded", "Top Drained" },
+        { "None", "Clock Speed: Stopped", "Clock Speed: Slow", "Clock Speed: Fast", "Clock Speed: Random" },
+    };
+    switch (aLevel) {
+        case LEVEL_DDD: return sLevelParams[1][MIN(4, aIndex)];
+        case LEVEL_WDW: return sLevelParams[2][MIN(4, aIndex)];
+        case LEVEL_THI: return sLevelParams[3][MIN(4, aIndex)];
+        case LEVEL_TTC: return sLevelParams[4][MIN(4, aIndex)];
+    }
+    return sLevelParams[0][MIN(4, aIndex)];
+}
+
+// Called thrice
+// Pass -1 to use the previous value (only once)
+void DynOS_Warp_SetParam(s32 aLevel, s32 aIndex) {
+    static s32 sDynosWarpPrevParamIndex = -1;
+    if (aIndex == -1) {
+        aIndex = sDynosWarpPrevParamIndex;
+        sDynosWarpPrevParamIndex = -1;
+    } else {
+        sDynosWarpPrevParamIndex = aIndex;
+    }
+
+    switch (aLevel) {
+    case LEVEL_DDD:
+        switch (aIndex) {
+            case 1: gDDDBowsersSub = 0; gDDDPoles = 0; break;
+            case 2: gDDDBowsersSub = 1; gDDDPoles = 0; break;
+            case 3: gDDDBowsersSub = 0; gDDDPoles = 1; break;
+            case 4: gDDDBowsersSub = 1; gDDDPoles = 1; break;
+        }
+        break;
+
+    case LEVEL_WDW:
+        if (gEnvironmentRegions) {
+        switch (aIndex) {
+            case 1: gEnvironmentRegions[6] = *gEnvironmentLevels =   31; gWdwWaterLevelSet = 1; break;
+            case 2: gEnvironmentRegions[6] = *gEnvironmentLevels = 1024; gWdwWaterLevelSet = 1; break;
+            case 3: gEnvironmentRegions[6] = *gEnvironmentLevels = 1792; gWdwWaterLevelSet = 1; break;
+            case 4: gEnvironmentRegions[6] = *gEnvironmentLevels = 2816; gWdwWaterLevelSet = 1; break;
+        }
+        }
+        break;
+
+    case LEVEL_THI:
+        switch (aIndex) {
+            case 1: gTHIWaterDrained = 0; break;
+            case 2: gTHIWaterDrained = 1; break;
+            case 3: gTHIWaterDrained = 0; break;
+            case 4: gTHIWaterDrained = 1; break;
+        }
+        break;
+
+    case LEVEL_TTC:
+        switch (aIndex) {
+            case 1: gTTCSpeedSetting = TTC_SPEED_STOPPED; break;
+            case 2: gTTCSpeedSetting = TTC_SPEED_SLOW; break;
+            case 3: gTTCSpeedSetting = TTC_SPEED_FAST; break;
+            case 4: gTTCSpeedSetting = TTC_SPEED_RANDOM; break;
+        }
+        break;
+    }
+}
+#endif
+
+//
+// Update
+//
+
+static void *DynOS_Warp_UpdateWarp(void *aCmd, bool aIsLevelInitDone) {
+    static s32 sDynosWarpTargetArea = -1;
+
+    // Phase 1 - Clear the previous level and set up the new level
+    if (sDynosWarpTargetArea == -1) {
+
+        // Close the pause menu if it was open
+        optmenu_toggle();
+        level_set_transition(0, NULL);
+        gDialogBoxState = 0;
+        gMenuMode = -1;
+
+        // Cancel out every music/sound/sequence
+        for (u16 seqid = 0; seqid != SEQ_COUNT; ++seqid) {
+        stop_background_music(seqid);
+        }
+        play_shell_music();
+        stop_shell_music();
+        stop_cap_music();
+        func_80321080(0);
+        fadeout_music(0);
+        fadeout_level_music(0);
+
+        // Free everything from the current level
+        clear_objects();
+        clear_area_graph_nodes();
+        clear_areas();
+        main_pool_pop_state();
+
+        // Reset Mario's state
+        gMarioState->healCounter = 0;
+        gMarioState->hurtCounter = 0;
+        gMarioState->numCoins = 0;
+        gMarioState->input = 0;
+        gMarioState->controller->buttonPressed = 0;
+        gHudDisplay.coins = 0;
+
+        // Set up new level values
+        gCurrLevelNum = sDynosWarpLevelNum;
+        gCurrCourseNum = DynOS_Level_GetCourse(gCurrLevelNum);
+        gSavedCourseNum = gCurrCourseNum;
+        gCurrActNum = MAX(1, sDynosWarpActNum * (gCurrCourseNum <= COURSE_STAGES_MAX));
+        gDialogCourseActNum = gCurrActNum;
+        gCurrAreaIndex = sDynosWarpAreaNum;
+#ifndef DYNOS_COOP
+        DynOS_Warp_SetParam(gCurrLevelNum, DynOS_Opt_GetValue("dynos_warp_param"));
+#endif
+        sDynosWarpTargetArea = gCurrAreaIndex;
+
+        // Set up new level script
+        sWarpDest.type = 0;
+        sWarpDest.levelNum = 0;
+        sWarpDest.areaIdx = gCurrAreaIndex;
+        sWarpDest.nodeId = 0;
+        sWarpDest.arg = 0;
+        return (void *) DynOS_Level_GetScript(gCurrLevelNum);
+
+    } else {
+    
+        // Phase 2 - Set Mario spawn info after the MARIO_POS command
+        if (*((u8 *) aCmd) == 0x2B) {
+            gMarioSpawnInfo->areaIndex = sDynosWarpTargetArea;
+            gCurrAreaIndex = sDynosWarpTargetArea;
+        }
+
+        // Phase 3 - End level initialization
+        if (aIsLevelInitDone) {
+
+            // Init Mario
+            s16 *_LevelEntryWarp = DynOS_Level_GetWarpEntry(gCurrLevelNum, gCurrAreaIndex);
+            s16 sDynosWarpSpawnType = sSpawnTypeFromWarpBhv[_LevelEntryWarp[2]];
+            gMarioSpawnInfo->startPos[0] = _LevelEntryWarp[3] + (sDynosWarpSpawnType == MARIO_SPAWN_DOOR_WARP) * 300.0f * sins(_LevelEntryWarp[6]);
+            gMarioSpawnInfo->startPos[1] = _LevelEntryWarp[4];
+            gMarioSpawnInfo->startPos[2] = _LevelEntryWarp[5] + (sDynosWarpSpawnType == MARIO_SPAWN_DOOR_WARP) * 300.0f * coss(_LevelEntryWarp[6]);
+            gMarioSpawnInfo->startAngle[0] = 0;
+            gMarioSpawnInfo->startAngle[1] = _LevelEntryWarp[6];
+            gMarioSpawnInfo->startAngle[2] = 0;
+            gMarioSpawnInfo->areaIndex = gCurrAreaIndex;
+            init_mario();
+            set_mario_initial_action(gMarioState, sDynosWarpSpawnType, 0);
+#ifndef DYNOS_COOP
+            DynOS_Warp_SetParam(gCurrLevelNum, DynOS_Opt_GetValue("dynos_warp_param"));
+#endif
+
+            // Init transition
+            reset_camera(gCurrentArea->camera);
+            init_camera(gCurrentArea->camera);
+            sDelayedWarpOp = WARP_OP_NONE;
+            switch (sDynosWarpSpawnType) {
+                case MARIO_SPAWN_UNKNOWN_03:           play_transition(WARP_TRANSITION_FADE_FROM_STAR,   0x10, 0x00, 0x00, 0x00); break;
+                case MARIO_SPAWN_DOOR_WARP:            play_transition(WARP_TRANSITION_FADE_FROM_CIRCLE, 0x10, 0x00, 0x00, 0x00); break;
+                case MARIO_SPAWN_TELEPORT:             play_transition(WARP_TRANSITION_FADE_FROM_COLOR,  0x14, 0xFF, 0xFF, 0xFF); break;
+                case MARIO_SPAWN_SPIN_AIRBORNE:        play_transition(WARP_TRANSITION_FADE_FROM_COLOR,  0x1A, 0xFF, 0xFF, 0xFF); break;
+                case MARIO_SPAWN_SPIN_AIRBORNE_CIRCLE: play_transition(WARP_TRANSITION_FADE_FROM_CIRCLE, 0x10, 0x00, 0x00, 0x00); break;
+                case MARIO_SPAWN_UNKNOWN_27:           play_transition(WARP_TRANSITION_FADE_FROM_COLOR,  0x10, 0x00, 0x00, 0x00); break;
+                default:                               play_transition(WARP_TRANSITION_FADE_FROM_STAR,   0x10, 0x00, 0x00, 0x00); break;
+            }
+
+            // Set music
+            set_background_music(gCurrentArea->musicParam, gCurrentArea->musicParam2, 0);
+            if (gMarioState->flags & MARIO_METAL_CAP)  play_cap_music(SEQUENCE_ARGS(4, SEQ_EVENT_METAL_CAP));
+            if (gMarioState->flags & MARIO_VANISH_CAP) play_cap_music(SEQUENCE_ARGS(4, SEQ_EVENT_POWERUP));
+            if (gMarioState->flags & MARIO_WING_CAP)   play_cap_music(SEQUENCE_ARGS(4, SEQ_EVENT_POWERUP));
+            if (gCurrLevelNum == LEVEL_BOWSER_1 ||
+                gCurrLevelNum == LEVEL_BOWSER_2 ||
+                gCurrLevelNum == LEVEL_BOWSER_3) {
+                sound_banks_enable(0, 0xFFFF); // Bowser levels sound fix
+            }
+
+            // Reset values
+            sDynosWarpTargetArea = -1;
+            sDynosWarpLevelNum   = -1;
+            sDynosWarpAreaNum    = -1;
+            sDynosWarpActNum     = -1;
+        }
+    }
+
+    return NULL;
+}
+
+static void DynOS_Warp_FindExitPosition(s16 &aPosX, s16 &aPosY, s16 &aPosZ, s16 aFYaw, f32 aDist) {
+    for (f32 _Dist = aDist; _Dist > 0.f; _Dist -= 10.f) {
+        f32 _PosX = (f32) aPosX + _Dist * sins(aFYaw + 0x8000);
+        f32 _PosZ = (f32) aPosZ + _Dist * coss(aFYaw + 0x8000);
+        for (f32 _DeltaY = 0.f; _DeltaY <= 5000.f; _DeltaY += 100.f) {
+            f32 _PosY = (f32) aPosY + _DeltaY;
+            struct Surface *_Floor;
+            f32 _FloorY = find_floor(_PosX, _PosY, _PosZ, &_Floor);
+            if (_Floor &&
+                _Floor->type != SURFACE_WARP &&
+                _Floor->type != SURFACE_BURNING &&
+                _Floor->type != SURFACE_DEATH_PLANE &&
+                _Floor->type != SURFACE_VERTICAL_WIND &&
+                _Floor->type != SURFACE_DEEP_QUICKSAND &&
+                _Floor->type != SURFACE_INSTANT_QUICKSAND &&
+                _Floor->type != SURFACE_INSTANT_MOVING_QUICKSAND) {
+                aPosX = _PosX;
+                aPosY = _FloorY;
+                aPosZ = _PosZ;
+                return;
+            }
+        }
+    }
+}
+
+static void *DynOS_Warp_UpdateExit(void *aCmd, bool aIsLevelInitDone) {
+    static s32  sDynosExitTargetArea = -1;
+    static s16 *sDynosExitTargetWarp = NULL;
+
+    // Phase 0 - Wait for the Mario head transition to end
+    if (sDynosExitTargetArea == -1 && DynOS_IsTransitionActive()) {
+        return NULL;
+    }
+
+    // Phase 1 - Clear the previous level and set up the new level
+    if (sDynosExitTargetArea == -1) {
+
+        // Bowser levels
+        if (sDynosExitLevelNum == LEVEL_BOWSER_1) sDynosExitLevelNum = LEVEL_BITDW;
+        if (sDynosExitLevelNum == LEVEL_BOWSER_2) sDynosExitLevelNum = LEVEL_BITFS;
+        if (sDynosExitLevelNum == LEVEL_BOWSER_3) sDynosExitLevelNum = LEVEL_BITS;
+
+        // Exit warp to Castle warp
+        // Uses the death warp, as it's the only warp that exists for every stage in the game
+        s16 *_ExitWarp = DynOS_Level_GetWarpDeath(sDynosExitLevelNum, sDynosExitAreaNum);
+        sDynosExitTargetWarp = DynOS_Level_GetWarp(_ExitWarp[7], _ExitWarp[8], _ExitWarp[9]);
+
+        // Free everything from the current level
+        clear_objects();
+        clear_area_graph_nodes();
+        clear_areas();
+        main_pool_pop_state();
+
+        // Reset Mario's state
+        gMarioState->healCounter = 0;
+        gMarioState->hurtCounter = 0;
+        gMarioState->numCoins = 0;
+        gMarioState->input = 0;
+        gMarioState->controller->buttonPressed = 0;
+        gHudDisplay.coins = 0;
+
+        // Set up new level values
+        gCurrLevelNum = _ExitWarp[7];
+        gCurrCourseNum = DynOS_Level_GetCourse(gCurrLevelNum);
+        gSavedCourseNum = gCurrCourseNum;
+        gDialogCourseActNum = gCurrActNum;
+        gCurrAreaIndex = _ExitWarp[8];
+        sDynosExitTargetArea = _ExitWarp[8];
+
+        // Set up new level script
+        sWarpDest.type = 0;
+        sWarpDest.levelNum = 0;
+        sWarpDest.areaIdx = gCurrAreaIndex;
+        sWarpDest.nodeId = 0;
+        sWarpDest.arg = 0;
+        return (void *) DynOS_Level_GetScript(gCurrLevelNum);
+
+    } else {
+    
+        // Phase 2 - Set Mario spawn info after the MARIO_POS command
+        if (*((u8 *) aCmd) == 0x2B) {
+            gMarioSpawnInfo->areaIndex = sDynosExitTargetArea;
+            gCurrAreaIndex = sDynosExitTargetArea;
+        }
+
+        // Phase 3 - End level initialization
+        if (sDynosExitTargetWarp && aIsLevelInitDone) {
+            
+            // Find target position
+            // Because of course, every hack has its own warp distances and orientations...
+            s16 _TargetPosX = sDynosExitTargetWarp[3];
+            s16 _TargetPosY = sDynosExitTargetWarp[4];
+            s16 _TargetPosZ = sDynosExitTargetWarp[5];
+            s16 _TargetFYaw = sDynosExitTargetWarp[6];
+            s16 _TargetDYaw = 0;
+            f32 _TargetDist = 500.f;
+            DynOS_Warp_FindExitPosition(_TargetPosX, _TargetPosY, _TargetPosZ, _TargetFYaw + _TargetDYaw, _TargetDist);
+
+            // Init Mario
+            gMarioSpawnInfo->startPos[0] = _TargetPosX;
+            gMarioSpawnInfo->startPos[1] = _TargetPosY;
+            gMarioSpawnInfo->startPos[2] = _TargetPosZ;
+            gMarioSpawnInfo->startAngle[0] = 0;
+            gMarioSpawnInfo->startAngle[1] = _TargetFYaw + _TargetDYaw;
+            gMarioSpawnInfo->startAngle[2] = 0;
+            gMarioSpawnInfo->areaIndex = gCurrAreaIndex;
+            init_mario();
+            set_mario_initial_action(gMarioState, MARIO_SPAWN_UNKNOWN_02, 0);
+
+            // Init transition
+            reset_camera(gCurrentArea->camera);
+            init_camera(gCurrentArea->camera);
+            sDelayedWarpOp = WARP_OP_NONE;
+            play_transition(WARP_TRANSITION_FADE_FROM_STAR, 15, 0x00, 0x00, 0x00);
+            play_sound(SOUND_MENU_MARIO_CASTLE_WARP, gDefaultSoundArgs);
+
+            // Set music
+            set_background_music(gCurrentArea->musicParam, gCurrentArea->musicParam2, 0);
+            sDynosExitTargetWarp = NULL;
+        }
+
+        // Phase 4 - Unlock Mario as soon as the second transition is ended
+        if (!sDynosExitTargetWarp && !DynOS_IsTransitionActive()) {
+            sDynosExitTargetArea = -1;
+            sDynosExitLevelNum   = -1;
+            sDynosExitAreaNum    = -1;
+        }
+    }
+
+    return NULL;
+}
+
+void *DynOS_Warp_Update(void *aCmd, bool aIsLevelInitDone) {
+
+    // Level Exit
+    if (sDynosExitLevelNum != -1 &&
+        sDynosExitAreaNum != -1) {
+        return DynOS_Warp_UpdateExit(aCmd, aIsLevelInitDone);
+    }
+
+    // Level Warp
+    if (sDynosWarpLevelNum != -1 &&
+        sDynosWarpAreaNum != -1 &&
+        sDynosWarpActNum != -1) {
+        return DynOS_Warp_UpdateWarp(aCmd, aIsLevelInitDone);
+    }
+
+#ifndef DYNOS_COOP
+    // Reset DDD settings to default
+    if (gCurrCourseNum == COURSE_NONE) {
+        gDDDBowsersSub = -1;
+        gDDDPoles = -1;
+    }
+#endif
+
+    return NULL;
+}
diff --git a/dynos.mk b/dynos.mk
new file mode 100644
index 00000000..349e3128
--- /dev/null
+++ b/dynos.mk
@@ -0,0 +1,27 @@
+# ----------------------
+# Dynamic Options System
+# ----------------------
+
+DYNOS_INPUT_DIR := ./dynos
+DYNOS_OUTPUT_DIR := $(BUILD_DIR)/dynos
+DYNOS_PACKS_DIR := $(BUILD_DIR)/dynos/packs
+DYNOS_INIT := \
+    mkdir -p $(DYNOS_INPUT_DIR); \
+    mkdir -p $(DYNOS_OUTPUT_DIR); \
+    mkdir -p $(DYNOS_PACKS_DIR); \
+    cp -f -r $(DYNOS_INPUT_DIR) $(BUILD_DIR) 2>/dev/null || true ;
+
+DYNOS_DO := $(shell $(call DYNOS_INIT))
+INCLUDE_CFLAGS += -DDYNOS
+
+$(BUILD_DIR)/data/dynos_opt_vanilla_c.o: $(BUILD_DIR)/include/text_strings.h
+
+# ----
+# Coop
+# ----
+
+SM64EX_COOP := $(or $(and $(wildcard src/pc/network/network.h),1),0)
+ifeq ($(SM64EX_COOP),1)
+INCLUDE_CFLAGS += -DDYNOS_COOP
+endif
+
diff --git a/dynos/cheater_menu.txt b/dynos/cheater_menu.txt
new file mode 100644
index 00000000..c186acc4
--- /dev/null
+++ b/dynos/cheater_menu.txt
@@ -0,0 +1,34 @@
+# Dynamic Options System aka DynOS v0.4
+# By PeachyPeach
+#
+# This is a comment
+# Here are the available commands:
+# SUBMENU [Name] [Label] [Label2]
+# TOGGLE  [Name] [Label] [ConfigName] [InitialValue]
+# SCROLL  [Name] [Label] [ConfigName] [InitialValue] [Min] [Max] [Step]
+# CHOICE  [Name] [Label] [ConfigName] [InitialValue] [ChoiceStrings...]
+# BIND    [Name] [Label] [ConfigName] [Mask] [DefaultValues]
+# BUTTON  [Name] [Label] [FuncName]
+# ENDMENU
+#
+# Valid Label characters:
+# 0-9 A-Z a-z
+# '.,-()&:!%?"~_
+#
+
+
+SUBMENU "cheater_submenu" "CHEATER" "CHEATER"
+	TOGGLE	"chaos_mode"	"CHAOS MODE"			"chaos_mode"	0
+	BIND	"time_button"	"Time Stop Button"		"time_button"	0x0080	0x0008 0x1001 0xFFFF
+	SUBMENU "che_submenu" "New Cheats!" "CHEATER"
+		TOGGLE	"no_heavy"	"No Hold Heavy"			"no_heavy"		0
+		TOGGLE	"swim_any"	"Swim Anywhere"			"swim_any"		0
+		TOGGLE	"haz_walk"	"Walk On Hazards"		"haz_walk"		0
+		TOGGLE	"coin_mag"	"Coin Magnet"			"coin_mag"		0
+		SCROLL	"spl"		"Spamba Per Level"		"spl"			0 0 7 1
+	ENDMENU
+	SUBMENU "wat_submenu" "Drain JRB?" "CHEATER"
+		TOGGLE	"wat_con"	"Water Control"			"wat_con"		0
+		SCROLL	"wat_lev"	"Water Level (9)"		"wat_lev"		0 1 20 1
+	ENDMENU
+ENDMENU
diff --git a/enhancements/60fps_ex.patch_installed b/enhancements/60fps_ex.patch_installed
new file mode 100644
index 00000000..e69de29b
diff --git a/enhancements/DynOS.1.0.patch_installed b/enhancements/DynOS.1.0.patch_installed
new file mode 100644
index 00000000..e69de29b
diff --git a/enhancements/exit_course_50_coin_fix.patch_installed b/enhancements/exit_course_50_coin_fix.patch_installed
new file mode 100644
index 00000000..e69de29b
diff --git a/enhancements/increase_delay_on_credits.patch_installed b/enhancements/increase_delay_on_credits.patch_installed
new file mode 100644
index 00000000..e69de29b
diff --git a/enhancements/increase_delay_on_star_select.patch_installed b/enhancements/increase_delay_on_star_select.patch_installed
new file mode 100644
index 00000000..e69de29b
diff --git a/enhancements/leave_ending_screen.patch_installed b/enhancements/leave_ending_screen.patch_installed
new file mode 100644
index 00000000..e69de29b
diff --git a/enhancements/time_trials.2.4.hotfix.patch_installed b/enhancements/time_trials.2.4.hotfix.patch_installed
new file mode 100644
index 00000000..e69de29b
diff --git a/enhancements/v11.5.ex.patch_installed b/enhancements/v11.5.ex.patch_installed
new file mode 100644
index 00000000..e69de29b
diff --git a/include/libc/time.h b/include/libc/time.h
new file mode 100644
index 00000000..907fcbee
--- /dev/null
+++ b/include/libc/time.h
@@ -0,0 +1,234 @@
+/* Copyright (C) 1991-2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+/*
+ *        ISO C99 Standard: 7.23 Date and time        <time.h>
+ */
+#ifndef        _TIME_H
+#define _TIME_H        1
+#include <features.h>
+#define __need_size_t
+#define __need_NULL
+#include <stddef.h>
+/* This defines CLOCKS_PER_SEC, which is the number of processor clock
+   ticks per second, and possibly a number of other constants.   */
+#include <bits/time.h>
+/* Many of the typedefs and structs whose official home is this header
+   may also need to be defined by other headers.  */
+#include <bits/types/clock_t.h>
+#include <bits/types/time_t.h>
+#include <bits/types/struct_tm.h>
+#if defined __USE_POSIX199309 || defined __USE_ISOC11
+# include <bits/types/struct_timespec.h>
+#endif
+#ifdef __USE_POSIX199309
+# include <bits/types/clockid_t.h>
+# include <bits/types/timer_t.h>
+# include <bits/types/struct_itimerspec.h>
+struct sigevent;
+#endif
+#ifdef __USE_XOPEN2K
+# ifndef __pid_t_defined
+typedef __pid_t pid_t;
+#  define __pid_t_defined
+# endif
+#endif
+#ifdef __USE_XOPEN2K8
+# include <bits/types/locale_t.h>
+#endif
+#ifdef __USE_ISOC11
+/* Time base values for timespec_get.  */
+# define TIME_UTC 1
+#endif
+__BEGIN_DECLS
+/* Time used by the program so far (user time + system time).
+   The result / CLOCKS_PER_SECOND is program time in seconds.  */
+extern clock_t clock (void) __THROW;
+/* Return the current time and put it in *TIMER if TIMER is not NULL.  */
+extern time_t time (time_t *__timer) __THROW;
+/* Return the difference between TIME1 and TIME0.  */
+extern double difftime (time_t __time1, time_t __time0)
+     __THROW __attribute__ ((__const__));
+/* Return the `time_t' representation of TP and normalize TP.  */
+extern time_t mktime (struct tm *__tp) __THROW;
+/* Format TP into S according to FORMAT.
+   Write no more than MAXSIZE characters and return the number
+   of characters written, or 0 if it would exceed MAXSIZE.  */
+extern size_t strftime (char *__restrict __s, size_t __maxsize,
+                        const char *__restrict __format,
+                        const struct tm *__restrict __tp) __THROW;
+#ifdef __USE_XOPEN
+/* Parse S according to FORMAT and store binary time information in TP.
+   The return value is a pointer to the first unparsed character in S.  */
+extern char *strptime (const char *__restrict __s,
+                       const char *__restrict __fmt, struct tm *__tp)
+     __THROW;
+#endif
+#ifdef __USE_XOPEN2K8
+/* Similar to the two functions above but take the information from
+   the provided locale and not the global locale.  */
+extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
+                          const char *__restrict __format,
+                          const struct tm *__restrict __tp,
+                          locale_t __loc) __THROW;
+#endif
+#ifdef __USE_GNU
+extern char *strptime_l (const char *__restrict __s,
+                         const char *__restrict __fmt, struct tm *__tp,
+                         locale_t __loc) __THROW;
+#endif
+/* Return the `struct tm' representation of *TIMER
+   in Universal Coordinated Time (aka Greenwich Mean Time).  */
+extern struct tm *gmtime (const time_t *__timer) __THROW;
+/* Return the `struct tm' representation
+   of *TIMER in the local timezone.  */
+extern struct tm *localtime (const time_t *__timer) __THROW;
+#ifdef __USE_POSIX
+/* Return the `struct tm' representation of *TIMER in UTC,
+   using *TP to store the result.  */
+extern struct tm *gmtime_r (const time_t *__restrict __timer,
+                            struct tm *__restrict __tp) __THROW;
+/* Return the `struct tm' representation of *TIMER in local time,
+   using *TP to store the result.  */
+extern struct tm *localtime_r (const time_t *__restrict __timer,
+                               struct tm *__restrict __tp) __THROW;
+#endif        /* POSIX */
+/* Return a string of the form "Day Mon dd hh:mm:ss yyyy\n"
+   that is the representation of TP in this format.  */
+extern char *asctime (const struct tm *__tp) __THROW;
+/* Equivalent to `asctime (localtime (timer))'.  */
+extern char *ctime (const time_t *__timer) __THROW;
+#ifdef __USE_POSIX
+/* Reentrant versions of the above functions.  */
+/* Return in BUF a string of the form "Day Mon dd hh:mm:ss yyyy\n"
+   that is the representation of TP in this format.  */
+extern char *asctime_r (const struct tm *__restrict __tp,
+                        char *__restrict __buf) __THROW;
+/* Equivalent to `asctime_r (localtime_r (timer, *TMP*), buf)'.  */
+extern char *ctime_r (const time_t *__restrict __timer,
+                      char *__restrict __buf) __THROW;
+#endif        /* POSIX */
+/* Defined in localtime.c.  */
+extern char *__tzname[2];        /* Current timezone names.  */
+extern int __daylight;                /* If daylight-saving time is ever in use.  */
+extern long int __timezone;        /* Seconds west of UTC.  */
+#ifdef        __USE_POSIX
+/* Same as above.  */
+extern char *tzname[2];
+/* Set time conversion information from the TZ environment variable.
+   If TZ is not defined, a locale-dependent default is used.  */
+extern void tzset (void) __THROW;
+#endif
+#if defined __USE_MISC || defined __USE_XOPEN
+extern int daylight;
+extern long int timezone;
+#endif
+#ifdef __USE_MISC
+/* Set the system time to *WHEN.
+   This call is restricted to the superuser.  */
+extern int stime (const time_t *__when) __THROW;
+#endif
+/* Nonzero if YEAR is a leap year (every 4 years,
+   except every 100th isn't, and every 400th is).  */
+#define __isleap(year)        \
+  ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
+#ifdef __USE_MISC
+/* Miscellaneous functions many Unices inherited from the public domain
+   localtime package.  These are included only for compatibility.  */
+/* Like `mktime', but for TP represents Universal Time, not local time.  */
+extern time_t timegm (struct tm *__tp) __THROW;
+/* Another name for `mktime'.  */
+extern time_t timelocal (struct tm *__tp) __THROW;
+/* Return the number of days in YEAR.  */
+extern int dysize (int __year) __THROW  __attribute__ ((__const__));
+#endif
+#ifdef __USE_POSIX199309
+/* Pause execution for a number of nanoseconds.
+   This function is a cancellation point and therefore not marked with
+   __THROW.  */
+extern int nanosleep (const struct timespec *__requested_time,
+                      struct timespec *__remaining);
+/* Get resolution of clock CLOCK_ID.  */
+extern int clock_getres (clockid_t __clock_id, struct timespec *__res) __THROW;
+/* Get current value of clock CLOCK_ID and store it in TP.  */
+extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) __THROW;
+/* Set clock CLOCK_ID to value TP.  */
+extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
+     __THROW;
+# ifdef __USE_XOPEN2K
+/* High-resolution sleep with the specified clock.
+   This function is a cancellation point and therefore not marked with
+   __THROW.  */
+extern int clock_nanosleep (clockid_t __clock_id, int __flags,
+                            const struct timespec *__req,
+                            struct timespec *__rem);
+/* Return clock ID for CPU-time clock.  */
+extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) __THROW;
+# endif
+/* Create new per-process timer using CLOCK_ID.  */
+extern int timer_create (clockid_t __clock_id,
+                         struct sigevent *__restrict __evp,
+                         timer_t *__restrict __timerid) __THROW;
+/* Delete timer TIMERID.  */
+extern int timer_delete (timer_t __timerid) __THROW;
+/* Set timer TIMERID to VALUE, returning old value in OVALUE.  */
+extern int timer_settime (timer_t __timerid, int __flags,
+                          const struct itimerspec *__restrict __value,
+                          struct itimerspec *__restrict __ovalue) __THROW;
+/* Get current value of timer TIMERID and store it in VALUE.  */
+extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
+     __THROW;
+/* Get expiration overrun for timer TIMERID.  */
+extern int timer_getoverrun (timer_t __timerid) __THROW;
+#endif
+#ifdef __USE_ISOC11
+/* Set TS to calendar time based in time base BASE.  */
+extern int timespec_get (struct timespec *__ts, int __base)
+     __THROW __nonnull ((1));
+#endif
+#ifdef __USE_XOPEN_EXTENDED
+/* Set to one of the following values to indicate an error.
+     1  the DATEMSK environment variable is null or undefined,
+     2  the template file cannot be opened for reading,
+     3  failed to get file status information,
+     4  the template file is not a regular file,
+     5  an error is encountered while reading the template file,
+     6  memory allication failed (not enough memory available),
+     7  there is no line in the template that matches the input,
+     8  invalid input specification Example: February 31 or a time is
+        specified that can not be represented in a time_t (representing
+        the time in seconds since 00:00:00 UTC, January 1, 1970) */
+extern int getdate_err;
+/* Parse the given string as a date specification and return a value
+   representing the value.  The templates from the file identified by
+   the environment variable DATEMSK are used.  In case of an error
+   `getdate_err' is set.
+   This function is a possible cancellation point and therefore not
+   marked with __THROW.  */
+extern struct tm *getdate (const char *__string);
+#endif
+#ifdef __USE_GNU
+/* Since `getdate' is not reentrant because of the use of `getdate_err'
+   and the static buffer to return the result in, we provide a thread-safe
+   variant.  The functionality is the same.  The result is returned in
+   the buffer pointed to by RESBUFP and in case of an error the return
+   value is != 0 with the same values as given above for `getdate_err'.
+   This function is not part of POSIX and therefore no official
+   cancellation point.  But due to similarity with an POSIX interface
+   or due to the implementation it is a cancellation point and
+   therefore not marked with __THROW.  */
+extern int getdate_r (const char *__restrict __string,
+                      struct tm *__restrict __resbufp);
+#endif
+__END_DECLS
+#endif /* time.h.  */
\ No newline at end of file
diff --git a/include/text_cheats_strings.h.in b/include/text_cheats_strings.h.in
new file mode 100644
index 00000000..e32067d9
--- /dev/null
+++ b/include/text_cheats_strings.h.in
@@ -0,0 +1,220 @@
+#ifndef TEXT_CHEATS_STRINGS_H
+#define TEXT_CHEATS_STRINGS_H
+
+#if defined(VERSION_JP) || defined(VERSION_SH)
+
+#define TEXT_OPT_COIN      _("COIN CHEATS (HOLD B)")
+#define TEXT_OPT_HOVER     _("HOVER MODE")
+#define TEXT_OPT_MOON      _("MOON GRAVITY")
+#define TEXT_OPT_RUN       _("RUN SPEED")
+#define TEXT_OPT_NDB       _("NO DEATH BARRIER")
+#define TEXT_OPT_JUMP      _("ALL JUMPS HIGHER")
+#define TEXT_OPT_SPDDPS    _("SPEED DISPLAY")
+#define TEXT_OPT_TPF       _("T POSE FLOAT")
+#define TEXT_OPT_JB       _("SONG LIST")
+#define TEXT_OPT_JBC      _("PLAY SONG")
+#define TEXT_OPT_QUIKEND   _("QUICK ENDING")
+#define TEXT_OPT_HURT      _("HURT MARIO")
+#define TEXT_OPT_CANN      _("CANNON ANYWHERE")
+#define TEXT_OPT_AWK       _("AUTOWALLKICK")
+#define TEXT_OPT_SHELL     _("GET SHELL")
+#define TEXT_OPT_BOB       _("GET BOBOMB")
+#define TEXT_OPT_SPAMBA    _("SPAMBA")
+#define TEXT_OPT_SWIM       _("QUICK SWIM")
+#define TEXT_OPT_WING_CAP    _("GET WING CAP")
+#define TEXT_OPT_METAL_CAP    _("GET METAL CAP")
+#define TEXT_OPT_VANISH_CAP    _("GET VANISH CAP")
+#define TEXT_OPT_REMOVE_CAP    _("REMOVE CAP")
+#define TEXT_OPT_NORMAL_CAP    _("RESET CAP")
+#define TEXT_OPT_BLJ   _("BLJ ANYWHERE")
+#define TEXT_OPT_PAC   _("PLAY AS")
+#define TEXT_OPT_TRIPLE _("ALL JUMPS TRIPLE")
+#define TEXT_OPT_FLY _("FLYER")
+#define TEXT_OPT_NOB _("NO BOUNDS")
+#define TEXT_OPT_FLJ _("FORWARD LONG JUMP")
+#define TEXT_OPT_TS _("TIME STOP")
+
+#define TEXT_OPT_COIN1 _("OFF")
+#define TEXT_OPT_COIN2 _("COIN")
+#define TEXT_OPT_COIN3 _("BLUE COIN")
+#define TEXT_OPT_COIN4 _("RED COIN")
+
+#define TEXT_OPT_SS1   _("NORMAL")
+#define TEXT_OPT_SS2   _("SLOW")
+#define TEXT_OPT_SS3   _("SLOWER")
+#define TEXT_OPT_SS4   _("FAST")
+#define TEXT_OPT_SS5   _("FASTER")
+
+#define TEXT_OPT_PA1    _("DISABLED")
+#define TEXT_OPT_PA2    _("BLACK BOBOMB")
+#define TEXT_OPT_PA3    _("PINK BOBOMB")
+#define TEXT_OPT_PA4    _("GOOMBA")
+#define TEXT_OPT_PA5    _("KAPPA SHELL")
+#define TEXT_OPT_PA6    _("CHUCKYA")
+#define TEXT_OPT_PA7    _("FLYGUY")
+#define TEXT_OPT_PA8    _("PER LEVEL")
+
+#define TEXT_OPT_SEQ1    _("INTRO")
+#define TEXT_OPT_SEQ2    _("GRASS")
+#define TEXT_OPT_SEQ3    _("CASTLE")
+#define TEXT_OPT_SEQ4    _("WATER")
+#define TEXT_OPT_SEQ5    _("HOT")
+#define TEXT_OPT_SEQ6    _("BOWSER")
+#define TEXT_OPT_SEQ7    _("SNOW")
+#define TEXT_OPT_SEQ8    _("SLIDE")
+#define TEXT_OPT_SEQ9    _("SPOOKY")
+#define TEXT_OPT_SEQ10   _("UNDERGROUND")
+#define TEXT_OPT_SEQ11   _("KOOPA ROAD")
+#define TEXT_OPT_SEQ12   _("FINAL BOWSER")
+#define TEXT_OPT_SEQ13   _("TITLE")
+#define TEXT_OPT_SEQ14   _("FILE SELECT")
+#define TEXT_OPT_SEQ15   _("POWERUP")
+#define TEXT_OPT_SEQ16   _("METAL CAP")
+#define TEXT_OPT_SEQ17   _("BOSS")
+#define TEXT_OPT_SEQ18   _("MERRYGOROUND")
+#define TEXT_OPT_SEQ19   _("CREDITS")
+
+#define TEXT_OPT_HURTCHT1  _("DISABLED")
+#define TEXT_OPT_HURTCHT2  _("BURN")
+#define TEXT_OPT_HURTCHT3  _("SHOCK")
+#define TEXT_OPT_HURTCHT4  _("ONE HP")
+
+#define TEXT_OPT_SPAMCHT1  _("DISABLED")
+#define TEXT_OPT_SPAMCHT2  _("AMP")
+#define TEXT_OPT_SPAMCHT3  _("BLUE COIN SWITCH")
+#define TEXT_OPT_SPAMCHT4  _("BOWLING BALL")
+#define TEXT_OPT_SPAMCHT5  _("BREAKABLE BOX")
+#define TEXT_OPT_SPAMCHT6  _("BREAKABLE BOX SMALL")
+#define TEXT_OPT_SPAMCHT7  _("JUMPING BOX")
+#define TEXT_OPT_SPAMCHT8  _("CHECKERBOARD PLATFORM")
+#define TEXT_OPT_SPAMCHT9  _("CHUCKYA")
+#define TEXT_OPT_SPAMCHT10 _("FLYGUY")
+#define TEXT_OPT_SPAMCHT11 _("GOOMBAS")
+#define TEXT_OPT_SPAMCHT12 _("HEART")
+#define TEXT_OPT_SPAMCHT13 _("METAL BOX")
+#define TEXT_OPT_SPAMCHT14 _("PURPLE SWITCH")
+
+#define TEXT_OPT_BLJCHT1  _("DISABLED")
+#define TEXT_OPT_BLJCHT2  _("ENABLED")
+#define TEXT_OPT_BLJCHT3  _("ENABLED - BOOST: 1")
+#define TEXT_OPT_BLJCHT4  _("ENABLED - BOOST: 2")
+#define TEXT_OPT_BLJCHT5  _("ENABLED - BOOST: 3")
+#define TEXT_OPT_BLJCHT6  _("ENABLED - BOOST: 4")
+#define TEXT_OPT_BLJCHT7  _("ENABLED - BOOST: 5")
+#define TEXT_OPT_BLJCHT8  _("RAPID FIRE")
+#define TEXT_OPT_BLJCHT9  _("RAPID FIRE - BOOST: 1")
+#define TEXT_OPT_BLJCHT10 _("RAPID FIRE - BOOST: 2")
+#define TEXT_OPT_BLJCHT11 _("RAPID FIRE - BOOST: 3")
+#define TEXT_OPT_BLJCHT12 _("RAPID FIRE - BOOST: 4")
+#define TEXT_OPT_BLJCHT13 _("RAPID FIRE - BOOST: 5")
+
+#else // VERSION
+
+#define TEXT_OPT_COIN      _("Coin Cheats Hold [B]")
+#define TEXT_OPT_HOVER     _("Hover Mode")
+#define TEXT_OPT_MOON      _("Moon Gravity")
+#define TEXT_OPT_RUN       _("Run Speed Modifier")
+#define TEXT_OPT_NDB       _("No Death Barrier")
+#define TEXT_OPT_JUMP      _("All Jumps Higher")
+#define TEXT_OPT_SPDDPS    _("Speed Display")
+#define TEXT_OPT_TPF       _("T Pose Float [A]")
+#define TEXT_OPT_JB       _("Jukebox List")
+#define TEXT_OPT_JBC      _("Jukebox Activate")
+#define TEXT_OPT_QUIKEND   _("Quick Ending")
+#define TEXT_OPT_HURT      _("Hurt Mario Ｌ & [A]")
+#define TEXT_OPT_CANN      _("Cannon Anywhere Ｌ & [C]^")
+#define TEXT_OPT_AWK       _("AutoWallKick")
+#define TEXT_OPT_SHELL     _("Get Shell Ｌ & [R]")
+#define TEXT_OPT_BOB       _("Get Bobomb Ｌ & [B]")
+#define TEXT_OPT_SPAMBA    _("Spamba Ｌ & [Z]")
+#define TEXT_OPT_SWIM      _("Swift Swim")
+#define TEXT_OPT_WING_CAP  _("Get WING Cap")
+#define TEXT_OPT_METAL_CAP _("Get METAL Cap")
+#define TEXT_OPT_VANISH_CAP _("Get VANISH Cap")
+#define TEXT_OPT_REMOVE_CAP _("REMOVE Cap")
+#define TEXT_OPT_NORMAL_CAP _("RESET Cap")
+#define TEXT_OPT_BLJ       _("BLJ Anywhere")
+#define TEXT_OPT_PAC   _("Play as")
+#define TEXT_OPT_TRIPLE _("All Jumps Triple")
+#define TEXT_OPT_FLY _("FLYER")
+#define TEXT_OPT_NOB _("No Bounds")
+#define TEXT_OPT_FLJ _("Forward Long Jump")
+#define TEXT_OPT_TS _("Time Stop")
+
+#define TEXT_OPT_COIN1 _("Off")
+#define TEXT_OPT_COIN2 _("Coin")
+#define TEXT_OPT_COIN3 _("Blue Coin")
+#define TEXT_OPT_COIN4 _("Red Coin")
+
+#define TEXT_OPT_SS1   _("Normal")
+#define TEXT_OPT_SS2   _("Slow")
+#define TEXT_OPT_SS3   _("Slower")
+#define TEXT_OPT_SS4   _("Fast")
+#define TEXT_OPT_SS5   _("Faster")
+
+#define TEXT_OPT_PA1    _("Disabled")
+#define TEXT_OPT_PA2    _("Black Bobomb")
+#define TEXT_OPT_PA3    _("Pink Bobomb")
+#define TEXT_OPT_PA4    _("Goomba")
+#define TEXT_OPT_PA5    _("Koopa Shell")
+#define TEXT_OPT_PA6    _("Chuckya")
+#define TEXT_OPT_PA7    _("FlyGuy")
+#define TEXT_OPT_PA8    _("Per Level")
+
+#define TEXT_OPT_SEQ1    _("Intro")
+#define TEXT_OPT_SEQ2    _("Grass")
+#define TEXT_OPT_SEQ3    _("Castle")
+#define TEXT_OPT_SEQ4    _("Water")
+#define TEXT_OPT_SEQ5    _("Hot")
+#define TEXT_OPT_SEQ6    _("Bowser")
+#define TEXT_OPT_SEQ7    _("Snow")
+#define TEXT_OPT_SEQ8    _("Slide")
+#define TEXT_OPT_SEQ9    _("Spooky")
+#define TEXT_OPT_SEQ10   _("Underground")
+#define TEXT_OPT_SEQ11   _("Koopa Road")
+#define TEXT_OPT_SEQ12   _("Rainbow Bowser")
+#define TEXT_OPT_SEQ13   _("Goddard")
+#define TEXT_OPT_SEQ14   _("File Select")
+#define TEXT_OPT_SEQ15   _("Powerup")
+#define TEXT_OPT_SEQ16   _("Metal Cap")
+#define TEXT_OPT_SEQ17   _("Boss")
+#define TEXT_OPT_SEQ18   _("MerryGoRound")
+#define TEXT_OPT_SEQ19   _("Credits")
+
+#define TEXT_OPT_HURTCHT1  _("Disabled")
+#define TEXT_OPT_HURTCHT2  _("Burn")
+#define TEXT_OPT_HURTCHT3  _("Shock")
+#define TEXT_OPT_HURTCHT4  _("One HP")
+
+#define TEXT_OPT_SPAMCHT1  _("Disabled")
+#define TEXT_OPT_SPAMCHT2  _("Amp")
+#define TEXT_OPT_SPAMCHT3  _("Blue Coin Switch")
+#define TEXT_OPT_SPAMCHT4  _("Bowling Ball")
+#define TEXT_OPT_SPAMCHT5  _("Breakable box, large")
+#define TEXT_OPT_SPAMCHT6  _("Breakable box, small")
+#define TEXT_OPT_SPAMCHT7  _("Jumping Box")
+#define TEXT_OPT_SPAMCHT8  _("Checkerboard Platform")
+#define TEXT_OPT_SPAMCHT9  _("Chuckya")
+#define TEXT_OPT_SPAMCHT10 _("FlyGuy")
+#define TEXT_OPT_SPAMCHT11 _("Goombas")
+#define TEXT_OPT_SPAMCHT12 _("Heart")
+#define TEXT_OPT_SPAMCHT13 _("Metal Box")
+#define TEXT_OPT_SPAMCHT14 _("Purple Switch")
+
+#define TEXT_OPT_BLJCHT1  _("Disabled")
+#define TEXT_OPT_BLJCHT2  _("Enabled")
+#define TEXT_OPT_BLJCHT3  _("Enabled - Boost: 1")
+#define TEXT_OPT_BLJCHT4  _("Enabled - Boost: 2")
+#define TEXT_OPT_BLJCHT5  _("Enabled - Boost: 3")
+#define TEXT_OPT_BLJCHT6  _("Enabled - Boost: 4")
+#define TEXT_OPT_BLJCHT7  _("Enabled - Boost: 5")
+#define TEXT_OPT_BLJCHT8  _("Rapid Fire")
+#define TEXT_OPT_BLJCHT9  _("Rapid Fire - Boost: 1")
+#define TEXT_OPT_BLJCHT10 _("Rapid Fire - Boost: 2")
+#define TEXT_OPT_BLJCHT11 _("Rapid Fire - Boost: 3")
+#define TEXT_OPT_BLJCHT12 _("Rapid Fire - Boost: 4")
+#define TEXT_OPT_BLJCHT13 _("Rapid Fire - Boost: 5")
+
+#endif // VERSION
+
+#endif // TEXT_CHEATS_STRINGS_H
diff --git a/src/game/cheats_menu.h b/src/game/cheats_menu.h
new file mode 100644
index 00000000..05505491
--- /dev/null
+++ b/src/game/cheats_menu.h
@@ -0,0 +1,215 @@
+#ifndef CHEATS_MENU_H
+#define CHEATS_MENU_H
+
+static const u8 optsCoinCheatStr[][32] = {
+    { TEXT_OPT_COIN1 },
+    { TEXT_OPT_COIN2 },
+    { TEXT_OPT_COIN3 },
+    { TEXT_OPT_COIN4 },
+};
+
+static const u8 *CoinChoices[] = {
+    optsCoinCheatStr[0],
+    optsCoinCheatStr[1],
+    optsCoinCheatStr[2],
+    optsCoinCheatStr[3],
+};
+
+static const u8 optsSeqStr[][64] = {
+    { TEXT_OPT_SEQ1 },
+    { TEXT_OPT_SEQ2 },
+    { TEXT_OPT_SEQ3 },
+    { TEXT_OPT_SEQ4 },
+    { TEXT_OPT_SEQ5 },
+    { TEXT_OPT_SEQ6 },
+    { TEXT_OPT_SEQ7 },
+    { TEXT_OPT_SEQ8 },
+    { TEXT_OPT_SEQ9 },
+    { TEXT_OPT_SEQ10 },
+    { TEXT_OPT_SEQ11 },
+    { TEXT_OPT_SEQ12 },
+    { TEXT_OPT_SEQ13 },
+    { TEXT_OPT_SEQ14 },
+    { TEXT_OPT_SEQ15 },
+    { TEXT_OPT_SEQ16 },
+    { TEXT_OPT_SEQ17 },
+    { TEXT_OPT_SEQ18 },
+    { TEXT_OPT_SEQ19 },
+};
+
+static const u8 *SeqChoices[] = {
+    optsSeqStr[0],
+    optsSeqStr[1],
+    optsSeqStr[2],
+    optsSeqStr[3],
+    optsSeqStr[4],
+    optsSeqStr[5],
+    optsSeqStr[6],
+    optsSeqStr[7],
+    optsSeqStr[8],
+    optsSeqStr[9],
+    optsSeqStr[10],
+    optsSeqStr[11],
+    optsSeqStr[12],
+    optsSeqStr[13],
+    optsSeqStr[14],
+    optsSeqStr[15],
+    optsSeqStr[16],
+    optsSeqStr[17],
+    optsSeqStr[18],
+};
+
+static const u8 optsSpeedStr[][16] = {
+    { TEXT_OPT_SS1 },
+    { TEXT_OPT_SS2 },
+    { TEXT_OPT_SS3 },
+    { TEXT_OPT_SS4 },
+    { TEXT_OPT_SS5 },
+};
+
+static const u8 *SpeedChoices[] = {
+    optsSpeedStr[0],
+    optsSpeedStr[1],
+    optsSpeedStr[2],
+    optsSpeedStr[3],
+    optsSpeedStr[4],
+};
+
+static const u8 optsPlayAsCheatStr[][32] = {
+    { TEXT_OPT_PA1 },
+    { TEXT_OPT_PA2 },
+    { TEXT_OPT_PA3 },
+    { TEXT_OPT_PA4 },
+    { TEXT_OPT_PA5 },
+    { TEXT_OPT_PA6 },
+    { TEXT_OPT_PA7 },
+    { TEXT_OPT_PA8 },
+};
+
+static const u8* PlayAsCheatChoices[] = {
+    optsPlayAsCheatStr[0],
+    optsPlayAsCheatStr[1],
+    optsPlayAsCheatStr[2],
+    optsPlayAsCheatStr[3],
+    optsPlayAsCheatStr[4],
+    optsPlayAsCheatStr[5],
+    optsPlayAsCheatStr[6],
+    optsPlayAsCheatStr[7],
+};
+
+
+static const u8 optsHurtCheatStr[][32] = {
+    { TEXT_OPT_HURTCHT1 },
+    { TEXT_OPT_HURTCHT2 },
+    { TEXT_OPT_HURTCHT3 },
+    { TEXT_OPT_HURTCHT4 },
+};
+
+static const u8* HurtCheatChoices[] = {
+    optsHurtCheatStr[0],
+    optsHurtCheatStr[1],
+    optsHurtCheatStr[2],
+    optsHurtCheatStr[3],
+};
+
+static const u8 optsSpamCheatStr[][32] = {
+    { TEXT_OPT_SPAMCHT1 },
+    { TEXT_OPT_SPAMCHT2 },
+    { TEXT_OPT_SPAMCHT3 },
+    { TEXT_OPT_SPAMCHT4 },
+    { TEXT_OPT_SPAMCHT5 },
+    { TEXT_OPT_SPAMCHT6 },
+    { TEXT_OPT_SPAMCHT7 },
+    { TEXT_OPT_SPAMCHT8 },
+    { TEXT_OPT_SPAMCHT9 },
+    { TEXT_OPT_SPAMCHT10 },
+    { TEXT_OPT_SPAMCHT11 },
+    { TEXT_OPT_SPAMCHT12 },
+    { TEXT_OPT_SPAMCHT13 },
+    { TEXT_OPT_SPAMCHT14 },
+};
+
+static const u8* SpamCheatChoices[] = {
+    optsSpamCheatStr[0],
+    optsSpamCheatStr[1],
+    optsSpamCheatStr[2],
+    optsSpamCheatStr[3],
+    optsSpamCheatStr[4],
+    optsSpamCheatStr[5],
+    optsSpamCheatStr[6],
+    optsSpamCheatStr[7],
+    optsSpamCheatStr[8],
+    optsSpamCheatStr[9],
+    optsSpamCheatStr[10],
+    optsSpamCheatStr[11],
+    optsSpamCheatStr[12],
+    optsSpamCheatStr[13],
+};
+
+static const u8 optsBLJCheatStr[][32] = {
+    { TEXT_OPT_BLJCHT1 },
+    { TEXT_OPT_BLJCHT2 },
+    { TEXT_OPT_BLJCHT3 },
+    { TEXT_OPT_BLJCHT4 },
+    { TEXT_OPT_BLJCHT5 },
+    { TEXT_OPT_BLJCHT6 },
+    { TEXT_OPT_BLJCHT7 },
+    { TEXT_OPT_BLJCHT8 },
+    { TEXT_OPT_BLJCHT9 },
+    { TEXT_OPT_BLJCHT10 },
+    { TEXT_OPT_BLJCHT11 },
+    { TEXT_OPT_BLJCHT12 },
+    { TEXT_OPT_BLJCHT13 },
+};
+
+static const u8* bljCheatChoices[] = {
+    optsBLJCheatStr[0],
+    optsBLJCheatStr[1],
+    optsBLJCheatStr[2],
+    optsBLJCheatStr[3],
+    optsBLJCheatStr[4],
+    optsBLJCheatStr[5],
+    optsBLJCheatStr[6],
+    optsBLJCheatStr[7],
+    optsBLJCheatStr[8],
+    optsBLJCheatStr[9],
+    optsBLJCheatStr[10],
+    optsBLJCheatStr[11],
+    optsBLJCheatStr[12],
+};
+
+static const u8 optsCheatsStr2[][64] = {
+    { TEXT_OPT_COIN },
+    { TEXT_OPT_HOVER },
+    { TEXT_OPT_MOON },
+    { TEXT_OPT_RUN },
+    { TEXT_OPT_NDB },
+    { TEXT_OPT_JUMP },
+    { TEXT_OPT_SPDDPS },
+    { TEXT_OPT_TPF },
+    { TEXT_OPT_JB },
+    { TEXT_OPT_JBC },
+    { TEXT_OPT_QUIKEND },
+    { TEXT_OPT_HURT },
+    { TEXT_OPT_CANN },
+    { TEXT_OPT_AWK },
+    { TEXT_OPT_SHELL },
+    { TEXT_OPT_BOB },
+    { TEXT_OPT_SPAMBA },
+    { TEXT_OPT_SWIM },
+    { TEXT_OPT_WING_CAP },
+    { TEXT_OPT_METAL_CAP },
+    { TEXT_OPT_VANISH_CAP },
+    { TEXT_OPT_REMOVE_CAP },
+    { TEXT_OPT_NORMAL_CAP },
+    { TEXT_OPT_BLJ },
+    { TEXT_OPT_PAC },
+    { TEXT_OPT_TRIPLE },
+    { TEXT_OPT_FLY },
+    { TEXT_OPT_NOB },
+    { TEXT_OPT_FLJ },
+    { TEXT_OPT_TS },
+
+};
+
+#endif // CHEATS_MENU_H
diff --git a/src/game/mario_cheats.c b/src/game/mario_cheats.c
new file mode 100644
index 00000000..f156529c
--- /dev/null
+++ b/src/game/mario_cheats.c
@@ -0,0 +1,1790 @@
+#include <stdlib.h>
+#include <time.h>
+#include <PR/ultratypes.h>
+
+#include "sm64.h"
+#include "area.h"
+#include "actors/common0.h"
+#include "actors/common1.h"
+#include "actors/group0.h"
+#include "actors/group1.h"
+#include "actors/group2.h"
+#include "actors/group4.h"
+#include "actors/group5.h"
+#include "actors/group6.h"
+#include "actors/group7.h"
+#include "actors/group9.h"
+#include "actors/group10.h"
+#include "actors/group11.h"
+#include "actors/group12.h"
+#include "actors/group13.h"
+#include "actors/group14.h"
+#include "actors/group15.h"
+#include "actors/group17.h"
+#include "audio/data.h"
+#include "audio/external.h"
+#include "behavior_actions.h"
+#include "behavior_data.h"
+#include "camera.h"
+#include "engine/behavior_script.h"
+#include "engine/graph_node.h"
+#include "engine/level_script.h"
+#include "engine/math_util.h"
+#include "engine/surface_collision.h"
+#include "game_init.h"
+#include "interaction.h"
+#include "level_table.h"
+#include "level_update.h"
+#include "macros.h"
+#include "main.h"
+#include "mario.h"
+#include "mario_actions_airborne.h"
+#include "mario_actions_automatic.h"
+#include "mario_actions_cutscene.h"
+#include "mario_actions_moving.h"
+#include "mario_actions_object.h"
+#include "mario_actions_stationary.h"
+#include "mario_actions_submerged.h"
+#include "mario_cheats.h"
+#include "mario_misc.h"
+#include "mario_step.h"
+#include "memory.h"
+#include "model_ids.h"
+#include "object_fields.h"
+#include "object_helpers.h"
+#include "object_list_processor.h"
+#include "print.h"
+#include "rendering_graph_node.h"
+#include "save_file.h"
+#include "seq_ids.h"
+#include "sound_init.h"
+#include "debug.h"
+#include "thread6.h"
+#include "pc/configfile.h"
+#include "pc/cheats.h"
+#ifdef R96
+#include "sgi/utils/characters.h"
+#endif // R96
+
+
+#define SwiftSwim 42.0f
+
+/*SwiftSwim Cheat*/
+void cheats_swimming_speed(struct MarioState* m) {
+    while (m->forwardVel < SwiftSwim && Cheats.EnableCheats == true && Cheats.Swim == true) {
+        while (m->controller->buttonDown & A_BUTTON) {
+            m->particleFlags |= PARTICLE_BUBBLE;
+            m->forwardVel += 5.0f;
+            break;
+        }
+        break;
+    }
+}
+
+/*BLJAnywhere Cheat*/
+void cheats_air_step(struct MarioState *m) {
+    if (Cheats.BLJAnywhere > 0 && Cheats.EnableCheats == TRUE && m->action == ACT_LONG_JUMP
+        && m->forwardVel < 1.0f && m->pos[1] - 50.0f < m->floorHeight) {
+        if (Cheats.BLJAnywhere < 7) {
+            if (m->controller->buttonPressed & A_BUTTON) {
+                m->forwardVel -= (Cheats.BLJAnywhere - 1) * 2.5f;
+                m->vel[1] = -50.0f;
+            }
+        } else if (m->controller->buttonDown & A_BUTTON) {
+            m->forwardVel -= (Cheats.BLJAnywhere - 7) * 2.5f;
+            m->vel[1] = -50.0f;
+        }
+    }
+}
+
+void cheats_long_jump(struct MarioState *m) {
+    if (Cheats.BLJAnywhere >= 7 && Cheats.EnableCheats == true && m->forwardVel < 1.0f
+        && (m->controller->buttonDown & A_BUTTON)) {
+        set_jumping_action(m, ACT_LONG_JUMP, 0);
+    }
+}
+
+/*Main cheat function*/
+void cheats_mario_inputs(struct MarioState *m) {
+    m->particleFlags = 0;
+    m->collidedObjInteractTypes = m->marioObj->collidedObjInteractTypes;
+    m->flags &= 0xFFFFFF;
+    u32 r;
+
+    while (Cheats.EnableCheats == true) {
+
+        /*Spamba Per Level*/
+        switch (gCurrLevelNum) {
+            case LEVEL_CASTLE_GROUNDS:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 160, 200, gCurrentObject, MODEL_BIRDS, bhvBird);
+                            break;
+                        }
+                        break;
+                    case 2:
+                    case 3:
+                    case 4:
+                    case 5:
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_CASTLE_COURTYARD:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_MAD_PIANO,
+                                                  bhvMadPiano);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 150, gCurrentObject, MODEL_BOO, bhvBoo);
+                            break;
+                        }
+                        break;
+                    case 3:
+                    case 4:
+                    case 5:
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_BITDW:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_BUBBA,
+                                                  bhvBubba);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 150, gCurrentObject, MODEL_ENEMY_LAKITU,
+                                                  bhvEnemyLakitu);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 300, 300, gCurrentObject, MODEL_SWOOP,
+                                                  bhvSwoop);
+                            break;
+                        }
+                        break;
+                    case 4:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 200, gCurrentObject, MODEL_SNUFIT,
+                                                  bhvSnufit);
+                            break;
+                        }
+                        break;
+                    case 5:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 10, 200, gCurrentObject, MODEL_DORRIE,
+                                                  bhvDorrie);
+                            break;
+                        }
+                        break;
+                    case 6:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_SCUTTLEBUG,
+                                                  bhvScuttlebug);
+                            break;
+                        }
+                        break;
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_BITFS:
+            case LEVEL_LLL:
+            case LEVEL_WMOTR:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_BULLY,
+                                                  bhvSmallBully);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 300, 300, gCurrentObject, MODEL_SWOOP,
+                                                  bhvSwoop);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 200, gCurrentObject, MODEL_SNUFIT,
+                                                  bhvSnufit);
+                            break;
+                        }
+                        break;
+                    case 4:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 10, 200, gCurrentObject, MODEL_DORRIE,
+                                                  bhvDorrie);
+                            break;
+                        }
+                        break;
+                    case 5:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_SCUTTLEBUG,
+                                                  bhvScuttlebug);
+                            break;
+                        }
+                        break;
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_BITS:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject,
+                                                  MODEL_KOOPA_WITH_SHELL, bhvKoopa);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 10, 200, gCurrentObject, MODEL_PIRANHA_PLANT,
+                                                  bhvPiranhaPlant);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_WHOMP,
+                                                  bhvSmallWhomp);
+                            break;
+                        }
+                        break;
+                    case 4:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 300, gCurrentObject, MODEL_CHAIN_CHOMP,
+                                                  bhvChainChomp);
+                            break;
+                        }
+                        break;
+                    case 5:
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_BOWSER_1:
+            case LEVEL_BOWSER_2:
+            case LEVEL_BOWSER_3:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 200, 200, gCurrentObject, MODEL_BOWSER,
+                                                  bhvBowser);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 200, 200, gCurrentObject,
+                                                  MODEL_BOWSER_BOMB_CHILD_OBJ, bhvBowserBomb);
+                            break;
+                        }
+                        break;
+                    case 3:
+                    case 4:
+                    case 5:
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_BOB:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 10, 300, gCurrentObject, MODEL_KING_BOBOMB,
+                                                  bhvKingBobomb);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject,
+                                                  MODEL_KOOPA_WITH_SHELL, bhvKoopa);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 10, 200, gCurrentObject, MODEL_PIRANHA_PLANT,
+                                                  bhvPiranhaPlant);
+                            break;
+                        }
+                        break;
+                    case 4:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_WHOMP,
+                                                  bhvSmallWhomp);
+                            break;
+                        }
+                        break;
+                    case 5:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 300, gCurrentObject, MODEL_CHAIN_CHOMP,
+                                                  bhvChainChomp);
+                            break;
+                        }
+                        break;
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_BBH:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_MAD_PIANO,
+                                                  bhvMadPiano);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 150, gCurrentObject, MODEL_BOO, bhvBoo);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 300, 300, gCurrentObject, MODEL_SWOOP,
+                                                  bhvSwoop);
+                            break;
+                        }
+                        break;
+                    case 4:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 200, gCurrentObject, MODEL_SNUFIT,
+                                                  bhvSnufit);
+                            break;
+                        }
+                        break;
+                    case 5:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 10, 200, gCurrentObject, MODEL_DORRIE,
+                                                  bhvDorrie);
+                            break;
+                        }
+                        break;
+                    case 6:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_SCUTTLEBUG,
+                                                  bhvScuttlebug);
+                            break;
+                        }
+                        break;
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_WF:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 150, gCurrentObject, MODEL_THWOMP,
+                                                  bhvThwomp);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 300, 300, gCurrentObject, MODEL_BULLET_BILL,
+                                                  bhvBulletBill);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 200, gCurrentObject, MODEL_HEAVE_HO,
+                                                  bhvHeaveHo);
+                            break;
+                        }
+                        break;
+                    case 4:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject,
+                                                  MODEL_KOOPA_WITH_SHELL, bhvKoopa);
+                            break;
+                        }
+                        break;
+                    case 5:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 10, 200, gCurrentObject, MODEL_PIRANHA_PLANT,
+                                                  bhvPiranhaPlant);
+                            break;
+                        }
+                        break;
+                    case 6:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_WHOMP,
+                                                  bhvSmallWhomp);
+                            break;
+                        }
+                        break;
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 300, gCurrentObject, MODEL_CHAIN_CHOMP,
+                                                  bhvChainChomp);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_JRB:
+            case LEVEL_DDD:
+            case LEVEL_SA:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 300, gCurrentObject, MODEL_CLAM_SHELL,
+                                                  bhvClamShell);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_MANTA_RAY,
+                                                  bhvMantaRay);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 10, 100, gCurrentObject, MODEL_SUSHI,
+                                                  bhvSushiShark);
+                            break;
+                        }
+                        break;
+                    case 4:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 300, 300, gCurrentObject, MODEL_UNAGI,
+                                                  bhvUnagi);
+                            break;
+                        }
+                        break;
+                    case 5:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_SKEETER,
+                                                  bhvSkeeter);
+                            break;
+                        }
+                        break;
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_CCM:
+            case LEVEL_SL:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_SPINDRIFT,
+                                                  bhvSpindrift);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 150, gCurrentObject, MODEL_BIG_CHILL_BULLY,
+                                                  bhvBigChillBully);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 200, gCurrentObject, MODEL_MONEYBAG,
+                                                  bhvMoneybag);
+                            break;
+                        }
+                        break;
+                    case 4:
+                    case 5:
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_HMC:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 50, 100, gCurrentObject, MODEL_MONTY_MOLE,
+                                                  bhvMontyMole);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 200, gCurrentObject, MODEL_UKIKI,
+                                                  bhvUkiki);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 300, 300, gCurrentObject, MODEL_SWOOP,
+                                                  bhvSwoop);
+                            break;
+                        }
+                        break;
+                    case 4:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 200, gCurrentObject, MODEL_SNUFIT,
+                                                  bhvSnufit);
+                            break;
+                        }
+                        break;
+                    case 5:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 10, 200, gCurrentObject, MODEL_DORRIE,
+                                                  bhvDorrie);
+                            break;
+                        }
+                        break;
+                    case 6:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_SCUTTLEBUG,
+                                                  bhvScuttlebug);
+                            break;
+                        }
+                        break;
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_SSL:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 200, gCurrentObject, MODEL_POKEY_HEAD,
+                                                  bhvPokey);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 300, 300, gCurrentObject, MODEL_KLEPTO,
+                                                  bhvKlepto);
+                            break;
+                        }
+                        break;
+                    case 3:
+                    case 4:
+                    case 5:
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_WDW:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 150, gCurrentObject, MODEL_THWOMP,
+                                                  bhvThwomp);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 300, 300, gCurrentObject, MODEL_BULLET_BILL,
+                                                  bhvBulletBill);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 200, gCurrentObject, MODEL_HEAVE_HO,
+                                                  bhvHeaveHo);
+                            break;
+                        }
+                        break;
+                    case 4:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_SKEETER,
+                                                  bhvSkeeter);
+                            break;
+                        }
+                        break;
+                    case 5:
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_TTM:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_MONTY_MOLE,
+                                                  bhvMontyMole);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 200, gCurrentObject, MODEL_UKIKI,
+                                                  bhvUkiki);
+                            break;
+                        }
+                        break;
+                    case 3:
+                    case 4:
+                    case 5:
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_THI:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_BUBBA,
+                                                  bhvBubba);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 150, gCurrentObject, MODEL_ENEMY_LAKITU,
+                                                  bhvEnemyLakitu);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject,
+                                                  MODEL_KOOPA_WITH_SHELL, bhvKoopa);
+                            break;
+                        }
+                        break;
+                    case 4:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 10, 200, gCurrentObject, MODEL_PIRANHA_PLANT,
+                                                  bhvPiranhaPlant);
+                            break;
+                        }
+                        break;
+                    case 5:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_WHOMP,
+                                                  bhvSmallWhomp);
+                            break;
+                        }
+                        break;
+                    case 6:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 300, gCurrentObject, MODEL_CHAIN_CHOMP,
+                                                  bhvChainChomp);
+                            break;
+                        }
+                        break;
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_TTC:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 150, gCurrentObject, MODEL_THWOMP,
+                                                  bhvThwomp);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 300, 300, gCurrentObject, MODEL_BULLET_BILL,
+                                                  bhvBulletBill);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 200, gCurrentObject, MODEL_HEAVE_HO,
+                                                  bhvHeaveHo);
+                            break;
+                        }
+                        break;
+                    case 4:
+                    case 5:
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_RR:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_BUBBA,
+                                                  bhvBubba);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 150, gCurrentObject, MODEL_ENEMY_LAKITU,
+                                                  bhvEnemyLakitu);
+                            break;
+                        }
+                        break;
+                    case 3:
+                    case 4:
+                    case 5:
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+            case LEVEL_COTMC:
+                switch (SPL) {
+                    case 0:
+                        break;
+                    case 1:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 300, 300, gCurrentObject, MODEL_SWOOP,
+                                                  bhvSwoop);
+                            break;
+                        }
+                        break;
+                    case 2:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 200, gCurrentObject, MODEL_SNUFIT,
+                                                  bhvSnufit);
+                            break;
+                        }
+                        break;
+                    case 3:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 10, 200, gCurrentObject, MODEL_DORRIE,
+                                                  bhvDorrie);
+                            break;
+                        }
+                        break;
+                    case 4:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_SCUTTLEBUG,
+                                                  bhvScuttlebug);
+                            break;
+                        }
+                        break;
+                    case 5:
+                    case 6:
+                    case 7:
+                        if (m->controller->buttonDown & L_TRIG
+                            && m->controller->buttonPressed & Z_TRIG) {
+                            play_sound(SOUND_MENU_CAMERA_BUZZ, gDefaultSoundArgs);
+                            break;
+                        }
+                        break;
+                }
+                break;
+        }
+
+        /*Drain JRB?*/
+        f32 watLev;
+        watLev -= 800;
+        if (WAT_CON == 1) {
+            watLev += WAT_LEV * 100;
+        }
+        if (WAT_CON == 1 && gCurrLevelNum == LEVEL_JRB) {
+            gEnvironmentRegions[6] = approach_f32_symmetric(gEnvironmentRegions[6], watLev * 10, 10.0f);
+            gEnvironmentRegions[12] = approach_f32_symmetric(gEnvironmentRegions[12], watLev * 10, 10.0f);
+        }
+
+        /*Coin Magnet*/
+        struct Object* coinMag = cur_obj_nearest_object_with_behavior(bhvYellowCoin);
+        struct Object* coinMagMove = cur_obj_nearest_object_with_behavior(bhvMovingYellowCoin);
+        f32 oDist;
+        f32 oDistMove;
+        if (coinMag != NULL && m->marioObj != NULL) {
+            oDist = dist_between_objects(coinMag, m->marioObj);
+        }
+        if (coinMagMove != NULL && m->marioObj != NULL) {
+            oDistMove = dist_between_objects(coinMagMove, m->marioObj);
+        }
+        while (COIN_MAG == 1 && oDist != 0 && oDist >= 100 && oDist < 1000) {
+            while (oDist >= 10) {
+                coinMag->oPosX = approach_f32_symmetric(coinMag->oPosX, m->pos[0], 28);
+                coinMag->oPosY = approach_f32_symmetric(coinMag->oPosY, m->pos[1], 28);
+                coinMag->oPosZ = approach_f32_symmetric(coinMag->oPosZ, m->pos[2], 28);
+                break;
+            }
+            break;
+        }
+        if (oDist == 0 && oDist > 1000) {
+            obj_mark_for_deletion(coinMag);
+            break;
+        }
+        while (COIN_MAG == 1 && coinMagMove != NULL && oDistMove >= 100 && oDistMove < 1000) {
+            while (oDistMove >= 10) {
+                coinMagMove->oPosX = approach_f32_symmetric(coinMagMove->oPosX, m->pos[0], 28);
+                coinMagMove->oPosY = approach_f32_symmetric(coinMagMove->oPosY, m->pos[1], 28);
+                coinMagMove->oPosZ = approach_f32_symmetric(coinMagMove->oPosZ, m->pos[2], 28);
+                break;
+            }
+            break;
+        }
+        if (oDistMove == 0 && oDistMove > 1000) {
+            obj_mark_for_deletion(coinMagMove);
+            break;
+        }
+
+        /*Swim Anywhere*/
+        if (SWIM_ANY == 1) {
+            set_submerged_cam_preset_and_spawn_bubbles(m);
+            m->waterLevel = m->pos[1] + 300;
+        }
+
+        /*No Hold Heavy*/
+        if (NO_HEAVY == 1) {
+            while ((m->action & ACT_GROUP_MASK) == ACT_GROUP_MOVING) {
+                if (m->action == ACT_HOLD_HEAVY_WALKING) {
+                    set_mario_action(m, ACT_HOLD_WALKING, 0);
+                    break;
+                }
+                break;
+            }
+        }
+
+        /*CHAOS Mode*/
+        if (CHAOS_MODE == 1) {
+            srand(time(NULL));
+            r = rand();
+
+            switch ((rand() % 30)) {
+                case 0:
+                    if (Cheats.Run <= 3) {
+                        Cheats.Run += 1;
+                    } else if (Cheats.Run >= 4) {
+                        Cheats.Run = 0;
+                    }
+                    break;
+                case 1:
+                    if (Cheats.HugeMario == true) {
+                        Cheats.HugeMario = false;
+                    } else {
+                        Cheats.HugeMario = true;
+                    }
+                    break;
+                case 2:
+                    if (Cheats.TinyMario == true) {
+                        Cheats.TinyMario = false;
+                    } else {
+                        Cheats.TinyMario = true;
+                    }
+                    break;
+                case 3:
+                    if (Cheats.Moon == true) {
+                        Cheats.Moon = false;
+                    } else {
+                        Cheats.Moon = true;
+                    }
+                    break;
+                case 4:
+                    if (Cheats.Jump == true) {
+                        Cheats.Jump = false;
+                    } else {
+                        Cheats.Jump = true;
+                    }
+                    break;
+                case 5:
+                    play_transition(WARP_TRANSITION_FADE_FROM_COLOR, 0x3C, 0xFF, 0xFF, 0xFF);
+                    break;
+                case 6:
+                    if (Cheats.Triple == true) {
+                        Cheats.Triple = false;
+                    } else {
+                        Cheats.Triple = true;
+                    }
+                    break;
+                case 7:
+                    obj_spawn_yellow_coins(m->marioObj, 1);
+                    break;
+                case 8:
+                    if (Cheats.PAC <= 6) {
+                        Cheats.PAC += 1;
+                    } else if (Cheats.PAC >= 7) {
+                        Cheats.PAC = 0;
+                    }
+                    break;
+                case 9:
+                    hurt_and_set_mario_action(m, ACT_FORWARD_AIR_KB, 0, 0);
+                    break;
+                case 10:
+                    cur_obj_shake_screen(SHAKE_POS_SMALL);
+                    break;
+                case 11:
+                    m->forwardVel = (m->forwardVel + 5.0f);
+                    break;
+                case 12:
+                    m->vel[1] -= 5;
+                    break;
+                case 13:
+                    // Empty Slot
+                    break;
+                case 14:
+                    // Empty Slot
+                    break;
+                case 15:
+                    // Empty Slot
+                    break;
+                case 16:
+                case 17:
+                    while (1) {
+                        print_text_fmt_int(90, 70, "CH3 %d 4T3R", m->forwardVel);
+                        break;
+                    }
+                    break;
+                case 18:
+                case 19:
+                    while (1) {
+                        print_text_fmt_int(90, 70, "%d CHEATER %d", m->forwardVel);
+                        break;
+                    }
+                    break;
+                case 20:
+                case 21:
+                case 22:
+                case 23:
+                case 24:
+                case 25:
+                case 26:
+                case 27:
+                case 28:
+                case 29:
+                case 30:
+                    while (1) {
+                        print_text(240, 92, " ");
+                        break;
+                    }
+                    break;
+            }
+        }
+
+        /*Time Stop Cheat*/
+        if (Cheats.TimeStop) {
+            enable_time_stop();
+        }
+        if (!Cheats.TimeStop) {
+            gTimeStopState &= ~(TIME_STOP_ENABLED);
+        }
+        /* Time Stop DynOS emhancements*/
+        if (Cheats.TimeSlow && Cheats.TimeStop == false && !(m->controller->buttonDown & TIME_BUTTON)) {
+            Cheats.TimeStop = true;
+        }
+        if (Cheats.TimeSlow == false && Cheats.TimeStop && !(m->controller->buttonDown & TIME_BUTTON)) {
+            Cheats.TimeStop = false;
+        }
+        if (m->controller->buttonDown & TIME_BUTTON) {
+            if (!Cheats.TimeSlow) {
+                Cheats.TimeSlow = true;
+            } else
+            if (Cheats.TimeSlow) {
+                Cheats.TimeSlow = false;
+            }
+        }
+
+
+        /*FLYER Cheat*/
+        if (Cheats.Fly) {
+            if (m->action == ACT_FLYING) {
+                if (m->controller->buttonDown & A_BUTTON) {
+                    m->particleFlags |= PARTICLE_SPARKLES;
+                }
+            }
+        }
+
+        /*Coin Spawner*/
+        switch (Cheats.Coin) {
+            case 0:
+                break;
+            case 1:
+                if (m->controller->buttonDown & B_BUTTON) {
+                    obj_spawn_yellow_coins(m->marioObj, 1);
+                    break;
+                }
+                break;
+            case 2:
+                if (m->controller->buttonDown & B_BUTTON) {
+                    spawn_object(m->marioObj, MODEL_BLUE_COIN, bhvBlueCoinJumping);
+                    break;
+                }
+                break;
+            case 3:
+                if (m->controller->buttonDown & B_BUTTON) {
+                    spawn_object_relative(0, 0, 70, 150, m->marioObj, MODEL_RED_COIN, bhvRedCoin);
+                    break;
+                }
+                break;
+        }
+
+        /*All Jumps Triple Cheat*/
+        while (Cheats.Triple && (m->action & ACT_GROUP_MASK) != ACT_GROUP_SUBMERGED) {
+            // While Triple Jump Cheat is true and Mario's is not underwater
+            if (m->controller->buttonPressed & A_BUTTON && m->action != ACT_TRIPLE_JUMP) {
+                // If A is pressed and not already triple jumping
+                set_mario_action(m, ACT_TRIPLE_JUMP, 0);
+                // Break out of the while
+                break;
+            }
+            // Break out of the while
+            break;
+        }
+
+        /*Hover Cheat*/
+        if (Cheats.Hover) {
+            set_mario_action(m, ACT_DEBUG_FREE_MOVE, 0);
+            Cheats.Hover = false;
+        }
+
+        /*Moon Gravity*/
+        while (Cheats.Moon) {
+            while ((m->action & ACT_GROUP_MASK) == ACT_GROUP_AIRBORNE) {
+                if (m->action != ACT_FREEFALL && m->action != ACT_LONG_JUMP) {
+                    m->vel[1] += 2;
+                    break;
+                } else {
+                    m->vel[1] += 1;
+                    break;
+                }
+                break;
+            }
+            break;
+        }
+        /*Jump Modifier*/
+        while (Cheats.Jump) {
+            while ((m->action & ACT_GROUP_MASK) == ACT_GROUP_AIRBORNE) {
+                if (m->action != ACT_FREEFALL) {
+                    m->vel[1] += 1;
+                    break;
+                }
+                if (m->action &= ACT_FREEFALL) {
+                    m->vel[1] -= 5;
+                    break;
+                }
+                break;
+            }
+            break;
+        }
+
+        /*Run Modifier Cheat*/
+        switch (Cheats.Run) {
+            case 0:
+                break;
+            case 1:
+                if (m->action == ACT_WALKING && m->forwardVel >= 0) {
+                    m->forwardVel = (m->forwardVel - 0.5f);
+                }
+                break;
+            case 2:
+                if (m->action == ACT_WALKING && m->forwardVel >= 0) {
+                    m->forwardVel = (m->forwardVel - 0.7f);
+                }
+                break;
+            case 3:
+                if (m->action == ACT_WALKING && m->forwardVel >= 0) {
+                    m->forwardVel = (m->forwardVel * 1.2f);
+                }
+                break;
+            case 4:
+                if (m->action == ACT_WALKING && m->forwardVel >= 0) {
+                    m->forwardVel = (m->forwardVel * 1.8f);
+                }
+                break;
+        }
+        /*Play As Cheat*/
+        switch(Cheats.PAC) {
+            /*Model Choices*/
+            case 0:
+#ifdef R96
+                m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_PLAYER];
+                if (isLuigi() == 1) {
+                    gMarioState->animation = &Data_LuigiAnims;
+                } else {
+                    gMarioState->animation = &D_80339D10;
+                }
+                break;
+#else
+                m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_MARIO]; //Use MODEL_PLAYER
+                m->animation = &D_80339D10; //Only Mario's animations
+                break;
+#endif // R96
+            case 1:
+                m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_BLACK_BOBOMB];
+                m->marioObj->header.gfx.unk38.curAnim = bobomb_seg8_anims_0802396C[0];
+                break;
+            case 2:
+                m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_BOBOMB_BUDDY];
+                m->marioObj->header.gfx.unk38.curAnim = bobomb_seg8_anims_0802396C[0];
+                break;
+            case 3:
+                m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_GOOMBA];
+                m->marioObj->header.gfx.unk38.curAnim = goomba_seg8_anims_0801DA4C[0];
+                break;
+            case 4:
+                m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_KOOPA_SHELL];
+                m->marioObj->header.gfx.unk38.curAnim = amp_seg8_anims_08004034[0];
+                break;
+            case 5:
+                m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_CHUCKYA];
+                m->marioObj->header.gfx.unk38.curAnim = chuckya_seg8_anims_0800C070[0];
+                break; //Forgot this in v7
+            case 6:
+                m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_FLYGUY];
+                m->marioObj->header.gfx.unk38.curAnim = flyguy_seg8_anims_08011A64[0];
+                break;
+            case 7:
+                switch (gCurrLevelNum) {
+                    case LEVEL_CASTLE_GROUNDS:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_YOSHI];
+                        m->marioObj->header.gfx.unk38.curAnim = yoshi_seg5_anims_05024100[0];
+                        break;
+                    case LEVEL_BOB:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_KOOPA_WITH_SHELL];
+                        m->marioObj->header.gfx.unk38.curAnim = koopa_seg6_anims_06011364[0];
+                        m->marioObj->header.gfx.unk38.animFrame += 1;
+                        break;
+                    case LEVEL_BBH:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_MAD_PIANO];
+                        m->marioObj->header.gfx.unk38.curAnim = mad_piano_seg5_anims_05009B14[0];
+                        break;
+                    case LEVEL_WF:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_WHOMP];
+                        m->marioObj->header.gfx.unk38.curAnim = whomp_seg6_anims_06020A04[0];
+                        break;
+                    case LEVEL_JRB:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_CLAM_SHELL];
+                        m->marioObj->header.gfx.unk38.curAnim = clam_shell_seg5_anims_05001744[0];
+                        break;
+                    case LEVEL_CCM:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_PENGUIN];
+                        m->marioObj->header.gfx.unk38.curAnim = penguin_seg5_anims_05008B74[0];
+                        break;
+                    case LEVEL_PSS:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_WOODEN_SIGNPOST];
+                        break;
+                    case LEVEL_HMC:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_HMC_ROLLING_ROCK];
+                        break;
+                    case LEVEL_LLL:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_BULLY];
+                        m->marioObj->header.gfx.unk38.curAnim = bully_seg5_anims_0500470C[0];
+                        break;
+                    case LEVEL_SSL:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_KLEPTO];
+                        m->marioObj->header.gfx.unk38.curAnim = klepto_seg5_anims_05008CFC[0];
+                        break;
+                    case LEVEL_DDD:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_SUSHI];
+                        m->marioObj->header.gfx.unk38.curAnim = sushi_seg5_anims_0500AE54[0];
+                        break;
+                    case LEVEL_SL:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_SPINDRIFT];
+                        m->marioObj->header.gfx.unk38.curAnim = spindrift_seg5_anims_05002D68[0];
+                        break;
+                    case LEVEL_WDW:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_SKEETER];
+                        m->marioObj->header.gfx.unk38.curAnim = skeeter_seg6_anims_06007DE0[0];
+                        break;
+                    case LEVEL_TTM:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_UKIKI];
+                        m->marioObj->header.gfx.unk38.curAnim = ukiki_seg5_anims_05015784[0];
+                        break;
+                    case LEVEL_THI:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_SPINY];
+                        m->marioObj->header.gfx.unk38.curAnim = spiny_seg5_anims_05016EAC[0];
+                        break;
+                    case LEVEL_TTC:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_THWOMP];
+                        break;
+                    case LEVEL_RR:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_ENEMY_LAKITU];
+                        m->marioObj->header.gfx.unk38.curAnim = lakitu_enemy_seg5_anims_050144D4[0];
+                        break;
+                    case LEVEL_SA:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_MANTA_RAY];
+                        m->marioObj->header.gfx.unk38.curAnim = manta_seg5_anims_05008EB4[0];
+                        break;
+                    case LEVEL_COTMC:
+                        m->marioObj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_SNUFIT];
+                        break;
+                }
+            }
+        while (Cheats.PAC > 0) {
+            /*stops softlock when dying as a Play As Character*/
+            if (m->action == ACT_STANDING_DEATH) {
+                level_trigger_warp(m, WARP_OP_DEATH);
+                m->numLives += 1;
+                update_mario_health(m);
+                break;
+            }
+            /*Instead of making a custom hitbox for each character,
+            I neutralized the only consistent problem, doors*/
+            while (m->collidedObjInteractTypes & INTERACT_DOOR) {
+                obj_mark_for_deletion(m->usedObj);
+                spawn_object(gCurrentObject, MODEL_SMOKE, bhvBobombBullyDeathSmoke);
+                obj_scale(gCurrentObject, gCurrentObject->oTimer / 4.f + 1.0f);
+                gCurrentObject->oOpacity -= 14;
+                gCurrentObject->oAnimState++;
+                play_sound(SOUND_GENERAL2_BOBOMB_EXPLOSION, m->marioObj->header.gfx.cameraToObject);
+                m->particleFlags |= PARTICLE_TRIANGLE;
+                obj_set_pos(m->marioObj, 0, 0, 100);
+                break;
+            }
+            break;
+        }
+
+
+        /*Speed Display*/
+        if (Cheats.SPD == true) {
+            print_text_fmt_int(210, 72, "SPD %d", m->forwardVel);
+        }
+
+        /*T Pose Float? Actually it's just twirling + MoonJump*/
+        while (Cheats.TPF == true) {
+            if (m->controller->buttonDown & A_BUTTON) {
+                m->vel[1] = 25;
+                set_mario_action(m, ACT_TWIRLING, 0);
+            }
+            break;
+        }
+
+        /*QuickEnding cheat*/
+        while (Cheats.QuikEnd == true) {
+            if (m->numStars == 120) {
+                level_trigger_warp(m, WARP_OP_CREDITS_START);
+                Cheats.QuikEnd = false;
+                save_file_do_save(gCurrSaveFileNum - 1);
+            }
+            break;
+        }
+
+        /*AutoWallKick cheat*/
+        if (Cheats.AutoWK == true && m->action == ACT_AIR_HIT_WALL) {
+            m->vel[1] = 52.0f;
+            m->faceAngle[1] += 0x8000;
+            set_mario_action(m, ACT_WALL_KICK_AIR, 0);
+            m->wallKickTimer = 0;
+            set_mario_animation(m, MARIO_ANIM_START_WALLKICK);
+        }
+
+        /*HurtMario cheat*/
+        while (Cheats.Hurt > 0 && m->controller->buttonDown & L_TRIG
+               && m->controller->buttonPressed & A_BUTTON) {
+            if (Cheats.Hurt == 1) {
+                act_burning_ground(m);
+            }
+            if (Cheats.Hurt == 2) {
+                m->flags |= MARIO_METAL_SHOCK;
+                drop_and_set_mario_action(m, ACT_SHOCKED, 0);
+            }
+            if (Cheats.Hurt == 3) {
+                hurt_and_set_mario_action(m, ACT_GROUND_BONK, 0, 1);
+                play_sound(SOUND_MARIO_OOOF, m->marioObj->header.gfx.cameraToObject);
+                queue_rumble_data(5, 80);
+            }
+            break;
+        }
+
+        /*CannonAnywhere cheat*/
+        if (Cheats.Cann == true && m->controller->buttonDown & L_TRIG
+            && m->controller->buttonPressed & U_CBUTTONS) {
+            spawn_object_relative(1, 0, 200, 0, gCurrentObject, MODEL_NONE, bhvCannon);
+        }
+
+        /*InstantDeath cheat*/
+        if (m->controller->buttonDown & L_TRIG && m->controller->buttonDown & A_BUTTON
+            && m->controller->buttonPressed & B_BUTTON && m->controller->buttonDown & Z_TRIG) {
+            level_trigger_warp(m, WARP_OP_DEATH);
+            break;
+        }
+
+        /*CAP Cheats, this whole thing needs to be refactored, but
+        I've only been adding to JAGSTAX's original patch*/
+        if (Cheats.EnableCheats) {
+            if (Cheats.WingCap) {
+                m->flags |= MARIO_WING_CAP;
+                if ((m->action & ACT_GROUP_MASK) == (!(ACT_GROUP_AIRBORNE) && !(ACT_GROUP_SUBMERGED))) {
+                    set_mario_action(m, ACT_PUTTING_ON_CAP, 0);
+                }
+                play_cap_music(SEQ_EVENT_POWERUP);
+                Cheats.WingCap = false;
+            }
+
+            if (Cheats.MetalCap) {
+                m->flags |= MARIO_METAL_CAP;
+                if ((m->action & ACT_GROUP_MASK) == (!(ACT_GROUP_AIRBORNE) && !(ACT_GROUP_SUBMERGED))) {
+                    set_mario_action(m, ACT_PUTTING_ON_CAP, 0);
+                }
+                play_cap_music(SEQ_EVENT_METAL_CAP);
+                Cheats.MetalCap = false;
+            }
+
+            if (Cheats.VanishCap) {
+                m->flags |= MARIO_VANISH_CAP;
+                if ((m->action & ACT_GROUP_MASK) == (!(ACT_GROUP_AIRBORNE) && !(ACT_GROUP_SUBMERGED))) {
+                    set_mario_action(m, ACT_PUTTING_ON_CAP, 0);
+                }
+                play_cap_music(SEQ_EVENT_POWERUP);
+                Cheats.VanishCap = false;
+            }
+
+            if (Cheats.RemoveCap) {
+                m->flags &= ~MARIO_CAP_ON_HEAD;
+                m->flags |= MARIO_CAP_IN_HAND;
+                if ((m->action & ACT_GROUP_MASK) == (!(ACT_GROUP_AIRBORNE) && !(ACT_GROUP_SUBMERGED))) {
+                    set_mario_action(m, ACT_SHIVERING, 0);
+                }
+                Cheats.RemoveCap = false;
+            }
+
+            if (Cheats.NormalCap) {
+                m->flags &= ~MARIO_CAP_ON_HEAD;
+                m->flags &= ~(MARIO_WING_CAP | MARIO_METAL_CAP | MARIO_VANISH_CAP);
+                if ((m->action & ACT_GROUP_MASK) == (!(ACT_GROUP_AIRBORNE) && !(ACT_GROUP_SUBMERGED))) {
+                    m->flags |= MARIO_CAP_IN_HAND;
+                    set_mario_action(m, ACT_PUTTING_ON_CAP, 0);
+                } else {
+                    m->flags &= ~MARIO_CAP_IN_HAND;
+                    m->flags |= MARIO_CAP_ON_HEAD;
+                }
+                stop_cap_music();
+                Cheats.NormalCap = false;
+            }
+        }
+
+        /* GetShell cheat */
+        while (Cheats.GetShell == true && m->controller->buttonDown & L_TRIG
+               && m->controller->buttonPressed & R_TRIG) {
+            if (m->action & ACT_FLAG_RIDING_SHELL) {
+                break;
+            }
+
+            /*This check should be added when creating a spawn cheat to prevent spamming*/
+            struct Object *obj = (struct Object *) gObjectLists[OBJ_LIST_LEVEL].next;
+            struct Object *first = (struct Object *) &gObjectLists[OBJ_LIST_LEVEL];
+            while (obj != NULL && obj != first) {
+                if (obj->header.gfx.sharedChild = gLoadedGraphNodes[MODEL_KOOPA_SHELL]) {
+                    obj_mark_for_deletion(obj);
+                    break;
+                }
+                obj = (struct Object *) obj->header.next;
+            }
+
+            if ((m->action & ACT_GROUP_MASK) == ACT_GROUP_SUBMERGED) {
+                spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_KOOPA_SHELL,
+                                      bhvKoopaShellUnderwater);
+                break;
+            } else {
+                spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_KOOPA_SHELL, bhvKoopaShell);
+                break;
+            }
+        }
+
+        /* GetBobomb cheat */
+        while (Cheats.GetBob == true && m->controller->buttonDown & L_TRIG
+               && m->controller->buttonPressed & B_BUTTON) {
+            spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_BLACK_BOBOMB, bhvBobomb);
+            break;
+        }
+
+        /* SpawnCommon0 aka Spamba cheat*/
+        switch (Cheats.Spamba) {
+            case 0:
+                break;
+            case 1:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_AMP, bhvHomingAmp);
+                    break;
+                }
+                break;
+            case 2:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, 0, 150, gCurrentObject, MODEL_BLUE_COIN_SWITCH,
+                                          bhvBlueCoinSwitch);
+                    break;
+                }
+                break;
+            case 3:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, 300, 300, gCurrentObject, MODEL_BOWLING_BALL,
+                                          bhvPitBowlingBall);
+                    break;
+                }
+                break;
+            case 4:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, 0, 200, gCurrentObject, MODEL_BREAKABLE_BOX,
+                                          bhvBreakableBox);
+                    break;
+                }
+                break;
+            case 5:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, 50, 100, gCurrentObject, MODEL_BREAKABLE_BOX_SMALL,
+                                          bhvBreakableBoxSmall);
+                    break;
+                }
+                break;
+            case 6:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, 10, 300, gCurrentObject, MODEL_BREAKABLE_BOX_SMALL,
+                                          bhvJumpingBox);
+                    break;
+                }
+                break;
+            case 7:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, -10, 100, gCurrentObject, MODEL_CHECKERBOARD_PLATFORM,
+                                          bhvCheckerboardPlatformSub);
+                    break;
+                }
+                break;
+            case 8:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_CHUCKYA, bhvChuckya);
+                    break;
+                }
+                break;
+            case 9:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_FLYGUY, bhvFlyGuy);
+                    break;
+                }
+                break;
+            case 10:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_NONE,
+                                          bhvGoombaTripletSpawner);
+                    break;
+                }
+                break;
+            case 11:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, 100, 100, gCurrentObject, MODEL_HEART,
+                                          bhvRecoveryHeart);
+                    break;
+                }
+                break;
+            case 12:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, 0, 200, gCurrentObject, MODEL_METAL_BOX,
+                                          bhvPushableMetalBox);
+                    break;
+                }
+                break;
+            case 13:
+                if (m->controller->buttonDown & L_TRIG && m->controller->buttonPressed & Z_TRIG) {
+                    spawn_object_relative(0, 0, 50, 50, gCurrentObject, MODEL_PURPLE_SWITCH,
+                                          bhvPurpleSwitchHiddenBoxes);
+                    break;
+                }
+                break;
+        }
+
+        /*Jukebox*/
+        if (Cheats.JBC) {
+            /*JBC is the bool, acting like the on/off*/
+            switch(Cheats.JB) {
+                case 0:
+                    play_cap_music(SEQ_EVENT_CUTSCENE_INTRO);
+                    Cheats.JBC = false;
+                    break;
+                case 1:
+                    play_cap_music(SEQ_LEVEL_GRASS);
+                    Cheats.JBC = false;
+                    break;
+                case 2:
+                    play_cap_music(SEQ_LEVEL_INSIDE_CASTLE);
+                    Cheats.JBC = false;
+                    break;
+                case 3:
+                    play_cap_music(SEQ_LEVEL_WATER);
+                    Cheats.JBC = false;
+                    break;
+                case 4:
+                    play_cap_music(SEQ_LEVEL_HOT);
+                    Cheats.JBC = false;
+                    break;
+                case 5:
+                    play_cap_music(SEQ_LEVEL_BOSS_KOOPA);
+                    Cheats.JBC = false;
+                    break;
+                case 6:
+                    play_cap_music(SEQ_LEVEL_SNOW);
+                    Cheats.JBC = false;
+                    break;
+                case 7:
+                    play_cap_music(SEQ_LEVEL_SLIDE);
+                    Cheats.JBC = false;
+                    break;
+                case 8:
+                    play_cap_music(SEQ_LEVEL_SPOOKY);
+                    Cheats.JBC = false;
+                    break;
+                case 9:
+                    play_cap_music(SEQ_LEVEL_UNDERGROUND);
+                    Cheats.JBC = false;
+                    break;
+                case 10:
+                    play_cap_music(SEQ_LEVEL_KOOPA_ROAD);
+                    Cheats.JBC = false;
+                    break;
+                case 11:
+                    play_cap_music(SEQ_LEVEL_BOSS_KOOPA_FINAL);
+                    Cheats.JBC = false;
+                    break;
+                case 12:
+                    play_cap_music(SEQ_MENU_TITLE_SCREEN);
+                    Cheats.JBC = false;
+                    break;
+                case 13:
+                    play_cap_music(SEQ_MENU_FILE_SELECT);
+                    Cheats.JBC = false;
+                    break;
+                case 14:
+                    play_cap_music(SEQ_EVENT_POWERUP);
+                    Cheats.JBC = false;
+                    break;
+                case 15:
+                    play_cap_music(SEQ_EVENT_METAL_CAP);
+                    Cheats.JBC = false;
+                    break;
+                case 16:
+                    play_cap_music(SEQ_EVENT_BOSS);
+                    Cheats.JBC = false;
+                    break;
+                case 17:
+                    play_cap_music(SEQ_EVENT_MERRY_GO_ROUND);
+                    Cheats.JBC = false;
+                    break;
+                case 18:
+                    play_cap_music(SEQ_EVENT_CUTSCENE_CREDITS);
+                    Cheats.JBC = false;
+                    break;
+            }
+        }
+        break;
+    }
+}
\ No newline at end of file
diff --git a/src/game/mario_cheats.h b/src/game/mario_cheats.h
new file mode 100644
index 00000000..73bc6523
--- /dev/null
+++ b/src/game/mario_cheats.h
@@ -0,0 +1,42 @@
+#ifndef MARIO_CHEATS_H
+#define MARIO_CHEATS_H
+
+#include <PR/ultratypes.h>
+
+#include "macros.h"
+#include "model_ids.h"
+#include "types.h"
+
+#if defined(MODEL_PLAYER) && defined(MODEL_LUIGIS_CAP)
+#define R96
+#endif
+
+void cheats_set_model(struct MarioState *m);
+void cheats_swimming_speed(struct MarioState *m);
+void cheats_air_step(struct MarioState *m);
+void cheats_long_jump(struct MarioState *m);
+void cheats_mario_inputs(struct MarioState *m);
+
+/* Options */
+#define TIME_BUTTON 0x0080
+
+#include "data/dynos.c.h"
+#define __chaos_mode__   dynos_opt_get_value("chaos_mode")
+#define __time_button__ dynos_opt_get_value("time_button")
+#define __spl__ dynos_opt_get_value("spl")
+#define __no_heavy__ dynos_opt_get_value("no_heavy")
+#define __haz_walk__ dynos_opt_get_value("haz_walk")
+#define __swim_any__ dynos_opt_get_value("swim_any")
+#define __coin_mag__ dynos_opt_get_value("coin_mag")
+#define __wat_con__ dynos_opt_get_value("wat_con")
+#define __wat_lev__ dynos_opt_get_value("wat_lev")
+#define CHAOS_MODE (__chaos_mode__ == 1)
+#define SPL (__spl__)
+#define NO_HEAVY (__no_heavy__ == 1)
+#define HAZ_WALK (__haz_walk__ == 1)
+#define SWIM_ANY (__swim_any__ == 1)
+#define COIN_MAG (__coin_mag__ == 1)
+#define WAT_CON (__wat_con__ == 1)
+#define WAT_LEV (__wat_lev__)
+
+#endif // MARIO_CHEATS_H
diff --git a/src/game/time_trials.c b/src/game/time_trials.c
new file mode 100644
index 00000000..8c83ce77
--- /dev/null
+++ b/src/game/time_trials.c
@@ -0,0 +1,1283 @@
+#include "time_trials.h"
+#include "sm64.h"
+#include "game_init.h"
+#include "sound_init.h"
+#include "geo_commands.h"
+#include "gfx_dimensions.h"
+#include "ingame_menu.h"
+#include "level_update.h"
+#include "object_helpers.h"
+#include "object_list_processor.h"
+#include "save_file.h"
+#include "segment2.h"
+#include "spawn_object.h"
+#include "pc/cheats.h"
+#include "pc/cliopts.h"
+#include "pc/configfile.h"
+#include "pc/fs/fs.h"
+#include "engine/math_util.h"
+#include "audio/external.h"
+#include <stdio.h>
+
+#define TIME_TRIALS_MAX_ALLOWED_TIME    17999 // 9'59"99
+#define TIME_TRIALS_UNDEFINED_TIME      -1
+#ifndef OMM_STARS_NON_STOP
+#define OMM_STARS_NON_STOP              (0)
+#endif
+#ifndef OMM_ALL_STARS
+#define OMM_ALL_STARS                   (0)
+#endif
+
+static bool sTimeTrialsEnabled = true;
+bool time_trials_enabled() {
+    return sTimeTrialsEnabled;
+}
+
+//
+// Models
+//
+
+#include "time_trials_ghost_geo.inl"
+
+static const BehaviorScript bhvTimeTrialGhost1[] = { 0x08000000, 0x09000000 };
+static const BehaviorScript bhvTimeTrialGhost2[] = { 0x08000000, 0x09000000 };
+
+enum {
+    GHOST_MARIO_DEFAULT = 0,
+    GHOST_MARIO_RED_COINS,
+    GHOST_MARIO_PSS_2,
+    GHOST_MARIO_100_COINS,
+    GHOST_MARIO_ALL_STARS
+};
+static struct GraphNode *time_trials_get_ghost_mario_graph_node(u8 color) {
+    static void *sGhostMarios[5][2] = {
+        { (void *) ghost_mario_blue_geo,  NULL }, // Default ghost
+        { (void *) ghost_mario_red_geo,   NULL }, // Bowser Red coins ghost
+        { (void *) ghost_mario_green_geo, NULL }, // PSS 2 ghost
+        { (void *) ghost_mario_gold_geo,  NULL }, // 100 coins ghost
+        { (void *) ghost_mario_pink_geo,  NULL }, // All Stars ghost
+    };
+    if (sGhostMarios[0][1] == NULL) {
+        for (u8 i = 0; i != 5; ++i) {
+            struct AllocOnlyPool *pool = calloc(1, 0x10000);
+            pool->totalSpace   = 0x10000 - sizeof(struct AllocOnlyPool);
+            pool->usedSpace    = 0;
+            pool->startPtr     = (u8 *) pool + sizeof(struct AllocOnlyPool);
+            pool->freePtr      = (u8 *) pool + sizeof(struct AllocOnlyPool);
+            sGhostMarios[i][1] = process_geo_layout(pool, sGhostMarios[i][0]);
+        }
+    }
+    return sGhostMarios[color][1];
+}
+
+//
+// Utils
+//
+
+static const char *time_trials_get_save_filename() {
+    static char buffer[256];
+    snprintf(buffer, 256, "%s", SAVE_FILENAME);
+    buffer[strlen(buffer) - 4] = 0; // cut extension
+    return buffer;
+}
+
+static const char *time_trials_get_folder(const char *path) {
+    static char buffer[256];
+    snprintf(buffer, 256, "%s/%s", path, time_trials_get_save_filename());
+    return buffer;
+}
+
+// For retro-compatibility
+static const char *time_trials_get_old_filename(const char *path, s32 fileIndex, s32 slotIndex) {
+    static char buffer[256];
+    snprintf(buffer, 256, "%s/%d.%d.ttg", time_trials_get_folder(path), fileIndex, slotIndex);
+    return buffer;
+}
+
+static const char *time_trials_get_new_filename(const char *path, s32 fileIndex, s32 courseIndex, s32 starIndex) {
+    static const char *sCourseTags[] = {
+        "bob", "wf", "jrb", "ccm", "bbh", "hmc", "lll", "ssl", "ddd", "sl", "wdw", "ttm", "thi", "ttc", "rr",
+        "bitdw", "bitfs", "bits", "pss", "cotmc", "totwc", "vcutm", "wmotr", "sa"
+    };
+    static char buffer[256];
+    snprintf(buffer, 256, "%s/%d.%s.%d.ttg", time_trials_get_folder(path), fileIndex, sCourseTags[courseIndex], starIndex);
+    return buffer;
+}
+
+static const u8 *time_trials_int_to_sm64_string(s32 value, const char *format) {
+    static u8 buffer[64];
+    bzero(buffer, 64);
+    if (!format || strlen(format) > 8) {
+        return buffer;
+    }
+    s32 len = snprintf((char *) buffer, 64, format, value);
+    for (s32 i = 0; i < len; ++i) {
+        if (buffer[i] >= 'A' && buffer[i] <= 'F') {
+            buffer[i] = buffer[i] - 'A';
+        } else if (buffer[i] >= 'a' && buffer[i] <= 'f') {
+            buffer[i] = buffer[i] - 'a';
+        } else {
+            buffer[i] = buffer[i] - '0';
+        }
+    }
+    buffer[len] = DIALOG_CHAR_TERMINATOR;
+    return buffer;
+}
+
+//
+// Time Trials Slots
+//
+
+#define NUM_SLOTS                   sizeof(sTimeTrialSlots) / sizeof(sTimeTrialSlots[0])
+#define STAR_CODE(course, star)     (u16)(((u16)(course & 0xFF) << 8) | ((u16)(star & 0xFF) << 0))
+
+static const u16 sTimeTrialSlots[] = {
+
+    /* Main courses */
+    STAR_CODE(COURSE_BOB, 0),
+    STAR_CODE(COURSE_BOB, 1),
+    STAR_CODE(COURSE_BOB, 2),
+    STAR_CODE(COURSE_BOB, 3),
+    STAR_CODE(COURSE_BOB, 4),
+    STAR_CODE(COURSE_BOB, 5),
+    STAR_CODE(COURSE_BOB, 6),
+    STAR_CODE(COURSE_WF, 0),
+    STAR_CODE(COURSE_WF, 1),
+    STAR_CODE(COURSE_WF, 2),
+    STAR_CODE(COURSE_WF, 3),
+    STAR_CODE(COURSE_WF, 4),
+    STAR_CODE(COURSE_WF, 5),
+    STAR_CODE(COURSE_WF, 6),
+    STAR_CODE(COURSE_JRB, 0),
+    STAR_CODE(COURSE_JRB, 1),
+    STAR_CODE(COURSE_JRB, 2),
+    STAR_CODE(COURSE_JRB, 3),
+    STAR_CODE(COURSE_JRB, 4),
+    STAR_CODE(COURSE_JRB, 5),
+    STAR_CODE(COURSE_JRB, 6),
+    STAR_CODE(COURSE_CCM, 0),
+    STAR_CODE(COURSE_CCM, 1),
+    STAR_CODE(COURSE_CCM, 2),
+    STAR_CODE(COURSE_CCM, 3),
+    STAR_CODE(COURSE_CCM, 4),
+    STAR_CODE(COURSE_CCM, 5),
+    STAR_CODE(COURSE_CCM, 6),
+    STAR_CODE(COURSE_BBH, 0),
+    STAR_CODE(COURSE_BBH, 1),
+    STAR_CODE(COURSE_BBH, 2),
+    STAR_CODE(COURSE_BBH, 3),
+    STAR_CODE(COURSE_BBH, 4),
+    STAR_CODE(COURSE_BBH, 5),
+    STAR_CODE(COURSE_BBH, 6),
+    STAR_CODE(COURSE_HMC, 0),
+    STAR_CODE(COURSE_HMC, 1),
+    STAR_CODE(COURSE_HMC, 2),
+    STAR_CODE(COURSE_HMC, 3),
+    STAR_CODE(COURSE_HMC, 4),
+    STAR_CODE(COURSE_HMC, 5),
+    STAR_CODE(COURSE_HMC, 6),
+    STAR_CODE(COURSE_LLL, 0),
+    STAR_CODE(COURSE_LLL, 1),
+    STAR_CODE(COURSE_LLL, 2),
+    STAR_CODE(COURSE_LLL, 3),
+    STAR_CODE(COURSE_LLL, 4),
+    STAR_CODE(COURSE_LLL, 5),
+    STAR_CODE(COURSE_LLL, 6),
+    STAR_CODE(COURSE_SSL, 0),
+    STAR_CODE(COURSE_SSL, 1),
+    STAR_CODE(COURSE_SSL, 2),
+    STAR_CODE(COURSE_SSL, 3),
+    STAR_CODE(COURSE_SSL, 4),
+    STAR_CODE(COURSE_SSL, 5),
+    STAR_CODE(COURSE_SSL, 6),
+    STAR_CODE(COURSE_DDD, 0),
+    STAR_CODE(COURSE_DDD, 1),
+    STAR_CODE(COURSE_DDD, 2),
+    STAR_CODE(COURSE_DDD, 3),
+    STAR_CODE(COURSE_DDD, 4),
+    STAR_CODE(COURSE_DDD, 5),
+    STAR_CODE(COURSE_DDD, 6),
+    STAR_CODE(COURSE_SL, 0),
+    STAR_CODE(COURSE_SL, 1),
+    STAR_CODE(COURSE_SL, 2),
+    STAR_CODE(COURSE_SL, 3),
+    STAR_CODE(COURSE_SL, 4),
+    STAR_CODE(COURSE_SL, 5),
+    STAR_CODE(COURSE_SL, 6),
+    STAR_CODE(COURSE_WDW, 0),
+    STAR_CODE(COURSE_WDW, 1),
+    STAR_CODE(COURSE_WDW, 2),
+    STAR_CODE(COURSE_WDW, 3),
+    STAR_CODE(COURSE_WDW, 4),
+    STAR_CODE(COURSE_WDW, 5),
+    STAR_CODE(COURSE_WDW, 6),
+    STAR_CODE(COURSE_TTM, 0),
+    STAR_CODE(COURSE_TTM, 1),
+    STAR_CODE(COURSE_TTM, 2),
+    STAR_CODE(COURSE_TTM, 3),
+    STAR_CODE(COURSE_TTM, 4),
+    STAR_CODE(COURSE_TTM, 5),
+    STAR_CODE(COURSE_TTM, 6),
+    STAR_CODE(COURSE_THI, 0),
+    STAR_CODE(COURSE_THI, 1),
+    STAR_CODE(COURSE_THI, 2),
+    STAR_CODE(COURSE_THI, 3),
+    STAR_CODE(COURSE_THI, 4),
+    STAR_CODE(COURSE_THI, 5),
+    STAR_CODE(COURSE_THI, 6),
+    STAR_CODE(COURSE_TTC, 0),
+    STAR_CODE(COURSE_TTC, 1),
+    STAR_CODE(COURSE_TTC, 2),
+    STAR_CODE(COURSE_TTC, 3),
+    STAR_CODE(COURSE_TTC, 4),
+    STAR_CODE(COURSE_TTC, 5),
+    STAR_CODE(COURSE_TTC, 6),
+    STAR_CODE(COURSE_RR, 0),
+    STAR_CODE(COURSE_RR, 1),
+    STAR_CODE(COURSE_RR, 2),
+    STAR_CODE(COURSE_RR, 3),
+    STAR_CODE(COURSE_RR, 4),
+    STAR_CODE(COURSE_RR, 5),
+    STAR_CODE(COURSE_RR, 6),
+
+    /* Bowser Courses */
+    STAR_CODE(COURSE_BITDW, 0),
+    STAR_CODE(COURSE_BITDW, 1),
+    STAR_CODE(COURSE_BITFS, 0),
+    STAR_CODE(COURSE_BITFS, 1),
+    STAR_CODE(COURSE_BITS, 0),
+    STAR_CODE(COURSE_BITS, 1),
+
+    /* Secret Courses */
+    STAR_CODE(COURSE_PSS, 0),
+    STAR_CODE(COURSE_PSS, 1),
+    STAR_CODE(COURSE_SA, 0),
+    STAR_CODE(COURSE_WMOTR, 0),
+    STAR_CODE(COURSE_TOTWC, 0),
+    STAR_CODE(COURSE_VCUTM, 0),
+    STAR_CODE(COURSE_COTMC, 0),
+
+    /* All Stars */
+    // Placed here for retro-compatibility
+    STAR_CODE(COURSE_BOB, 7),
+    STAR_CODE(COURSE_WF, 7),
+    STAR_CODE(COURSE_JRB, 7),
+    STAR_CODE(COURSE_CCM, 7),
+    STAR_CODE(COURSE_BBH, 7),
+    STAR_CODE(COURSE_HMC, 7),
+    STAR_CODE(COURSE_LLL, 7),
+    STAR_CODE(COURSE_SSL, 7),
+    STAR_CODE(COURSE_DDD, 7),
+    STAR_CODE(COURSE_SL, 7),
+    STAR_CODE(COURSE_WDW, 7),
+    STAR_CODE(COURSE_TTM, 7),
+    STAR_CODE(COURSE_THI, 7),
+    STAR_CODE(COURSE_TTC, 7),
+    STAR_CODE(COURSE_RR, 7),
+};
+
+static s32 time_trials_get_slot_index(s32 courseNum, s32 starIndex) {
+    u16 starCode = STAR_CODE(courseNum, starIndex);
+    for (u32 i = 0; i != NUM_SLOTS; ++i) {
+        if (sTimeTrialSlots[i] == starCode) {
+            return (s32) i;
+        }
+    }
+    return -1;
+}
+
+#undef STAR_CODE
+
+//
+// Ghost Frame data
+//
+
+struct TimeTrialGhostFrameData {
+    s16 posX;
+    s16 posY;
+    s16 posZ;
+    s8 pitch;
+    s8 yaw;
+    s8 roll;
+    u8 scaleX;
+    u8 scaleY;
+    u8 scaleZ;
+    u8 animIndex;
+    u8 animFrame;
+    u8 level;
+    u8 area;
+};
+#define time_trials_is_end_frame(p, f) (p[f].level == 0)
+
+//
+// Data
+//
+
+enum { TT_TIMER_DISABLED, TT_TIMER_RUNNING, TT_TIMER_STOPPED };
+static s8 sTimeTrialTimerState = TT_TIMER_DISABLED;
+static s16 sTimeTrialTimer = 0;
+static bool sTimeTrialHiScore = false;
+static struct TimeTrialGhostFrameData sTimeTrialGhostDataR1[TIME_TRIALS_MAX_ALLOWED_TIME]; // Read-only, normal/all-stars ghost
+static struct TimeTrialGhostFrameData sTimeTrialGhostDataR2[TIME_TRIALS_MAX_ALLOWED_TIME]; // Read-only, special ghost
+static struct TimeTrialGhostFrameData sTimeTrialGhostDataW[TIME_TRIALS_MAX_ALLOWED_TIME]; // Write-only
+
+//
+// Read
+//
+
+static u16 read_u16(FILE *f) {
+    u8 low, high;
+    if (fread(&high, 1, 1, f)) {
+        if (fread(&low, 1, 1, f)) {
+            return (u16)(((u16)(high) << 8) | ((u16)(low)));
+        }
+    }
+    return 0;
+}
+
+static u8 read_u8(FILE *f) {
+    u8 byte;
+    if (fread(&byte, 1, 1, f)) {
+        return byte;
+    }
+    return 0;
+}
+
+static s16 time_trials_read_ghost_data(s32 fileIndex, s32 courseIndex, s32 starIndex, s32 slotIndex, struct TimeTrialGhostFrameData* ghostData) {
+    if (ghostData != NULL) {
+        bzero(ghostData, (sizeof(struct TimeTrialGhostFrameData) * TIME_TRIALS_MAX_ALLOWED_TIME));
+    }
+
+    // Valid slotIndex
+    if (slotIndex == -1) {
+        return 0;
+    }
+
+    // Open file
+    const char *filename = time_trials_get_new_filename(fs_writepath, fileIndex, courseIndex, starIndex);
+    FILE *f = fopen(filename, "rb");
+    if (f == NULL) {
+        filename = time_trials_get_old_filename(fs_writepath, fileIndex, slotIndex);
+        f = fopen(filename, "rb");
+        if (f == NULL) {
+            return 0;
+        }
+    }
+
+    // Read data
+    s16 length = (s16) read_u16(f);
+    if (ghostData != NULL) {
+        for (s16 i = 0; i != length; ++i) {
+            ghostData[i].posX      = (s16) read_u16(f);
+            ghostData[i].posY      = (s16) read_u16(f);
+            ghostData[i].posZ      = (s16) read_u16(f);
+            ghostData[i].pitch     = (s8) read_u8(f);
+            ghostData[i].yaw       = (s8) read_u8(f);
+            ghostData[i].roll      = (s8) read_u8(f);
+            ghostData[i].scaleX    = read_u8(f);
+            ghostData[i].scaleY    = read_u8(f);
+            ghostData[i].scaleZ    = read_u8(f);
+            ghostData[i].animIndex = read_u8(f);
+            ghostData[i].animFrame = read_u8(f);
+            ghostData[i].level     = read_u8(f);
+            ghostData[i].area      = read_u8(f);
+        }
+    }
+
+    fclose(f);
+    return length;
+}
+
+static s16 *time_trials_time(s32 fileIndex, s32 slotIndex) {
+    static s16 sTimeTrialTimes[NUM_SAVE_FILES][NUM_SLOTS];
+    static bool inited = false;
+    if (!inited) {
+        for (s32 i = 0; i != NUM_SAVE_FILES; ++i) {
+            for (s32 courseIndex = 0; courseIndex != COURSE_MAX; ++courseIndex) {
+                for (s32 starIndex = 0; starIndex != 8; ++starIndex) {
+                    s32 s = time_trials_get_slot_index(courseIndex + 1, starIndex);
+                    if (s != -1) {
+                        s16 t = time_trials_read_ghost_data(i, courseIndex, starIndex, s, NULL);
+                        if (t <= 0 || t > TIME_TRIALS_MAX_ALLOWED_TIME) {
+                            t = TIME_TRIALS_UNDEFINED_TIME;
+                        }
+                        sTimeTrialTimes[i][s] = t;
+                    }
+                }
+            }
+        }
+        inited = true;
+    }
+    return &sTimeTrialTimes[fileIndex][slotIndex];
+}
+
+//
+// Write
+//
+
+static void write_u16(FILE *f, u16 word) {
+    u8 low = (u8)(word);
+    u8 high = (u8)(word >> 8);
+    fwrite(&high, 1, 1, f);
+    fwrite(&low, 1, 1, f);
+}
+
+static void write_u8(FILE *f, u8 byte) {
+    fwrite(&byte, 1, 1, f);
+}
+
+static void time_trials_write_ghost_data(s32 fileIndex, s32 courseIndex, s32 starIndex) {
+
+    // Make folder
+    fs_sys_mkdir(time_trials_get_folder(fs_writepath));
+
+    // Open file
+    const char *filename = time_trials_get_new_filename(fs_writepath, fileIndex, courseIndex, starIndex);
+    FILE *f = fopen(filename, "wb");
+    if (f == NULL) {
+        return;
+    }
+
+    // Write length
+    s16 length = sTimeTrialTimer;
+    write_u16(f, length);
+
+    // Write data
+    for (s16 i = 0; i != length; ++i) {
+        write_u16(f, (u16) sTimeTrialGhostDataW[i].posX);
+        write_u16(f, (u16) sTimeTrialGhostDataW[i].posY);
+        write_u16(f, (u16) sTimeTrialGhostDataW[i].posZ);
+        write_u8(f, (u8) sTimeTrialGhostDataW[i].pitch);
+        write_u8(f, (u8) sTimeTrialGhostDataW[i].yaw);
+        write_u8(f, (u8) sTimeTrialGhostDataW[i].roll);
+        write_u8(f, sTimeTrialGhostDataW[i].scaleX);
+        write_u8(f, sTimeTrialGhostDataW[i].scaleY);
+        write_u8(f, sTimeTrialGhostDataW[i].scaleZ);
+        write_u8(f, sTimeTrialGhostDataW[i].animIndex);
+        write_u8(f, sTimeTrialGhostDataW[i].animFrame);
+        write_u8(f, sTimeTrialGhostDataW[i].level);
+        write_u8(f, sTimeTrialGhostDataW[i].area);
+    }
+
+    // Update times
+    *time_trials_time(fileIndex, time_trials_get_slot_index(courseIndex + 1, starIndex)) = length;
+    fclose(f);
+}
+
+//
+// Get
+//
+
+static s16 time_trials_get_time(s32 fileIndex, s32 courseNum, s32 starIndex) {
+    s32 slotIndex = time_trials_get_slot_index(courseNum, starIndex);
+    if (slotIndex == -1) return TIME_TRIALS_UNDEFINED_TIME;
+    return *time_trials_time(fileIndex, slotIndex);
+}
+
+static s32 time_trials_get_course_time(s32 fileIndex, s32 courseNum) {
+    s32 courseTime = 0;
+    for (s32 starIndex = 0; starIndex < 7; starIndex++) {
+        s32 slotIndex = time_trials_get_slot_index(courseNum, starIndex);
+        s16 t = *time_trials_time(fileIndex, slotIndex);
+        if (t == TIME_TRIALS_UNDEFINED_TIME) {
+            return TIME_TRIALS_UNDEFINED_TIME;
+        }
+
+        courseTime += (s32) t;
+    }
+    return courseTime;
+}
+
+static s32 time_trials_get_bowser_time(s32 fileIndex) {
+    s32 bitdw = time_trials_get_course_time(fileIndex, COURSE_BITDW);
+    if (bitdw == TIME_TRIALS_UNDEFINED_TIME) {
+        return TIME_TRIALS_UNDEFINED_TIME;
+    }
+    s32 bitfs = time_trials_get_course_time(fileIndex, COURSE_BITFS);
+    if (bitfs == TIME_TRIALS_UNDEFINED_TIME) {
+        return TIME_TRIALS_UNDEFINED_TIME;
+    }
+    s32 bits = time_trials_get_course_time(fileIndex, COURSE_BITS);
+    if (bits == TIME_TRIALS_UNDEFINED_TIME) {
+        return TIME_TRIALS_UNDEFINED_TIME;
+    }
+    return bitdw + bitfs + bits;
+}
+
+static s32 time_trials_get_secret_time(s32 fileIndex) {
+    s32 pss = time_trials_get_course_time(fileIndex, COURSE_PSS);
+    if (pss == TIME_TRIALS_UNDEFINED_TIME) {
+        return TIME_TRIALS_UNDEFINED_TIME;
+    }
+    s32 cotmc = time_trials_get_course_time(fileIndex, COURSE_COTMC);
+    if (cotmc == TIME_TRIALS_UNDEFINED_TIME) {
+        return TIME_TRIALS_UNDEFINED_TIME;
+    }
+    s32 totwc = time_trials_get_course_time(fileIndex, COURSE_TOTWC);
+    if (totwc == TIME_TRIALS_UNDEFINED_TIME) {
+        return TIME_TRIALS_UNDEFINED_TIME;
+    }
+    s32 vcutm = time_trials_get_course_time(fileIndex, COURSE_VCUTM);
+    if (vcutm == TIME_TRIALS_UNDEFINED_TIME) {
+        return TIME_TRIALS_UNDEFINED_TIME;
+    }
+    s32 wmotr = time_trials_get_course_time(fileIndex, COURSE_WMOTR);
+    if (wmotr == TIME_TRIALS_UNDEFINED_TIME) {
+        return TIME_TRIALS_UNDEFINED_TIME;
+    }
+    s32 sa = time_trials_get_course_time(fileIndex, COURSE_SA);
+    if (sa == TIME_TRIALS_UNDEFINED_TIME) {
+        return TIME_TRIALS_UNDEFINED_TIME;
+    }
+    return pss + cotmc + totwc + vcutm + wmotr + sa;
+}
+
+static s32 time_trials_get_total_time(s32 fileIndex) {
+    s32 coursesTime = 0;
+    for (s32 course = COURSE_MIN; course <= COURSE_STAGES_MAX; course++) {
+        s32 t = time_trials_get_course_time(fileIndex, course);
+        if (t == TIME_TRIALS_UNDEFINED_TIME) {
+            return TIME_TRIALS_UNDEFINED_TIME;
+        }
+        coursesTime += t;
+    }
+
+    s32 bowserTime = time_trials_get_bowser_time(fileIndex);
+    if (bowserTime == TIME_TRIALS_UNDEFINED_TIME) {
+        return TIME_TRIALS_UNDEFINED_TIME;
+    }
+
+    s32 secretTime = time_trials_get_secret_time(fileIndex);
+    if (secretTime == TIME_TRIALS_UNDEFINED_TIME) {
+        return TIME_TRIALS_UNDEFINED_TIME;
+    }
+
+    return coursesTime + bowserTime + secretTime;
+}
+
+//
+// Ghost
+//
+
+struct TimeTrialGhostAnimationData {
+    struct Animation animation;
+    u8 animationData[0x40000];
+    u8 color;
+    u16 prevValidAnimIndex;
+};
+static struct TimeTrialGhostAnimationData sGhostAnimData1;
+static struct TimeTrialGhostAnimationData sGhostAnimData2;
+
+static u16 time_trials_ghost_retrieve_current_animation_index(struct MarioState *m) {
+    struct MarioAnimDmaRelatedThing *animDmaTable = m->animation->animDmaTable;
+    void *a = m->animation->currentAnimAddr;
+    for (u16 i = 0; i != animDmaTable->count; ++i) {
+        void *b = animDmaTable->srcAddr + animDmaTable->anim[i].offset;
+        if (a == b) {
+            return i;
+        }
+    }
+    return 0;
+}
+
+static s32 time_trials_ghost_load_animation(struct TimeTrialGhostAnimationData *animData, struct MarioState *m, u16 animIndex) {
+    struct MarioAnimDmaRelatedThing *animDmaTable = m->animation->animDmaTable;
+    if (animIndex >= animDmaTable->count) {
+        return FALSE;
+    }
+
+    // Raw data
+    u8 *addr = animDmaTable->srcAddr + animDmaTable->anim[animIndex].offset;
+    u32 size = animDmaTable->anim[animIndex].size;        
+    bcopy(addr, animData->animationData, size);
+
+    // Seek index and values pointers
+    struct Animation *a = (struct Animation *) animData->animationData;
+    const u16 *indexStart = (const u16 *) ((uintptr_t) (animData->animationData) + (uintptr_t) (a->index));
+    const s16 *valueStart = (const s16 *) ((uintptr_t) (animData->animationData) + (uintptr_t) (a->values));
+
+    // Fill ghost animation data
+    bcopy(animData->animationData, &animData->animation, sizeof(struct Animation));
+    animData->animation.index = indexStart;
+    animData->animation.values = valueStart;
+    return TRUE;
+}
+
+static void time_trials_ghost_update_animation(struct TimeTrialGhostAnimationData *animData, struct Object *obj, struct MarioState *m, u16 animIndex, u16 animFrame) {
+    if (obj->header.gfx.unk38.curAnim == NULL) {
+        animData->prevValidAnimIndex = 0xFFFF;
+    }
+
+    // Load & set animation
+    if (animIndex != animData->prevValidAnimIndex && time_trials_ghost_load_animation(animData, m, animIndex)) {
+        obj->header.gfx.unk38.curAnim = &animData->animation;
+        obj->header.gfx.unk38.animAccel = 0;
+        obj->header.gfx.unk38.animYTrans = m->unkB0;
+        animData->prevValidAnimIndex = animIndex;
+    }
+
+    // Set frame
+    if (obj->header.gfx.unk38.curAnim != NULL) {
+        obj->header.gfx.unk38.animFrame = MIN(animFrame, obj->header.gfx.unk38.curAnim->unk08 - 1);
+    }
+}
+
+static struct Object *obj_get_time_trials_ghost(const BehaviorScript *behavior) {
+    struct ObjectNode *listHead = &gObjectLists[OBJ_LIST_DEFAULT];
+    struct Object *next = (struct Object *) listHead->next;
+    while (next != (struct Object *) listHead) {
+        if (next->behavior == behavior && next->activeFlags != 0) {
+            return next;
+        }
+        next = (struct Object *) next->header.next;
+    }
+    return NULL;
+}
+
+static void time_trials_update_ghost(struct TimeTrialGhostFrameData *ghostData, struct TimeTrialGhostAnimationData *animData, const BehaviorScript *behavior, struct MarioState *m, s16 frame, s16 level, s16 area) {
+    struct Object *ghost = obj_get_time_trials_ghost(behavior);
+
+    // If timer reached its max or frame data is ended, unload the ghost
+    if (frame >= TIME_TRIALS_MAX_ALLOWED_TIME || time_trials_is_end_frame(ghostData, frame)) {
+        if (ghost != NULL) {
+            obj_mark_for_deletion(ghost);
+        }
+        return;
+    }
+
+    // Spawn ghost if not loaded
+    if (ghost == NULL) {
+        ghost = spawn_object(m->marioObj, 0, behavior);
+    }
+
+    // Hide ghost if disabled, on first frame or its level or area differs from Mario
+    if (frame == 0 || ghostData[frame].level != (u8) level || ghostData[frame].area != (u8) area) {
+        ghost->header.gfx.node.flags |= GRAPH_RENDER_INVISIBLE;
+        return;
+    }
+
+    // Update ghost
+    ghost->hitboxRadius           = 0;
+    ghost->hitboxHeight           = 0;
+    ghost->oOpacity               = 160;
+    ghost->oPosX                  = (f32) ghostData[frame].posX;
+    ghost->oPosY                  = (f32) ghostData[frame].posY;
+    ghost->oPosZ                  = (f32) ghostData[frame].posZ;
+    ghost->oFaceAnglePitch        = (s16) ghostData[frame].pitch  * 0x100;
+    ghost->oFaceAngleYaw          = (s16) ghostData[frame].yaw    * 0x100;
+    ghost->oFaceAngleRoll         = (s16) ghostData[frame].roll   * 0x100;
+    ghost->oMoveAnglePitch        = (s16) ghostData[frame].pitch  * 0x100;
+    ghost->oMoveAngleYaw          = (s16) ghostData[frame].yaw    * 0x100;
+    ghost->oMoveAngleRoll         = (s16) ghostData[frame].roll   * 0x100;
+    ghost->header.gfx.pos[0]      = (f32) ghostData[frame].posX;
+    ghost->header.gfx.pos[1]      = (f32) ghostData[frame].posY;
+    ghost->header.gfx.pos[2]      = (f32) ghostData[frame].posZ;
+    ghost->header.gfx.angle[0]    = (s16) ghostData[frame].pitch  * 0x100;
+    ghost->header.gfx.angle[1]    = (s16) ghostData[frame].yaw    * 0x100;
+    ghost->header.gfx.angle[2]    = (s16) ghostData[frame].roll   * 0x100;
+    ghost->header.gfx.scale[0]    = (f32) ghostData[frame].scaleX / 100.f;
+    ghost->header.gfx.scale[1]    = (f32) ghostData[frame].scaleY / 100.f;
+    ghost->header.gfx.scale[2]    = (f32) ghostData[frame].scaleZ / 100.f;
+    ghost->header.gfx.node.flags &= ~GRAPH_RENDER_INVISIBLE;
+    ghost->header.gfx.sharedChild = time_trials_get_ghost_mario_graph_node(animData->color);
+    time_trials_ghost_update_animation(animData, ghost, m, (u16) ghostData[frame].animIndex, (u16) ghostData[frame].animFrame);
+}
+
+static void time_trials_record_ghost(struct MarioState *m, s32 frame) {
+    if (frame < 0 || frame >= TIME_TRIALS_MAX_ALLOWED_TIME) {
+        return;
+    }
+
+    if (m->marioObj && m->marioObj->header.gfx.unk38.curAnim) {
+        sTimeTrialGhostDataW[frame].posX      = (s16) m->marioObj->header.gfx.pos[0];
+        sTimeTrialGhostDataW[frame].posY      = (s16) m->marioObj->header.gfx.pos[1];
+        sTimeTrialGhostDataW[frame].posZ      = (s16) m->marioObj->header.gfx.pos[2];
+        sTimeTrialGhostDataW[frame].pitch     = (s8) (m->marioObj->header.gfx.angle[0] / 0x100);
+        sTimeTrialGhostDataW[frame].yaw       = (s8) (m->marioObj->header.gfx.angle[1] / 0x100);
+        sTimeTrialGhostDataW[frame].roll      = (s8) (m->marioObj->header.gfx.angle[2] / 0x100);
+        sTimeTrialGhostDataW[frame].scaleX    = (u8) MAX(0, MIN(255, m->marioObj->header.gfx.scale[0] * 100.f));
+        sTimeTrialGhostDataW[frame].scaleY    = (u8) MAX(0, MIN(255, m->marioObj->header.gfx.scale[1] * 100.f));
+        sTimeTrialGhostDataW[frame].scaleZ    = (u8) MAX(0, MIN(255, m->marioObj->header.gfx.scale[2] * 100.f));
+        sTimeTrialGhostDataW[frame].animIndex = (u8) time_trials_ghost_retrieve_current_animation_index(m);
+        sTimeTrialGhostDataW[frame].animFrame = (u8) MAX(0, MIN(255, MIN(m->marioObj->header.gfx.unk38.animFrame, m->marioObj->header.gfx.unk38.curAnim->unk08 - 1)));
+        sTimeTrialGhostDataW[frame].level     = (u8) gCurrLevelNum;
+        sTimeTrialGhostDataW[frame].area      = (u8) gCurrAreaIndex;
+    } else if (frame > 0) {
+        sTimeTrialGhostDataW[frame]           = sTimeTrialGhostDataW[frame - 1];
+    }
+}
+
+static void time_trials_ghost_unload(const BehaviorScript *behavior) {
+    struct Object *ghost = obj_get_time_trials_ghost(behavior);
+    if (ghost != NULL) {
+        obj_mark_for_deletion(ghost);
+    }
+}
+
+//
+// SM64 Strings
+//
+
+static u8 *time_trials_to_sm64_string(const char *str) {
+    u8 *str64 = calloc(strlen(str) + 1, sizeof(u8));
+    for (int k = 0;; str++) {
+        if (*str == 0) {                str64[k++] = 0xFF; break; }
+        if (*str >= '0' && *str <= '9') str64[k++] = (u8) (*str - '0' + 0);
+        if (*str >= 'A' && *str <= 'Z') str64[k++] = (u8) (*str - 'A' + 10);
+        if (*str >= 'a' && *str <= 'z') str64[k++] = (u8) (*str - 'a' + 36);
+        if (*str == '\'')               str64[k++] = (u8) (62);
+        if (*str == '.')                str64[k++] = (u8) (63);
+        if (*str == ':')                str64[k++] = (u8) (230);
+        if (*str == ',')                str64[k++] = (u8) (111);
+        if (*str == '-')                str64[k++] = (u8) (159);
+        if (*str == '"')                str64[k++] = (u8) (246);
+        if (*str == '@')                str64[k++] = (u8) (249); // coin
+        if (*str == '_')                str64[k++] = (u8) (253); // empty star
+        if (*str == '+')                str64[k++] = (u8) (250); // star filled
+        if (*str == '*')                str64[k++] = (u8) (251); // x
+        if (*str == ' ')                str64[k++] = (u8) (158); // space
+    }
+    return str64;
+}
+
+//
+// Int to String
+//
+
+static u8 *time_trials_time_to_string(s16 time) {
+    if (time == TIME_TRIALS_UNDEFINED_TIME) {
+        return time_trials_to_sm64_string("-'--\"--");
+    }
+
+    char buffer[32];
+    sprintf(buffer, "%01d'%02d\"%02d", (time / 1800) % 10, (time / 30) % 60, ((time * 10) / 3) % 100);
+    return time_trials_to_sm64_string(buffer);
+}
+
+static u8 *time_trials_course_time_to_string(s32 coursetime) {
+    if (coursetime == TIME_TRIALS_UNDEFINED_TIME) {
+        return time_trials_to_sm64_string("-'--\"--");
+    }
+
+    char buffer[32];
+    sprintf(buffer, "%02d'%02d\"%02d", (coursetime / 1800) % 100, (coursetime / 30) % 60, ((coursetime * 10) / 3) % 100);
+    return time_trials_to_sm64_string(buffer);
+}
+
+static u8 *time_trials_total_time_to_string(s32 totaltime) {
+    if (totaltime == TIME_TRIALS_UNDEFINED_TIME) {
+        return time_trials_to_sm64_string("--:--:--.--");
+    }
+
+    char buffer[32];
+    sprintf(buffer, "%02d:%02d:%02d.%02d", (totaltime / 1080000) % 100, (totaltime / 1800) % 60, (totaltime / 30) % 60, ((totaltime * 10) / 3) % 100);
+    return time_trials_to_sm64_string(buffer);
+}
+
+//
+// Render
+//
+
+extern u8 gDialogCharWidths[256];
+static s16 time_trials_get_string_length(const u8 *str) {
+    s16 length = 0;
+    for (; *str != DIALOG_CHAR_TERMINATOR; ++str) {
+        length += gDialogCharWidths[*str];
+    }
+    return length;
+}
+
+enum { screen_left_edge = 0, screen_center = 1, screen_right_edge = 2 };
+enum { align_left = 0, align_center = 1, align_right = 2 };
+enum { color_white = 0, color_gray, color_yellow };
+static void time_trials_render_string(s16 dx, s16 y, u8 *str, s8 origin, s8 alignment, s8 color) {
+
+    // Compute x position from origin and alignment
+    s16 x = 0;
+    s16 l = time_trials_get_string_length(str);
+    s8 mode = origin * 10 + alignment;
+    switch (mode) {
+        case 00: x = GFX_DIMENSIONS_FROM_LEFT_EDGE (dx);         break; // screen_left_edge, align_left
+        case 01: x = GFX_DIMENSIONS_FROM_LEFT_EDGE (dx - l / 2); break; // screen_left_edge, align_center
+        case 02: x = GFX_DIMENSIONS_FROM_LEFT_EDGE (dx - l);     break; // screen_left_edge, align_right
+        case 10: x = SCREEN_WIDTH / 2 +            (dx);         break; // screen_center, align_left
+        case 11: x = SCREEN_WIDTH / 2 +            (dx - l / 2); break; // screen_center, align_center
+        case 12: x = SCREEN_WIDTH / 2 +            (dx - l);     break; // screen_center, align_right
+        case 20: x = GFX_DIMENSIONS_FROM_RIGHT_EDGE(dx);         break; // screen_right_edge, align_left
+        case 21: x = GFX_DIMENSIONS_FROM_RIGHT_EDGE(dx + l / 2); break; // screen_right_edge, align_center
+        case 22: x = GFX_DIMENSIONS_FROM_RIGHT_EDGE(dx + l);     break; // screen_right_edge, align_right
+    }
+
+    // Render characters
+    static const u8 colors[][3] = {
+        { 0xff, 0xff, 0xff },
+        { 0xa0, 0xa0, 0xa0 },
+        { 0xff, 0xff, 0x00 },
+    };
+    void **fontLUT = (void **) segmented_to_virtual(main_font_lut);
+    gSPDisplayList(gDisplayListHead++, dl_ia_text_begin);
+    gDPSetEnvColor(gDisplayListHead++, colors[color][0], colors[color][1], colors[color][2], gDialogTextAlpha);
+    create_dl_translation_matrix(MENU_MTX_PUSH, x, y, 0);
+    for (u8 *p = str; *p != DIALOG_CHAR_TERMINATOR; ++p) {
+        if (*p != DIALOG_CHAR_SPACE) {
+            void *tex = segmented_to_virtual(fontLUT[*p]);
+            gDPPipeSync(gDisplayListHead++);
+            gDPSetTextureImage(gDisplayListHead++, G_IM_FMT_IA, G_IM_SIZ_16b, 1, VIRTUAL_TO_PHYSICAL(tex));
+            gSPDisplayList(gDisplayListHead++, dl_ia_text_tex_settings);
+        }
+        create_dl_translation_matrix(MENU_MTX_NOPUSH, gDialogCharWidths[*p], 0, 0);
+    }
+    gSPPopMatrix(gDisplayListHead++, G_MTX_MODELVIEW);
+    gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 255);
+    gSPDisplayList(gDisplayListHead++, dl_ia_text_end);
+
+    // Free the string after rendering it
+    free(str);
+}
+
+static void time_trials_render_centered_box(s32 y, s32 w, s32 h) {
+    Mtx *matrix = (Mtx *) alloc_display_list(sizeof(Mtx));
+    if (!matrix) return;
+    create_dl_translation_matrix(MENU_MTX_PUSH, (SCREEN_WIDTH - w) / 2, y + h, 0);
+    guScale(matrix, (f32) w / 130.f, (f32) h / 80.f, 1.f);
+    gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(matrix), G_MTX_MODELVIEW | G_MTX_MUL | G_MTX_NOPUSH);
+    gDPSetEnvColor(gDisplayListHead++, 0, 0, 0, 105);
+    gSPDisplayList(gDisplayListHead++, dl_draw_text_bg_box);
+    gSPPopMatrix(gDisplayListHead++, G_MTX_MODELVIEW);
+}
+
+/*
+Position:
+Title
+1 5
+2 6
+3 7
+4 8
+C T
+*/
+
+#define TIME_TRIALS_BOX_H_MARGIN    (22.5f * sqr(gfx_current_dimensions.aspect_ratio))
+#define TIME_TRIALS_BOX_V_MARGIN    (40.f)
+#define TIME_TRIALS_TEXT_H_MARGIN   (9.f * gfx_current_dimensions.aspect_ratio)
+#define TIME_TRIALS_TEXT_V_MARGIN   (12.f)
+
+struct RenderParams { const char *label; bool starGet; s16 time; };
+static const struct RenderParams sNoParam = { NULL, 0, 0 };
+
+static void time_trials_render_pause_times(struct RenderParams params[8], const char *title, s32 courseTime, s32 totalTime) {
+
+    // Title
+    time_trials_render_string(0, SCREEN_HEIGHT - TIME_TRIALS_BOX_V_MARGIN - TIME_TRIALS_TEXT_V_MARGIN - 14, time_trials_to_sm64_string(title), screen_center, align_center, color_white);
+
+    // Stars
+    for (s32 i = 0; i != 8; ++i) {
+        if (params[i].label == NULL) continue;
+        s16 dx, y = (SCREEN_HEIGHT / 2) + ((TIME_TRIALS_TEXT_V_MARGIN / 2) + 10 + TIME_TRIALS_TEXT_V_MARGIN) - (10 + TIME_TRIALS_TEXT_V_MARGIN) * (i % 4) - 3;
+        u8 color = ((strcmp(params[i].label, "ALL STARS") == 0) ? color_yellow : color_white);
+
+        // Label
+        dx = TIME_TRIALS_TEXT_H_MARGIN + (i < 4 ? TIME_TRIALS_BOX_H_MARGIN : 0);
+        time_trials_render_string(dx, y, time_trials_to_sm64_string(params[i].label), (i < 4 ? screen_left_edge : screen_center), align_left, color);
+
+        // Time
+        bool undefined = (params[i].time == TIME_TRIALS_UNDEFINED_TIME);
+        dx = (TIME_TRIALS_TEXT_H_MARGIN + (i < 4 ? 0 : TIME_TRIALS_BOX_H_MARGIN)) * (i < 4 ? -1 : +1);
+        time_trials_render_string(dx, y, time_trials_time_to_string(params[i].time), (i < 4 ? screen_center : screen_right_edge), align_right, undefined ? color_gray : color);
+
+        // Star icon
+        bool collected = (params[i].starGet);
+        dx = (TIME_TRIALS_TEXT_H_MARGIN + (i < 4 ? 0 : TIME_TRIALS_BOX_H_MARGIN) + 48) * (i < 4 ? -1 : +1);
+        time_trials_render_string(dx, y, time_trials_to_sm64_string(params[i].starGet ? "+" : "_"), (i < 4 ? screen_center : screen_right_edge), align_right, collected ? color : color_gray);
+    }
+
+    // Course time
+    {
+        bool undefined = (courseTime == TIME_TRIALS_UNDEFINED_TIME);
+        time_trials_render_string(TIME_TRIALS_TEXT_H_MARGIN + TIME_TRIALS_BOX_H_MARGIN, TIME_TRIALS_BOX_V_MARGIN + TIME_TRIALS_TEXT_V_MARGIN - 3, time_trials_to_sm64_string("COURSE"), screen_left_edge, align_left, color_white);
+        time_trials_render_string(-TIME_TRIALS_TEXT_H_MARGIN, TIME_TRIALS_BOX_V_MARGIN + TIME_TRIALS_TEXT_V_MARGIN - 3, time_trials_course_time_to_string(courseTime), screen_center, align_right, undefined ? color_gray : color_white);
+    }
+    
+    // Total time
+    {
+        bool undefined = (totalTime == TIME_TRIALS_UNDEFINED_TIME);
+        time_trials_render_string(TIME_TRIALS_TEXT_H_MARGIN, TIME_TRIALS_BOX_V_MARGIN + TIME_TRIALS_TEXT_V_MARGIN - 3, time_trials_to_sm64_string("TOTAL"), screen_center, align_left, color_white);
+        time_trials_render_string(TIME_TRIALS_TEXT_H_MARGIN + TIME_TRIALS_BOX_H_MARGIN, TIME_TRIALS_BOX_V_MARGIN + TIME_TRIALS_TEXT_V_MARGIN - 3, time_trials_total_time_to_string(totalTime), screen_right_edge, align_right, undefined ? color_gray : color_white);
+    }
+}
+
+static void time_trials_render_pause_course_times(s32 fileIndex, s32 courseNum) {
+    static const char *sCourseNames[] = {
+        "1 - BOB-OMB BATTLEFIELD",
+        "2 - WHOMP FORTRESS",
+        "3 - JOLLY ROGER BAY",
+        "4 - COOL, COOL MOUNTAIN",
+        "5 - BIG BOO'S HAUNT",
+        "6 - HAZY MAZE CAVE",
+        "7 - LETHAL LAVA LAND",
+        "8 - SHIFTING SAND LAND",
+        "9 - DIRE, DIRE DOCKS",
+        "10 - SNOWMAN'S LAND",
+        "11 - WET-DRY WORLD",
+        "12 - TALL, TALL MOUNTAIN",
+        "13 - TINY-HUGE ISLAND",
+        "14 - TICK TOCK CLOCK",
+        "15 - RAINBOW RIDE"
+    };
+
+    u8 starFlags = save_file_get_star_flags(fileIndex, courseNum - COURSE_MIN);
+    u8 allStars  = time_trials_get_time(fileIndex, courseNum, 7) != TIME_TRIALS_UNDEFINED_TIME;
+
+    time_trials_render_pause_times((struct RenderParams[]) {
+        (struct RenderParams) { "STAR 1",    (starFlags >> 0) & 1, time_trials_get_time(fileIndex, courseNum, 0) }, 
+        (struct RenderParams) { "STAR 2",    (starFlags >> 1) & 1, time_trials_get_time(fileIndex, courseNum, 1) },
+        (struct RenderParams) { "STAR 3",    (starFlags >> 2) & 1, time_trials_get_time(fileIndex, courseNum, 2) },
+        OMM_STARS_NON_STOP ?
+        (struct RenderParams) { "ALL STARS", (allStars)      != 0, time_trials_get_time(fileIndex, courseNum, 7) } :
+        sNoParam,
+        (struct RenderParams) { "STAR 4",    (starFlags >> 3) & 1, time_trials_get_time(fileIndex, courseNum, 3) },
+        (struct RenderParams) { "STAR 5",    (starFlags >> 4) & 1, time_trials_get_time(fileIndex, courseNum, 4) },
+        (struct RenderParams) { "STAR 6",    (starFlags >> 5) & 1, time_trials_get_time(fileIndex, courseNum, 5) },
+        (struct RenderParams) { "STAR @",    (starFlags >> 6) & 1, time_trials_get_time(fileIndex, courseNum, 6) },
+    },
+        sCourseNames[courseNum - COURSE_MIN],
+        time_trials_get_course_time(fileIndex, courseNum),
+        time_trials_get_total_time(fileIndex)
+    );
+}
+
+static void time_trials_render_pause_bowser_times(s32 fileIndex) {
+    u8 bitdwStarFlags = save_file_get_star_flags(fileIndex, COURSE_BITDW - COURSE_MIN);
+    u8 bitfsStarFlags = save_file_get_star_flags(fileIndex, COURSE_BITFS - COURSE_MIN);
+    u8 bitsStarFlags  = save_file_get_star_flags(fileIndex, COURSE_BITS - COURSE_MIN);
+    u8 bitdwKeyFlag   = save_file_get_flags() & (SAVE_FLAG_HAVE_KEY_1 | SAVE_FLAG_UNLOCKED_BASEMENT_DOOR);
+    u8 bitfsKeyFlag   = save_file_get_flags() & (SAVE_FLAG_HAVE_KEY_2 | SAVE_FLAG_UNLOCKED_UPSTAIRS_DOOR);
+    u8 bitsGrandStar  = time_trials_get_time(fileIndex, COURSE_BITS, 1) != TIME_TRIALS_UNDEFINED_TIME;
+
+    time_trials_render_pause_times((struct RenderParams[]) {
+        (struct RenderParams) { "STAR 1", (bitdwStarFlags >> 0) & 1, time_trials_get_time(fileIndex, COURSE_BITDW, 0) }, 
+        (struct RenderParams) { "STAR 2", (bitfsStarFlags >> 0) & 1, time_trials_get_time(fileIndex, COURSE_BITFS, 0) },
+        (struct RenderParams) { "STAR 3", (bitsStarFlags  >> 0) & 1, time_trials_get_time(fileIndex, COURSE_BITS,  0) },
+        sNoParam,
+        (struct RenderParams) { "KEY 1",  (bitdwKeyFlag)       != 0, time_trials_get_time(fileIndex, COURSE_BITDW, 1) },
+        (struct RenderParams) { "KEY 2",  (bitfsKeyFlag)       != 0, time_trials_get_time(fileIndex, COURSE_BITFS, 1) },
+        (struct RenderParams) { "FINAL",  (bitsGrandStar)      != 0, time_trials_get_time(fileIndex, COURSE_BITS,  1) },
+        sNoParam,
+    },
+        "BOWSER COURSES",
+        time_trials_get_bowser_time(fileIndex),
+        time_trials_get_total_time(fileIndex)
+    );
+}
+
+static void time_trials_render_pause_secret_times(s32 fileIndex) {
+    u8 totwcStarFlags = save_file_get_star_flags(fileIndex, COURSE_TOTWC - COURSE_MIN);
+    u8 vcutmStarFlags = save_file_get_star_flags(fileIndex, COURSE_VCUTM - COURSE_MIN);
+    u8 cotmcStarFlags = save_file_get_star_flags(fileIndex, COURSE_COTMC - COURSE_MIN);
+    u8 pssStarFlags   = save_file_get_star_flags(fileIndex, COURSE_PSS - COURSE_MIN);
+    u8 saStarFlags    = save_file_get_star_flags(fileIndex, COURSE_SA - COURSE_MIN);
+    u8 wmotrStarFlags = save_file_get_star_flags(fileIndex, COURSE_WMOTR - COURSE_MIN);
+
+    time_trials_render_pause_times((struct RenderParams[]) {
+        (struct RenderParams) { "PSS 1",  (pssStarFlags   >> 0) & 1, time_trials_get_time(fileIndex, COURSE_PSS,   0) },
+        (struct RenderParams) { "PSS 2",  (pssStarFlags   >> 1) & 1, time_trials_get_time(fileIndex, COURSE_PSS,   1) },
+        (struct RenderParams) { "SA",     (saStarFlags    >> 0) & 1, time_trials_get_time(fileIndex, COURSE_SA,    0) },
+        (struct RenderParams) { "WMOTR",  (wmotrStarFlags >> 0) & 1, time_trials_get_time(fileIndex, COURSE_WMOTR, 0) },
+        (struct RenderParams) { "TOTWC",  (totwcStarFlags >> 0) & 1, time_trials_get_time(fileIndex, COURSE_TOTWC, 0) }, 
+        (struct RenderParams) { "VCUTM",  (vcutmStarFlags >> 0) & 1, time_trials_get_time(fileIndex, COURSE_VCUTM, 0) },
+        (struct RenderParams) { "COTMC",  (cotmcStarFlags >> 0) & 1, time_trials_get_time(fileIndex, COURSE_COTMC, 0) },
+        sNoParam,
+    },
+        "SECRET COURSES",
+        time_trials_get_secret_time(fileIndex),
+        time_trials_get_total_time(fileIndex)
+    );
+}
+
+Gfx *gTimeTableDisplayListHead;
+static bool sSetIndexToCurrentCourse = false;
+extern void create_dl_rotation_matrix(s8 pushOp, f32 a, f32 x, f32 y, f32 z);
+bool time_trials_render_time_table(s8 *index) {
+    if (!sTimeTrialsEnabled) {
+        return false;
+    }
+
+    // Handle menu scrolling
+    static s8 sCastleHubCurrentCourse = 0;
+    if (sSetIndexToCurrentCourse) {
+        if (gCurrCourseNum == COURSE_NONE) *index = sCastleHubCurrentCourse;
+        else if (gCurrCourseNum >= COURSE_BITDW && gCurrCourseNum <= COURSE_BITS) *index = COURSE_STAGES_COUNT;
+        else if (gCurrCourseNum > COURSE_BITS) *index = COURSE_STAGES_COUNT + 1;
+        else *index = gCurrCourseNum - 1;
+        sSetIndexToCurrentCourse = false;
+    }
+    handle_menu_scrolling(MENU_SCROLL_VERTICAL, index, -1, COURSE_STAGES_COUNT + 2);
+    if (*index == COURSE_STAGES_COUNT + 2) *index = 0;
+    if (*index == -1) *index = COURSE_STAGES_COUNT + 1;
+    sCastleHubCurrentCourse = *index;
+
+    // Render the colorful "PAUSE"
+    gDisplayListHead = gTimeTableDisplayListHead;
+    u8 *pause = time_trials_to_sm64_string("TIME TRIALS");
+    gSPDisplayList(gDisplayListHead++, dl_rgba16_text_begin);
+    gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, gDialogTextAlpha);
+    print_hud_lut_string(HUD_LUT_GLOBAL, SCREEN_WIDTH / 2 - 64, 8, pause);
+    gSPDisplayList(gDisplayListHead++, dl_rgba16_text_end);
+    free(pause);
+
+    // Render the black box behind the text
+    time_trials_render_centered_box(TIME_TRIALS_BOX_V_MARGIN, GFX_DIMENSIONS_FROM_RIGHT_EDGE(TIME_TRIALS_BOX_H_MARGIN) - GFX_DIMENSIONS_FROM_LEFT_EDGE(TIME_TRIALS_BOX_H_MARGIN), SCREEN_HEIGHT - 2 * TIME_TRIALS_BOX_V_MARGIN);
+    create_dl_translation_matrix(MENU_MTX_PUSH, SCREEN_WIDTH / 2 + 8, SCREEN_HEIGHT - TIME_TRIALS_BOX_V_MARGIN + 4, 0);
+    create_dl_rotation_matrix(MENU_MTX_NOPUSH, 90.0f, 0, 0, 1.0f);
+    gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, gDialogTextAlpha);
+    gSPDisplayList(gDisplayListHead++, dl_draw_triangle);
+    gSPPopMatrix(gDisplayListHead++, G_MTX_MODELVIEW);
+    create_dl_translation_matrix(MENU_MTX_PUSH, SCREEN_WIDTH / 2 - 8, TIME_TRIALS_BOX_V_MARGIN - 4, 0);
+    create_dl_rotation_matrix(MENU_MTX_NOPUSH, 270.0f, 0, 0, 1.0f);
+    gSPDisplayList(gDisplayListHead++, dl_draw_triangle);
+    gSPPopMatrix(gDisplayListHead++, G_MTX_MODELVIEW);
+
+    // Render the text
+    gSPDisplayList(gDisplayListHead++, dl_ia_text_begin);
+    gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, gDialogTextAlpha);
+    switch (*index) {
+        case COURSE_STAGES_COUNT + 1: time_trials_render_pause_secret_times(gCurrSaveFileNum - 1); break;
+        case COURSE_STAGES_COUNT:     time_trials_render_pause_bowser_times(gCurrSaveFileNum - 1); break;
+        default:                      time_trials_render_pause_course_times(gCurrSaveFileNum - 1, *index + 1); break;
+    }
+    gSPDisplayList(gDisplayListHead++, dl_ia_text_end);
+    return true;
+}
+
+//
+// HUD
+//
+
+static s16 time_trials_get_x_from_center(const u8 *str64) {
+    s16 len = 0;
+    while (*str64 != 0xFF) {
+        len += (*str64 == GLOBAL_CHAR_SPACE ? 8 : 12);
+        str64++;
+    }
+    return (SCREEN_WIDTH / 2) - len;
+}
+
+static void time_trials_render_timer(s16 y, const char *text, s16 time, u8 colorFade) {
+    u8 *s = time_trials_to_sm64_string(text);
+    s16 x = time_trials_get_x_from_center(s);
+    gSPDisplayList(gDisplayListHead++, dl_rgba16_text_begin);
+    gDPSetEnvColor(gDisplayListHead++, colorFade, colorFade, colorFade, 255);
+    print_hud_lut_string(HUD_LUT_GLOBAL,                x -  6, y,     s);
+    print_hud_lut_string(HUD_LUT_GLOBAL, SCREEN_WIDTH / 2 +  6, y,     time_trials_int_to_sm64_string( (time / 1800)    % 60,  "%01d"));
+    print_hud_lut_string(HUD_LUT_GLOBAL, SCREEN_WIDTH / 2 + 26, y,     time_trials_int_to_sm64_string( (time / 30)      % 60,  "%02d"));
+    print_hud_lut_string(HUD_LUT_GLOBAL, SCREEN_WIDTH / 2 + 60, y,     time_trials_int_to_sm64_string(((time * 10) / 3) % 100, "%02d"));
+    print_hud_lut_string(HUD_LUT_GLOBAL, SCREEN_WIDTH / 2 + 16, y - 8, (const u8 *) (const u8 []) { 56, 255 });
+    print_hud_lut_string(HUD_LUT_GLOBAL, SCREEN_WIDTH / 2 + 51, y - 8, (const u8 *) (const u8 []) { 57, 255 });
+    gSPDisplayList(gDisplayListHead++, dl_rgba16_text_end);
+    gDPSetEnvColor(gDisplayListHead++, 255, 255, 255, 255);
+    free(s);
+}
+
+void time_trials_render_star_select_time(s32 starIndex) {
+    if (sTimeTrialsEnabled) {
+        s16 time = time_trials_get_time(gCurrSaveFileNum - 1, gCurrCourseNum, starIndex);
+        if (time != TIME_TRIALS_UNDEFINED_TIME) {
+            time_trials_render_timer(12, "HI SCORE", time, 255);
+        }
+    }
+}
+
+//
+// Update
+//
+
+static s32 time_trials_get_ghost_data_to_load(s32 courseNum, s32 starIndex) {
+    if (courseNum >= COURSE_BOB   && courseNum <= COURSE_RR)   return MAX(0, MIN(starIndex, 5));
+    if (courseNum >= COURSE_BITDW && courseNum <= COURSE_BITS) return 1;
+    if (courseNum == COURSE_PSS)                               return 0;
+    return 0;
+}
+
+static s32 time_trials_get_special_ghost_data_to_load(s32 courseNum) {
+    if (courseNum >= COURSE_BOB   && courseNum <= COURSE_RR)   return 6;
+    if (courseNum >= COURSE_BITDW && courseNum <= COURSE_BITS) return 0;
+    if (courseNum == COURSE_PSS)                               return 1;
+    return -1;
+}
+
+static bool time_trials_should_start_timer(struct MarioState *m) {
+    switch (m->action) {
+        case ACT_SPAWN_SPIN_AIRBORNE:       return (gCurrCourseNum >= COURSE_BOB && gCurrCourseNum <= COURSE_STAGES_MAX);
+        case ACT_SPAWN_NO_SPIN_AIRBORNE:    return (gCurrCourseNum >  COURSE_STAGES_MAX);
+        case ACT_FLYING:                    return (gCurrCourseNum == COURSE_TOTWC && m->actionArg == 2 && m->actionTimer++ == 0);
+        case ACT_WATER_IDLE:                return (gCurrCourseNum == COURSE_SA && m->actionArg == 1 && m->actionTimer++ == 0);
+    }
+    return false;
+}
+
+void time_trials_update(bool isPaused) {
+    
+    // Hold L and press B to enable/disable Time Trials during the pause
+    if (isPaused) {
+        if ((gControllers[0].buttonDown & L_TRIG) && (gControllers[0].buttonPressed & B_BUTTON)) {
+            sTimeTrialsEnabled = !sTimeTrialsEnabled;
+            if (sTimeTrialsEnabled) {
+                play_sound(SOUND_MENU_STAR_SOUND, gDefaultSoundArgs);
+            }
+        }
+    }
+    if (!sTimeTrialsEnabled) {
+        sTimeTrialTimer = TIME_TRIALS_MAX_ALLOWED_TIME;
+        sTimeTrialTimerState = TT_TIMER_DISABLED;
+        time_trials_ghost_unload(bhvTimeTrialGhost1);
+        time_trials_ghost_unload(bhvTimeTrialGhost2);
+        return;
+    }
+
+    // Pause
+    static bool sIsPaused = false;
+    if (isPaused && !sIsPaused) {
+        sSetIndexToCurrentCourse = true;
+    }
+    sIsPaused = isPaused;
+
+    // Update running ghost, record ghost data, and advance timer if it's running
+    if (sTimeTrialTimerState == TT_TIMER_RUNNING) {
+        sTimeTrialHiScore = false;
+            
+        // Update ghosts and advance timer if not paused
+        if (!isPaused) {
+            time_trials_update_ghost(sTimeTrialGhostDataR1, &sGhostAnimData1, bhvTimeTrialGhost1, gMarioState, sTimeTrialTimer, gCurrLevelNum, gCurrAreaIndex);
+            time_trials_update_ghost(sTimeTrialGhostDataR2, &sGhostAnimData2, bhvTimeTrialGhost2, gMarioState, sTimeTrialTimer, gCurrLevelNum, gCurrAreaIndex);
+            time_trials_record_ghost(gMarioState, sTimeTrialTimer);
+            sTimeTrialTimer = MIN(sTimeTrialTimer + 1, TIME_TRIALS_MAX_ALLOWED_TIME);
+        }
+    }
+
+    // Runs timer if course is TTable
+    static s16 sLoadedSvFileNum = -1;
+    static s16 sLoadedCourseNum = -1;
+    static s16 sLoadedStarIndex = -1;
+    if (time_trials_get_slot_index(gCurrCourseNum, 0) != -1) {
+        if (sTimeTrialTimerState != TT_TIMER_STOPPED) {
+            sTimeTrialTimerState = TT_TIMER_RUNNING;
+            sTimeTrialHiScore = false;
+
+            // Start timer and init ghost if a course entry is detected
+            if (time_trials_should_start_timer(gMarioState)) {
+                bzero(sTimeTrialGhostDataW, sizeof(sTimeTrialGhostDataW));
+                sTimeTrialTimer = 0;
+
+                // Load ghosts only if not already loaded
+                s32 starIndex = time_trials_get_ghost_data_to_load(gCurrCourseNum, gCurrActNum - 1);
+                if ((sLoadedSvFileNum != gCurrSaveFileNum) || (sLoadedCourseNum != gCurrCourseNum) || (sLoadedStarIndex != starIndex)) {
+
+                    // Default ghost (blue)
+                    // All Stars ghost (pink)
+                    if (OMM_STARS_NON_STOP && gCurrCourseNum >= COURSE_BOB && gCurrCourseNum <= COURSE_RR) {
+                        starIndex = 7;
+                    }
+                    s32 slotIndex = time_trials_get_slot_index(gCurrCourseNum, starIndex);
+                    time_trials_read_ghost_data(gCurrSaveFileNum - 1, gCurrCourseNum - 1, starIndex, slotIndex, sTimeTrialGhostDataR1);
+                    sGhostAnimData1.color = (starIndex == 7 ? GHOST_MARIO_ALL_STARS : GHOST_MARIO_DEFAULT);
+                    sGhostAnimData1.prevValidAnimIndex = 0xFFFF;
+
+                    // Special ghost
+                    // Bowser Red coins (red)
+                    // PSS 2 (green)
+                    // 100 coins (gold)
+                    s32 specialIndex = time_trials_get_special_ghost_data_to_load(gCurrCourseNum);
+                    if (specialIndex != -1) {
+                        slotIndex = time_trials_get_slot_index(gCurrCourseNum, specialIndex);
+                        time_trials_read_ghost_data(gCurrSaveFileNum - 1, gCurrCourseNum - 1, specialIndex, slotIndex, sTimeTrialGhostDataR2);
+                        if (specialIndex == 0) sGhostAnimData2.color = GHOST_MARIO_RED_COINS;
+                        if (specialIndex == 1) sGhostAnimData2.color = GHOST_MARIO_PSS_2;
+                        if (specialIndex == 6) sGhostAnimData2.color = GHOST_MARIO_100_COINS;
+                        sGhostAnimData2.prevValidAnimIndex = 0xFFFF;
+                    }
+
+                    sLoadedSvFileNum = gCurrSaveFileNum;
+                    sLoadedCourseNum = gCurrCourseNum;
+                    sLoadedStarIndex = starIndex;
+                }
+            }
+
+            // Stop timer and save time when Mario collects a star
+            struct MarioState *m = gMarioState;
+            if (m->action == ACT_STAR_DANCE_EXIT ||
+                m->action == ACT_STAR_DANCE_NO_EXIT ||
+                m->action == ACT_STAR_DANCE_WATER ||
+                m->action == ACT_FALL_AFTER_STAR_GRAB ||
+                m->action == ACT_JUMBO_STAR_CUTSCENE) {
+
+                // Force Mario to leave the course if he collects a main course star
+                // Ignore this if OMM Non-Stop mode is enabled
+                if (gCurrCourseNum >= COURSE_MIN && gCurrCourseNum <= COURSE_STAGES_MAX) {
+                    if (!OMM_STARS_NON_STOP || OMM_ALL_STARS) {
+                        drop_queued_background_music();
+                        fadeout_level_music(126);
+                        m->actionArg = 0;
+                    }
+                }
+
+                // Save the time
+                if (sTimeTrialTimerState == TT_TIMER_RUNNING) {
+                    s32 starIndex = gLastCompletedStarNum - 1;
+
+                    // Bowser Key or Grand Star
+                    if (gCurrLevelNum == LEVEL_BOWSER_1 ||
+                        gCurrLevelNum == LEVEL_BOWSER_2 ||
+                        gCurrLevelNum == LEVEL_BOWSER_3) {
+                        starIndex = 1;
+                        m->actionArg = 0;
+                    }
+
+                    // Write time and ghost data if new record
+                    s32 slotIndex = time_trials_get_slot_index(gCurrCourseNum, starIndex);
+                    if (slotIndex != -1) {
+                        s16 t = *time_trials_time(gCurrSaveFileNum - 1, slotIndex);
+                        if (t == TIME_TRIALS_UNDEFINED_TIME || t > sTimeTrialTimer) {
+                            time_trials_write_ghost_data(gCurrSaveFileNum - 1, gCurrCourseNum - 1, starIndex);
+                            sTimeTrialHiScore = true;
+                        } else {
+                            sTimeTrialHiScore = false;
+                        }
+                    }
+
+                    // All Stars
+                    if (OMM_ALL_STARS) {
+                        slotIndex = time_trials_get_slot_index(gCurrCourseNum, 7);
+                        if (slotIndex != -1) {
+                            s16 t = *time_trials_time(gCurrSaveFileNum - 1, slotIndex);
+                            if (t == TIME_TRIALS_UNDEFINED_TIME || t > sTimeTrialTimer) {
+                                time_trials_write_ghost_data(gCurrSaveFileNum - 1, gCurrCourseNum - 1, 7);
+                                sTimeTrialHiScore = true;
+                            } else {
+                                sTimeTrialHiScore = false;
+                            }
+                        }
+                    }
+
+                    // Stop the timer if Mario leaves the course
+                    if (m->actionArg == 0) {
+                        sTimeTrialTimerState = TT_TIMER_STOPPED;
+                    }
+                }
+            }
+        }
+    } else {
+        sTimeTrialTimer = TIME_TRIALS_MAX_ALLOWED_TIME;
+        sTimeTrialTimerState = TT_TIMER_DISABLED;
+        sLoadedSvFileNum = -1;
+        sLoadedCourseNum = -1;
+        sLoadedStarIndex = -1;
+    }
+
+    // Render timer
+    if (gHudDisplay.flags != HUD_DISPLAY_NONE && configHUD && sTimeTrialTimerState != TT_TIMER_DISABLED) {
+        if (sTimeTrialHiScore && sTimeTrialTimerState == TT_TIMER_STOPPED) {
+            time_trials_render_timer(SCREEN_HEIGHT - 24, "HI SCORE", sTimeTrialTimer, (sins(gGlobalTimer * 0x1000) * 50.f + 205.f));
+        } else if (sTimeTrialTimer > 0) {
+            time_trials_render_timer(SCREEN_HEIGHT - 24, "TIME", sTimeTrialTimer, 255);
+        }
+    }
+}
diff --git a/src/game/time_trials.h b/src/game/time_trials.h
new file mode 100644
index 00000000..6998c625
--- /dev/null
+++ b/src/game/time_trials.h
@@ -0,0 +1,15 @@
+#ifndef TIME_TRIALS_H
+#define TIME_TRIALS_H
+
+#include <stdbool.h>
+#include "types.h"
+
+#define TIME_TRIALS time_trials_enabled()
+
+extern Gfx *gTimeTableDisplayListHead;
+bool time_trials_enabled();
+void time_trials_update(bool isPaused);
+bool time_trials_render_time_table(s8 *index);
+void time_trials_render_star_select_time(s32 starIndex);
+
+#endif // TIME_TRIALS_H
diff --git a/src/game/time_trials_ghost_geo.inl b/src/game/time_trials_ghost_geo.inl
new file mode 100644
index 00000000..b0b4871c
--- /dev/null
+++ b/src/game/time_trials_ghost_geo.inl
@@ -0,0 +1,1931 @@
+//
+// Ghost Mario
+//
+
+static const Lights1 ghost_mario_blue_light  = gdSPDefLights1(0x20, 0x20, 0xA0, 0x20, 0x20, 0xA0, 0x28, 0x28, 0x28);
+static const Lights1 ghost_mario_red_light   = gdSPDefLights1(0x80, 0x20, 0x20, 0x80, 0x20, 0x20, 0x28, 0x28, 0x28);
+static const Lights1 ghost_mario_green_light = gdSPDefLights1(0x20, 0x60, 0x20, 0x20, 0x60, 0x20, 0x28, 0x28, 0x28);
+static const Lights1 ghost_mario_gold_light  = gdSPDefLights1(0xA0, 0x80, 0x00, 0xA0, 0x80, 0x00, 0x28, 0x28, 0x28);
+static const Lights1 ghost_mario_pink_light  = gdSPDefLights1(0xC0, 0x40, 0xA0, 0xC0, 0x40, 0xA0, 0x28, 0x28, 0x28);
+
+//
+// Ghost light display list
+//
+
+static const Gfx ghost_mario_blue_light_dl[] = {
+    gsDPPipeSync(),
+    gsDPSetCombineLERP(0, 0, 0, SHADE, 0, 0, 0, ENVIRONMENT, 0, 0, 0, SHADE, 0, 0, 0, ENVIRONMENT),
+    gsSPLight(&ghost_mario_blue_light.l, 1),
+    gsSPLight(&ghost_mario_blue_light.a, 2),
+    gsSPEndDisplayList(),
+};
+
+static const Gfx ghost_mario_red_light_dl[] = {
+    gsDPPipeSync(),
+    gsDPSetCombineLERP(0, 0, 0, SHADE, 0, 0, 0, ENVIRONMENT, 0, 0, 0, SHADE, 0, 0, 0, ENVIRONMENT),
+    gsSPLight(&ghost_mario_red_light.l, 1),
+    gsSPLight(&ghost_mario_red_light.a, 2),
+    gsSPEndDisplayList(),
+};
+
+static const Gfx ghost_mario_green_light_dl[] = {
+    gsDPPipeSync(),
+    gsDPSetCombineLERP(0, 0, 0, SHADE, 0, 0, 0, ENVIRONMENT, 0, 0, 0, SHADE, 0, 0, 0, ENVIRONMENT),
+    gsSPLight(&ghost_mario_green_light.l, 1),
+    gsSPLight(&ghost_mario_green_light.a, 2),
+    gsSPEndDisplayList(),
+};
+
+static const Gfx ghost_mario_gold_light_dl[] = {
+    gsDPPipeSync(),
+    gsDPSetCombineLERP(0, 0, 0, SHADE, 0, 0, 0, ENVIRONMENT, 0, 0, 0, SHADE, 0, 0, 0, ENVIRONMENT),
+    gsSPLight(&ghost_mario_gold_light.l, 1),
+    gsSPLight(&ghost_mario_gold_light.a, 2),
+    gsSPEndDisplayList(),
+};
+
+static const Gfx ghost_mario_pink_light_dl[] = {
+    gsDPPipeSync(),
+    gsDPSetCombineLERP(0, 0, 0, SHADE, 0, 0, 0, ENVIRONMENT, 0, 0, 0, SHADE, 0, 0, 0, ENVIRONMENT),
+    gsSPLight(&ghost_mario_pink_light.l, 1),
+    gsSPLight(&ghost_mario_pink_light.a, 2),
+    gsSPEndDisplayList(),
+};
+
+//
+// Mario's butt
+//
+
+static const Vtx ghost_mario_butt_dl_vertex_group1[] = {
+    {{{    -9,     73,    -34}, 0, {     0,      0}, {0xc2, 0x6b, 0xe6, 0x00}}},
+    {{{    -9,     73,     34}, 0, {     0,      0}, {0xbe, 0x6a, 0x12, 0x00}}},
+    {{{    22,     82,    -26}, 0, {     0,      0}, {0x07, 0x7e, 0xf5, 0x00}}},
+    {{{    73,     11,      0}, 0, {     0,      0}, {0x7e, 0x04, 0x00, 0x00}}},
+    {{{    55,    -61,    -36}, 0, {     0,      0}, {0x67, 0xbe, 0xe1, 0x00}}},
+    {{{    44,    -10,    -92}, 0, {     0,      0}, {0x4f, 0xf2, 0x9e, 0x00}}},
+    {{{     7,     33,     95}, 0, {     0,      0}, {0xe6, 0x26, 0x75, 0x00}}},
+    {{{    44,     -9,     92}, 0, {     0,      0}, {0x4f, 0xf2, 0x62, 0x00}}},
+    {{{    43,     40,     91}, 0, {     0,      0}, {0x4e, 0x30, 0x57, 0x00}}},
+    {{{     8,     -8,    -99}, 0, {     0,      0}, {0xf3, 0xee, 0x84, 0x00}}},
+    {{{    36,    -51,    -79}, 0, {     0,      0}, {0x30, 0xb8, 0xa4, 0x00}}},
+    {{{    26,    -74,    -46}, 0, {     0,      0}, {0x18, 0x88, 0xe2, 0x00}}},
+    {{{    36,    -52,     79}, 0, {     0,      0}, {0x30, 0xb8, 0x5c, 0x00}}},
+    {{{    26,    -74,     45}, 0, {     0,      0}, {0x12, 0x88, 0x22, 0x00}}},
+    {{{    55,    -61,     36}, 0, {     0,      0}, {0x60, 0xb3, 0x1a, 0x00}}},
+};
+
+static const Vtx ghost_mario_butt_dl_vertex_group2[] = {
+    {{{    -5,     59,     72}, 0, {     0,      0}, {0xc0, 0x52, 0x47, 0x00}}},
+    {{{    -9,     73,     34}, 0, {     0,      0}, {0xbe, 0x6a, 0x12, 0x00}}},
+    {{{   -32,     40,     39}, 0, {     0,      0}, {0x8b, 0x25, 0x1d, 0x00}}},
+    {{{    52,     70,     38}, 0, {     0,      0}, {0x53, 0x5d, 0x16, 0x00}}},
+    {{{    22,     82,     26}, 0, {     0,      0}, {0x07, 0x7d, 0x11, 0x00}}},
+    {{{    27,     72,     63}, 0, {     0,      0}, {0x06, 0x6c, 0x42, 0x00}}},
+    {{{    43,     40,    -91}, 0, {     0,      0}, {0x4e, 0x30, 0xa9, 0x00}}},
+    {{{    27,     72,    -63}, 0, {     0,      0}, {0x07, 0x6b, 0xbe, 0x00}}},
+    {{{    52,     70,    -39}, 0, {     0,      0}, {0x59, 0x56, 0xe5, 0x00}}},
+    {{{    -5,     59,    -72}, 0, {     0,      0}, {0xc0, 0x52, 0xb9, 0x00}}},
+    {{{   -17,     32,    -79}, 0, {     0,      0}, {0xa4, 0x23, 0xb1, 0x00}}},
+    {{{   -32,     40,    -39}, 0, {     0,      0}, {0x89, 0x25, 0xeb, 0x00}}},
+    {{{    73,     11,      0}, 0, {     0,      0}, {0x7e, 0x04, 0x00, 0x00}}},
+    {{{    43,     40,     91}, 0, {     0,      0}, {0x4e, 0x30, 0x57, 0x00}}},
+};
+
+static const Vtx ghost_mario_butt_dl_vertex_group3[] = {
+    {{{   -14,    -74,      0}, 0, {     0,      0}, {0xcb, 0x8d, 0x00, 0x00}}},
+    {{{    -9,    -69,     55}, 0, {     0,      0}, {0xcd, 0x97, 0x30, 0x00}}},
+    {{{   -31,    -51,     42}, 0, {     0,      0}, {0x8d, 0xd7, 0x1f, 0x00}}},
+    {{{    26,    -74,    -46}, 0, {     0,      0}, {0x18, 0x88, 0xe2, 0x00}}},
+    {{{    -9,    -69,    -55}, 0, {     0,      0}, {0xcd, 0x97, 0xd0, 0x00}}},
+    {{{     4,    -48,    -86}, 0, {     0,      0}, {0xd8, 0xba, 0x9f, 0x00}}},
+    {{{     4,    -49,     86}, 0, {     0,      0}, {0xd8, 0xb9, 0x61, 0x00}}},
+    {{{    26,    -74,     45}, 0, {     0,      0}, {0x12, 0x88, 0x22, 0x00}}},
+    {{{   -32,     40,     39}, 0, {     0,      0}, {0x8b, 0x25, 0x1d, 0x00}}},
+    {{{    -9,     73,     34}, 0, {     0,      0}, {0xbe, 0x6a, 0x12, 0x00}}},
+    {{{   -32,     40,    -39}, 0, {     0,      0}, {0x89, 0x25, 0xeb, 0x00}}},
+    {{{    27,     72,     63}, 0, {     0,      0}, {0x06, 0x6c, 0x42, 0x00}}},
+    {{{    -5,     59,     72}, 0, {     0,      0}, {0xc0, 0x52, 0x47, 0x00}}},
+    {{{    52,     70,    -39}, 0, {     0,      0}, {0x59, 0x56, 0xe5, 0x00}}},
+    {{{    22,     82,    -26}, 0, {     0,      0}, {0x07, 0x7e, 0xf5, 0x00}}},
+    {{{    52,     70,     38}, 0, {     0,      0}, {0x53, 0x5d, 0x16, 0x00}}},
+};
+
+static const Vtx ghost_mario_butt_dl_vertex_group4[] = {
+    {{{     6,     33,    -95}, 0, {     0,      0}, {0xe6, 0x26, 0x8b, 0x00}}},
+    {{{    27,     72,    -63}, 0, {     0,      0}, {0x07, 0x6b, 0xbe, 0x00}}},
+    {{{    43,     40,    -91}, 0, {     0,      0}, {0x4e, 0x30, 0xa9, 0x00}}},
+    {{{   -31,    -51,     42}, 0, {     0,      0}, {0x8d, 0xd7, 0x1f, 0x00}}},
+    {{{   -31,    -51,    -42}, 0, {     0,      0}, {0x91, 0xd0, 0xdc, 0x00}}},
+    {{{   -14,    -74,      0}, 0, {     0,      0}, {0xcb, 0x8d, 0x00, 0x00}}},
+    {{{    -9,    -69,    -55}, 0, {     0,      0}, {0xcd, 0x97, 0xd0, 0x00}}},
+    {{{    73,     11,      0}, 0, {     0,      0}, {0x7e, 0x04, 0x00, 0x00}}},
+    {{{    44,    -10,    -92}, 0, {     0,      0}, {0x4f, 0xf2, 0x9e, 0x00}}},
+    {{{    52,     70,     38}, 0, {     0,      0}, {0x53, 0x5d, 0x16, 0x00}}},
+    {{{    52,     70,    -39}, 0, {     0,      0}, {0x59, 0x56, 0xe5, 0x00}}},
+    {{{    43,     40,     91}, 0, {     0,      0}, {0x4e, 0x30, 0x57, 0x00}}},
+    {{{    44,     -9,     92}, 0, {     0,      0}, {0x4f, 0xf2, 0x62, 0x00}}},
+    {{{     7,     33,     95}, 0, {     0,      0}, {0xe6, 0x26, 0x75, 0x00}}},
+    {{{    27,     72,     63}, 0, {     0,      0}, {0x06, 0x6c, 0x42, 0x00}}},
+};
+
+static const Vtx ghost_mario_butt_dl_vertex_group5[] = {
+    {{{    -5,     59,    -72}, 0, {     0,      0}, {0xc0, 0x52, 0xb9, 0x00}}},
+    {{{    -9,     73,    -34}, 0, {     0,      0}, {0xc2, 0x6b, 0xe6, 0x00}}},
+    {{{    27,     72,    -63}, 0, {     0,      0}, {0x07, 0x6b, 0xbe, 0x00}}},
+    {{{   -32,     40,    -39}, 0, {     0,      0}, {0x89, 0x25, 0xeb, 0x00}}},
+    {{{   -32,     40,     39}, 0, {     0,      0}, {0x8b, 0x25, 0x1d, 0x00}}},
+    {{{   -18,     32,     79}, 0, {     0,      0}, {0xa4, 0x23, 0x4f, 0x00}}},
+    {{{    -5,     59,     72}, 0, {     0,      0}, {0xc0, 0x52, 0x47, 0x00}}},
+    {{{    22,     82,    -26}, 0, {     0,      0}, {0x07, 0x7e, 0xf5, 0x00}}},
+    {{{    52,     70,    -39}, 0, {     0,      0}, {0x59, 0x56, 0xe5, 0x00}}},
+    {{{    27,     72,     63}, 0, {     0,      0}, {0x06, 0x6c, 0x42, 0x00}}},
+    {{{    43,     40,     91}, 0, {     0,      0}, {0x4e, 0x30, 0x57, 0x00}}},
+    {{{    52,     70,     38}, 0, {     0,      0}, {0x53, 0x5d, 0x16, 0x00}}},
+    {{{     8,     -8,     99}, 0, {     0,      0}, {0xf3, 0xef, 0x7c, 0x00}}},
+    {{{    36,    -52,     79}, 0, {     0,      0}, {0x30, 0xb8, 0x5c, 0x00}}},
+    {{{    44,     -9,     92}, 0, {     0,      0}, {0x4f, 0xf2, 0x62, 0x00}}},
+};
+
+static const Vtx ghost_mario_butt_dl_vertex_group6[] = {
+    {{{     6,     33,    -95}, 0, {     0,      0}, {0xe6, 0x26, 0x8b, 0x00}}},
+    {{{    43,     40,    -91}, 0, {     0,      0}, {0x4e, 0x30, 0xa9, 0x00}}},
+    {{{    44,    -10,    -92}, 0, {     0,      0}, {0x4f, 0xf2, 0x9e, 0x00}}},
+    {{{    44,     -9,     92}, 0, {     0,      0}, {0x4f, 0xf2, 0x62, 0x00}}},
+    {{{    36,    -52,     79}, 0, {     0,      0}, {0x30, 0xb8, 0x5c, 0x00}}},
+    {{{    55,    -61,     36}, 0, {     0,      0}, {0x60, 0xb3, 0x1a, 0x00}}},
+    {{{   -18,     32,     79}, 0, {     0,      0}, {0xa4, 0x23, 0x4f, 0x00}}},
+    {{{     7,     33,     95}, 0, {     0,      0}, {0xe6, 0x26, 0x75, 0x00}}},
+    {{{    -5,     59,     72}, 0, {     0,      0}, {0xc0, 0x52, 0x47, 0x00}}},
+    {{{   -20,     -7,     81}, 0, {     0,      0}, {0xa3, 0xf9, 0x55, 0x00}}},
+    {{{     8,     -8,     99}, 0, {     0,      0}, {0xf3, 0xef, 0x7c, 0x00}}},
+    {{{     4,    -49,     86}, 0, {     0,      0}, {0xd8, 0xb9, 0x61, 0x00}}},
+    {{{   -20,     -8,    -81}, 0, {     0,      0}, {0xa3, 0xf8, 0xab, 0x00}}},
+    {{{     8,     -8,    -99}, 0, {     0,      0}, {0xf3, 0xee, 0x84, 0x00}}},
+    {{{     4,    -48,    -86}, 0, {     0,      0}, {0xd8, 0xba, 0x9f, 0x00}}},
+};
+
+static const Vtx ghost_mario_butt_dl_vertex_group7[] = {
+    {{{    -5,     59,    -72}, 0, {     0,      0}, {0xc0, 0x52, 0xb9, 0x00}}},
+    {{{     6,     33,    -95}, 0, {     0,      0}, {0xe6, 0x26, 0x8b, 0x00}}},
+    {{{   -17,     32,    -79}, 0, {     0,      0}, {0xa4, 0x23, 0xb1, 0x00}}},
+    {{{   -20,     -8,    -81}, 0, {     0,      0}, {0xa3, 0xf8, 0xab, 0x00}}},
+    {{{     7,     33,     95}, 0, {     0,      0}, {0xe6, 0x26, 0x75, 0x00}}},
+    {{{   -18,     32,     79}, 0, {     0,      0}, {0xa4, 0x23, 0x4f, 0x00}}},
+    {{{   -20,     -7,     81}, 0, {     0,      0}, {0xa3, 0xf9, 0x55, 0x00}}},
+    {{{   -32,     40,    -39}, 0, {     0,      0}, {0x89, 0x25, 0xeb, 0x00}}},
+    {{{    55,    -61,     36}, 0, {     0,      0}, {0x60, 0xb3, 0x1a, 0x00}}},
+    {{{    73,     11,      0}, 0, {     0,      0}, {0x7e, 0x04, 0x00, 0x00}}},
+    {{{    44,     -9,     92}, 0, {     0,      0}, {0x4f, 0xf2, 0x62, 0x00}}},
+    {{{    55,    -61,    -36}, 0, {     0,      0}, {0x67, 0xbe, 0xe1, 0x00}}},
+    {{{    36,    -51,    -79}, 0, {     0,      0}, {0x30, 0xb8, 0xa4, 0x00}}},
+    {{{    44,    -10,    -92}, 0, {     0,      0}, {0x4f, 0xf2, 0x9e, 0x00}}},
+    {{{     8,     -8,    -99}, 0, {     0,      0}, {0xf3, 0xee, 0x84, 0x00}}},
+};
+
+static const Vtx ghost_mario_butt_dl_vertex_group8[] = {
+    {{{     8,     -8,     99}, 0, {     0,      0}, {0xf3, 0xef, 0x7c, 0x00}}},
+    {{{     4,    -49,     86}, 0, {     0,      0}, {0xd8, 0xb9, 0x61, 0x00}}},
+    {{{    36,    -52,     79}, 0, {     0,      0}, {0x30, 0xb8, 0x5c, 0x00}}},
+    {{{    -9,     73,    -34}, 0, {     0,      0}, {0xc2, 0x6b, 0xe6, 0x00}}},
+    {{{    22,     82,    -26}, 0, {     0,      0}, {0x07, 0x7e, 0xf5, 0x00}}},
+    {{{    27,     72,    -63}, 0, {     0,      0}, {0x07, 0x6b, 0xbe, 0x00}}},
+    {{{    27,     72,     63}, 0, {     0,      0}, {0x06, 0x6c, 0x42, 0x00}}},
+    {{{    -5,     59,     72}, 0, {     0,      0}, {0xc0, 0x52, 0x47, 0x00}}},
+    {{{     7,     33,     95}, 0, {     0,      0}, {0xe6, 0x26, 0x75, 0x00}}},
+    {{{     6,     33,    -95}, 0, {     0,      0}, {0xe6, 0x26, 0x8b, 0x00}}},
+    {{{    -5,     59,    -72}, 0, {     0,      0}, {0xc0, 0x52, 0xb9, 0x00}}},
+    {{{    22,     82,     26}, 0, {     0,      0}, {0x07, 0x7d, 0x11, 0x00}}},
+    {{{    52,     70,     38}, 0, {     0,      0}, {0x53, 0x5d, 0x16, 0x00}}},
+    {{{    -9,     73,     34}, 0, {     0,      0}, {0xbe, 0x6a, 0x12, 0x00}}},
+    {{{   -32,     40,    -39}, 0, {     0,      0}, {0x89, 0x25, 0xeb, 0x00}}},
+    {{{    26,    -74,     45}, 0, {     0,      0}, {0x12, 0x88, 0x22, 0x00}}},
+};
+
+static const Vtx ghost_mario_butt_dl_vertex_group9[] = {
+    {{{     4,    -48,    -86}, 0, {     0,      0}, {0xd8, 0xba, 0x9f, 0x00}}},
+    {{{    36,    -51,    -79}, 0, {     0,      0}, {0x30, 0xb8, 0xa4, 0x00}}},
+    {{{    26,    -74,    -46}, 0, {     0,      0}, {0x18, 0x88, 0xe2, 0x00}}},
+    {{{   -20,     -7,     81}, 0, {     0,      0}, {0xa3, 0xf9, 0x55, 0x00}}},
+    {{{   -18,     32,     79}, 0, {     0,      0}, {0xa4, 0x23, 0x4f, 0x00}}},
+    {{{   -32,     40,     39}, 0, {     0,      0}, {0x8b, 0x25, 0x1d, 0x00}}},
+    {{{     8,     -8,    -99}, 0, {     0,      0}, {0xf3, 0xee, 0x84, 0x00}}},
+    {{{     7,     33,     95}, 0, {     0,      0}, {0xe6, 0x26, 0x75, 0x00}}},
+    {{{     8,     -8,     99}, 0, {     0,      0}, {0xf3, 0xef, 0x7c, 0x00}}},
+    {{{    44,     -9,     92}, 0, {     0,      0}, {0x4f, 0xf2, 0x62, 0x00}}},
+    {{{    -9,     73,     34}, 0, {     0,      0}, {0xbe, 0x6a, 0x12, 0x00}}},
+    {{{    22,     82,     26}, 0, {     0,      0}, {0x07, 0x7d, 0x11, 0x00}}},
+    {{{    22,     82,    -26}, 0, {     0,      0}, {0x07, 0x7e, 0xf5, 0x00}}},
+    {{{    -9,    -69,    -55}, 0, {     0,      0}, {0xcd, 0x97, 0xd0, 0x00}}},
+    {{{   -31,    -51,    -42}, 0, {     0,      0}, {0x91, 0xd0, 0xdc, 0x00}}},
+    {{{   -20,     -8,    -81}, 0, {     0,      0}, {0xa3, 0xf8, 0xab, 0x00}}},
+};
+
+static const Vtx ghost_mario_butt_dl_vertex_group10[] = {
+    {{{   -31,    -51,     42}, 0, {     0,      0}, {0x8d, 0xd7, 0x1f, 0x00}}},
+    {{{    -9,    -69,     55}, 0, {     0,      0}, {0xcd, 0x97, 0x30, 0x00}}},
+    {{{     4,    -49,     86}, 0, {     0,      0}, {0xd8, 0xb9, 0x61, 0x00}}},
+    {{{   -20,     -7,     81}, 0, {     0,      0}, {0xa3, 0xf9, 0x55, 0x00}}},
+    {{{   -32,     40,     39}, 0, {     0,      0}, {0x8b, 0x25, 0x1d, 0x00}}},
+    {{{   -32,     40,    -39}, 0, {     0,      0}, {0x89, 0x25, 0xeb, 0x00}}},
+    {{{   -20,     -8,    -81}, 0, {     0,      0}, {0xa3, 0xf8, 0xab, 0x00}}},
+    {{{   -31,    -51,    -42}, 0, {     0,      0}, {0x91, 0xd0, 0xdc, 0x00}}},
+    {{{    55,    -61,     36}, 0, {     0,      0}, {0x60, 0xb3, 0x1a, 0x00}}},
+    {{{    26,    -74,     45}, 0, {     0,      0}, {0x12, 0x88, 0x22, 0x00}}},
+    {{{    26,    -74,    -46}, 0, {     0,      0}, {0x18, 0x88, 0xe2, 0x00}}},
+    {{{   -14,    -74,      0}, 0, {     0,      0}, {0xcb, 0x8d, 0x00, 0x00}}},
+    {{{    -9,    -69,    -55}, 0, {     0,      0}, {0xcd, 0x97, 0xd0, 0x00}}},
+    {{{    55,    -61,    -36}, 0, {     0,      0}, {0x67, 0xbe, 0xe1, 0x00}}},
+};
+
+static const Gfx ghost_mario_butt[] = {
+    gsDPPipeSync(),
+    gsSPVertex(ghost_mario_butt_dl_vertex_group1, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(6, 7, 8, 0x0, 9, 5, 10, 0x0),
+    gsSP2Triangles(4, 11, 10, 0x0, 12, 13, 14, 0x0),
+    gsSPVertex(ghost_mario_butt_dl_vertex_group2, 14, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(6, 7, 8, 0x0, 9, 10, 11, 0x0),
+    gsSP2Triangles(12, 3, 13, 0x0, 6, 8, 12, 0x0),
+    gsSPVertex(ghost_mario_butt_dl_vertex_group3, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(6, 1, 7, 0x0, 8, 9, 10, 0x0),
+    gsSP2Triangles(11, 9, 12, 0x0, 13, 14, 15, 0x0),
+    gsSPVertex(ghost_mario_butt_dl_vertex_group4, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(4, 6, 5, 0x0, 7, 8, 2, 0x0),
+    gsSP2Triangles(9, 7, 10, 0x0, 11, 12, 7, 0x0),
+    gsSP1Triangle(13, 11, 14, 0x0),
+    gsSPVertex(ghost_mario_butt_dl_vertex_group5, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 1, 0, 0x0),
+    gsSP2Triangles(4, 5, 6, 0x0, 2, 7, 8, 0x0),
+    gsSP2Triangles(9, 10, 11, 0x0, 12, 13, 14, 0x0),
+    gsSPVertex(ghost_mario_butt_dl_vertex_group6, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(6, 7, 8, 0x0, 9, 10, 7, 0x0),
+    gsSP2Triangles(11, 10, 9, 0x0, 12, 13, 14, 0x0),
+    gsSP1Triangle(0, 13, 12, 0x0),
+    gsSPVertex(ghost_mario_butt_dl_vertex_group7, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 2, 1, 0x0),
+    gsSP2Triangles(4, 5, 6, 0x0, 7, 2, 3, 0x0),
+    gsSP2Triangles(8, 9, 10, 0x0, 9, 8, 11, 0x0),
+    gsSP2Triangles(11, 12, 13, 0x0, 13, 14, 1, 0x0),
+    gsSPVertex(ghost_mario_butt_dl_vertex_group8, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(6, 7, 8, 0x0, 9, 10, 5, 0x0),
+    gsSP2Triangles(4, 11, 12, 0x0, 6, 11, 13, 0x0),
+    gsSP2Triangles(13, 3, 14, 0x0, 15, 2, 1, 0x0),
+    gsSPVertex(ghost_mario_butt_dl_vertex_group9, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(1, 0, 6, 0x0, 7, 8, 9, 0x0),
+    gsSP2Triangles(10, 11, 12, 0x0, 0, 13, 14, 0x0),
+    gsSP1Triangle(15, 0, 14, 0x0),
+    gsSPVertex(ghost_mario_butt_dl_vertex_group10, 14, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 2, 3, 0, 0x0),
+    gsSP2Triangles(3, 4, 0, 0x0, 0, 4, 5, 0x0),
+    gsSP2Triangles(5, 6, 7, 0x0, 5, 7, 0, 0x0),
+    gsSP2Triangles(8, 9, 10, 0x0, 9, 11, 10, 0x0),
+    gsSP2Triangles(9, 1, 11, 0x0, 11, 12, 10, 0x0),
+    gsSP1Triangle(10, 13, 8, 0x0),
+    gsSPEndDisplayList(),
+};
+
+//
+// Left arm
+//
+
+static const Vtx ghost_mario_left_arm_shared_dl_vertex_group1[] = {
+    {{{     7,     27,     20}, 0, {     0,      0}, {0xda, 0x61, 0x47, 0x00}}},
+    {{{    59,     20,     15}, 0, {     0,      0}, {0x44, 0x4a, 0x4c, 0x00}}},
+    {{{    59,     21,    -21}, 0, {     0,      0}, {0x37, 0x67, 0xd0, 0x00}}},
+    {{{     6,    -16,     32}, 0, {     0,      0}, {0xd5, 0xdc, 0x71, 0x00}}},
+    {{{    58,    -15,     25}, 0, {     0,      0}, {0x32, 0xc6, 0x64, 0x00}}},
+    {{{     5,    -42,     -5}, 0, {     0,      0}, {0xd3, 0x8a, 0xff, 0x00}}},
+    {{{    57,    -36,     -5}, 0, {     0,      0}, {0x3e, 0x93, 0xef, 0x00}}},
+    {{{     6,    -13,    -42}, 0, {     0,      0}, {0xd6, 0xde, 0x8e, 0x00}}},
+    {{{    58,    -13,    -34}, 0, {     0,      0}, {0x3b, 0xfb, 0x90, 0x00}}},
+    {{{     7,     29,    -26}, 0, {     0,      0}, {0xda, 0x62, 0xbb, 0x00}}},
+    {{{    -8,     17,    -17}, 0, {     0,      0}, {0x90, 0x2a, 0xd6, 0x00}}},
+    {{{    -8,     16,     10}, 0, {     0,      0}, {0x9a, 0x44, 0x1d, 0x00}}},
+    {{{    -8,     -9,    -27}, 0, {     0,      0}, {0x8e, 0xe8, 0xce, 0x00}}},
+    {{{    -9,    -26,     -5}, 0, {     0,      0}, {0x96, 0xbd, 0x0e, 0x00}}},
+    {{{    -8,    -11,     18}, 0, {     0,      0}, {0x8b, 0xff, 0x2f, 0x00}}},
+};
+
+static const Vtx ghost_mario_left_arm_shared_dl_vertex_group2[] = {
+    {{{    68,     13,    -16}, 0, {     0,      0}, {0x6a, 0x38, 0xd9, 0x00}}},
+    {{{    68,    -10,    -25}, 0, {     0,      0}, {0x75, 0xe7, 0xd9, 0x00}}},
+    {{{    58,    -13,    -34}, 0, {     0,      0}, {0x3b, 0xfb, 0x90, 0x00}}},
+    {{{    59,     20,     15}, 0, {     0,      0}, {0x44, 0x4a, 0x4c, 0x00}}},
+    {{{    68,     12,      9}, 0, {     0,      0}, {0x78, 0x1f, 0x1b, 0x00}}},
+    {{{    67,    -12,     16}, 0, {     0,      0}, {0x6f, 0xe8, 0x37, 0x00}}},
+    {{{    57,    -36,     -5}, 0, {     0,      0}, {0x3e, 0x93, 0xef, 0x00}}},
+    {{{    67,    -26,     -5}, 0, {     0,      0}, {0x6e, 0xc2, 0xfe, 0x00}}},
+    {{{    58,    -15,     25}, 0, {     0,      0}, {0x32, 0xc6, 0x64, 0x00}}},
+    {{{    59,     21,    -21}, 0, {     0,      0}, {0x37, 0x67, 0xd0, 0x00}}},
+    {{{     7,     27,     20}, 0, {     0,      0}, {0xda, 0x61, 0x47, 0x00}}},
+    {{{    -8,    -11,     18}, 0, {     0,      0}, {0x8b, 0xff, 0x2f, 0x00}}},
+    {{{     6,    -16,     32}, 0, {     0,      0}, {0xd5, 0xdc, 0x71, 0x00}}},
+    {{{    -9,    -26,     -5}, 0, {     0,      0}, {0x96, 0xbd, 0x0e, 0x00}}},
+    {{{     5,    -42,     -5}, 0, {     0,      0}, {0xd3, 0x8a, 0xff, 0x00}}},
+};
+
+static const Vtx ghost_mario_left_arm_shared_dl_vertex_group3[] = {
+    {{{     5,    -42,     -5}, 0, {     0,      0}, {0xd3, 0x8a, 0xff, 0x00}}},
+    {{{    -8,     -9,    -27}, 0, {     0,      0}, {0x8e, 0xe8, 0xce, 0x00}}},
+    {{{     6,    -13,    -42}, 0, {     0,      0}, {0xd6, 0xde, 0x8e, 0x00}}},
+    {{{    -8,     17,    -17}, 0, {     0,      0}, {0x90, 0x2a, 0xd6, 0x00}}},
+    {{{     7,     29,    -26}, 0, {     0,      0}, {0xda, 0x62, 0xbb, 0x00}}},
+    {{{    -8,     16,     10}, 0, {     0,      0}, {0x9a, 0x44, 0x1d, 0x00}}},
+    {{{     7,     27,     20}, 0, {     0,      0}, {0xda, 0x61, 0x47, 0x00}}},
+    {{{    58,    -13,    -34}, 0, {     0,      0}, {0x3b, 0xfb, 0x90, 0x00}}},
+    {{{    57,    -36,     -5}, 0, {     0,      0}, {0x3e, 0x93, 0xef, 0x00}}},
+    {{{     6,    -16,     32}, 0, {     0,      0}, {0xd5, 0xdc, 0x71, 0x00}}},
+    {{{    58,    -15,     25}, 0, {     0,      0}, {0x32, 0xc6, 0x64, 0x00}}},
+    {{{    59,     20,     15}, 0, {     0,      0}, {0x44, 0x4a, 0x4c, 0x00}}},
+    {{{    59,     21,    -21}, 0, {     0,      0}, {0x37, 0x67, 0xd0, 0x00}}},
+    {{{    -8,    -11,     18}, 0, {     0,      0}, {0x8b, 0xff, 0x2f, 0x00}}},
+};
+
+static const Vtx ghost_mario_left_arm_shared_dl_vertex_group4[] = {
+    {{{    68,     12,      9}, 0, {     0,      0}, {0x78, 0x1f, 0x1b, 0x00}}},
+    {{{    68,    -10,    -25}, 0, {     0,      0}, {0x75, 0xe7, 0xd9, 0x00}}},
+    {{{    68,     13,    -16}, 0, {     0,      0}, {0x6a, 0x38, 0xd9, 0x00}}},
+    {{{    67,    -12,     16}, 0, {     0,      0}, {0x6f, 0xe8, 0x37, 0x00}}},
+    {{{    67,    -26,     -5}, 0, {     0,      0}, {0x6e, 0xc2, 0xfe, 0x00}}},
+    {{{    -8,     17,    -17}, 0, {     0,      0}, {0x90, 0x2a, 0xd6, 0x00}}},
+    {{{    -8,     -9,    -27}, 0, {     0,      0}, {0x8e, 0xe8, 0xce, 0x00}}},
+    {{{    -8,    -11,     18}, 0, {     0,      0}, {0x8b, 0xff, 0x2f, 0x00}}},
+    {{{    -9,    -26,     -5}, 0, {     0,      0}, {0x96, 0xbd, 0x0e, 0x00}}},
+};
+
+static const Gfx ghost_mario_left_arm_shared_dl[] = {
+    gsSPVertex(ghost_mario_left_arm_shared_dl_vertex_group1, 15, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  4,  1, 0x0),
+    gsSP2Triangles( 5,  6,  4, 0x0,  7,  8,  6, 0x0),
+    gsSP2Triangles( 9,  2,  8, 0x0,  9, 10, 11, 0x0),
+    gsSP2Triangles( 7, 12, 10, 0x0,  5, 13, 12, 0x0),
+    gsSP2Triangles( 3, 14, 13, 0x0,  0, 11, 14, 0x0),
+    gsSPVertex(ghost_mario_left_arm_shared_dl_vertex_group2, 15, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  4,  0, 0x0),
+    gsSP2Triangles( 5,  4,  3, 0x0,  6,  7,  5, 0x0),
+    gsSP2Triangles( 1,  7,  6, 0x0,  2,  1,  6, 0x0),
+    gsSP2Triangles( 6,  5,  8, 0x0,  8,  5,  3, 0x0),
+    gsSP2Triangles( 3,  0,  9, 0x0,  9,  0,  2, 0x0),
+    gsSP2Triangles(10, 11, 12, 0x0, 12, 13, 14, 0x0),
+    gsSPVertex(ghost_mario_left_arm_shared_dl_vertex_group3, 14, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  2,  3,  4, 0x0),
+    gsSP2Triangles( 4,  5,  6, 0x0,  2,  4,  7, 0x0),
+    gsSP2Triangles( 0,  2,  8, 0x0,  9,  0, 10, 0x0),
+    gsSP2Triangles( 6,  9, 11, 0x0,  4,  6, 12, 0x0),
+    gsSP1Triangle(13,  5,  3, 0x0),
+    gsSPVertex(ghost_mario_left_arm_shared_dl_vertex_group4, 9, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  0,  3,  1, 0x0),
+    gsSP2Triangles( 3,  4,  1, 0x0,  5,  6,  7, 0x0),
+    gsSP1Triangle( 6,  8,  7, 0x0),
+    gsSPEndDisplayList(),
+};
+
+static const Vtx ghost_mario_left_forearm_shared_dl_vertex[] = {
+    {{{    -2,     19,     16}, 0, {     0,      0}, {0xdb, 0x61, 0x48, 0x00}}},
+    {{{    47,     14,     13}, 0, {     0,      0}, {0x44, 0x44, 0x51, 0x00}}},
+    {{{    47,     16,    -19}, 0, {     0,      0}, {0x45, 0x61, 0xd6, 0x00}}},
+    {{{    -3,    -17,     26}, 0, {     0,      0}, {0xd7, 0xdb, 0x71, 0x00}}},
+    {{{    46,    -17,     22}, 0, {     0,      0}, {0x41, 0xc7, 0x5c, 0x00}}},
+    {{{    -3,    -38,     -4}, 0, {     0,      0}, {0xd4, 0x89, 0xfe, 0x00}}},
+    {{{    45,    -34,     -4}, 0, {     0,      0}, {0x3f, 0x95, 0xe8, 0x00}}},
+    {{{    -3,    -14,    -34}, 0, {     0,      0}, {0xd7, 0xde, 0x8e, 0x00}}},
+    {{{    46,    -14,    -30}, 0, {     0,      0}, {0x42, 0xf4, 0x95, 0x00}}},
+    {{{    -2,     21,    -21}, 0, {     0,      0}, {0xdb, 0x63, 0xbb, 0x00}}},
+    {{{   -14,     13,    -15}, 0, {     0,      0}, {0x93, 0x2c, 0xd3, 0x00}}},
+    {{{   -14,     11,     10}, 0, {     0,      0}, {0x93, 0x3b, 0x19, 0x00}}},
+    {{{   -15,    -11,    -24}, 0, {     0,      0}, {0x9a, 0xde, 0xbe, 0x00}}},
+    {{{   -15,    -27,     -4}, 0, {     0,      0}, {0x8b, 0xd2, 0x0a, 0x00}}},
+    {{{   -15,    -13,     17}, 0, {     0,      0}, {0x9b, 0xfb, 0x4c, 0x00}}},
+    {{{    58,     -7,     -3}, 0, {     0,      0}, {0x7e, 0xfc, 0x00, 0x00}}},
+};
+
+static const Gfx ghost_mario_left_forearm_shared_dl[] = {
+    gsSPVertex(ghost_mario_left_forearm_shared_dl_vertex, 16, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  4,  1, 0x0),
+    gsSP2Triangles( 5,  6,  4, 0x0,  7,  8,  6, 0x0),
+    gsSP2Triangles( 9,  2,  8, 0x0,  9, 10, 11, 0x0),
+    gsSP2Triangles( 7, 12, 10, 0x0,  5, 13, 12, 0x0),
+    gsSP2Triangles( 3, 14, 13, 0x0,  0, 11, 14, 0x0),
+    gsSP2Triangles( 8, 15,  6, 0x0,  6, 15,  4, 0x0),
+    gsSP2Triangles( 4, 15,  1, 0x0,  1, 15,  2, 0x0),
+    gsSP2Triangles( 2, 15,  8, 0x0,  0, 14,  3, 0x0),
+    gsSP2Triangles( 3, 13,  5, 0x0,  5, 12,  7, 0x0),
+    gsSP2Triangles( 7, 10,  9, 0x0,  9, 11,  0, 0x0),
+    gsSP2Triangles( 7,  9,  8, 0x0,  5,  7,  6, 0x0),
+    gsSP2Triangles( 3,  5,  4, 0x0,  0,  3,  1, 0x0),
+    gsSP2Triangles( 9,  0,  2, 0x0, 12, 13, 10, 0x0),
+    gsSP2Triangles(13, 11, 10, 0x0, 13, 14, 11, 0x0),
+    gsSPEndDisplayList(),
+};
+
+static const Vtx ghost_mario_left_hand_closed_shared_dl_vertex_group1[] = {
+    {{{    36,      6,     42}, 0, {     0,      0}, {0xe1, 0xf0, 0x79, 0x00}}},
+    {{{    17,     -1,     27}, 0, {     0,      0}, {0x00, 0xfd, 0x7f, 0x00}}},
+    {{{    34,    -41,      3}, 0, {     0,      0}, {0x42, 0xa3, 0x36, 0x00}}},
+    {{{    26,    -25,    -32}, 0, {     0,      0}, {0x09, 0xc7, 0x8f, 0x00}}},
+    {{{     4,     24,    -31}, 0, {     0,      0}, {0xd5, 0x3f, 0x9c, 0x00}}},
+    {{{    33,      7,    -44}, 0, {     0,      0}, {0xc6, 0xfe, 0x90, 0x00}}},
+    {{{    -1,     39,      5}, 0, {     0,      0}, {0xea, 0x6e, 0x3a, 0x00}}},
+    {{{     5,     -6,     36}, 0, {     0,      0}, {0x44, 0x1b, 0x67, 0x00}}},
+    {{{   -10,     26,    -38}, 0, {     0,      0}, {0xf0, 0x41, 0x95, 0x00}}},
+    {{{    17,    -38,    -39}, 0, {     0,      0}, {0x1a, 0xb7, 0x9d, 0x00}}},
+    {{{    86,     29,     41}, 0, {     0,      0}, {0x4b, 0x20, 0x60, 0x00}}},
+    {{{    59,     81,      8}, 0, {     0,      0}, {0x11, 0x7a, 0x1d, 0x00}}},
+    {{{   107,    -26,      4}, 0, {     0,      0}, {0x67, 0xc5, 0x2b, 0x00}}},
+    {{{    61,     12,    -60}, 0, {     0,      0}, {0x00, 0x21, 0x86, 0x00}}},
+    {{{    90,     17,    -46}, 0, {     0,      0}, {0x43, 0x35, 0xa3, 0x00}}},
+    {{{   100,     -6,    -46}, 0, {     0,      0}, {0x63, 0x0a, 0xb3, 0x00}}},
+};
+
+static const Vtx ghost_mario_left_hand_closed_shared_dl_vertex_group2[] = {
+    {{{    90,     17,    -46}, 0, {     0,      0}, {0x43, 0x35, 0xa3, 0x00}}},
+    {{{    57,     55,    -37}, 0, {     0,      0}, {0x22, 0x54, 0xa9, 0x00}}},
+    {{{    99,     40,    -16}, 0, {     0,      0}, {0x6c, 0x3c, 0xe5, 0x00}}},
+    {{{    32,     63,    -28}, 0, {     0,      0}, {0xd0, 0x4f, 0xaa, 0x00}}},
+    {{{    12,     59,     10}, 0, {     0,      0}, {0xaa, 0x58, 0x1b, 0x00}}},
+    {{{    59,     81,      8}, 0, {     0,      0}, {0x11, 0x7a, 0x1d, 0x00}}},
+    {{{    80,    -31,    -61}, 0, {     0,      0}, {0x0c, 0xb2, 0x9d, 0x00}}},
+    {{{   100,     -6,    -46}, 0, {     0,      0}, {0x63, 0x0a, 0xb3, 0x00}}},
+    {{{   107,    -26,      4}, 0, {     0,      0}, {0x67, 0xc5, 0x2b, 0x00}}},
+    {{{    61,     12,    -60}, 0, {     0,      0}, {0x00, 0x21, 0x86, 0x00}}},
+    {{{    33,      7,    -44}, 0, {     0,      0}, {0xc6, 0xfe, 0x90, 0x00}}},
+    {{{    86,     29,     41}, 0, {     0,      0}, {0x4b, 0x20, 0x60, 0x00}}},
+    {{{    58,    -45,      7}, 0, {     0,      0}, {0x01, 0x85, 0x1c, 0x00}}},
+    {{{    36,      6,     42}, 0, {     0,      0}, {0xe1, 0xf0, 0x79, 0x00}}},
+};
+
+static const Vtx ghost_mario_left_hand_closed_shared_dl_vertex_group3[] = {
+    {{{    27,    -58,      6}, 0, {     0,      0}, {0xa3, 0xad, 0x12, 0x00}}},
+    {{{   -14,    -14,     -4}, 0, {     0,      0}, {0x8c, 0xcd, 0x02, 0x00}}},
+    {{{    17,    -38,    -39}, 0, {     0,      0}, {0x1a, 0xb7, 0x9d, 0x00}}},
+    {{{   -10,     26,    -38}, 0, {     0,      0}, {0xf0, 0x41, 0x95, 0x00}}},
+    {{{   -18,     45,      8}, 0, {     0,      0}, {0x84, 0xf3, 0x13, 0x00}}},
+    {{{     5,     -6,     36}, 0, {     0,      0}, {0x99, 0xd2, 0x38, 0x00}}},
+    {{{    34,    -41,      3}, 0, {     0,      0}, {0x42, 0xa3, 0x36, 0x00}}},
+    {{{    27,    -58,      6}, 0, {     0,      0}, {0x73, 0xd5, 0x1d, 0x00}}},
+    {{{    26,    -25,    -32}, 0, {     0,      0}, {0x09, 0xc7, 0x8f, 0x00}}},
+    {{{   -18,     45,      8}, 0, {     0,      0}, {0x2d, 0x71, 0x21, 0x00}}},
+    {{{    -1,     39,      5}, 0, {     0,      0}, {0xea, 0x6e, 0x3a, 0x00}}},
+    {{{     5,     -6,     36}, 0, {     0,      0}, {0x44, 0x1b, 0x67, 0x00}}},
+    {{{    36,      6,     42}, 0, {     0,      0}, {0xe1, 0xf0, 0x79, 0x00}}},
+    {{{    12,     59,     10}, 0, {     0,      0}, {0xaa, 0x58, 0x1b, 0x00}}},
+    {{{    58,    -45,      7}, 0, {     0,      0}, {0x01, 0x85, 0x1c, 0x00}}},
+};
+
+static const Vtx ghost_mario_left_hand_closed_shared_dl_vertex_group4[] = {
+    {{{    26,    -25,    -32}, 0, {     0,      0}, {0x09, 0xc7, 0x8f, 0x00}}},
+    {{{    33,      7,    -44}, 0, {     0,      0}, {0xc6, 0xfe, 0x90, 0x00}}},
+    {{{    80,    -31,    -61}, 0, {     0,      0}, {0x0c, 0xb2, 0x9d, 0x00}}},
+    {{{    58,    -45,      7}, 0, {     0,      0}, {0x01, 0x85, 0x1c, 0x00}}},
+    {{{    34,    -41,      3}, 0, {     0,      0}, {0x42, 0xa3, 0x36, 0x00}}},
+    {{{    61,     12,    -60}, 0, {     0,      0}, {0x00, 0x21, 0x86, 0x00}}},
+    {{{    12,     59,     10}, 0, {     0,      0}, {0xaa, 0x58, 0x1b, 0x00}}},
+    {{{    32,     63,    -28}, 0, {     0,      0}, {0xd0, 0x4f, 0xaa, 0x00}}},
+    {{{     4,     24,    -31}, 0, {     0,      0}, {0xd5, 0x3f, 0x9c, 0x00}}},
+    {{{    -1,     39,      5}, 0, {     0,      0}, {0xea, 0x6e, 0x3a, 0x00}}},
+};
+
+static const Gfx ghost_mario_left_hand_closed_shared_dl[] = {
+    gsSPVertex(ghost_mario_left_hand_closed_shared_dl_vertex_group1, 16, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  4,  5, 0x0),
+    gsSP2Triangles( 6,  1,  0, 0x0,  2,  1,  7, 0x0),
+    gsSP2Triangles( 7,  1,  6, 0x0,  6,  4,  8, 0x0),
+    gsSP2Triangles( 8,  4,  3, 0x0,  9,  3,  2, 0x0),
+    gsSP2Triangles( 0, 10, 11, 0x0, 12, 10,  0, 0x0),
+    gsSP1Triangle(13, 14, 15, 0x0),
+    gsSPVertex(ghost_mario_left_hand_closed_shared_dl_vertex_group2, 14, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  4,  5, 0x0),
+    gsSP2Triangles( 5,  1,  3, 0x0,  6,  7,  8, 0x0),
+    gsSP2Triangles( 9, 10,  3, 0x0,  1,  0,  9, 0x0),
+    gsSP2Triangles( 9,  3,  1, 0x0,  5,  2,  1, 0x0),
+    gsSP2Triangles( 0,  2,  7, 0x0,  7,  2,  8, 0x0),
+    gsSP2Triangles( 8,  2, 11, 0x0, 11,  2,  5, 0x0),
+    gsSP2Triangles( 9,  7,  6, 0x0,  6,  8, 12, 0x0),
+    gsSP2Triangles(12,  8, 13, 0x0, 13,  5,  4, 0x0),
+    gsSPVertex(ghost_mario_left_hand_closed_shared_dl_vertex_group3, 15, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  2,  1,  3, 0x0),
+    gsSP2Triangles( 3,  1,  4, 0x0,  4,  1,  5, 0x0),
+    gsSP2Triangles( 5,  1,  0, 0x0,  6,  7,  2, 0x0),
+    gsSP2Triangles( 8,  2,  3, 0x0,  3,  9, 10, 0x0),
+    gsSP2Triangles(10,  9, 11, 0x0, 11,  7,  6, 0x0),
+    gsSP2Triangles(10, 12, 13, 0x0,  6, 14, 12, 0x0),
+    gsSPVertex(ghost_mario_left_hand_closed_shared_dl_vertex_group4, 10, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  4,  0, 0x0),
+    gsSP2Triangles( 1,  5,  2, 0x0,  0,  2,  3, 0x0),
+    gsSP2Triangles( 6,  7,  8, 0x0,  8,  9,  6, 0x0),
+    gsSP1Triangle( 7,  1,  8, 0x0),
+    gsSPEndDisplayList(),
+};
+
+//
+// Right arm
+//
+
+static const Vtx ghost_mario_right_arm_shared_dl_vertex_group1[] = {
+    {{{    57,    -14,    -22}, 0, {     0,      0}, {0x33, 0xcf, 0x97, 0x00}}},
+    {{{     5,    -44,      5}, 0, {     0,      0}, {0xd3, 0x8a, 0xf7, 0x00}}},
+    {{{     6,    -15,    -30}, 0, {     0,      0}, {0xd6, 0xe6, 0x8c, 0x00}}},
+    {{{    57,    -38,      6}, 0, {     0,      0}, {0x3e, 0x93, 0x07, 0x00}}},
+    {{{     6,    -19,     44}, 0, {     0,      0}, {0xd5, 0xd4, 0x6e, 0x00}}},
+    {{{    57,    -17,     37}, 0, {     0,      0}, {0x33, 0xe8, 0x71, 0x00}}},
+    {{{     7,     25,     32}, 0, {     0,      0}, {0xd9, 0x5c, 0x4d, 0x00}}},
+    {{{    58,     17,     27}, 0, {     0,      0}, {0x44, 0x59, 0x39, 0x00}}},
+    {{{     7,     27,    -13}, 0, {     0,      0}, {0xda, 0x67, 0xc2, 0x00}}},
+    {{{    58,     19,     -9}, 0, {     0,      0}, {0x3e, 0x4a, 0xaf, 0x00}}},
+    {{{    -9,    -28,      6}, 0, {     0,      0}, {0x96, 0xbf, 0xec, 0x00}}},
+    {{{    -9,    -10,    -15}, 0, {     0,      0}, {0x8f, 0x01, 0xc7, 0x00}}},
+    {{{    -8,     15,     -5}, 0, {     0,      0}, {0x91, 0x39, 0xed, 0x00}}},
+    {{{    -8,     14,     22}, 0, {     0,      0}, {0x99, 0x2e, 0x38, 0x00}}},
+    {{{    -9,    -13,     30}, 0, {     0,      0}, {0x8a, 0xe9, 0x26, 0x00}}},
+    {{{    67,    -12,    -13}, 0, {     0,      0}, {0x68, 0xeb, 0xbc, 0x00}}},
+};
+
+static const Vtx ghost_mario_right_arm_shared_dl_vertex_group2[] = {
+    {{{    57,    -38,      6}, 0, {     0,      0}, {0x3e, 0x93, 0x07, 0x00}}},
+    {{{    67,    -14,     28}, 0, {     0,      0}, {0x6f, 0xe8, 0x37, 0x00}}},
+    {{{    57,    -17,     37}, 0, {     0,      0}, {0x33, 0xe8, 0x71, 0x00}}},
+    {{{    58,     17,     27}, 0, {     0,      0}, {0x44, 0x59, 0x39, 0x00}}},
+    {{{    67,     11,     -4}, 0, {     0,      0}, {0x78, 0x26, 0xf1, 0x00}}},
+    {{{    58,     19,     -9}, 0, {     0,      0}, {0x3e, 0x4a, 0xaf, 0x00}}},
+    {{{    67,     10,     21}, 0, {     0,      0}, {0x71, 0x2a, 0x25, 0x00}}},
+    {{{    66,    -28,      6}, 0, {     0,      0}, {0x75, 0xd1, 0xfe, 0x00}}},
+    {{{    67,    -12,    -13}, 0, {     0,      0}, {0x68, 0xeb, 0xbc, 0x00}}},
+    {{{    -9,    -13,     30}, 0, {     0,      0}, {0x8a, 0xe9, 0x26, 0x00}}},
+    {{{    -9,    -28,      6}, 0, {     0,      0}, {0x96, 0xbf, 0xec, 0x00}}},
+    {{{     5,    -44,      5}, 0, {     0,      0}, {0xd3, 0x8a, 0xf7, 0x00}}},
+    {{{    -8,     14,     22}, 0, {     0,      0}, {0x99, 0x2e, 0x38, 0x00}}},
+    {{{     6,    -19,     44}, 0, {     0,      0}, {0xd5, 0xd4, 0x6e, 0x00}}},
+    {{{    -8,     15,     -5}, 0, {     0,      0}, {0x91, 0x39, 0xed, 0x00}}},
+    {{{     7,     25,     32}, 0, {     0,      0}, {0xd9, 0x5c, 0x4d, 0x00}}},
+};
+
+static const Vtx ghost_mario_right_arm_shared_dl_vertex_group3[] = {
+    {{{    -9,    -10,    -15}, 0, {     0,      0}, {0x8f, 0x01, 0xc7, 0x00}}},
+    {{{    -8,     15,     -5}, 0, {     0,      0}, {0x91, 0x39, 0xed, 0x00}}},
+    {{{     7,     27,    -13}, 0, {     0,      0}, {0xda, 0x67, 0xc2, 0x00}}},
+    {{{    -9,    -28,      6}, 0, {     0,      0}, {0x96, 0xbf, 0xec, 0x00}}},
+    {{{     6,    -15,    -30}, 0, {     0,      0}, {0xd6, 0xe6, 0x8c, 0x00}}},
+    {{{    58,     19,     -9}, 0, {     0,      0}, {0x3e, 0x4a, 0xaf, 0x00}}},
+    {{{    57,    -14,    -22}, 0, {     0,      0}, {0x33, 0xcf, 0x97, 0x00}}},
+    {{{    58,     17,     27}, 0, {     0,      0}, {0x44, 0x59, 0x39, 0x00}}},
+    {{{    57,    -17,     37}, 0, {     0,      0}, {0x33, 0xe8, 0x71, 0x00}}},
+    {{{     7,     25,     32}, 0, {     0,      0}, {0xd9, 0x5c, 0x4d, 0x00}}},
+    {{{    57,    -38,      6}, 0, {     0,      0}, {0x3e, 0x93, 0x07, 0x00}}},
+    {{{     6,    -19,     44}, 0, {     0,      0}, {0xd5, 0xd4, 0x6e, 0x00}}},
+    {{{     5,    -44,      5}, 0, {     0,      0}, {0xd3, 0x8a, 0xf7, 0x00}}},
+    {{{    67,    -12,    -13}, 0, {     0,      0}, {0x68, 0xeb, 0xbc, 0x00}}},
+    {{{    67,     11,     -4}, 0, {     0,      0}, {0x78, 0x26, 0xf1, 0x00}}},
+    {{{    66,    -28,      6}, 0, {     0,      0}, {0x75, 0xd1, 0xfe, 0x00}}},
+};
+
+static const Vtx ghost_mario_right_arm_shared_dl_vertex_group4[] = {
+    {{{    -9,    -10,    -15}, 0, {     0,      0}, {0x8f, 0x01, 0xc7, 0x00}}},
+    {{{    -9,    -28,      6}, 0, {     0,      0}, {0x96, 0xbf, 0xec, 0x00}}},
+    {{{    -9,    -13,     30}, 0, {     0,      0}, {0x8a, 0xe9, 0x26, 0x00}}},
+    {{{    -8,     15,     -5}, 0, {     0,      0}, {0x91, 0x39, 0xed, 0x00}}},
+    {{{    -8,     14,     22}, 0, {     0,      0}, {0x99, 0x2e, 0x38, 0x00}}},
+    {{{    67,     11,     -4}, 0, {     0,      0}, {0x78, 0x26, 0xf1, 0x00}}},
+    {{{    67,    -14,     28}, 0, {     0,      0}, {0x6f, 0xe8, 0x37, 0x00}}},
+    {{{    66,    -28,      6}, 0, {     0,      0}, {0x75, 0xd1, 0xfe, 0x00}}},
+    {{{    67,     10,     21}, 0, {     0,      0}, {0x71, 0x2a, 0x25, 0x00}}},
+};
+
+static const Gfx ghost_mario_right_arm_shared_dl[] = {
+    gsSPVertex(ghost_mario_right_arm_shared_dl_vertex_group1, 16, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  4,  1, 0x0),
+    gsSP2Triangles( 5,  6,  4, 0x0,  7,  8,  6, 0x0),
+    gsSP2Triangles( 9,  2,  8, 0x0,  1, 10,  2, 0x0),
+    gsSP2Triangles( 2, 11,  8, 0x0,  8, 12,  6, 0x0),
+    gsSP2Triangles( 6, 13,  4, 0x0,  4, 14,  1, 0x0),
+    gsSP2Triangles( 9, 15,  0, 0x0,  0, 15,  3, 0x0),
+    gsSPVertex(ghost_mario_right_arm_shared_dl_vertex_group2, 16, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  2,  1,  3, 0x0),
+    gsSP2Triangles( 3,  4,  5, 0x0,  3,  6,  4, 0x0),
+    gsSP2Triangles( 1,  6,  3, 0x0,  0,  7,  1, 0x0),
+    gsSP2Triangles( 8,  7,  0, 0x0,  5,  4,  8, 0x0),
+    gsSP2Triangles( 9, 10, 11, 0x0, 12,  9, 13, 0x0),
+    gsSP1Triangle(14, 12, 15, 0x0),
+    gsSPVertex(ghost_mario_right_arm_shared_dl_vertex_group3, 16, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  0,  4, 0x0),
+    gsSP2Triangles( 5,  6,  4, 0x0,  7,  5,  2, 0x0),
+    gsSP2Triangles( 8,  7,  9, 0x0, 10,  8, 11, 0x0),
+    gsSP2Triangles( 6, 10, 12, 0x0, 13, 14, 15, 0x0),
+    gsSPVertex(ghost_mario_right_arm_shared_dl_vertex_group4, 9, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  2,  3,  0, 0x0),
+    gsSP2Triangles( 2,  4,  3, 0x0,  5,  6,  7, 0x0),
+    gsSP1Triangle( 5,  8,  6, 0x0),
+    gsSPEndDisplayList(),
+};
+
+static const Vtx ghost_mario_right_forearm_shared_dl_vertex[] = {
+    {{{    47,    -15,    -19}, 0, {     0,      0}, {0x41, 0xcf, 0x9f, 0x00}}},
+    {{{    -3,    -39,      6}, 0, {     0,      0}, {0xd4, 0x8a, 0xf8, 0x00}}},
+    {{{    -2,    -15,    -23}, 0, {     0,      0}, {0xd7, 0xe5, 0x8c, 0x00}}},
+    {{{    46,    -36,      6}, 0, {     0,      0}, {0x3f, 0x94, 0x0f, 0x00}}},
+    {{{    -2,    -18,     38}, 0, {     0,      0}, {0xd6, 0xd5, 0x6f, 0x00}}},
+    {{{    47,    -17,     34}, 0, {     0,      0}, {0x42, 0xec, 0x6a, 0x00}}},
+    {{{    -1,     18,     28}, 0, {     0,      0}, {0xdb, 0x5d, 0x4d, 0x00}}},
+    {{{    48,     13,     25}, 0, {     0,      0}, {0x45, 0x5d, 0x32, 0x00}}},
+    {{{    -1,     20,     -9}, 0, {     0,      0}, {0xdb, 0x67, 0xc1, 0x00}}},
+    {{{    48,     15,     -7}, 0, {     0,      0}, {0x45, 0x4c, 0xb6, 0x00}}},
+    {{{   -14,    -28,      6}, 0, {     0,      0}, {0x90, 0xc9, 0xef, 0x00}}},
+    {{{   -14,    -12,    -13}, 0, {     0,      0}, {0x91, 0x01, 0xc3, 0x00}}},
+    {{{   -13,     12,     -4}, 0, {     0,      0}, {0x9e, 0x4b, 0xe7, 0x00}}},
+    {{{   -13,     10,     21}, 0, {     0,      0}, {0x8d, 0x22, 0x28, 0x00}}},
+    {{{   -14,    -14,     28}, 0, {     0,      0}, {0x9a, 0xd8, 0x3f, 0x00}}},
+    {{{    59,     -8,      7}, 0, {     0,      0}, {0x7f, 0xfd, 0x00, 0x00}}},
+};
+
+static const Gfx ghost_mario_right_forearm_shared_dl[] = {
+    gsSPVertex(ghost_mario_right_forearm_shared_dl_vertex, 16, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  4,  1, 0x0),
+    gsSP2Triangles( 5,  6,  4, 0x0,  7,  8,  6, 0x0),
+    gsSP2Triangles( 9,  2,  8, 0x0,  1, 10,  2, 0x0),
+    gsSP2Triangles( 2, 11,  8, 0x0,  8, 12,  6, 0x0),
+    gsSP2Triangles( 6, 13,  4, 0x0,  4, 14,  1, 0x0),
+    gsSP2Triangles( 9, 15,  0, 0x0,  0, 15,  3, 0x0),
+    gsSP2Triangles( 3, 15,  5, 0x0,  5, 15,  7, 0x0),
+    gsSP2Triangles( 7, 15,  9, 0x0, 14, 10,  1, 0x0),
+    gsSP2Triangles(13, 14,  4, 0x0, 12, 13,  6, 0x0),
+    gsSP2Triangles(11, 12,  8, 0x0, 10, 11,  2, 0x0),
+    gsSP2Triangles( 9,  0,  2, 0x0,  7,  9,  8, 0x0),
+    gsSP2Triangles( 5,  7,  6, 0x0,  3,  5,  4, 0x0),
+    gsSP2Triangles( 0,  3,  1, 0x0, 11, 13, 12, 0x0),
+    gsSP2Triangles(11, 10, 13, 0x0, 10, 14, 13, 0x0),
+    gsSPEndDisplayList(),
+};
+
+static const Vtx ghost_mario_right_hand_closed_dl_vertex_group1[] = {
+    {{{    35,      9,    -37}, 0, {     0,      0}, {0xe5, 0xf5, 0x85, 0x00}}},
+    {{{    55,    -44,     -4}, 0, {     0,      0}, {0x00, 0x86, 0xdf, 0x00}}},
+    {{{    31,    -40,     -1}, 0, {     0,      0}, {0x43, 0xa4, 0xc9, 0x00}}},
+    {{{    10,     60,     -4}, 0, {     0,      0}, {0xac, 0x5a, 0xe5, 0x00}}},
+    {{{    -2,     41,     -1}, 0, {     0,      0}, {0xed, 0x70, 0xc9, 0x00}}},
+    {{{    24,    -57,     -4}, 0, {     0,      0}, {0x73, 0xd4, 0xe6, 0x00}}},
+    {{{     4,     -3,    -33}, 0, {     0,      0}, {0x48, 0x1e, 0x9d, 0x00}}},
+    {{{   -19,     47,     -4}, 0, {     0,      0}, {0x30, 0x72, 0xe5, 0x00}}},
+    {{{   -14,     26,     41}, 0, {     0,      0}, {0xed, 0x3d, 0x6d, 0x00}}},
+    {{{    13,    -38,     41}, 0, {     0,      0}, {0x15, 0xb3, 0x61, 0x00}}},
+    {{{    23,    -26,     35}, 0, {     0,      0}, {0x04, 0xc3, 0x6e, 0x00}}},
+    {{{    24,    -57,     -4}, 0, {     0,      0}, {0xa2, 0xaf, 0xe7, 0x00}}},
+    {{{   -16,    -12,      6}, 0, {     0,      0}, {0x8c, 0xcf, 0xf8, 0x00}}},
+    {{{     4,     -3,    -33}, 0, {     0,      0}, {0x9b, 0xd5, 0xc2, 0x00}}},
+    {{{   -19,     47,     -4}, 0, {     0,      0}, {0x85, 0xf5, 0xe7, 0x00}}},
+    {{{    58,     81,      0}, 0, {     0,      0}, {0x14, 0x7b, 0xe9, 0x00}}},
+};
+
+static const Vtx ghost_mario_right_hand_closed_dl_vertex_group2[] = {
+    {{{    35,      9,    -37}, 0, {     0,      0}, {0xe5, 0xf5, 0x85, 0x00}}},
+    {{{   104,    -26,      1}, 0, {     0,      0}, {0x68, 0xc5, 0xd7, 0x00}}},
+    {{{    55,    -44,     -4}, 0, {     0,      0}, {0x00, 0x86, 0xdf, 0x00}}},
+    {{{    75,    -33,     66}, 0, {     0,      0}, {0x08, 0xaf, 0x60, 0x00}}},
+    {{{    96,     -8,     52}, 0, {     0,      0}, {0x60, 0x06, 0x51, 0x00}}},
+    {{{    57,     10,     66}, 0, {     0,      0}, {0xfd, 0x1c, 0x7b, 0x00}}},
+    {{{    58,     81,      0}, 0, {     0,      0}, {0x14, 0x7b, 0xe9, 0x00}}},
+    {{{    97,     39,     24}, 0, {     0,      0}, {0x6b, 0x3a, 0x21, 0x00}}},
+    {{{    86,     30,    -33}, 0, {     0,      0}, {0x4f, 0x22, 0xa4, 0x00}}},
+    {{{    86,     15,     52}, 0, {     0,      0}, {0x40, 0x30, 0x61, 0x00}}},
+    {{{    54,     54,     44}, 0, {     0,      0}, {0x20, 0x51, 0x5c, 0x00}}},
+    {{{    29,     62,     34}, 0, {     0,      0}, {0xce, 0x4c, 0x57, 0x00}}},
+    {{{    29,      6,     49}, 0, {     0,      0}, {0xc2, 0xfa, 0x6e, 0x00}}},
+    {{{    10,     60,     -4}, 0, {     0,      0}, {0xac, 0x5a, 0xe5, 0x00}}},
+};
+
+static const Vtx ghost_mario_right_hand_closed_dl_vertex_group3[] = {
+    {{{    31,    -40,     -1}, 0, {     0,      0}, {0x43, 0xa4, 0xc9, 0x00}}},
+    {{{    23,    -26,     35}, 0, {     0,      0}, {0x04, 0xc3, 0x6e, 0x00}}},
+    {{{    13,    -38,     41}, 0, {     0,      0}, {0x15, 0xb3, 0x61, 0x00}}},
+    {{{     1,     24,     35}, 0, {     0,      0}, {0xd2, 0x3c, 0x65, 0x00}}},
+    {{{   -14,     26,     41}, 0, {     0,      0}, {0xed, 0x3d, 0x6d, 0x00}}},
+    {{{    -2,     41,     -1}, 0, {     0,      0}, {0xed, 0x70, 0xc9, 0x00}}},
+    {{{    15,      0,    -23}, 0, {     0,      0}, {0x04, 0x01, 0x82, 0x00}}},
+    {{{     4,     -3,    -33}, 0, {     0,      0}, {0x48, 0x1e, 0x9d, 0x00}}},
+    {{{    35,      9,    -37}, 0, {     0,      0}, {0xe5, 0xf5, 0x85, 0x00}}},
+    {{{    29,      6,     49}, 0, {     0,      0}, {0xc2, 0xfa, 0x6e, 0x00}}},
+    {{{    55,    -44,     -4}, 0, {     0,      0}, {0x00, 0x86, 0xdf, 0x00}}},
+    {{{    75,    -33,     66}, 0, {     0,      0}, {0x08, 0xaf, 0x60, 0x00}}},
+    {{{    57,     10,     66}, 0, {     0,      0}, {0xfd, 0x1c, 0x7b, 0x00}}},
+    {{{    10,     60,     -4}, 0, {     0,      0}, {0xac, 0x5a, 0xe5, 0x00}}},
+    {{{    29,     62,     34}, 0, {     0,      0}, {0xce, 0x4c, 0x57, 0x00}}},
+};
+
+static const Gfx ghost_mario_right_hand_closed[] = {
+    gsSPVertex(ghost_mario_right_hand_closed_dl_vertex_group1, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 0, 4, 0x0),
+    gsSP2Triangles(2, 5, 6, 0x0, 6, 7, 4, 0x0),
+    gsSP2Triangles(4, 7, 8, 0x0, 8, 9, 10, 0x0),
+    gsSP2Triangles(9, 5, 2, 0x0, 11, 12, 13, 0x0),
+    gsSP2Triangles(13, 12, 14, 0x0, 14, 12, 8, 0x0),
+    gsSP2Triangles(8, 12, 9, 0x0, 9, 12, 11, 0x0),
+    gsSP1Triangle(3, 15, 0, 0x0),
+    gsSPVertex(ghost_mario_right_hand_closed_dl_vertex_group2, 14, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 2, 1, 3, 0x0),
+    gsSP2Triangles(3, 4, 5, 0x0, 6, 7, 8, 0x0),
+    gsSP2Triangles(8, 7, 1, 0x0, 1, 7, 4, 0x0),
+    gsSP2Triangles(4, 7, 9, 0x0, 10, 7, 6, 0x0),
+    gsSP2Triangles(9, 10, 5, 0x0, 10, 11, 5, 0x0),
+    gsSP2Triangles(11, 12, 5, 0x0, 1, 4, 3, 0x0),
+    gsSP2Triangles(11, 10, 6, 0x0, 6, 13, 11, 0x0),
+    gsSP2Triangles(7, 10, 9, 0x0, 4, 9, 5, 0x0),
+    gsSP2Triangles(0, 8, 1, 0x0, 6, 8, 0, 0x0),
+    gsSPVertex(ghost_mario_right_hand_closed_dl_vertex_group3, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 1, 3, 4, 0x0),
+    gsSP2Triangles(4, 3, 5, 0x0, 5, 6, 7, 0x0),
+    gsSP2Triangles(7, 6, 0, 0x0, 8, 6, 5, 0x0),
+    gsSP2Triangles(9, 3, 1, 0x0, 0, 6, 8, 0x0),
+    gsSP2Triangles(10, 11, 1, 0x0, 11, 9, 1, 0x0),
+    gsSP2Triangles(11, 12, 9, 0x0, 1, 0, 10, 0x0),
+    gsSP2Triangles(13, 5, 3, 0x0, 3, 9, 14, 0x0),
+    gsSP1Triangle(14, 13, 3, 0x0),
+    gsSPEndDisplayList(),
+};
+
+//
+// Left leg
+//
+
+static const Vtx ghost_mario_left_thigh_dl_vertex_group1[] = {
+    {{{     1,    -44,      8}, 0, {     0,      0}, {0xab, 0xa2, 0x00, 0x00}}},
+    {{{   -15,      0,      7}, 0, {     0,      0}, {0x82, 0xf7, 0xff, 0x00}}},
+    {{{     0,    -13,    -32}, 0, {     0,      0}, {0x9f, 0xe1, 0xb5, 0x00}}},
+    {{{    -4,     37,    -17}, 0, {     0,      0}, {0x9e, 0x30, 0xc0, 0x00}}},
+    {{{    -5,     37,     31}, 0, {     0,      0}, {0xa0, 0x3f, 0x34, 0x00}}},
+    {{{    -1,    -12,     47}, 0, {     0,      0}, {0x9e, 0xe3, 0x49, 0x00}}},
+    {{{    95,     -5,     48}, 0, {     0,      0}, {0x4e, 0xe9, 0x60, 0x00}}},
+    {{{   116,     10,      8}, 0, {     0,      0}, {0x7e, 0x09, 0x01, 0x00}}},
+    {{{    91,     45,     32}, 0, {     0,      0}, {0x3c, 0x4e, 0x4f, 0x00}}},
+    {{{    92,     45,    -16}, 0, {     0,      0}, {0x35, 0x5d, 0xbd, 0x00}}},
+    {{{    96,     -5,    -31}, 0, {     0,      0}, {0x50, 0xe8, 0xa1, 0x00}}},
+    {{{    98,    -37,      8}, 0, {     0,      0}, {0x46, 0x97, 0x01, 0x00}}},
+    {{{    19,    -15,    -42}, 0, {     0,      0}, {0xec, 0xd9, 0x8a, 0x00}}},
+    {{{    14,     48,    -23}, 0, {     0,      0}, {0xd7, 0x67, 0xc5, 0x00}}},
+    {{{    13,     48,     38}, 0, {     0,      0}, {0xe7, 0x6d, 0x3a, 0x00}}},
+    {{{    18,    -15,     58}, 0, {     0,      0}, {0xea, 0xda, 0x76, 0x00}}},
+};
+
+static const Vtx ghost_mario_left_thigh_dl_vertex_group2[] = {
+    {{{    18,    -15,     58}, 0, {     0,      0}, {0xea, 0xda, 0x76, 0x00}}},
+    {{{     1,    -44,      8}, 0, {     0,      0}, {0xab, 0xa2, 0x00, 0x00}}},
+    {{{    21,    -54,      8}, 0, {     0,      0}, {0xf0, 0x83, 0x00, 0x00}}},
+    {{{    19,    -15,    -42}, 0, {     0,      0}, {0xec, 0xd9, 0x8a, 0x00}}},
+    {{{    -1,    -12,     47}, 0, {     0,      0}, {0x9e, 0xe3, 0x49, 0x00}}},
+    {{{   -15,      0,      7}, 0, {     0,      0}, {0x82, 0xf7, 0xff, 0x00}}},
+    {{{    98,    -37,      8}, 0, {     0,      0}, {0x46, 0x97, 0x01, 0x00}}},
+    {{{    13,     48,     38}, 0, {     0,      0}, {0xe7, 0x6d, 0x3a, 0x00}}},
+    {{{    91,     45,     32}, 0, {     0,      0}, {0x3c, 0x4e, 0x4f, 0x00}}},
+    {{{    14,     48,    -23}, 0, {     0,      0}, {0xd7, 0x67, 0xc5, 0x00}}},
+    {{{    92,     45,    -16}, 0, {     0,      0}, {0x35, 0x5d, 0xbd, 0x00}}},
+    {{{    96,     -5,    -31}, 0, {     0,      0}, {0x50, 0xe8, 0xa1, 0x00}}},
+    {{{    95,     -5,     48}, 0, {     0,      0}, {0x4e, 0xe9, 0x60, 0x00}}},
+    {{{     0,    -13,    -32}, 0, {     0,      0}, {0x9f, 0xe1, 0xb5, 0x00}}},
+    {{{    -5,     37,     31}, 0, {     0,      0}, {0xa0, 0x3f, 0x34, 0x00}}},
+    {{{    -4,     37,    -17}, 0, {     0,      0}, {0x9e, 0x30, 0xc0, 0x00}}},
+};
+
+static const Gfx ghost_mario_left_thigh[] = {
+    gsDPPipeSync(),
+    gsSPVertex(ghost_mario_left_thigh_dl_vertex_group1, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 2, 1, 3, 0x0),
+    gsSP2Triangles(3, 1, 4, 0x0, 4, 1, 5, 0x0),
+    gsSP2Triangles(6, 7, 8, 0x0, 8, 7, 9, 0x0),
+    gsSP2Triangles(9, 7, 10, 0x0, 10, 7, 11, 0x0),
+    gsSP2Triangles(11, 7, 6, 0x0, 12, 3, 13, 0x0),
+    gsSP2Triangles(13, 4, 14, 0x0, 14, 4, 15, 0x0),
+    gsSPVertex(ghost_mario_left_thigh_dl_vertex_group2, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 2, 1, 3, 0x0),
+    gsSP2Triangles(4, 5, 1, 0x0, 0, 2, 6, 0x0),
+    gsSP2Triangles(7, 0, 8, 0x0, 9, 7, 10, 0x0),
+    gsSP2Triangles(3, 9, 10, 0x0, 2, 3, 6, 0x0),
+    gsSP2Triangles(3, 11, 6, 0x0, 10, 11, 3, 0x0),
+    gsSP2Triangles(7, 8, 10, 0x0, 0, 12, 8, 0x0),
+    gsSP2Triangles(6, 12, 0, 0x0, 1, 13, 3, 0x0),
+    gsSP2Triangles(0, 4, 1, 0x0, 14, 4, 0, 0x0),
+    gsSP2Triangles(9, 15, 14, 0x0, 3, 13, 15, 0x0),
+    gsSPEndDisplayList(),
+};
+
+static const Vtx ghost_mario_left_leg_shared_dl_vertex[] = {
+    {{{     4,    -37,      9}, 0, {     0,      0}, {0xc1, 0x93, 0x00, 0x00}}},
+    {{{    64,    -46,      9}, 0, {     0,      0}, {0x4b, 0x9a, 0x01, 0x00}}},
+    {{{    65,    -11,     54}, 0, {     0,      0}, {0x2d, 0xdb, 0x70, 0x00}}},
+    {{{     8,     44,     33}, 0, {     0,      0}, {0xcc, 0x5e, 0x43, 0x00}}},
+    {{{    68,     45,     37}, 0, {     0,      0}, {0x52, 0x4b, 0x3c, 0x00}}},
+    {{{    69,     45,    -18}, 0, {     0,      0}, {0x42, 0x61, 0xd1, 0x00}}},
+    {{{     9,     44,    -16}, 0, {     0,      0}, {0xc4, 0x4d, 0xaf, 0x00}}},
+    {{{    66,    -11,    -36}, 0, {     0,      0}, {0x2e, 0xda, 0x91, 0x00}}},
+    {{{     6,     -6,    -31}, 0, {     0,      0}, {0xb4, 0xe5, 0x9f, 0x00}}},
+    {{{     6,     -6,     49}, 0, {     0,      0}, {0xb3, 0xe7, 0x60, 0x00}}},
+    {{{   -14,      8,      8}, 0, {     0,      0}, {0x82, 0x06, 0xff, 0x00}}},
+    {{{    81,      3,      9}, 0, {     0,      0}, {0x7e, 0xfa, 0x01, 0x00}}},
+};
+
+static const Gfx ghost_mario_left_leg_shared_dl[] = {
+    gsSPVertex(ghost_mario_left_leg_shared_dl_vertex, 12, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  2,  4, 0x0),
+    gsSP2Triangles( 3,  4,  5, 0x0,  6,  5,  7, 0x0),
+    gsSP2Triangles( 0,  7,  1, 0x0,  0,  8,  7, 0x0),
+    gsSP2Triangles( 7,  8,  6, 0x0,  5,  6,  3, 0x0),
+    gsSP2Triangles( 3,  9,  2, 0x0,  2,  9,  0, 0x0),
+    gsSP2Triangles( 3, 10,  9, 0x0,  5, 11,  7, 0x0),
+    gsSP2Triangles( 7, 11,  1, 0x0,  1, 11,  2, 0x0),
+    gsSP2Triangles( 2, 11,  4, 0x0,  4, 11,  5, 0x0),
+    gsSP2Triangles( 9, 10,  0, 0x0,  0, 10,  8, 0x0),
+    gsSP2Triangles( 8, 10,  6, 0x0,  6, 10,  3, 0x0),
+    gsSPEndDisplayList(),
+};
+
+static const Vtx ghost_mario_left_foot_shared_dl_vertex_group1[] = {
+    {{{   110,      9,     35}, 0, {     0,      0}, {0x2b, 0x77, 0xff, 0x00}}},
+    {{{   110,      8,    -20}, 0, {     0,      0}, {0x2b, 0x77, 0xff, 0x00}}},
+    {{{    76,     20,    -41}, 0, {     0,      0}, {0x2b, 0x77, 0xff, 0x00}}},
+    {{{    78,     21,     61}, 0, {     0,      0}, {0x2b, 0x77, 0xff, 0x00}}},
+    {{{   -12,     53,    -32}, 0, {     0,      0}, {0x2b, 0x77, 0xff, 0x00}}},
+    {{{   -11,     54,     53}, 0, {     0,      0}, {0x2b, 0x77, 0xff, 0x00}}},
+    {{{   -39,     64,     -8}, 0, {     0,      0}, {0x2b, 0x77, 0xff, 0x00}}},
+    {{{   -41,     65,     26}, 0, {     0,      0}, {0x2b, 0x77, 0xff, 0x00}}},
+    {{{    43,    -18,     54}, 0, {     0,      0}, {0x07, 0xb3, 0x64, 0x00}}},
+    {{{    78,     21,     61}, 0, {     0,      0}, {0x15, 0xdb, 0x77, 0x00}}},
+    {{{   -11,     54,     53}, 0, {     0,      0}, {0xd9, 0x00, 0x78, 0x00}}},
+    {{{    44,    -12,    -33}, 0, {     0,      0}, {0x01, 0xb7, 0x99, 0x00}}},
+    {{{   -35,     11,    -21}, 0, {     0,      0}, {0xb5, 0xd2, 0xa5, 0x00}}},
+    {{{   -12,     53,    -32}, 0, {     0,      0}, {0xd7, 0xfd, 0x89, 0x00}}},
+    {{{   -34,     12,     44}, 0, {     0,      0}, {0xb2, 0xd2, 0x58, 0x00}}},
+    {{{    76,     20,    -41}, 0, {     0,      0}, {0x0c, 0xd8, 0x89, 0x00}}},
+};
+
+static const Vtx ghost_mario_left_foot_shared_dl_vertex_group2[] = {
+    {{{    44,    -12,    -33}, 0, {     0,      0}, {0x01, 0xb7, 0x99, 0x00}}},
+    {{{    76,     20,    -41}, 0, {     0,      0}, {0x0c, 0xd8, 0x89, 0x00}}},
+    {{{   110,      8,    -20}, 0, {     0,      0}, {0x44, 0xad, 0xbe, 0x00}}},
+    {{{    80,    -31,      7}, 0, {     0,      0}, {0x34, 0x8d, 0xfb, 0x00}}},
+    {{{   110,      9,     35}, 0, {     0,      0}, {0x4c, 0xaf, 0x3c, 0x00}}},
+    {{{    78,     21,     61}, 0, {     0,      0}, {0x15, 0xdb, 0x77, 0x00}}},
+    {{{    43,    -18,     54}, 0, {     0,      0}, {0x07, 0xb3, 0x64, 0x00}}},
+    {{{   -34,     12,     44}, 0, {     0,      0}, {0xb2, 0xd2, 0x58, 0x00}}},
+    {{{   -11,     54,     53}, 0, {     0,      0}, {0xd9, 0x00, 0x78, 0x00}}},
+    {{{   -41,     65,     26}, 0, {     0,      0}, {0x90, 0x17, 0x35, 0x00}}},
+    {{{   -39,     64,     -8}, 0, {     0,      0}, {0x93, 0x16, 0xc4, 0x00}}},
+    {{{   -35,     11,    -21}, 0, {     0,      0}, {0xb5, 0xd2, 0xa5, 0x00}}},
+    {{{   -54,     15,      8}, 0, {     0,      0}, {0x88, 0xd8, 0xfd, 0x00}}},
+    {{{   -12,     53,    -32}, 0, {     0,      0}, {0xd7, 0xfd, 0x89, 0x00}}},
+    {{{    27,    -35,     11}, 0, {     0,      0}, {0xdb, 0x87, 0xfc, 0x00}}},
+};
+
+static const Gfx ghost_mario_left_foot_shared_dl[] = {
+    gsSPVertex(ghost_mario_left_foot_shared_dl_vertex_group1, 16, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  0,  2, 0x0),
+    gsSP2Triangles( 3,  2,  4, 0x0,  5,  3,  4, 0x0),
+    gsSP2Triangles( 5,  4,  6, 0x0,  5,  6,  7, 0x0),
+    gsSP2Triangles( 8,  9, 10, 0x0, 11, 12, 13, 0x0),
+    gsSP2Triangles(14,  8, 10, 0x0, 11, 13, 15, 0x0),
+    gsSPVertex(ghost_mario_left_foot_shared_dl_vertex_group2, 15, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  2,  4, 0x0),
+    gsSP2Triangles( 2,  3,  0, 0x0,  4,  5,  6, 0x0),
+    gsSP2Triangles( 6,  3,  4, 0x0,  7,  8,  9, 0x0),
+    gsSP2Triangles(10, 11, 12, 0x0, 10, 13, 11, 0x0),
+    gsSP2Triangles(12,  9, 10, 0x0,  9, 12,  7, 0x0),
+    gsSP2Triangles(14,  0,  3, 0x0, 11,  0, 14, 0x0),
+    gsSP2Triangles( 3,  6, 14, 0x0, 14,  6,  7, 0x0),
+    gsSP2Triangles(14,  7, 12, 0x0, 12, 11, 14, 0x0),
+    gsSPEndDisplayList(),
+};
+
+//
+// Right leg
+//
+
+static const Vtx ghost_mario_right_thigh_shared_dl_vertex_group1[] = {
+    {{{    98,    -35,    -10}, 0, {     0,      0}, {0x47, 0x97, 0xfc, 0x00}}},
+    {{{    19,    -16,     41}, 0, {     0,      0}, {0xee, 0xd6, 0x76, 0x00}}},
+    {{{    22,    -54,     -9}, 0, {     0,      0}, {0xf2, 0x82, 0xfd, 0x00}}},
+    {{{    91,     46,     16}, 0, {     0,      0}, {0x35, 0x5c, 0x44, 0x00}}},
+    {{{    13,     48,     24}, 0, {     0,      0}, {0xd6, 0x66, 0x3e, 0x00}}},
+    {{{    12,     49,    -37}, 0, {     0,      0}, {0xe5, 0x6e, 0xc9, 0x00}}},
+    {{{    90,     47,    -32}, 0, {     0,      0}, {0x3b, 0x50, 0xb2, 0x00}}},
+    {{{    18,    -13,    -58}, 0, {     0,      0}, {0xea, 0xdc, 0x89, 0x00}}},
+    {{{     1,    -44,     -9}, 0, {     0,      0}, {0xad, 0xa1, 0xff, 0x00}}},
+    {{{   -15,      0,     -7}, 0, {     0,      0}, {0x82, 0xf5, 0x02, 0x00}}},
+    {{{    -1,    -11,    -47}, 0, {     0,      0}, {0x9d, 0xe3, 0xb7, 0x00}}},
+    {{{    -6,     38,    -31}, 0, {     0,      0}, {0x9e, 0x3f, 0xcf, 0x00}}},
+    {{{    -5,     36,     18}, 0, {     0,      0}, {0x9e, 0x2d, 0x42, 0x00}}},
+    {{{    95,     -3,    -49}, 0, {     0,      0}, {0x4d, 0xec, 0x9e, 0x00}}},
+    {{{   116,     11,     -9}, 0, {     0,      0}, {0x7e, 0x0b, 0xfe, 0x00}}},
+    {{{    96,     -5,     30}, 0, {     0,      0}, {0x51, 0xe7, 0x5d, 0x00}}},
+};
+
+static const Vtx ghost_mario_right_thigh_shared_dl_vertex_group2[] = {
+    {{{    -5,     36,     18}, 0, {     0,      0}, {0x9e, 0x2d, 0x42, 0x00}}},
+    {{{   -15,      0,     -7}, 0, {     0,      0}, {0x82, 0xf5, 0x02, 0x00}}},
+    {{{     0,    -14,     31}, 0, {     0,      0}, {0xa0, 0xdf, 0x4b, 0x00}}},
+    {{{     1,    -44,     -9}, 0, {     0,      0}, {0xad, 0xa1, 0xff, 0x00}}},
+    {{{    19,    -16,     41}, 0, {     0,      0}, {0xee, 0xd6, 0x76, 0x00}}},
+    {{{    -6,     38,    -31}, 0, {     0,      0}, {0x9e, 0x3f, 0xcf, 0x00}}},
+    {{{    13,     48,     24}, 0, {     0,      0}, {0xd6, 0x66, 0x3e, 0x00}}},
+    {{{    18,    -13,    -58}, 0, {     0,      0}, {0xea, 0xdc, 0x89, 0x00}}},
+    {{{    -1,    -11,    -47}, 0, {     0,      0}, {0x9d, 0xe3, 0xb7, 0x00}}},
+    {{{    95,     -3,    -49}, 0, {     0,      0}, {0x4d, 0xec, 0x9e, 0x00}}},
+    {{{    98,    -35,    -10}, 0, {     0,      0}, {0x47, 0x97, 0xfc, 0x00}}},
+    {{{    90,     47,    -32}, 0, {     0,      0}, {0x3b, 0x50, 0xb2, 0x00}}},
+    {{{    91,     46,     16}, 0, {     0,      0}, {0x35, 0x5c, 0x44, 0x00}}},
+    {{{    12,     49,    -37}, 0, {     0,      0}, {0xe5, 0x6e, 0xc9, 0x00}}},
+    {{{    96,     -5,     30}, 0, {     0,      0}, {0x51, 0xe7, 0x5d, 0x00}}},
+};
+
+static const Gfx ghost_mario_right_thigh_shared_dl[] = {
+    gsSPVertex(ghost_mario_right_thigh_shared_dl_vertex_group1, 16, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  4,  1, 0x0),
+    gsSP2Triangles( 3,  5,  4, 0x0,  6,  7,  5, 0x0),
+    gsSP2Triangles( 0,  2,  7, 0x0,  8,  9, 10, 0x0),
+    gsSP2Triangles( 1,  8,  2, 0x0,  2,  8,  7, 0x0),
+    gsSP2Triangles( 7, 11,  5, 0x0,  5, 11,  4, 0x0),
+    gsSP2Triangles( 4, 12,  1, 0x0, 13, 14,  0, 0x0),
+    gsSP2Triangles( 0, 14, 15, 0x0, 15, 14,  3, 0x0),
+    gsSP2Triangles( 3, 14,  6, 0x0,  6, 14, 13, 0x0),
+    gsSP2Triangles(10,  9, 11, 0x0, 11,  9, 12, 0x0),
+    gsSPVertex(ghost_mario_right_thigh_shared_dl_vertex_group2, 15, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  2,  1,  3, 0x0),
+    gsSP2Triangles( 0,  2,  4, 0x0,  5,  0,  6, 0x0),
+    gsSP2Triangles( 7,  8,  5, 0x0,  3,  8,  7, 0x0),
+    gsSP2Triangles( 4,  2,  3, 0x0,  7,  9, 10, 0x0),
+    gsSP2Triangles(11,  9,  7, 0x0, 12, 11, 13, 0x0),
+    gsSP2Triangles( 4, 14, 12, 0x0, 10, 14,  4, 0x0),
+    gsSPEndDisplayList(),
+};
+
+static const Vtx ghost_mario_right_leg_shared_dl_vertex_group1[] = {
+    {{{    63,    -45,    -12}, 0, {     0,      0}, {0xf2, 0x9b, 0x4a, 0x00}}},
+    {{{    66,    -11,     34}, 0, {     0,      0}, {0xf2, 0x9b, 0x4a, 0x00}}},
+    {{{     4,    -36,    -10}, 0, {     0,      0}, {0xc0, 0x93, 0xfe, 0x00}}},
+    {{{    66,    -11,     34}, 0, {     0,      0}, {0xfb, 0x22, 0x7a, 0x00}}},
+    {{{    69,     45,     18}, 0, {     0,      0}, {0xfc, 0x22, 0x7a, 0x00}}},
+    {{{     9,     44,     16}, 0, {     0,      0}, {0xc6, 0x4b, 0x53, 0x00}}},
+    {{{    69,     45,     18}, 0, {     0,      0}, {0xff, 0x7f, 0x03, 0x00}}},
+    {{{    69,     46,    -37}, 0, {     0,      0}, {0xff, 0x7f, 0x03, 0x00}}},
+    {{{     9,     46,    -33}, 0, {     0,      0}, {0xcd, 0x60, 0xc0, 0x00}}},
+    {{{    69,     46,    -37}, 0, {     0,      0}, {0xf7, 0x27, 0x88, 0x00}}},
+    {{{    65,     -9,    -56}, 0, {     0,      0}, {0xf8, 0x28, 0x88, 0x00}}},
+    {{{    65,     -9,    -56}, 0, {     0,      0}, {0xef, 0xa0, 0xb0, 0x00}}},
+    {{{    63,    -45,    -12}, 0, {     0,      0}, {0xef, 0xa0, 0xb0, 0x00}}},
+    {{{     6,     -6,     30}, 0, {     0,      0}, {0xb4, 0xe4, 0x61, 0x00}}},
+    {{{   -13,     10,     -9}, 0, {     0,      0}, {0x82, 0x08, 0x02, 0x00}}},
+    {{{     5,     -3,    -50}, 0, {     0,      0}, {0xb2, 0xea, 0xa0, 0x00}}},
+};
+
+static const Vtx ghost_mario_right_leg_shared_dl_vertex_group2[] = {
+    {{{    65,     -9,    -56}, 0, {     0,      0}, {0x75, 0xee, 0xd5, 0x00}}},
+    {{{    83,      4,    -10}, 0, {     0,      0}, {0x7e, 0xf9, 0xfe, 0x00}}},
+    {{{    63,    -45,    -12}, 0, {     0,      0}, {0x75, 0xd1, 0xfd, 0x00}}},
+    {{{    66,    -11,     34}, 0, {     0,      0}, {0x77, 0xec, 0x26, 0x00}}},
+    {{{    69,     45,     18}, 0, {     0,      0}, {0x7a, 0x18, 0x17, 0x00}}},
+    {{{    69,     46,    -37}, 0, {     0,      0}, {0x79, 0x19, 0xe6, 0x00}}},
+    {{{     4,    -36,    -10}, 0, {     0,      0}, {0xc0, 0x93, 0xfe, 0x00}}},
+    {{{     5,     -3,    -50}, 0, {     0,      0}, {0xb2, 0xea, 0xa0, 0x00}}},
+    {{{    65,     -9,    -56}, 0, {     0,      0}, {0xef, 0xa0, 0xb0, 0x00}}},
+    {{{    65,     -9,    -56}, 0, {     0,      0}, {0xf8, 0x28, 0x88, 0x00}}},
+    {{{     9,     46,    -33}, 0, {     0,      0}, {0xcd, 0x60, 0xc0, 0x00}}},
+    {{{     9,     44,     16}, 0, {     0,      0}, {0xc6, 0x4b, 0x53, 0x00}}},
+    {{{    69,     45,     18}, 0, {     0,      0}, {0xff, 0x7f, 0x03, 0x00}}},
+    {{{     6,     -6,     30}, 0, {     0,      0}, {0xb4, 0xe4, 0x61, 0x00}}},
+    {{{    66,    -11,     34}, 0, {     0,      0}, {0xfb, 0x22, 0x7a, 0x00}}},
+    {{{    66,    -11,     34}, 0, {     0,      0}, {0xf2, 0x9b, 0x4a, 0x00}}},
+};
+
+static const Gfx ghost_mario_right_leg_shared_dl[] = {
+    gsSPVertex(ghost_mario_right_leg_shared_dl_vertex_group1, 16, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  3,  4,  5, 0x0),
+    gsSP2Triangles( 6,  7,  8, 0x0,  9, 10,  8, 0x0),
+    gsSP2Triangles(11, 12,  2, 0x0, 13, 14,  2, 0x0),
+    gsSP2Triangles( 2, 14, 15, 0x0, 15, 14,  8, 0x0),
+    gsSP2Triangles( 8, 14,  5, 0x0,  5, 14, 13, 0x0),
+    gsSPVertex(ghost_mario_right_leg_shared_dl_vertex_group2, 16, 0),
+    gsSP2Triangles( 0,  1,  2, 0x0,  2,  1,  3, 0x0),
+    gsSP2Triangles( 3,  1,  4, 0x0,  4,  1,  5, 0x0),
+    gsSP2Triangles( 5,  1,  0, 0x0,  6,  7,  8, 0x0),
+    gsSP2Triangles( 9,  7, 10, 0x0, 10, 11, 12, 0x0),
+    gsSP2Triangles(11, 13, 14, 0x0, 15, 13,  6, 0x0),
+    gsSPEndDisplayList(),
+};
+
+static const Vtx ghost_mario_right_foot_dl_vertex_group1[] = {
+    {{{    27,    -35,    -11}, 0, {     0,      0}, {0xdc, 0x87, 0x06, 0x00}}},
+    {{{   -36,     11,     19}, 0, {     0,      0}, {0xb5, 0xd3, 0x5b, 0x00}}},
+    {{{   -54,     14,    -10}, 0, {     0,      0}, {0x89, 0xd6, 0x03, 0x00}}},
+    {{{   -34,     11,    -46}, 0, {     0,      0}, {0xb4, 0xd0, 0xa8, 0x00}}},
+    {{{    43,    -18,    -55}, 0, {     0,      0}, {0x0a, 0xb2, 0x9d, 0x00}}},
+    {{{    80,    -29,     -7}, 0, {     0,      0}, {0x36, 0x8e, 0x08, 0x00}}},
+    {{{    44,    -11,     32}, 0, {     0,      0}, {0x01, 0xb8, 0x68, 0x00}}},
+    {{{   -42,     64,    -29}, 0, {     0,      0}, {0x90, 0x14, 0xc9, 0x00}}},
+    {{{   -40,     63,      5}, 0, {     0,      0}, {0x92, 0x15, 0x3b, 0x00}}},
+    {{{   -14,     54,     29}, 0, {     0,      0}, {0xd5, 0xfe, 0x77, 0x00}}},
+    {{{   -11,     53,    -56}, 0, {     0,      0}, {0xda, 0xfe, 0x87, 0x00}}},
+    {{{   110,     11,    -36}, 0, {     0,      0}, {0x4e, 0xb0, 0xc6, 0x00}}},
+    {{{    78,     22,    -61}, 0, {     0,      0}, {0x17, 0xd9, 0x8a, 0x00}}},
+    {{{   109,     11,     20}, 0, {     0,      0}, {0x45, 0xaf, 0x44, 0x00}}},
+    {{{    75,     23,     40}, 0, {     0,      0}, {0x0b, 0xda, 0x78, 0x00}}},
+};
+
+static const Vtx ghost_mario_right_foot_dl_vertex_group2[] = {
+    {{{   -42,     64,    -29}, 0, {     0,      0}, {0x29, 0x77, 0x00, 0x00}}},
+    {{{   -40,     63,      5}, 0, {     0,      0}, {0x29, 0x77, 0x00, 0x00}}},
+    {{{   -11,     53,    -56}, 0, {     0,      0}, {0x29, 0x77, 0x00, 0x00}}},
+    {{{   -14,     54,     29}, 0, {     0,      0}, {0x29, 0x77, 0x00, 0x00}}},
+    {{{    78,     22,    -61}, 0, {     0,      0}, {0x29, 0x77, 0x00, 0x00}}},
+    {{{    75,     23,     40}, 0, {     0,      0}, {0x29, 0x77, 0x00, 0x00}}},
+    {{{   110,     11,    -36}, 0, {     0,      0}, {0x29, 0x77, 0x00, 0x00}}},
+    {{{   109,     11,     20}, 0, {     0,      0}, {0x29, 0x77, 0x00, 0x00}}},
+};
+
+static const Gfx ghost_mario_right_foot[] = {
+    gsSPVertex(ghost_mario_right_foot_dl_vertex_group1, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 2, 3, 0, 0x0),
+    gsSP2Triangles(3, 4, 0, 0x0, 0, 4, 5, 0x0),
+    gsSP2Triangles(0, 6, 1, 0x0, 5, 6, 0, 0x0),
+    gsSP2Triangles(3, 2, 7, 0x0, 8, 7, 2, 0x0),
+    gsSP2Triangles(1, 9, 8, 0x0, 2, 1, 8, 0x0),
+    gsSP2Triangles(7, 10, 3, 0x0, 11, 5, 4, 0x0),
+    gsSP2Triangles(4, 12, 11, 0x0, 6, 5, 13, 0x0),
+    gsSP2Triangles(11, 13, 5, 0x0, 13, 14, 6, 0x0),
+    gsSP2Triangles(14, 9, 6, 0x0, 10, 4, 3, 0x0),
+    gsSP2Triangles(9, 1, 6, 0x0, 10, 12, 4, 0x0),
+    gsSPVertex(ghost_mario_right_foot_dl_vertex_group2, 8, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 1, 3, 2, 0x0),
+    gsSP2Triangles(3, 4, 2, 0x0, 3, 5, 4, 0x0),
+    gsSP2Triangles(5, 6, 4, 0x0, 5, 7, 6, 0x0),
+    gsSPEndDisplayList(),
+};
+
+//
+// Body
+//
+
+static const Vtx ghost_mario_gold_button_dl_vertex[] = {
+    {{{     9,     89,     41}, 0, {   180,    962}, {0x14, 0x78, 0x23, 0xff}}},
+    {{{     3,     77,     62}, 0, {   682,    966}, {0x04, 0x6a, 0x44, 0xff}}},
+    {{{    47,     75,     35}, 0, {    34,    106}, {0x39, 0x6a, 0x26, 0xff}}},
+    {{{    28,     85,     30}, 0, {   -60,    572}, {0x2c, 0x76, 0x08, 0xff}}},
+    {{{    17,     66,     76}, 0, {   966,    590}, {0x19, 0x58, 0x57, 0xff}}},
+    {{{    32,     62,     74}, 0, {   902,    252}, {0x29, 0x53, 0x56, 0xff}}},
+    {{{    48,     64,     59}, 0, {   548,      0}, {0x4d, 0x51, 0x3a, 0xff}}},
+    {{{     9,     89,    -40}, 0, {   776,    920}, {0x10, 0x7b, 0xe7, 0xff}}},
+    {{{    28,     85,    -29}, 0, {   990,    512}, {0x2d, 0x75, 0xf2, 0xff}}},
+    {{{    47,     75,    -34}, 0, {   850,     72}, {0x3e, 0x6a, 0xe2, 0xff}}},
+    {{{     3,     77,    -61}, 0, {   264,    972}, {0x03, 0x6a, 0xbb, 0xff}}},
+    {{{    48,     64,    -58}, 0, {   312,      0}, {0x4d, 0x50, 0xc5, 0xff}}},
+    {{{    32,     62,    -73}, 0, {   -24,    310}, {0x29, 0x52, 0xa9, 0xff}}},
+    {{{    17,     66,    -75}, 0, {   -58,    642}, {0x17, 0x58, 0xa8, 0xff}}},
+};
+
+static const Vtx ghost_mario_tshirt_shared_dl_vertex_group1[] = {
+    {{{    47,     75,    -34}, 0, {     0,      0}, {0x3e, 0x6a, 0xe2, 0xff}}},
+    {{{    47,     75,     35}, 0, {     0,      0}, {0x39, 0x6a, 0x26, 0xff}}},
+    {{{    82,     37,     27}, 0, {     0,      0}, {0x66, 0x48, 0x14, 0xff}}},
+    {{{    82,     37,    -26}, 0, {     0,      0}, {0x69, 0x43, 0xec, 0xff}}},
+    {{{   100,      1,     24}, 0, {     0,      0}, {0x7a, 0x17, 0x16, 0xff}}},
+    {{{   100,      1,    -23}, 0, {     0,      0}, {0x7c, 0x09, 0xea, 0xff}}},
+    {{{     6,    -10,    -92}, 0, {     0,      0}, {0x00, 0xeb, 0x83, 0xff}}},
+    {{{    47,      3,    -88}, 0, {     0,      0}, {0x30, 0x09, 0x8b, 0xff}}},
+    {{{    46,    -34,    -83}, 0, {     0,      0}, {0x24, 0xc8, 0x95, 0xff}}},
+    {{{    12,     33,    -90}, 0, {     0,      0}, {0x11, 0x20, 0x87, 0xff}}},
+    {{{    20,    -61,    -67}, 0, {     0,      0}, {0x0a, 0x9a, 0xb7, 0xff}}},
+    {{{    66,    -52,    -50}, 0, {     0,      0}, {0x3b, 0x9a, 0xd3, 0xff}}},
+    {{{    84,    -29,    -62}, 0, {     0,      0}, {0x5f, 0xde, 0xb4, 0xff}}},
+    {{{    20,    -61,     68}, 0, {     0,      0}, {0x0a, 0x99, 0x49, 0xff}}},
+    {{{    66,    -52,     51}, 0, {     0,      0}, {0x3b, 0x9a, 0x2d, 0xff}}},
+    {{{    46,    -34,     84}, 0, {     0,      0}, {0x24, 0xc8, 0x6b, 0xff}}},
+};
+
+static const Vtx ghost_mario_tshirt_shared_dl_vertex_group2[] = {
+    {{{    20,    -61,     68}, 0, {     0,      0}, {0x0a, 0x99, 0x49, 0xff}}},
+    {{{    46,    -34,     84}, 0, {     0,      0}, {0x24, 0xc8, 0x6b, 0xff}}},
+    {{{     6,    -11,     93}, 0, {     0,      0}, {0x00, 0xea, 0x7c, 0xff}}},
+    {{{    47,      3,     89}, 0, {     0,      0}, {0x30, 0x08, 0x75, 0xff}}},
+    {{{    84,    -29,     63}, 0, {     0,      0}, {0x5f, 0xde, 0x4c, 0xff}}},
+    {{{    66,    -52,     51}, 0, {     0,      0}, {0x3b, 0x9a, 0x2d, 0xff}}},
+    {{{    13,     33,     91}, 0, {     0,      0}, {0x12, 0x20, 0x79, 0xff}}},
+    {{{   100,      1,    -23}, 0, {     0,      0}, {0x7c, 0x09, 0xea, 0xff}}},
+    {{{   100,      1,     24}, 0, {     0,      0}, {0x7a, 0x17, 0x16, 0xff}}},
+    {{{    93,    -36,     26}, 0, {     0,      0}, {0x6b, 0xbf, 0x0d, 0xff}}},
+    {{{    93,    -36,    -25}, 0, {     0,      0}, {0x66, 0xb7, 0xf0, 0xff}}},
+    {{{    54,    -63,      0}, 0, {     0,      0}, {0x30, 0x8b, 0x00, 0xff}}},
+    {{{    80,     14,     62}, 0, {     0,      0}, {0x60, 0x28, 0x47, 0xff}}},
+    {{{    44,     51,     75}, 0, {     0,      0}, {0x3c, 0x34, 0x62, 0xff}}},
+};
+
+static const Vtx ghost_mario_tshirt_shared_dl_vertex_group3[] = {
+    {{{    80,     14,    -61}, 0, {     0,      0}, {0x60, 0x28, 0xb8, 0xff}}},
+    {{{    47,      3,    -88}, 0, {     0,      0}, {0x30, 0x09, 0x8b, 0xff}}},
+    {{{    43,     51,    -74}, 0, {     0,      0}, {0x3c, 0x32, 0x9d, 0xff}}},
+    {{{    84,    -29,    -62}, 0, {     0,      0}, {0x5f, 0xde, 0xb4, 0xff}}},
+    {{{    12,     33,    -90}, 0, {     0,      0}, {0x11, 0x20, 0x87, 0xff}}},
+};
+
+static const Vtx ghost_mario_pants_overalls_shared_dl_vertex_group1[] = {
+    {{{    47,     75,    -34}, 0, {     0,      0}, {0x3e, 0x6a, 0xe2, 0xff}}},
+    {{{    28,     85,     30}, 0, {     0,      0}, {0x2c, 0x76, 0x08, 0xff}}},
+    {{{    47,     75,     35}, 0, {     0,      0}, {0x39, 0x6a, 0x26, 0xff}}},
+    {{{    28,     85,    -29}, 0, {     0,      0}, {0x2d, 0x75, 0xf2, 0xff}}},
+    {{{     9,     89,     41}, 0, {     0,      0}, {0x14, 0x78, 0x23, 0xff}}},
+    {{{     9,     89,    -40}, 0, {     0,      0}, {0x10, 0x7b, 0xe7, 0xff}}},
+    {{{   -15,     88,     35}, 0, {     0,      0}, {0xec, 0x7a, 0x1c, 0xff}}},
+    {{{   -15,     87,    -35}, 0, {     0,      0}, {0xea, 0x76, 0xda, 0xff}}},
+    {{{     3,     77,    -61}, 0, {     0,      0}, {0x03, 0x6a, 0xbb, 0xff}}},
+    {{{   -43,     83,    -24}, 0, {     0,      0}, {0xcc, 0x72, 0xee, 0xff}}},
+    {{{   -28,     63,    -74}, 0, {     0,      0}, {0xd1, 0x4f, 0xaa, 0xff}}},
+    {{{   -40,     72,    -54}, 0, {     0,      0}, {0xc5, 0x5f, 0xc6, 0xff}}},
+    {{{   -40,     72,     55}, 0, {     0,      0}, {0xc4, 0x5e, 0x3a, 0xff}}},
+    {{{   -43,     83,     25}, 0, {     0,      0}, {0xbc, 0x69, 0x11, 0xff}}},
+    {{{   -28,     63,     75}, 0, {     0,      0}, {0xd0, 0x50, 0x55, 0xff}}},
+};
+
+static const Vtx ghost_mario_pants_overalls_shared_dl_vertex_group2[] = {
+    {{{    80,     14,    -61}, 0, {     0,      0}, {0x60, 0x28, 0xb8, 0xff}}},
+    {{{    43,     51,    -74}, 0, {     0,      0}, {0x3c, 0x32, 0x9d, 0xff}}},
+    {{{    48,     64,    -58}, 0, {     0,      0}, {0x4d, 0x50, 0xc5, 0xff}}},
+    {{{     3,     77,     62}, 0, {     0,      0}, {0x04, 0x6a, 0x44, 0xff}}},
+    {{{     9,     89,     41}, 0, {     0,      0}, {0x14, 0x78, 0x23, 0xff}}},
+    {{{   -15,     88,     35}, 0, {     0,      0}, {0xec, 0x7a, 0x1c, 0xff}}},
+    {{{    47,     75,     35}, 0, {     0,      0}, {0x39, 0x6a, 0x26, 0xff}}},
+    {{{    48,     64,     59}, 0, {     0,      0}, {0x4d, 0x51, 0x3a, 0xff}}},
+    {{{    82,     37,     27}, 0, {     0,      0}, {0x66, 0x48, 0x14, 0xff}}},
+    {{{    32,     62,     74}, 0, {     0,      0}, {0x29, 0x53, 0x56, 0xff}}},
+    {{{    44,     51,     75}, 0, {     0,      0}, {0x3c, 0x34, 0x62, 0xff}}},
+    {{{    80,     14,     62}, 0, {     0,      0}, {0x60, 0x28, 0x47, 0xff}}},
+    {{{   100,      1,     24}, 0, {     0,      0}, {0x7a, 0x17, 0x16, 0xff}}},
+    {{{    82,     37,    -26}, 0, {     0,      0}, {0x69, 0x43, 0xec, 0xff}}},
+    {{{    32,     62,    -73}, 0, {     0,      0}, {0x29, 0x52, 0xa9, 0xff}}},
+    {{{    47,     75,    -34}, 0, {     0,      0}, {0x3e, 0x6a, 0xe2, 0xff}}},
+};
+
+static const Vtx ghost_mario_pants_overalls_shared_dl_vertex_group3[] = {
+    {{{    80,     14,    -61}, 0, {     0,      0}, {0x60, 0x28, 0xb8, 0xff}}},
+    {{{    82,     37,    -26}, 0, {     0,      0}, {0x69, 0x43, 0xec, 0xff}}},
+    {{{   100,      1,    -23}, 0, {     0,      0}, {0x7c, 0x09, 0xea, 0xff}}},
+    {{{    20,    -61,    -67}, 0, {     0,      0}, {0x0a, 0x9a, 0xb7, 0xff}}},
+    {{{    66,    -52,    -50}, 0, {     0,      0}, {0x3b, 0x9a, 0xd3, 0xff}}},
+    {{{    54,    -63,      0}, 0, {     0,      0}, {0x30, 0x8b, 0x00, 0xff}}},
+    {{{   -27,    -25,    -86}, 0, {     0,      0}, {0xcb, 0xd5, 0x96, 0xff}}},
+    {{{     6,    -10,    -92}, 0, {     0,      0}, {0x00, 0xeb, 0x83, 0xff}}},
+    {{{   -29,    -58,    -59}, 0, {     0,      0}, {0xc9, 0x9a, 0xcf, 0xff}}},
+    {{{     8,    -74,      0}, 0, {     0,      0}, {0xfd, 0x82, 0x00, 0xff}}},
+    {{{   -59,    -28,    -37}, 0, {     0,      0}, {0x90, 0xd5, 0xd9, 0xff}}},
+    {{{   -30,    -66,      0}, 0, {     0,      0}, {0xb8, 0x98, 0x00, 0xff}}},
+    {{{   -27,     26,    -89}, 0, {     0,      0}, {0xc7, 0x0f, 0x90, 0xff}}},
+    {{{    12,     33,    -90}, 0, {     0,      0}, {0x11, 0x20, 0x87, 0xff}}},
+    {{{    20,    -61,     68}, 0, {     0,      0}, {0x0a, 0x99, 0x49, 0xff}}},
+    {{{    66,    -52,     51}, 0, {     0,      0}, {0x3b, 0x9a, 0x2d, 0xff}}},
+};
+
+static const Vtx ghost_mario_pants_overalls_shared_dl_vertex_group4[] = {
+    {{{     8,    -74,      0}, 0, {     0,      0}, {0xfd, 0x82, 0x00, 0xff}}},
+    {{{    20,    -61,     68}, 0, {     0,      0}, {0x0a, 0x99, 0x49, 0xff}}},
+    {{{   -29,    -58,     59}, 0, {     0,      0}, {0xc8, 0x99, 0x30, 0xff}}},
+    {{{   -27,    -25,     87}, 0, {     0,      0}, {0xcb, 0xd3, 0x69, 0xff}}},
+    {{{     6,    -11,     93}, 0, {     0,      0}, {0x00, 0xea, 0x7c, 0xff}}},
+    {{{   -27,     26,     91}, 0, {     0,      0}, {0xc8, 0x0e, 0x70, 0xff}}},
+    {{{    13,     33,     91}, 0, {     0,      0}, {0x12, 0x20, 0x79, 0xff}}},
+    {{{   -59,    -28,     38}, 0, {     0,      0}, {0x8d, 0xd8, 0x21, 0xff}}},
+    {{{   -30,    -66,      0}, 0, {     0,      0}, {0xb8, 0x98, 0x00, 0xff}}},
+    {{{   -28,     63,    -74}, 0, {     0,      0}, {0xd1, 0x4f, 0xaa, 0xff}}},
+    {{{   -27,     26,    -89}, 0, {     0,      0}, {0xc7, 0x0f, 0x90, 0xff}}},
+    {{{   -71,     54,    -29}, 0, {     0,      0}, {0x8f, 0x2a, 0xda, 0xff}}},
+    {{{   -59,    -28,    -37}, 0, {     0,      0}, {0x90, 0xd5, 0xd9, 0xff}}},
+    {{{   -71,     54,     30}, 0, {     0,      0}, {0x94, 0x2a, 0x31, 0xff}}},
+    {{{   -43,     83,     25}, 0, {     0,      0}, {0xbc, 0x69, 0x11, 0xff}}},
+    {{{   -43,     83,    -24}, 0, {     0,      0}, {0xcc, 0x72, 0xee, 0xff}}},
+};
+
+static const Vtx ghost_mario_pants_overalls_shared_dl_vertex_group5[] = {
+    {{{   -71,     54,    -29}, 0, {     0,      0}, {0x8f, 0x2a, 0xda, 0xff}}},
+    {{{   -43,     83,    -24}, 0, {     0,      0}, {0xcc, 0x72, 0xee, 0xff}}},
+    {{{   -40,     72,    -54}, 0, {     0,      0}, {0xc5, 0x5f, 0xc6, 0xff}}},
+    {{{   -59,    -28,    -37}, 0, {     0,      0}, {0x90, 0xd5, 0xd9, 0xff}}},
+    {{{   -59,    -28,     38}, 0, {     0,      0}, {0x8d, 0xd8, 0x21, 0xff}}},
+    {{{   -28,     63,    -74}, 0, {     0,      0}, {0xd1, 0x4f, 0xaa, 0xff}}},
+    {{{   -43,     83,     25}, 0, {     0,      0}, {0xbc, 0x69, 0x11, 0xff}}},
+    {{{   -71,     54,     30}, 0, {     0,      0}, {0x94, 0x2a, 0x31, 0xff}}},
+    {{{   -30,    -66,      0}, 0, {     0,      0}, {0xb8, 0x98, 0x00, 0xff}}},
+    {{{   -27,     26,     91}, 0, {     0,      0}, {0xc8, 0x0e, 0x70, 0xff}}},
+    {{{   -28,     63,     75}, 0, {     0,      0}, {0xd0, 0x50, 0x55, 0xff}}},
+    {{{   -40,     72,     55}, 0, {     0,      0}, {0xc4, 0x5e, 0x3a, 0xff}}},
+    {{{    13,     33,     91}, 0, {     0,      0}, {0x12, 0x20, 0x79, 0xff}}},
+    {{{    -4,     58,     84}, 0, {     0,      0}, {0xfb, 0x43, 0x6b, 0xff}}},
+};
+
+static const Vtx ghost_mario_pants_overalls_shared_dl_vertex_group6[] = {
+    {{{   -27,     26,    -89}, 0, {     0,      0}, {0xc7, 0x0f, 0x90, 0xff}}},
+    {{{    -4,     58,    -82}, 0, {     0,      0}, {0xf9, 0x42, 0x94, 0xff}}},
+    {{{    12,     33,    -90}, 0, {     0,      0}, {0x11, 0x20, 0x87, 0xff}}},
+    {{{   -28,     63,    -74}, 0, {     0,      0}, {0xd1, 0x4f, 0xaa, 0xff}}},
+    {{{    80,     14,    -61}, 0, {     0,      0}, {0x60, 0x28, 0xb8, 0xff}}},
+    {{{   100,      1,    -23}, 0, {     0,      0}, {0x7c, 0x09, 0xea, 0xff}}},
+    {{{    84,    -29,    -62}, 0, {     0,      0}, {0x5f, 0xde, 0xb4, 0xff}}},
+    {{{    93,    -36,    -25}, 0, {     0,      0}, {0x66, 0xb7, 0xf0, 0xff}}},
+    {{{    66,    -52,    -50}, 0, {     0,      0}, {0x3b, 0x9a, 0xd3, 0xff}}},
+    {{{    54,    -63,      0}, 0, {     0,      0}, {0x30, 0x8b, 0x00, 0xff}}},
+    {{{    66,    -52,     51}, 0, {     0,      0}, {0x3b, 0x9a, 0x2d, 0xff}}},
+    {{{    93,    -36,     26}, 0, {     0,      0}, {0x6b, 0xbf, 0x0d, 0xff}}},
+    {{{    84,    -29,     63}, 0, {     0,      0}, {0x5f, 0xde, 0x4c, 0xff}}},
+    {{{   100,      1,     24}, 0, {     0,      0}, {0x7a, 0x17, 0x16, 0xff}}},
+    {{{    80,     14,     62}, 0, {     0,      0}, {0x60, 0x28, 0x47, 0xff}}},
+};
+
+static const Vtx ghost_mario_pants_overalls_shared_dl_vertex_group7[] = {
+    {{{    17,     66,    -75}, 0, {     0,      0}, {0x17, 0x58, 0xa8, 0xff}}},
+    {{{    -4,     58,    -82}, 0, {     0,      0}, {0xf9, 0x42, 0x94, 0xff}}},
+    {{{     3,     77,    -61}, 0, {     0,      0}, {0x03, 0x6a, 0xbb, 0xff}}},
+    {{{   -28,     63,    -74}, 0, {     0,      0}, {0xd1, 0x4f, 0xaa, 0xff}}},
+    {{{    32,     62,     74}, 0, {     0,      0}, {0x29, 0x53, 0x56, 0xff}}},
+    {{{    17,     66,     76}, 0, {     0,      0}, {0x19, 0x58, 0x57, 0xff}}},
+    {{{    13,     33,     91}, 0, {     0,      0}, {0x12, 0x20, 0x79, 0xff}}},
+    {{{   -28,     63,     75}, 0, {     0,      0}, {0xd0, 0x50, 0x55, 0xff}}},
+    {{{    -4,     58,     84}, 0, {     0,      0}, {0xfb, 0x43, 0x6b, 0xff}}},
+    {{{     3,     77,     62}, 0, {     0,      0}, {0x04, 0x6a, 0x44, 0xff}}},
+    {{{   -15,     88,     35}, 0, {     0,      0}, {0xec, 0x7a, 0x1c, 0xff}}},
+    {{{    12,     33,    -90}, 0, {     0,      0}, {0x11, 0x20, 0x87, 0xff}}},
+    {{{    32,     62,    -73}, 0, {     0,      0}, {0x29, 0x52, 0xa9, 0xff}}},
+    {{{    43,     51,    -74}, 0, {     0,      0}, {0x3c, 0x32, 0x9d, 0xff}}},
+    {{{    44,     51,     75}, 0, {     0,      0}, {0x3c, 0x34, 0x62, 0xff}}},
+};
+
+static const Gfx ghost_mario_torso_shared_dl[] = {
+    gsSPVertex(ghost_mario_gold_button_dl_vertex, 14, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 2, 3, 0, 0x0),
+    gsSP2Triangles(1, 4, 2, 0x0, 5, 6, 2, 0x0),
+    gsSP2Triangles(4, 5, 2, 0x0, 7, 8, 9, 0x0),
+    gsSP2Triangles(10, 7, 9, 0x0, 9, 11, 12, 0x0),
+    gsSP2Triangles(12, 13, 9, 0x0, 13, 10, 9, 0x0),
+    gsSPVertex(ghost_mario_pants_overalls_shared_dl_vertex_group1, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 0, 3, 1, 0x0),
+    gsSP2Triangles(4, 1, 5, 0x0, 1, 3, 5, 0x0),
+    gsSP2Triangles(4, 5, 6, 0x0, 5, 7, 6, 0x0),
+    gsSP2Triangles(7, 5, 8, 0x0, 9, 6, 7, 0x0),
+    gsSP2Triangles(7, 8, 10, 0x0, 10, 11, 7, 0x0),
+    gsSP2Triangles(9, 7, 11, 0x0, 12, 6, 13, 0x0),
+    gsSP2Triangles(9, 13, 6, 0x0, 6, 12, 14, 0x0),
+    gsSPVertex(ghost_mario_pants_overalls_shared_dl_vertex_group2, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(6, 7, 8, 0x0, 9, 10, 7, 0x0),
+    gsSP2Triangles(7, 10, 11, 0x0, 11, 8, 7, 0x0),
+    gsSP2Triangles(12, 8, 11, 0x0, 13, 0, 2, 0x0),
+    gsSP2Triangles(2, 1, 14, 0x0, 2, 15, 13, 0x0),
+    gsSPVertex(ghost_mario_pants_overalls_shared_dl_vertex_group3, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(3, 6, 7, 0x0, 3, 8, 6, 0x0),
+    gsSP2Triangles(5, 9, 3, 0x0, 8, 3, 9, 0x0),
+    gsSP2Triangles(6, 8, 10, 0x0, 11, 10, 8, 0x0),
+    gsSP2Triangles(9, 11, 8, 0x0, 6, 12, 7, 0x0),
+    gsSP2Triangles(12, 6, 10, 0x0, 7, 12, 13, 0x0),
+    gsSP2Triangles(14, 5, 15, 0x0, 14, 9, 5, 0x0),
+    gsSPVertex(ghost_mario_pants_overalls_shared_dl_vertex_group4, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 2, 1, 3, 0x0),
+    gsSP2Triangles(1, 4, 3, 0x0, 5, 4, 6, 0x0),
+    gsSP2Triangles(4, 5, 3, 0x0, 2, 3, 7, 0x0),
+    gsSP2Triangles(7, 3, 5, 0x0, 8, 2, 7, 0x0),
+    gsSP2Triangles(2, 8, 0, 0x0, 9, 10, 11, 0x0),
+    gsSP2Triangles(12, 11, 10, 0x0, 11, 7, 13, 0x0),
+    gsSP1Triangle(14, 15, 11, 0x0),
+    gsSPVertex(ghost_mario_pants_overalls_shared_dl_vertex_group5, 14, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 0, 3, 4, 0x0),
+    gsSP2Triangles(2, 5, 0, 0x0, 6, 0, 7, 0x0),
+    gsSP2Triangles(4, 3, 8, 0x0, 9, 7, 4, 0x0),
+    gsSP2Triangles(7, 10, 11, 0x0, 11, 6, 7, 0x0),
+    gsSP2Triangles(9, 12, 13, 0x0, 10, 9, 13, 0x0),
+    gsSP1Triangle(7, 9, 10, 0x0),
+    gsSPVertex(ghost_mario_pants_overalls_shared_dl_vertex_group6, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 0, 3, 1, 0x0),
+    gsSP2Triangles(4, 5, 6, 0x0, 5, 7, 6, 0x0),
+    gsSP2Triangles(6, 7, 8, 0x0, 9, 8, 7, 0x0),
+    gsSP2Triangles(10, 11, 12, 0x0, 12, 11, 13, 0x0),
+    gsSP2Triangles(14, 12, 13, 0x0, 11, 10, 9, 0x0),
+    gsSPVertex(ghost_mario_pants_overalls_shared_dl_vertex_group7, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 2, 1, 0x0),
+    gsSP2Triangles(4, 5, 6, 0x0, 7, 8, 9, 0x0),
+    gsSP2Triangles(10, 7, 9, 0x0, 9, 8, 5, 0x0),
+    gsSP2Triangles(5, 8, 6, 0x0, 11, 1, 0, 0x0),
+    gsSP2Triangles(11, 12, 13, 0x0, 6, 14, 4, 0x0),
+    gsSP1Triangle(11, 0, 12, 0x0),
+    gsSPVertex(ghost_mario_tshirt_shared_dl_vertex_group1, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 0, 2, 3, 0x0),
+    gsSP2Triangles(4, 3, 2, 0x0, 4, 5, 3, 0x0),
+    gsSP2Triangles(6, 7, 8, 0x0, 6, 9, 7, 0x0),
+    gsSP2Triangles(6, 8, 10, 0x0, 11, 8, 12, 0x0),
+    gsSP2Triangles(12, 8, 7, 0x0, 8, 11, 10, 0x0),
+    gsSP1Triangle(13, 14, 15, 0x0),
+    gsSPVertex(ghost_mario_tshirt_shared_dl_vertex_group2, 14, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 1, 3, 2, 0x0),
+    gsSP2Triangles(3, 1, 4, 0x0, 4, 1, 5, 0x0),
+    gsSP2Triangles(6, 2, 3, 0x0, 7, 8, 9, 0x0),
+    gsSP2Triangles(7, 9, 10, 0x0, 11, 10, 9, 0x0),
+    gsSP2Triangles(12, 3, 4, 0x0, 13, 3, 12, 0x0),
+    gsSP1Triangle(6, 3, 13, 0x0),
+    gsSPVertex(ghost_mario_tshirt_shared_dl_vertex_group3, 5, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 1, 0, 0x0),
+    gsSP1Triangle(1, 4, 2, 0x0),
+    gsSPEndDisplayList(),
+};
+
+//
+// Head
+//
+
+static const Vtx ghost_mario_m_logo_dl_vertex[] = {
+    {{{   195,     93,     32}, 0, {   744,    732}, {0x51, 0x54, 0x30, 0xff}}},
+    {{{   153,     33,     95}, 0, {  1250,   1066}, {0x04, 0x46, 0x69, 0xff}}},
+    {{{   252,     62,     70}, 0, {  1032,    152}, {0x39, 0x4a, 0x55, 0xff}}},
+    {{{   272,     85,      0}, 0, {   472,    -16}, {0x5f, 0x54, 0x00, 0xff}}},
+    {{{   252,     62,    -69}, 0, {   -78,    158}, {0x39, 0x4a, 0xab, 0xff}}},
+    {{{   195,     93,    -31}, 0, {   232,    736}, {0x51, 0x54, 0xcf, 0xff}}},
+    {{{   153,     33,    -94}, 0, {  -258,   1076}, {0x03, 0x46, 0x97, 0xff}}},
+};
+
+static const Vtx ghost_mario_eyes_cap_on_dl_vertex[] = {
+    {{{   145,    101,      0}, 0, {   480,    446}, {0x13, 0x7d, 0x00, 0xff}}},
+    {{{   108,    105,      0}, 0, {   488,    854}, {0x69, 0x46, 0x00, 0xff}}},
+    {{{    97,    103,     25}, 0, {   724,    958}, {0x40, 0x5a, 0x3d, 0xff}}},
+    {{{    97,    103,    -24}, 0, {   256,    970}, {0x40, 0x5a, 0xc3, 0xff}}},
+    {{{   175,     91,    -38}, 0, {   106,    130}, {0xc6, 0x6d, 0xe7, 0xff}}},
+    {{{   144,     83,    -66}, 0, {  -146,    460}, {0x19, 0x5b, 0xad, 0xff}}},
+    {{{   104,     87,    -69}, 0, {  -160,    898}, {0x30, 0x5c, 0xb7, 0xff}}},
+    {{{   175,     91,     39}, 0, {   842,    112}, {0xc6, 0x6d, 0x19, 0xff}}},
+    {{{   153,     33,    -94}, 0, {  -404,    342}, {0x03, 0x46, 0x97, 0xff}}},
+    {{{   104,     87,     70}, 0, {  1138,    864}, {0x30, 0x5c, 0x49, 0xff}}},
+    {{{   144,     83,     67}, 0, {  1108,    428}, {0x19, 0x5b, 0x53, 0xff}}},
+    {{{   153,     33,     95}, 0, {  1362,    296}, {0x04, 0x46, 0x69, 0xff}}},
+};
+
+static const Vtx ghost_mario_hair_sideburn_cap_on_dl_vertex[] = {
+    {{{   120,    -12,   -109}, 0, {   916,    184}, {0xed, 0x24, 0x88, 0xff}}},
+    {{{    96,     49,    -93}, 0, {   -70,    700}, {0x11, 0x27, 0x89, 0xff}}},
+    {{{   153,     33,    -94}, 0, {    90,    -58}, {0x03, 0x46, 0x97, 0xff}}},
+    {{{    85,    -23,   -110}, 0, {  1150,    582}, {0x06, 0x59, 0xa6, 0xff}}},
+    {{{    42,      0,   -102}, 0, {   842,   1210}, {0xc3, 0x05, 0x92, 0xff}}},
+    {{{    44,     44,    -96}, 0, {   118,   1334}, {0xda, 0x21, 0x8c, 0xff}}},
+    {{{    96,     49,     94}, 0, {   -74,    726}, {0x10, 0x28, 0x77, 0xff}}},
+    {{{    44,     44,     97}, 0, {   196,   1366}, {0xda, 0x21, 0x74, 0xff}}},
+    {{{    42,      0,    103}, 0, {   968,   1192}, {0xc3, 0x05, 0x6e, 0xff}}},
+    {{{    85,    -23,    111}, 0, {  1238,    518}, {0x04, 0x58, 0x5a, 0xff}}},
+    {{{   120,    -11,    111}, 0, {   922,    122}, {0xed, 0x24, 0x78, 0xff}}},
+    {{{   153,     33,     95}, 0, {    22,    -68}, {0x04, 0x46, 0x69, 0xff}}},
+};
+
+static const Vtx ghost_mario_mustache_cap_on_dl_vertex_group1[] = {
+    {{{    77,    108,     34}, 0, {   342,    368}, {0x0e, 0x16, 0x7c, 0xff}}},
+    {{{    92,     88,     84}, 0, {   898,    -18}, {0x23, 0x59, 0x53, 0xff}}},
+    {{{    97,    103,     25}, 0, {   224,    146}, {0x40, 0x5a, 0x3d, 0xff}}},
+    {{{    48,     94,     76}, 0, {   888,    564}, {0xd7, 0x60, 0x47, 0xff}}},
+    {{{    52,    111,     31}, 0, {   354,    690}, {0xa8, 0x33, 0x4b, 0xff}}},
+    {{{    27,    100,     30}, 0, {   442,    982}, {0xb1, 0x60, 0x16, 0xff}}},
+    {{{    41,    109,      0}, 0, {    70,    924}, {0x95, 0x44, 0x00, 0xff}}},
+    {{{    44,     44,     97}, 0, {  1296,    438}, {0xda, 0x21, 0x74, 0xff}}},
+    {{{     3,     54,     52}, 0, {   892,   1090}, {0x95, 0x1d, 0x3c, 0xff}}},
+    {{{    52,    111,    -30}, 0, {   340,    684}, {0xa8, 0x32, 0xb5, 0xff}}},
+    {{{    48,     94,    -75}, 0, {   856,    608}, {0xd7, 0x60, 0xb9, 0xff}}},
+    {{{    27,    100,    -29}, 0, {   394,    998}, {0xb1, 0x60, 0xea, 0xff}}},
+    {{{     3,     54,    -51}, 0, {   806,   1162}, {0x95, 0x1d, 0xc4, 0xff}}},
+    {{{    44,     44,    -96}, 0, {  1250,    518}, {0xda, 0x21, 0x8c, 0xff}}},
+    {{{    77,    108,    -33}, 0, {   362,    344}, {0x0e, 0x16, 0x84, 0xff}}},
+    {{{    41,    109,      0}, 0, {    50,    900}, {0x95, 0x44, 0x00, 0xff}}},
+};
+
+static const Vtx ghost_mario_mustache_cap_on_dl_vertex_group2[] = {
+    {{{    48,     94,    -75}, 0, {   856,    608}, {0xd7, 0x60, 0xb9, 0xff}}},
+    {{{    77,    108,    -33}, 0, {   362,    344}, {0x0e, 0x16, 0x84, 0xff}}},
+    {{{    92,     88,    -83}, 0, {   922,     -4}, {0x23, 0x59, 0xad, 0xff}}},
+    {{{    97,    103,    -24}, 0, {   274,    100}, {0x40, 0x5a, 0xc3, 0xff}}},
+    {{{    44,     44,    -96}, 0, {  1250,    518}, {0xda, 0x21, 0x8c, 0xff}}},
+};
+
+static const Vtx ghost_mario_face_cap_dl_vertex_group1[] = {
+    {{{   164,    -89,    -74}, 0, {     0,      0}, {0x51, 0xa9, 0xd5, 0xff}}},
+    {{{   122,   -139,    -48}, 0, {     0,      0}, {0x28, 0x94, 0xcd, 0xff}}},
+    {{{   131,    -56,   -123}, 0, {     0,      0}, {0xde, 0xd4, 0x8f, 0xff}}},
+    {{{   187,     -6,   -133}, 0, {     0,      0}, {0x1e, 0x04, 0x85, 0xff}}},
+    {{{   120,    -12,   -109}, 0, {     0,      0}, {0xed, 0x24, 0x88, 0xff}}},
+    {{{    91,    -54,    -85}, 0, {     0,      0}, {0xd9, 0xb0, 0xa7, 0xff}}},
+    {{{    77,   -138,    -50}, 0, {     0,      0}, {0xbc, 0x9e, 0xd8, 0xff}}},
+    {{{    64,   -103,    -51}, 0, {     0,      0}, {0xde, 0x94, 0xc7, 0xff}}},
+    {{{   122,   -139,     49}, 0, {     0,      0}, {0x2d, 0x8f, 0x22, 0xff}}},
+    {{{    77,   -138,     51}, 0, {     0,      0}, {0xc1, 0xa4, 0x3c, 0xff}}},
+    {{{    64,   -103,     52}, 0, {     0,      0}, {0xc9, 0x9a, 0x31, 0xff}}},
+    {{{   131,    -56,    124}, 0, {     0,      0}, {0xdf, 0xd3, 0x71, 0xff}}},
+    {{{   164,    -89,     75}, 0, {     0,      0}, {0x4e, 0xa6, 0x2b, 0xff}}},
+    {{{    91,    -54,     86}, 0, {     0,      0}, {0xd9, 0xaf, 0x59, 0xff}}},
+    {{{   187,     -6,    134}, 0, {     0,      0}, {0x1f, 0x04, 0x7a, 0xff}}},
+    {{{   120,    -11,    111}, 0, {     0,      0}, {0xed, 0x24, 0x78, 0xff}}},
+};
+
+static const Vtx ghost_mario_face_cap_dl_vertex_group2[] = {
+    {{{   153,     33,    -94}, 0, {     0,      0}, {0x03, 0x46, 0x97, 0xff}}},
+    {{{   187,     -6,   -133}, 0, {     0,      0}, {0x1e, 0x04, 0x85, 0xff}}},
+    {{{   120,    -12,   -109}, 0, {     0,      0}, {0xed, 0x24, 0x88, 0xff}}},
+    {{{   175,     91,    -38}, 0, {     0,      0}, {0xc6, 0x6d, 0xe7, 0xff}}},
+    {{{   173,    132,    -65}, 0, {     0,      0}, {0xda, 0x5a, 0xb0, 0xff}}},
+    {{{   195,     93,    -31}, 0, {     0,      0}, {0x51, 0x54, 0xcf, 0xff}}},
+    {{{   252,     62,    -69}, 0, {     0,      0}, {0x39, 0x4a, 0xab, 0xff}}},
+    {{{   164,    -89,    -74}, 0, {     0,      0}, {0x51, 0xa9, 0xd5, 0xff}}},
+    {{{   271,      0,    -41}, 0, {     0,      0}, {0x6e, 0xcf, 0xdc, 0xff}}},
+    {{{   187,     -6,    134}, 0, {     0,      0}, {0x1f, 0x04, 0x7a, 0xff}}},
+    {{{   153,     33,     95}, 0, {     0,      0}, {0x04, 0x46, 0x69, 0xff}}},
+    {{{   120,    -11,    111}, 0, {     0,      0}, {0xed, 0x24, 0x78, 0xff}}},
+    {{{   252,     62,     70}, 0, {     0,      0}, {0x39, 0x4a, 0x55, 0xff}}},
+    {{{   271,      0,     42}, 0, {     0,      0}, {0x71, 0xdc, 0x2b, 0xff}}},
+    {{{   164,    -89,     75}, 0, {     0,      0}, {0x4e, 0xa6, 0x2b, 0xff}}},
+};
+
+static const Vtx ghost_mario_face_cap_dl_vertex_group3[] = {
+    {{{   195,     93,     32}, 0, {     0,      0}, {0x51, 0x54, 0x30, 0xff}}},
+    {{{   173,    132,     66}, 0, {     0,      0}, {0xda, 0x5a, 0x50, 0xff}}},
+    {{{   153,     33,     95}, 0, {     0,      0}, {0x04, 0x46, 0x69, 0xff}}},
+    {{{   175,     91,     39}, 0, {     0,      0}, {0xc6, 0x6d, 0x19, 0xff}}},
+    {{{   164,    -89,    -74}, 0, {     0,      0}, {0x51, 0xa9, 0xd5, 0xff}}},
+    {{{   271,      0,    -41}, 0, {     0,      0}, {0x6e, 0xcf, 0xdc, 0xff}}},
+    {{{   164,    -89,     75}, 0, {     0,      0}, {0x4e, 0xa6, 0x2b, 0xff}}},
+    {{{   271,      0,     42}, 0, {     0,      0}, {0x71, 0xdc, 0x2b, 0xff}}},
+    {{{   252,     62,    -69}, 0, {     0,      0}, {0x39, 0x4a, 0xab, 0xff}}},
+    {{{   272,     85,      0}, 0, {     0,      0}, {0x5f, 0x54, 0x00, 0xff}}},
+    {{{   182,    155,      0}, 0, {     0,      0}, {0xed, 0x7d, 0x00, 0xff}}},
+    {{{   195,     93,    -31}, 0, {     0,      0}, {0x51, 0x54, 0xcf, 0xff}}},
+    {{{   175,     91,    -38}, 0, {     0,      0}, {0xc6, 0x6d, 0xe7, 0xff}}},
+    {{{   173,    132,    -65}, 0, {     0,      0}, {0xda, 0x5a, 0xb0, 0xff}}},
+    {{{   252,     62,     70}, 0, {     0,      0}, {0x39, 0x4a, 0x55, 0xff}}},
+};
+
+static const Vtx ghost_mario_face_part_cap_on_dl_vertex_group1[] = {
+    {{{    41,    109,      0}, 0, {     0,      0}, {0x95, 0x44, 0x00, 0xff}}},
+    {{{    27,    100,    -29}, 0, {     0,      0}, {0xb1, 0x60, 0xea, 0xff}}},
+    {{{    27,    100,     30}, 0, {     0,      0}, {0xb1, 0x60, 0x16, 0xff}}},
+    {{{    -7,     62,      0}, 0, {     0,      0}, {0x85, 0x1d, 0x00, 0xff}}},
+    {{{     3,     54,     52}, 0, {     0,      0}, {0x95, 0x1d, 0x3c, 0xff}}},
+    {{{     3,     54,    -51}, 0, {     0,      0}, {0x95, 0x1d, 0xc4, 0xff}}},
+    {{{    17,    -52,    -46}, 0, {     0,      0}, {0x89, 0xf8, 0xd7, 0xff}}},
+    {{{    17,    -52,     47}, 0, {     0,      0}, {0x89, 0xf8, 0x29, 0xff}}},
+    {{{    42,      0,    103}, 0, {     0,      0}, {0xc3, 0x05, 0x6e, 0xff}}},
+    {{{    44,     44,     97}, 0, {     0,      0}, {0xda, 0x21, 0x74, 0xff}}},
+    {{{    42,      0,   -102}, 0, {     0,      0}, {0xc3, 0x05, 0x92, 0xff}}},
+    {{{    44,     44,    -96}, 0, {     0,      0}, {0xda, 0x21, 0x8c, 0xff}}},
+    {{{    64,    -25,    135}, 0, {     0,      0}, {0xcc, 0xe5, 0x70, 0xff}}},
+    {{{    91,    -54,     86}, 0, {     0,      0}, {0xd9, 0xaf, 0x59, 0xff}}},
+    {{{   102,    -33,    135}, 0, {     0,      0}, {0x30, 0x18, 0x72, 0xff}}},
+};
+
+static const Vtx ghost_mario_face_part_cap_on_dl_vertex_group2[] = {
+    {{{   102,    -33,   -134}, 0, {     0,      0}, {0x32, 0x19, 0x8f, 0xff}}},
+    {{{   120,    -12,   -109}, 0, {     0,      0}, {0xed, 0x24, 0x88, 0xff}}},
+    {{{    91,    -54,    -85}, 0, {     0,      0}, {0xd9, 0xb0, 0xa7, 0xff}}},
+    {{{    64,    -25,    135}, 0, {     0,      0}, {0xcc, 0xe5, 0x70, 0xff}}},
+    {{{    56,    -45,     77}, 0, {     0,      0}, {0xe3, 0xca, 0x6e, 0xff}}},
+    {{{    91,    -54,     86}, 0, {     0,      0}, {0xd9, 0xaf, 0x59, 0xff}}},
+    {{{   120,    -11,    111}, 0, {     0,      0}, {0xed, 0x24, 0x78, 0xff}}},
+    {{{    85,    -23,    111}, 0, {     0,      0}, {0x04, 0x58, 0x5a, 0xff}}},
+    {{{   102,    -33,    135}, 0, {     0,      0}, {0x30, 0x18, 0x72, 0xff}}},
+    {{{    42,      0,    103}, 0, {     0,      0}, {0xc3, 0x05, 0x6e, 0xff}}},
+    {{{    85,    -23,   -110}, 0, {     0,      0}, {0x06, 0x59, 0xa6, 0xff}}},
+    {{{    64,    -25,   -134}, 0, {     0,      0}, {0xcc, 0xe5, 0x90, 0xff}}},
+    {{{    42,      0,   -102}, 0, {     0,      0}, {0xc3, 0x05, 0x92, 0xff}}},
+    {{{    33,    165,      0}, 0, {     0,      0}, {0x8f, 0x38, 0x09, 0xff}}},
+    {{{    52,    164,    -40}, 0, {     0,      0}, {0xb8, 0x34, 0xa6, 0xff}}},
+    {{{    32,    132,      0}, 0, {     0,      0}, {0x84, 0xe8, 0xf8, 0xff}}},
+};
+
+static const Vtx ghost_mario_face_part_cap_on_dl_vertex_group3[] = {
+    {{{    56,    -45,    -76}, 0, {     0,      0}, {0xe3, 0xca, 0x92, 0xff}}},
+    {{{    64,    -25,   -134}, 0, {     0,      0}, {0xcc, 0xe5, 0x90, 0xff}}},
+    {{{    91,    -54,    -85}, 0, {     0,      0}, {0xd9, 0xb0, 0xa7, 0xff}}},
+    {{{    42,      0,   -102}, 0, {     0,      0}, {0xc3, 0x05, 0x92, 0xff}}},
+    {{{    17,    -52,     47}, 0, {     0,      0}, {0x89, 0xf8, 0x29, 0xff}}},
+    {{{    56,    -45,     77}, 0, {     0,      0}, {0xe3, 0xca, 0x6e, 0xff}}},
+    {{{    42,      0,    103}, 0, {     0,      0}, {0xc3, 0x05, 0x6e, 0xff}}},
+    {{{    17,    -52,    -46}, 0, {     0,      0}, {0x89, 0xf8, 0xd7, 0xff}}},
+    {{{    32,    132,      0}, 0, {     0,      0}, {0x84, 0xe8, 0xf8, 0xff}}},
+    {{{    47,    131,     41}, 0, {     0,      0}, {0xb0, 0xe4, 0x5e, 0xff}}},
+    {{{    33,    165,      0}, 0, {     0,      0}, {0x8f, 0x38, 0x09, 0xff}}},
+    {{{    52,    111,     31}, 0, {     0,      0}, {0xa8, 0x33, 0x4b, 0xff}}},
+    {{{    52,    111,    -30}, 0, {     0,      0}, {0xa8, 0x32, 0xb5, 0xff}}},
+    {{{    41,    109,      0}, 0, {     0,      0}, {0x95, 0x44, 0x00, 0xff}}},
+    {{{    77,    108,     34}, 0, {     0,      0}, {0x0e, 0x16, 0x7c, 0xff}}},
+};
+
+static const Vtx ghost_mario_face_part_cap_on_dl_vertex_group4[] = {
+    {{{    92,     88,     84}, 0, {     0,      0}, {0x23, 0x59, 0x53, 0xff}}},
+    {{{   104,     87,     70}, 0, {     0,      0}, {0x30, 0x5c, 0x49, 0xff}}},
+    {{{    97,    103,     25}, 0, {     0,      0}, {0x40, 0x5a, 0x3d, 0xff}}},
+    {{{   117,    128,      0}, 0, {     0,      0}, {0x7a, 0xe1, 0x06, 0xff}}},
+    {{{   102,    129,     41}, 0, {     0,      0}, {0x45, 0xd6, 0x61, 0xff}}},
+    {{{    77,    108,     34}, 0, {     0,      0}, {0x0e, 0x16, 0x7c, 0xff}}},
+    {{{   108,    105,      0}, 0, {     0,      0}, {0x69, 0x46, 0x00, 0xff}}},
+    {{{    97,    103,    -24}, 0, {     0,      0}, {0x40, 0x5a, 0xc3, 0xff}}},
+    {{{   119,    161,      0}, 0, {     0,      0}, {0x79, 0x23, 0xf6, 0xff}}},
+    {{{   104,    162,     41}, 0, {     0,      0}, {0x52, 0x27, 0x58, 0xff}}},
+    {{{   102,    129,    -40}, 0, {     0,      0}, {0x50, 0xdc, 0xa6, 0xff}}},
+    {{{    75,    130,     46}, 0, {     0,      0}, {0x00, 0xec, 0x7d, 0xff}}},
+    {{{    78,    163,     46}, 0, {     0,      0}, {0x03, 0x55, 0x5d, 0xff}}},
+    {{{   101,    179,      0}, 0, {     0,      0}, {0x27, 0x78, 0x00, 0xff}}},
+    {{{    52,    164,     41}, 0, {     0,      0}, {0xc8, 0x3d, 0x5f, 0xff}}},
+    {{{    47,    131,     41}, 0, {     0,      0}, {0xb0, 0xe4, 0x5e, 0xff}}},
+};
+
+static const Vtx ghost_mario_face_part_cap_on_dl_vertex_group5[] = {
+    {{{    47,    131,     41}, 0, {     0,      0}, {0xb0, 0xe4, 0x5e, 0xff}}},
+    {{{    52,    164,     41}, 0, {     0,      0}, {0xc8, 0x3d, 0x5f, 0xff}}},
+    {{{    33,    165,      0}, 0, {     0,      0}, {0x8f, 0x38, 0x09, 0xff}}},
+    {{{    75,    130,     46}, 0, {     0,      0}, {0x00, 0xec, 0x7d, 0xff}}},
+    {{{    77,    108,     34}, 0, {     0,      0}, {0x0e, 0x16, 0x7c, 0xff}}},
+    {{{    78,    163,     46}, 0, {     0,      0}, {0x03, 0x55, 0x5d, 0xff}}},
+    {{{    60,    181,      0}, 0, {     0,      0}, {0xea, 0x7c, 0x00, 0xff}}},
+    {{{    52,    164,    -40}, 0, {     0,      0}, {0xb8, 0x34, 0xa6, 0xff}}},
+    {{{    96,     49,     94}, 0, {     0,      0}, {0x10, 0x28, 0x77, 0xff}}},
+    {{{   153,     33,     95}, 0, {     0,      0}, {0x04, 0x46, 0x69, 0xff}}},
+    {{{   144,     83,     67}, 0, {     0,      0}, {0x19, 0x5b, 0x53, 0xff}}},
+    {{{   101,    179,      0}, 0, {     0,      0}, {0x27, 0x78, 0x00, 0xff}}},
+    {{{   104,     87,     70}, 0, {     0,      0}, {0x30, 0x5c, 0x49, 0xff}}},
+    {{{    92,     88,     84}, 0, {     0,      0}, {0x23, 0x59, 0x53, 0xff}}},
+    {{{    44,     44,     97}, 0, {     0,      0}, {0xda, 0x21, 0x74, 0xff}}},
+};
+
+static const Vtx ghost_mario_face_part_cap_on_dl_vertex_group6[] = {
+    {{{    17,    -52,    -46}, 0, {     0,      0}, {0x89, 0xf8, 0xd7, 0xff}}},
+    {{{    31,    -84,      0}, 0, {     0,      0}, {0xa0, 0xae, 0x00, 0xff}}},
+    {{{    17,    -52,     47}, 0, {     0,      0}, {0x89, 0xf8, 0x29, 0xff}}},
+    {{{   144,     83,    -66}, 0, {     0,      0}, {0x19, 0x5b, 0xad, 0xff}}},
+    {{{   153,     33,    -94}, 0, {     0,      0}, {0x03, 0x46, 0x97, 0xff}}},
+    {{{    96,     49,    -93}, 0, {     0,      0}, {0x11, 0x27, 0x89, 0xff}}},
+    {{{    92,     88,    -83}, 0, {     0,      0}, {0x23, 0x59, 0xad, 0xff}}},
+    {{{   104,     87,    -69}, 0, {     0,      0}, {0x30, 0x5c, 0xb7, 0xff}}},
+    {{{    44,     44,    -96}, 0, {     0,      0}, {0xda, 0x21, 0x8c, 0xff}}},
+    {{{    75,    130,    -45}, 0, {     0,      0}, {0x00, 0xec, 0x83, 0xff}}},
+    {{{    78,    163,    -45}, 0, {     0,      0}, {0x03, 0x54, 0xa2, 0xff}}},
+    {{{   104,    162,    -40}, 0, {     0,      0}, {0x44, 0x31, 0xa1, 0xff}}},
+    {{{    97,    103,    -24}, 0, {     0,      0}, {0x40, 0x5a, 0xc3, 0xff}}},
+    {{{    52,    164,    -40}, 0, {     0,      0}, {0xb8, 0x34, 0xa6, 0xff}}},
+    {{{    47,    131,    -40}, 0, {     0,      0}, {0xbc, 0xde, 0x9c, 0xff}}},
+    {{{    60,    181,      0}, 0, {     0,      0}, {0xea, 0x7c, 0x00, 0xff}}},
+};
+
+static const Vtx ghost_mario_face_part_cap_on_dl_vertex_group7[] = {
+    {{{    52,    164,    -40}, 0, {     0,      0}, {0xb8, 0x34, 0xa6, 0xff}}},
+    {{{    47,    131,    -40}, 0, {     0,      0}, {0xbc, 0xde, 0x9c, 0xff}}},
+    {{{    32,    132,      0}, 0, {     0,      0}, {0x84, 0xe8, 0xf8, 0xff}}},
+    {{{    77,    108,    -33}, 0, {     0,      0}, {0x0e, 0x16, 0x84, 0xff}}},
+    {{{    52,    111,    -30}, 0, {     0,      0}, {0xa8, 0x32, 0xb5, 0xff}}},
+    {{{    75,    130,    -45}, 0, {     0,      0}, {0x00, 0xec, 0x83, 0xff}}},
+    {{{   104,    162,    -40}, 0, {     0,      0}, {0x44, 0x31, 0xa1, 0xff}}},
+    {{{   102,    129,    -40}, 0, {     0,      0}, {0x50, 0xdc, 0xa6, 0xff}}},
+    {{{   119,    161,      0}, 0, {     0,      0}, {0x79, 0x23, 0xf6, 0xff}}},
+    {{{    97,    103,    -24}, 0, {     0,      0}, {0x40, 0x5a, 0xc3, 0xff}}},
+    {{{    78,    163,    -45}, 0, {     0,      0}, {0x03, 0x54, 0xa2, 0xff}}},
+    {{{    60,    181,      0}, 0, {     0,      0}, {0xea, 0x7c, 0x00, 0xff}}},
+    {{{   101,    179,      0}, 0, {     0,      0}, {0x27, 0x78, 0x00, 0xff}}},
+};
+
+static const Vtx ghost_mario_face_back_hair_cap_on_dl_vertex_group1[] = {
+    {{{    31,    -84,      0}, 0, {     0,      0}, {0xa0, 0xae, 0x00, 0xff}}},
+    {{{    36,   -116,    -35}, 0, {     0,      0}, {0xfb, 0x8e, 0x37, 0xff}}},
+    {{{    64,   -103,    -51}, 0, {     0,      0}, {0xde, 0x94, 0xc7, 0xff}}},
+    {{{    31,    -85,     87}, 0, {     0,      0}, {0xdb, 0xfd, 0x79, 0xff}}},
+    {{{    35,   -120,     68}, 0, {     0,      0}, {0xda, 0x94, 0x35, 0xff}}},
+    {{{    58,   -114,     60}, 0, {     0,      0}, {0x57, 0xb4, 0x32, 0xff}}},
+    {{{    64,   -103,     52}, 0, {     0,      0}, {0xc9, 0x9a, 0x31, 0xff}}},
+    {{{    56,    -45,     77}, 0, {     0,      0}, {0xe3, 0xca, 0x6e, 0xff}}},
+    {{{    36,   -116,     36}, 0, {     0,      0}, {0xfb, 0x8e, 0xc9, 0xff}}},
+    {{{    91,    -54,     86}, 0, {     0,      0}, {0xd9, 0xaf, 0x59, 0xff}}},
+    {{{    17,    -52,     47}, 0, {     0,      0}, {0x89, 0xf8, 0x29, 0xff}}},
+    {{{    35,   -120,    -67}, 0, {     0,      0}, {0xda, 0x94, 0xcb, 0xff}}},
+    {{{    58,   -114,    -59}, 0, {     0,      0}, {0x57, 0xb4, 0xce, 0xff}}},
+    {{{    31,    -85,    -86}, 0, {     0,      0}, {0xdb, 0xfd, 0x87, 0xff}}},
+    {{{    56,    -45,    -76}, 0, {     0,      0}, {0xe3, 0xca, 0x92, 0xff}}},
+    {{{    17,    -52,    -46}, 0, {     0,      0}, {0x89, 0xf8, 0xd7, 0xff}}},
+};
+
+static const Vtx ghost_mario_face_back_hair_cap_on_dl_vertex_group2[] = {
+    {{{    31,    -85,    -86}, 0, {     0,      0}, {0xdb, 0xfd, 0x87, 0xff}}},
+    {{{    35,   -120,    -67}, 0, {     0,      0}, {0xda, 0x94, 0xcb, 0xff}}},
+    {{{     9,    -88,    -58}, 0, {     0,      0}, {0x87, 0xdf, 0xf5, 0xff}}},
+    {{{    17,    -52,    -46}, 0, {     0,      0}, {0x89, 0xf8, 0xd7, 0xff}}},
+    {{{    56,    -45,    -76}, 0, {     0,      0}, {0xe3, 0xca, 0x92, 0xff}}},
+    {{{    91,    -54,    -85}, 0, {     0,      0}, {0xd9, 0xb0, 0xa7, 0xff}}},
+    {{{    64,   -103,    -51}, 0, {     0,      0}, {0xde, 0x94, 0xc7, 0xff}}},
+    {{{    31,    -84,      0}, 0, {     0,      0}, {0xa0, 0xae, 0x00, 0xff}}},
+    {{{    36,   -116,     36}, 0, {     0,      0}, {0xfb, 0x8e, 0xc9, 0xff}}},
+    {{{     9,    -88,     59}, 0, {     0,      0}, {0x87, 0xdf, 0x0b, 0xff}}},
+    {{{    17,    -52,     47}, 0, {     0,      0}, {0x89, 0xf8, 0x29, 0xff}}},
+    {{{    36,   -116,    -35}, 0, {     0,      0}, {0xfb, 0x8e, 0x37, 0xff}}},
+    {{{    35,   -120,     68}, 0, {     0,      0}, {0xda, 0x94, 0x35, 0xff}}},
+    {{{    31,    -85,     87}, 0, {     0,      0}, {0xdb, 0xfd, 0x79, 0xff}}},
+};
+
+static const Gfx ghost_mario_cap_on_shared_dl[] = {
+    gsSPVertex(ghost_mario_m_logo_dl_vertex, 7, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(2, 3, 0, 0x0, 3, 5, 0, 0x0),
+    gsSP1Triangle(4, 6, 5, 0x0),
+    gsSPVertex(ghost_mario_eyes_cap_on_dl_vertex, 12, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(3, 0, 4, 0x0, 6, 3, 5, 0x0),
+    gsSP2Triangles(3, 1, 0, 0x0, 4, 0, 7, 0x0),
+    gsSP2Triangles(5, 4, 8, 0x0, 2, 9, 10, 0x0),
+    gsSP2Triangles(10, 7, 2, 0x0, 11, 7, 10, 0x0),
+    gsSP1Triangle(7, 0, 2, 0x0),
+    gsSPVertex(ghost_mario_hair_sideburn_cap_on_dl_vertex, 12, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 1, 3, 4, 0x0),
+    gsSP2Triangles(4, 5, 1, 0x0, 3, 1, 0, 0x0),
+    gsSP2Triangles(6, 7, 8, 0x0, 8, 9, 6, 0x0),
+    gsSP2Triangles(9, 10, 6, 0x0, 11, 6, 10, 0x0),
+    gsSPVertex(ghost_mario_mustache_cap_on_dl_vertex_group1, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 1, 0, 3, 0x0),
+    gsSP2Triangles(0, 4, 3, 0x0, 5, 3, 4, 0x0),
+    gsSP2Triangles(5, 4, 6, 0x0, 7, 3, 8, 0x0),
+    gsSP2Triangles(8, 3, 5, 0x0, 3, 7, 1, 0x0),
+    gsSP2Triangles(9, 10, 11, 0x0, 12, 10, 13, 0x0),
+    gsSP2Triangles(11, 10, 12, 0x0, 10, 9, 14, 0x0),
+    gsSP1Triangle(15, 9, 11, 0x0),
+    gsSPVertex(ghost_mario_mustache_cap_on_dl_vertex_group2, 5, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 2, 1, 3, 0x0),
+    gsSP1Triangle(2, 4, 0, 0x0),
+    gsSPVertex(ghost_mario_face_part_cap_on_dl_vertex_group1, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 2, 1, 3, 0x0),
+    gsSP2Triangles(3, 4, 2, 0x0, 1, 5, 3, 0x0),
+    gsSP2Triangles(6, 7, 3, 0x0, 7, 4, 3, 0x0),
+    gsSP2Triangles(6, 3, 5, 0x0, 4, 7, 8, 0x0),
+    gsSP2Triangles(9, 4, 8, 0x0, 10, 6, 5, 0x0),
+    gsSP2Triangles(10, 5, 11, 0x0, 12, 13, 14, 0x0),
+    gsSPVertex(ghost_mario_face_part_cap_on_dl_vertex_group2, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(6, 7, 8, 0x0, 5, 6, 8, 0x0),
+    gsSP2Triangles(3, 8, 7, 0x0, 9, 3, 7, 0x0),
+    gsSP2Triangles(3, 9, 4, 0x0, 10, 11, 12, 0x0),
+    gsSP2Triangles(0, 10, 1, 0x0, 10, 0, 11, 0x0),
+    gsSP2Triangles(11, 0, 2, 0x0, 13, 14, 15, 0x0),
+    gsSPVertex(ghost_mario_face_part_cap_on_dl_vertex_group3, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 1, 0, 0x0),
+    gsSP2Triangles(4, 5, 6, 0x0, 3, 0, 7, 0x0),
+    gsSP2Triangles(8, 9, 10, 0x0, 11, 9, 8, 0x0),
+    gsSP2Triangles(12, 13, 8, 0x0, 8, 13, 11, 0x0),
+    gsSP1Triangle(9, 11, 14, 0x0),
+    gsSPVertex(ghost_mario_face_part_cap_on_dl_vertex_group4, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 2, 0x0),
+    gsSP2Triangles(5, 2, 4, 0x0, 2, 6, 3, 0x0),
+    gsSP2Triangles(3, 6, 7, 0x0, 8, 9, 3, 0x0),
+    gsSP2Triangles(9, 4, 3, 0x0, 7, 10, 3, 0x0),
+    gsSP2Triangles(3, 10, 8, 0x0, 11, 4, 9, 0x0),
+    gsSP2Triangles(12, 11, 9, 0x0, 13, 9, 8, 0x0),
+    gsSP2Triangles(9, 13, 12, 0x0, 4, 11, 5, 0x0),
+    gsSP1Triangle(14, 15, 11, 0x0),
+    gsSPVertex(ghost_mario_face_part_cap_on_dl_vertex_group5, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 0, 4, 0x0),
+    gsSP2Triangles(1, 5, 6, 0x0, 1, 3, 5, 0x0),
+    gsSP2Triangles(2, 1, 6, 0x0, 2, 6, 7, 0x0),
+    gsSP2Triangles(8, 9, 10, 0x0, 6, 5, 11, 0x0),
+    gsSP2Triangles(12, 13, 8, 0x0, 10, 12, 8, 0x0),
+    gsSP1Triangle(14, 8, 13, 0x0),
+    gsSPVertex(ghost_mario_face_part_cap_on_dl_vertex_group6, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(5, 6, 7, 0x0, 6, 5, 8, 0x0),
+    gsSP2Triangles(5, 7, 3, 0x0, 9, 10, 11, 0x0),
+    gsSP2Triangles(6, 12, 7, 0x0, 13, 10, 9, 0x0),
+    gsSP2Triangles(14, 13, 9, 0x0, 15, 10, 13, 0x0),
+    gsSPVertex(ghost_mario_face_part_cap_on_dl_vertex_group7, 13, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 1, 0x0),
+    gsSP2Triangles(1, 5, 3, 0x0, 2, 1, 4, 0x0),
+    gsSP2Triangles(5, 6, 7, 0x0, 7, 6, 8, 0x0),
+    gsSP2Triangles(7, 9, 3, 0x0, 5, 7, 3, 0x0),
+    gsSP2Triangles(10, 11, 12, 0x0, 12, 6, 10, 0x0),
+    gsSP1Triangle(12, 8, 6, 0x0),
+    gsSPVertex(ghost_mario_face_cap_dl_vertex_group1, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 2, 4, 0x0),
+    gsSP2Triangles(4, 2, 5, 0x0, 3, 0, 2, 0x0),
+    gsSP2Triangles(2, 1, 6, 0x0, 6, 7, 2, 0x0),
+    gsSP2Triangles(5, 2, 7, 0x0, 6, 1, 8, 0x0),
+    gsSP2Triangles(8, 1, 0, 0x0, 6, 8, 9, 0x0),
+    gsSP2Triangles(10, 7, 6, 0x0, 9, 10, 6, 0x0),
+    gsSP2Triangles(11, 10, 9, 0x0, 9, 8, 11, 0x0),
+    gsSP2Triangles(11, 8, 12, 0x0, 0, 12, 8, 0x0),
+    gsSP2Triangles(13, 10, 11, 0x0, 11, 12, 14, 0x0),
+    gsSP2Triangles(15, 11, 14, 0x0, 13, 11, 15, 0x0),
+    gsSPVertex(ghost_mario_face_cap_dl_vertex_group2, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 0, 0x0),
+    gsSP2Triangles(4, 5, 0, 0x0, 0, 6, 1, 0x0),
+    gsSP2Triangles(7, 1, 8, 0x0, 8, 1, 6, 0x0),
+    gsSP2Triangles(9, 10, 11, 0x0, 9, 12, 10, 0x0),
+    gsSP2Triangles(12, 9, 13, 0x0, 13, 9, 14, 0x0),
+    gsSPVertex(ghost_mario_face_cap_dl_vertex_group3, 15, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 2, 1, 3, 0x0),
+    gsSP2Triangles(4, 5, 6, 0x0, 5, 7, 6, 0x0),
+    gsSP2Triangles(8, 9, 5, 0x0, 0, 10, 1, 0x0),
+    gsSP2Triangles(1, 10, 3, 0x0, 11, 10, 0, 0x0),
+    gsSP2Triangles(12, 3, 10, 0x0, 12, 10, 13, 0x0),
+    gsSP2Triangles(13, 10, 11, 0x0, 5, 9, 7, 0x0),
+    gsSP1Triangle(7, 9, 14, 0x0),
+    gsSPVertex(ghost_mario_face_back_hair_cap_on_dl_vertex_group1, 16, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 3, 4, 5, 0x0),
+    gsSP2Triangles(5, 6, 7, 0x0, 5, 8, 6, 0x0),
+    gsSP2Triangles(5, 4, 8, 0x0, 7, 3, 5, 0x0),
+    gsSP2Triangles(0, 2, 6, 0x0, 6, 9, 7, 0x0),
+    gsSP2Triangles(0, 6, 8, 0x0, 3, 7, 10, 0x0),
+    gsSP2Triangles(1, 11, 12, 0x0, 12, 13, 14, 0x0),
+    gsSP2Triangles(11, 13, 12, 0x0, 1, 12, 2, 0x0),
+    gsSP2Triangles(14, 2, 12, 0x0, 15, 14, 13, 0x0),
+    gsSPVertex(ghost_mario_face_back_hair_cap_on_dl_vertex_group2, 14, 0),
+    gsSP2Triangles(0, 1, 2, 0x0, 0, 2, 3, 0x0),
+    gsSP2Triangles(4, 5, 6, 0x0, 7, 3, 2, 0x0),
+    gsSP2Triangles(7, 8, 9, 0x0, 9, 10, 7, 0x0),
+    gsSP2Triangles(2, 1, 11, 0x0, 2, 11, 7, 0x0),
+    gsSP2Triangles(9, 12, 13, 0x0, 10, 9, 13, 0x0),
+    gsSP1Triangle(8, 12, 9, 0x0),
+    gsSPEndDisplayList(),
+};
+
+//
+// Ghost Mario geo
+//
+
+static const GeoLayout ghost_mario_geo_body[] = {
+    GEO_ANIMATED_PART(LAYER_TRANSPARENT, 0, 0, 0, NULL),
+    GEO_OPEN_NODE(),
+        GEO_ANIMATED_PART(LAYER_TRANSPARENT, 0, 0, 0, ghost_mario_butt),
+        GEO_OPEN_NODE(),
+            GEO_OPEN_NODE(),
+                GEO_ANIMATED_PART(LAYER_TRANSPARENT, 68, 0, 0, ghost_mario_torso_shared_dl),
+                GEO_OPEN_NODE(),
+                    GEO_ANIMATED_PART(LAYER_TRANSPARENT, 87, 0, 0, NULL),
+                    GEO_OPEN_NODE(),
+                        GEO_DISPLAY_LIST(LAYER_TRANSPARENT, ghost_mario_cap_on_shared_dl),
+                    GEO_CLOSE_NODE(),
+                    GEO_ANIMATED_PART(LAYER_TRANSPARENT, 67, -10, 79, NULL),
+                    GEO_OPEN_NODE(),
+                        GEO_ANIMATED_PART(LAYER_TRANSPARENT, 0, 0, 0, ghost_mario_left_arm_shared_dl),
+                        GEO_OPEN_NODE(),
+                            GEO_ANIMATED_PART(LAYER_TRANSPARENT, 65, 0, 0, ghost_mario_left_forearm_shared_dl),
+                            GEO_OPEN_NODE(),
+                                GEO_ANIMATED_PART(LAYER_TRANSPARENT, 60, 0, 0, NULL),
+                                GEO_OPEN_NODE(),
+                                    GEO_DISPLAY_LIST(LAYER_TRANSPARENT, ghost_mario_left_hand_closed_shared_dl),
+                                GEO_CLOSE_NODE(),
+                            GEO_CLOSE_NODE(),
+                        GEO_CLOSE_NODE(),
+                    GEO_CLOSE_NODE(),
+                    GEO_ANIMATED_PART(LAYER_TRANSPARENT, 68, -10, -79, NULL),
+                    GEO_OPEN_NODE(),
+                        GEO_ANIMATED_PART(LAYER_TRANSPARENT, 0, 0, 0, ghost_mario_right_arm_shared_dl),
+                        GEO_OPEN_NODE(),
+                            GEO_ANIMATED_PART(LAYER_TRANSPARENT, 65, 0, 0, ghost_mario_right_forearm_shared_dl),
+                            GEO_OPEN_NODE(),
+                                GEO_ANIMATED_PART(LAYER_TRANSPARENT, 60, 0, 0, NULL),
+                                GEO_OPEN_NODE(),
+                                    GEO_DISPLAY_LIST(LAYER_TRANSPARENT, ghost_mario_right_hand_closed),
+                                GEO_CLOSE_NODE(),
+                            GEO_CLOSE_NODE(),
+                        GEO_CLOSE_NODE(),
+                    GEO_CLOSE_NODE(),
+                GEO_CLOSE_NODE(),
+            GEO_CLOSE_NODE(),
+            GEO_ANIMATED_PART(LAYER_TRANSPARENT, 13, -8, 42, NULL),
+            GEO_OPEN_NODE(),
+                GEO_ANIMATED_PART(LAYER_TRANSPARENT, 0, 0, 0, ghost_mario_left_thigh),
+                GEO_OPEN_NODE(),
+                    GEO_ANIMATED_PART(LAYER_TRANSPARENT, 89, 0, 0, ghost_mario_left_leg_shared_dl),
+                    GEO_OPEN_NODE(),
+                        GEO_ANIMATED_PART(LAYER_TRANSPARENT, 67, 0, 0, ghost_mario_left_foot_shared_dl),
+                    GEO_CLOSE_NODE(),
+                GEO_CLOSE_NODE(),
+            GEO_CLOSE_NODE(),
+            GEO_ANIMATED_PART(LAYER_TRANSPARENT, 13, -8, -42, NULL),
+            GEO_OPEN_NODE(),
+                GEO_ANIMATED_PART(LAYER_TRANSPARENT, 0, 0, 0, ghost_mario_right_thigh_shared_dl),
+                GEO_OPEN_NODE(),
+                    GEO_ANIMATED_PART(LAYER_TRANSPARENT, 89, 0, 0, ghost_mario_right_leg_shared_dl),
+                    GEO_OPEN_NODE(),
+                        GEO_ANIMATED_PART(LAYER_TRANSPARENT, 67, 0, 0, NULL),
+                        GEO_OPEN_NODE(),
+                            GEO_OPEN_NODE(),
+                                GEO_DISPLAY_LIST(LAYER_TRANSPARENT, ghost_mario_right_foot),
+                            GEO_CLOSE_NODE(),
+                        GEO_CLOSE_NODE(),
+                    GEO_CLOSE_NODE(),
+                GEO_CLOSE_NODE(),
+            GEO_CLOSE_NODE(),
+        GEO_CLOSE_NODE(),
+    GEO_CLOSE_NODE(),
+    GEO_RETURN(),
+};
+
+static const GeoLayout ghost_mario_blue_geo[] = {
+    GEO_SHADOW(SHADOW_CIRCLE_PLAYER, 0xB4, 0),
+    GEO_OPEN_NODE(),
+        GEO_SCALE(0x00, 16384),
+        GEO_OPEN_NODE(),
+            GEO_ASM(10, geo_update_layer_transparency),
+            GEO_OPEN_NODE(),
+                GEO_NODE_START(),
+                GEO_OPEN_NODE(),
+                    GEO_RENDER_RANGE(-2048, 32767),
+                    GEO_OPEN_NODE(),
+                        GEO_DISPLAY_LIST(LAYER_TRANSPARENT, ghost_mario_blue_light_dl),
+                        GEO_OPEN_NODE(),
+                            GEO_BRANCH(1, ghost_mario_geo_body),
+                        GEO_CLOSE_NODE(),
+                    GEO_CLOSE_NODE(),
+                GEO_CLOSE_NODE(),
+            GEO_CLOSE_NODE(),
+        GEO_CLOSE_NODE(),
+    GEO_CLOSE_NODE(),
+    GEO_END(),
+};
+
+static const GeoLayout ghost_mario_red_geo[] = {
+    GEO_SHADOW(SHADOW_CIRCLE_PLAYER, 0xB4, 0),
+    GEO_OPEN_NODE(),
+        GEO_SCALE(0x00, 16384),
+        GEO_OPEN_NODE(),
+            GEO_ASM(10, geo_update_layer_transparency),
+            GEO_OPEN_NODE(),
+                GEO_NODE_START(),
+                GEO_OPEN_NODE(),
+                    GEO_RENDER_RANGE(-2048, 32767),
+                    GEO_OPEN_NODE(),
+                        GEO_DISPLAY_LIST(LAYER_TRANSPARENT, ghost_mario_red_light_dl),
+                        GEO_OPEN_NODE(),
+                            GEO_BRANCH(1, ghost_mario_geo_body),
+                        GEO_CLOSE_NODE(),
+                    GEO_CLOSE_NODE(),
+                GEO_CLOSE_NODE(),
+            GEO_CLOSE_NODE(),
+        GEO_CLOSE_NODE(),
+    GEO_CLOSE_NODE(),
+    GEO_END(),
+};
+
+static const GeoLayout ghost_mario_green_geo[] = {
+    GEO_SHADOW(SHADOW_CIRCLE_PLAYER, 0xB4, 0),
+    GEO_OPEN_NODE(),
+        GEO_SCALE(0x00, 16384),
+        GEO_OPEN_NODE(),
+            GEO_ASM(10, geo_update_layer_transparency),
+            GEO_OPEN_NODE(),
+                GEO_NODE_START(),
+                GEO_OPEN_NODE(),
+                    GEO_RENDER_RANGE(-2048, 32767),
+                    GEO_OPEN_NODE(),
+                        GEO_DISPLAY_LIST(LAYER_TRANSPARENT, ghost_mario_green_light_dl),
+                        GEO_OPEN_NODE(),
+                            GEO_BRANCH(1, ghost_mario_geo_body),
+                        GEO_CLOSE_NODE(),
+                    GEO_CLOSE_NODE(),
+                GEO_CLOSE_NODE(),
+            GEO_CLOSE_NODE(),
+        GEO_CLOSE_NODE(),
+    GEO_CLOSE_NODE(),
+    GEO_END(),
+};
+
+static const GeoLayout ghost_mario_gold_geo[] = {
+    GEO_SHADOW(SHADOW_CIRCLE_PLAYER, 0xB4, 0),
+    GEO_OPEN_NODE(),
+        GEO_SCALE(0x00, 16384),
+        GEO_OPEN_NODE(),
+            GEO_ASM(10, geo_update_layer_transparency),
+            GEO_OPEN_NODE(),
+                GEO_NODE_START(),
+                GEO_OPEN_NODE(),
+                    GEO_RENDER_RANGE(-2048, 32767),
+                    GEO_OPEN_NODE(),
+                        GEO_DISPLAY_LIST(LAYER_TRANSPARENT, ghost_mario_gold_light_dl),
+                        GEO_OPEN_NODE(),
+                            GEO_BRANCH(1, ghost_mario_geo_body),
+                        GEO_CLOSE_NODE(),
+                    GEO_CLOSE_NODE(),
+                GEO_CLOSE_NODE(),
+            GEO_CLOSE_NODE(),
+        GEO_CLOSE_NODE(),
+    GEO_CLOSE_NODE(),
+    GEO_END(),
+};
+
+
+static const GeoLayout ghost_mario_pink_geo[] = {
+    GEO_SHADOW(SHADOW_CIRCLE_PLAYER, 0xB4, 0),
+    GEO_OPEN_NODE(),
+        GEO_SCALE(0x00, 16384),
+        GEO_OPEN_NODE(),
+            GEO_ASM(10, geo_update_layer_transparency),
+            GEO_OPEN_NODE(),
+                GEO_NODE_START(),
+                GEO_OPEN_NODE(),
+                    GEO_RENDER_RANGE(-2048, 32767),
+                    GEO_OPEN_NODE(),
+                        GEO_DISPLAY_LIST(LAYER_TRANSPARENT, ghost_mario_pink_light_dl),
+                        GEO_OPEN_NODE(),
+                            GEO_BRANCH(1, ghost_mario_geo_body),
+                        GEO_CLOSE_NODE(),
+                    GEO_CLOSE_NODE(),
+                GEO_CLOSE_NODE(),
+            GEO_CLOSE_NODE(),
+        GEO_CLOSE_NODE(),
+    GEO_CLOSE_NODE(),
+    GEO_END(),
+};