diff --git a/include/FileContainerReader.h b/include/FileContainerReader.h
index f439dbd..2515fcf 100644
--- a/include/FileContainerReader.h
+++ b/include/FileContainerReader.h
@@ -7,33 +7,43 @@
 #define DEFAULT_CHUNK_SIZE 2048
 
 /**
- * @brief This class provides functionality to read files from the file container format
- * created by the make-file-container tool.
+ * @brief This class provides functionality to read files from the file
+ * container format created by the make-file-container tool.
  *
  * This format consists of multiple compressed chunks.
  *
- * It is done this way to keep the decompression buffer small (because we can't afford to consume too much IWRAM)
- * but still allow for large file containers and bundling files together. (which you might want to do to improve compression ratios)
- * The chunk size can be configured when creating the file container, and the
- * FileContainerReader will read and decompress chunks on demand when seeking or reading data.
+ * It is done this way to keep the decompression buffer small (because we can't
+ * afford to consume too much IWRAM) but still allow for large file containers
+ * and bundling files together. (which you might want to do to improve
+ * compression ratios) The chunk size can be configured when creating the file
+ * container, and the FileContainerReader will read and decompress chunks on
+ * demand when seeking or reading data.
  */
 class FileContainerReader
 {
-public:
-    FileContainerReader(const u8 **chunkList, u32 chunkCount, u32 chunkSize = DEFAULT_CHUNK_SIZE);
+  public:
+    FileContainerReader(const u8 **chunkList, u32 chunkCount,
+        u32 chunkSize = DEFAULT_CHUNK_SIZE);
     ~FileContainerReader();
 
     /**
-     * @brief This function initializes the FileContainerReader. It should be called before any other function is used.
-     * The reason for this initialization step is to give you control over the moment when the first chunk is decompressed.
-     * This can be useful if you want to perform some setup or checks before the decompression process begins. By calling init() explicitly, you can ensure that the FileContainerReader is ready to handle file reading operations at the appropriate time in your application.
+     * @brief This function initializes the FileContainerReader. It should be
+     * called before any other function is used. The reason for this
+     * initialization step is to give you control over the moment when the first
+     * chunk is decompressed. This can be useful if you want to perform some
+     * setup or checks before the decompression process begins. By calling
+     * init() explicitly, you can ensure that the FileContainerReader is ready
+     * to handle file reading operations at the appropriate time in your
+     * application.
      *
      * Note: because of this, we also only pass the decompression buffer here
      * If the decompression buffer is not large enough to hold the chunks,
-     * the function will return false and the FileContainerReader will not be initialized. In this case, you should provide a larger decompression buffer and call init() again.
+     * the function will return false and the FileContainerReader will not be
+     * initialized. In this case, you should provide a larger decompression
+     * buffer and call init() again.
      *
-     * If it DOES return true, please note that the FileContainerReader will keep using the decompressionBuffer_ until
-     * it gets destroyed.
+     * If it DOES return true, please note that the FileContainerReader will
+     * keep using the decompressionBuffer_ until it gets destroyed.
      */
     bool init(u8 *decompressionBuffer, u32 decompressionBufferSize);
 
@@ -44,10 +54,10 @@ public:
 
     /**
      * @brief IF the file container stores the file names,
-     * this function returns a pointer to the file name of the file at the given index.
-     * Otherwise, it returns nullptr.
+     * this function returns a pointer to the file name of the file at the given
+     * index. Otherwise, it returns nullptr.
      */
-    const char* getFileName(u32 fileIndex);
+    const char *getFileName(u32 fileIndex);
 
     /**
      * @brief This function returns the size of the file at the given index.
@@ -55,26 +65,33 @@ public:
     u32 getFileSize(u32 fileIndex) const;
 
     /**
-     * @brief This function seeks to the beginning of the file at the given index.
+     * @brief This function seeks to the beginning of the file at the given
+     * index.
      */
     void seekToFile(u32 fileIndex);
 
     /**
-     * @brief Read data from the current position in the file container into the provided buffer.
+     * @brief Read data from the current position in the file container into the
+     * provided buffer.
      */
     void read(u8 *buffer, u32 size);
 
     /**
-     * @brief Gives you a direct pointer to the specified file in the decompression buffer. (unsafe!)
+     * @brief Gives you a direct pointer to the specified file in the
+     * decompression buffer. (unsafe!)
      *
-     * This is useful to use data directly from the decompression buffer without having to allocate and
-     * copy another buffer. This is essential in high memory pressure scenarios, such as mystery_gift_builder.
-     * We can't afford to keep multiple linebuffers in memory in addition to the decompression buffer and all the other variables there.
+     * This is useful to use data directly from the decompression buffer without
+     * having to allocate and copy another buffer. This is essential in high
+     * memory pressure scenarios, such as mystery_gift_builder. We can't afford
+     * to keep multiple linebuffers in memory in addition to the decompression
+     * buffer and all the other variables there.
      *
-     * WARNING: this is only safe if you know the file is stored fully in the current chunk, because files may span multiple chunks.
-     * Or if the container only consists of a single chunk.
-     * Pointers acquired this way will become stale whenever a seek is done to a position in a different chunk, 
-     * as that will cause the decompression buffer to be overwritten with the new chunk's data.
+     * WARNING: this is only safe if you know the file is stored fully in the
+     * current chunk, because files may span multiple chunks. Or if the
+     * container only consists of a single chunk. Pointers acquired this way
+     * will become stale whenever a seek is done to a position in a different
+     * chunk, as that will cause the decompression buffer to be overwritten with
+     * the new chunk's data.
      */
     u8 *getPointerToFileInDecompressionBuffer(u32 fileIndex);
 
@@ -85,25 +102,28 @@ public:
     void seekAndRead(u32 fileIndex, u8 *buffer, u32 size);
 
     /**
-     * @brief Even shorter variant of seekAndRead that reads the entire file at once.
-     * But it assumes you have provided a large enough buffer to hold the entire file.
+     * @brief Even shorter variant of seekAndRead that reads the entire file at
+     * once. But it assumes you have provided a large enough buffer to hold the
+     * entire file.
      *
      * (useful for text table reading)
      */
     void readFile(u32 fileIndex, u8 *buffer);
-protected:
-private:
+
+  protected:
+  private:
     /**
-     * @brief This function calculates the file offset for the specified file index
-     * The file offset is determined by reading the file index (which contains the file entry sizes)
-     * and summing up the sizes of all previous entries + header size + optional name table size
-     * (if names are stored).
+     * @brief This function calculates the file offset for the specified file
+     * index The file offset is determined by reading the file index (which
+     * contains the file entry sizes) and summing up the sizes of all previous
+     * entries + header size + optional name table size (if names are stored).
      */
     u32 getFileOffset(u32 fileIndex) const;
 
     /**
-     * @brief This function seeks to the specified absolute offset in the file container data.
-     * Absolute offset refers to an offset across the file container chunks.
+     * @brief This function seeks to the specified absolute offset in the file
+     * container data. Absolute offset refers to an offset across the file
+     * container chunks.
      */
     void seek(u32 offset);
 
diff --git a/include/Gen3CartridgeSaveReader.h b/include/Gen3CartridgeSaveReader.h
index dc10807..8c198a1 100644
--- a/include/Gen3CartridgeSaveReader.h
+++ b/include/Gen3CartridgeSaveReader.h
@@ -7,29 +7,30 @@
 /**
  * @brief This class is an adapter implementation for Gen3SaveManager,
  * which is used by libPCCS' Gen3SaveManager class.
- * 
- * This specific implementation will allow read/write operations to the cartridge save.
- * That way, actual data origin is abstracted away from libPCCS' Gen3SaveManager.
- * 
- * Note: to avoid runtime bounds-checking overhead, we assume that the caller takes care 
- * not to cross sector boundaries with its read/write operations.
- * 
- * When moving to a different sector with seek(), flush() will get called if there are pending changes in
- * the current buffer.
- * 
+ *
+ * This specific implementation will allow read/write operations to the
+ * cartridge save. That way, actual data origin is abstracted away from libPCCS'
+ * Gen3SaveManager.
+ *
+ * Note: to avoid runtime bounds-checking overhead, we assume that the caller
+ * takes care not to cross sector boundaries with its read/write operations.
+ *
+ * When moving to a different sector with seek(), flush() will get called if
+ * there are pending changes in the current buffer.
+ *
  * Note: this class won't automatically load any sector when initialized.
  * Make sure to trigger seek() before doing anything with it.
  */
 class Gen3CartridgeSaveReader
 {
-public:
+  public:
     Gen3CartridgeSaveReader(u8 *sector_buffer);
     ~Gen3CartridgeSaveReader();
 
     void read(u8 *buffer, u32 size);
-    void readUint8(u8& outByte);
-    void readUint16(u16& outWord, Endianness fieldEndianness);
-    void readUint32(u32& outDWord, Endianness fieldEndianness);
+    void readUint8(u8 &outByte);
+    void readUint16(u16 &outWord, Endianness fieldEndianness);
+    void readUint32(u32 &outDWord, Endianness fieldEndianness);
 
     void write(const u8 *buffer, u32 size);
     void writeUint8(u8 value);
@@ -38,8 +39,8 @@ public:
 
     void seek(u32 offset);
 
-    // WARNING: advance and rewind won't cross sector boundaries, so make sure to trigger seek()
-    // if you want to move to a different sector.
+    // WARNING: advance and rewind won't cross sector boundaries, so make sure
+    // to trigger seek() if you want to move to a different sector.
     void advance(u32 numBytes);
     void rewind(u32 numBytes);
 
@@ -49,11 +50,13 @@ public:
     void flush();
 
     /**
-     * @brief Indicates whether the Gen3SaveManager should recalculate checksums when finishSave is called.
+     * @brief Indicates whether the Gen3SaveManager should recalculate checksums
+     * when finishSave is called.
      */
     bool shouldRecalculateChecksumsOnFinish() const;
-protected:
-private:
+
+  protected:
+  private:
     uintptr_t sector_start_;
     u8 *sector_buffer_;
     u8 *cur_;
diff --git a/include/background_engine.h b/include/background_engine.h
index b782175..dd07854 100644
--- a/include/background_engine.h
+++ b/include/background_engine.h
@@ -1,9 +1,9 @@
 #ifndef BG_ENGINE_H
 #define BG_ENGINE_H
 
+#include "global_frame_controller.h"
 #include "sprite_data.h"
 #include "text_engine.h"
-#include "global_frame_controller.h"
 
 // This order does matter, as if two backgrounds are on the same layer,
 // the lowest number will be the one that is displayed
@@ -15,9 +15,10 @@
 void background_frame(int global_frame_count);
 
 /**
- * @brief This function draws the textbox (=copies the tiles) for a specific text table and text key.
- * Each text table entry could have a different type of textbox associated with it.
- * This function will look up the textbox type for the given text table and text key, and then draw the textbox accordingly.
+ * @brief This function draws the textbox (=copies the tiles) for a specific
+ * text table and text key. Each text table entry could have a different type of
+ * textbox associated with it. This function will look up the textbox type for
+ * the given text table and text key, and then draw the textbox accordingly.
  */
 void create_textbox(int text_section, int text_key, bool eraseMainBox);
 
@@ -27,11 +28,13 @@ void create_textbox(int text_section, int text_key, bool eraseMainBox);
 void create_textbox(u8 textbox_type, bool eraseMainBox);
 
 /**
- * @brief This function draws a textbox at the specified tile coordinates, with the specified text space dimensions. 
- * This is the most low-level version of the create_textbox function, and it doesn't do any lookup for textbox types. 
+ * @brief This function draws a textbox at the specified tile coordinates, with
+ * the specified text space dimensions. This is the most low-level version of
+ * the create_textbox function, and it doesn't do any lookup for textbox types.
  * It just draws a textbox with the given parameters.
  */
-void create_textbox(int startTileX, int startTileY, int text_space_width, int text_space_height, bool eraseMainBox);
+void create_textbox(int startTileX, int startTileY, int text_space_width,
+    int text_space_height, bool eraseMainBox);
 void show_textbox();
 void hide_textbox();
 #endif
\ No newline at end of file
diff --git a/include/box_menu.h b/include/box_menu.h
index 6e76126..da7bc4e 100644
--- a/include/box_menu.h
+++ b/include/box_menu.h
@@ -1,17 +1,17 @@
 #ifndef BOX_MENU_H
 #define BOX_MENU_H
 
-#include <tonc.h>
-#include "string.h"
-#include "button_handler.h"
-#include "string_view"
-#include "button_handler.h"
 #include "PokeBox.h"
+#include "button_handler.h"
+#include "string.h"
+#include "string_view"
+#include <tonc.h>
 
 #define CANCEL_BUTTON 1
 #define CONFIRM_BUTTON 2
 
-// Box is 144 x 104, top left is 88 32, sprite is 16x16, sprites are not centered
+// Box is 144 x 104, top left is 88 32, sprite is 16x16, sprites are not
+// centered
 #define BOXMENU_TOP (32 - 12)
 #define BOXMENU_LEFT 88
 #define BOXMENU_VSPACE -4
@@ -24,14 +24,14 @@
 
 class Box_Menu
 {
-public:
+  public:
     Box_Menu();
-    int box_main(PokeBox* box, Version vers);
-private:
+    int box_main(PokeBox *box, Version vers);
+
+  private:
     int curr_button;
     int x;
     int y;
-
 };
 
 #endif
\ No newline at end of file
diff --git a/include/button_handler.h b/include/button_handler.h
index d4ce3ef..3951e75 100644
--- a/include/button_handler.h
+++ b/include/button_handler.h
@@ -5,7 +5,7 @@
 
 class Button
 {
-public:
+  public:
     Button();
     Button(OBJ_ATTR *L, OBJ_ATTR *R, int nLeft_button_width); // wide buttons
     Button(OBJ_ATTR *B);                                      // short button
@@ -17,7 +17,7 @@ public:
     int x;
     int y;
 
-private:
+  private:
     int left_button_width;
     bool highlighted;
     OBJ_ATTR *button_L;
diff --git a/include/button_menu.h b/include/button_menu.h
index 0aea43c..275c785 100644
--- a/include/button_menu.h
+++ b/include/button_menu.h
@@ -1,8 +1,8 @@
 #ifndef MAIN_MENU_H
 #define MAIN_MENU_H
 
-#include <tonc.h>
 #include "libstd_replacements.h"
+#include <tonc.h>
 
 #include "button_handler.h"
 
@@ -19,8 +19,9 @@
 
 class Button_Menu
 {
-public:
-    Button_Menu(int nRows, int nColumns, int nButton_width, int nButton_height, bool enable_cancel);
+  public:
+    Button_Menu(int nRows, int nColumns, int nButton_width, int nButton_height,
+        bool enable_cancel);
     int button_main();
     void add_button(Button btn, int return_val);
     void hide_buttons();
@@ -34,7 +35,7 @@ public:
     void set_bottom_row_offset(int nBottom_offset);
     void clear_vector();
 
-private:
+  private:
     ptgb::vector<Button> button_vector;
     ptgb::vector<int> return_values;
     int columns;
diff --git a/include/custom_malloc.h b/include/custom_malloc.h
index 67f05d9..5ae0477 100644
--- a/include/custom_malloc.h
+++ b/include/custom_malloc.h
@@ -4,16 +4,18 @@
 #include "dbg/debug_mode.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
-#include <stdint.h>
 #include <stddef.h>
+#include <stdint.h>
 
-/// malloc.c defines a custom bitmap allocator implementation that replaces newlibs'
-/// if the USE_CUSTOM_MALLOC flag is set. That makes sure the linker won't pull in all the malloc related code
-/// in newlibc (alongside the 1KB IWRAM __malloc_av variable)
+    /// malloc.c defines a custom bitmap allocator implementation that replaces
+    /// newlibs' if the USE_CUSTOM_MALLOC flag is set. That makes sure the
+    /// linker won't pull in all the malloc related code in newlibc (alongside
+    /// the 1KB IWRAM __malloc_av variable)
 
-void malloc_init_default_pool(void);
+    void malloc_init_default_pool(void);
 
 #ifdef __cplusplus
 }
diff --git a/include/dbg/debug_menu.h b/include/dbg/debug_menu.h
index 2bf8880..ffaa49d 100644
--- a/include/dbg/debug_menu.h
+++ b/include/dbg/debug_menu.h
@@ -1,8 +1,8 @@
 #ifndef _DEBUG_MENU_H
 #define _DEBUG_MENU_H
 
-#include "vertical_menu.h"
 #include "debug_menu_entries.h"
+#include "vertical_menu.h"
 
 #define MAX_MENU_LAYERS 3
 
@@ -14,7 +14,8 @@
 typedef void (*on_execute_callback)(void *context, unsigned user_param);
 
 /**
- * @brief This struct represents the metadata associated to a single toggle option of a single row in the debug menu.
+ * @brief This struct represents the metadata associated to a single toggle
+ * option of a single row in the debug menu.
  */
 typedef struct option_data
 {
@@ -23,8 +24,9 @@ typedef struct option_data
 } option_data;
 
 /**
- * @brief This struct represents a single row in the debug menu. Each row has a label and a set of options.
- * 
+ * @brief This struct represents a single row in the debug menu. Each row has a
+ * label and a set of options.
+ *
  */
 typedef struct debug_menu_row_data
 {
@@ -40,65 +42,75 @@ typedef struct debug_menu_row_data
     /**
      * @brief Toggle options below (optional):
      */
-    struct {
+    struct
+    {
         /**
-         * @brief Number of options. If this is 0, then this row will just be a label with no options to select.
+         * @brief Number of options. If this is 0, then this row will just be a
+         * label with no options to select.
          */
         u8 num_options;
 
         /**
          * @brief The actual array of options alongside their values.
-         * Note: if you want the widget to free() the array when the widget is getting destroyed,
-         * set the should_free_on_destruct flag.
+         * Note: if you want the widget to free() the array when the widget is
+         * getting destroyed, set the should_free_on_destruct flag.
          */
         const option_data *options;
 
         /**
-         * @brief This callback will be fired when the user selects an option. (just with LEFT/RIGHT)
+         * @brief This callback will be fired when the user selects an option.
+         * (just with LEFT/RIGHT)
          */
         on_execute_callback on_option_activate;
 
         /**
          * @brief The initial selected option index.
-         * But this field will get maintained by the widget to track the current selected index.
+         * But this field will get maintained by the widget to track the current
+         * selected index.
          */
         u8 selected_option_index;
 
         /**
-         * @brief This flag indicates whether the widget should call free() on the options pointer when the widget is getting destroyed.
+         * @brief This flag indicates whether the widget should call free() on
+         * the options pointer when the widget is getting destroyed.
          */
         bool should_free_on_destruct;
     } option_section;
 
     /**
-     * @brief A callback that you can set to execute when the user selects this row and presses the A button. (optional)
+     * @brief A callback that you can set to execute when the user selects this
+     * row and presses the A button. (optional)
      */
     on_execute_callback on_execute;
 
     /**
-     * @brief Context for the on_option-activate and on_execute callbacks. (optional)
+     * @brief Context for the on_option-activate and on_execute callbacks.
+     * (optional)
      */
     void *context;
 
     /**
-     * @brief This user_param will be passed as an argument to the on_execute callback. (optional)
+     * @brief This user_param will be passed as an argument to the on_execute
+     * callback. (optional)
      */
     unsigned user_param;
 } debug_menu_row_data;
 
 /**
- * @brief This class is responsible for rendering and handling input for a single row in the vertical_menu based
- * debug menu.
+ * @brief This class is responsible for rendering and handling input for a
+ * single row in the vertical_menu based debug menu.
  */
 class debug_menu_row_widget : public i_item_widget
 {
-public:
+  public:
     debug_menu_row_widget(const debug_menu_row_data &data);
     virtual ~debug_menu_row_widget();
-    void render_item(FileContainerReader &text_table, unsigned x, unsigned y, bool is_focused) override;
+    void render_item(FileContainerReader &text_table, unsigned x, unsigned y,
+        bool is_focused) override;
     MenuInputHandleState handle_input() override;
-protected:
-private:
+
+  protected:
+  private:
     debug_menu_row_data data_;
 };
 
diff --git a/include/dbg/debug_menu_entries.h b/include/dbg/debug_menu_entries.h
index f6e02a0..a069854 100644
--- a/include/dbg/debug_menu_entries.h
+++ b/include/dbg/debug_menu_entries.h
@@ -12,7 +12,8 @@ enum class DebugMenuSection
 };
 
 /**
- * @brief This function pointer is used to define a function filling a specifi DebugMenuSection
+ * @brief This function pointer is used to define a function filling a specifi
+ * DebugMenuSection
  */
 typedef void (*fill_menu_entries_func)(vertical_menu &menu, u16 *charset);
 
@@ -23,8 +24,10 @@ typedef struct MenuSectionMapEntry
 } MenuSectionMapEntry;
 
 /**
- * @brief This function constructs the actual debug menu entries and fills the provided menu with them.
+ * @brief This function constructs the actual debug menu entries and fills the
+ * provided menu with them.
  */
-void fill_debug_menu_with_entries(vertical_menu &menu, u16 *charset, DebugMenuSection section);
+void fill_debug_menu_with_entries(
+    vertical_menu &menu, u16 *charset, DebugMenuSection section);
 
 #endif
\ No newline at end of file
diff --git a/include/dbg/debug_menu_functions.h b/include/dbg/debug_menu_functions.h
index 1132e5a..c1c6275 100644
--- a/include/dbg/debug_menu_functions.h
+++ b/include/dbg/debug_menu_functions.h
@@ -1,12 +1,14 @@
 #ifndef _DEBUG_MENU_FUNCTIONS_H
 #define _DEBUG_MENU_FUNCTIONS_H
 
-// Here we define debug menu callback functions, to be used as on_execute_callback or on_option_activate in the debug menu entries.
+// Here we define debug menu callback functions, to be used as
+// on_execute_callback or on_option_activate in the debug menu entries.
 
 /**
  * @brief Shows a submenu
- * 
- * @param user_param the DebugMenuSection enum value corresponding to the submenu to show.
+ *
+ * @param user_param the DebugMenuSection enum value corresponding to the
+ * submenu to show.
  */
 void show_debug_menu_section(void *context, unsigned user_param);
 
@@ -16,7 +18,8 @@ void show_debug_menu_section(void *context, unsigned user_param);
 void show_text_debug_screen(void *context, unsigned user_param);
 
 /**
- * @brief This function will show the debug info screen, which contains various flags and info about the current game state.
+ * @brief This function will show the debug info screen, which contains various
+ * flags and info about the current game state.
  */
 void show_debug_info_screen(void *context, unsigned user_param);
 
@@ -24,7 +27,8 @@ void show_debug_info_screen(void *context, unsigned user_param);
  * @brief This is a generic u8/bool value set callback
  *
  * @param context a (u8* or bool*) pointer to the flag you want to set/unset.
- * @param user_param the value to set the flag to. 0 -> false, anything else -> true.
+ * @param user_param the value to set the flag to. 0 -> false, anything else ->
+ * true.
  */
 void dbg_set_byte_val(void *context, unsigned user_param);
 
diff --git a/include/dbg/debug_mode.h b/include/dbg/debug_mode.h
index 5c2fcc8..61ed133 100644
--- a/include/dbg/debug_mode.h
+++ b/include/dbg/debug_mode.h
@@ -28,90 +28,105 @@ enum WriteCableDataMode
  */
 typedef struct debug_options
 {
-    /** This option will print the link cable data. Pause the transfer with L, resume with R. Skip printing with DOWN. */
+    /** This option will print the link cable data. Pause the transfer with L,
+     * resume with R. Skip printing with DOWN. */
     bool print_link_data;
 
-    /** This option will print the link cable packets. Pause the transfer with L, resume with R. Skip printing with DOWN. */
+    /** This option will print the link cable packets. Pause the transfer with
+     * L, resume with R. Skip printing with DOWN. */
     bool print_link_packets;
 
     /**
-     * @brief If this option has been set, we won't animate the text, but show the full text immediately.
+     * @brief If this option has been set, we won't animate the text, but show
+     * the full text immediately.
      */
     bool instant_text_speed;
 
     /**
-     * @brief If this option is set, we won't try to access a game cartridge. Instead, we'll pretend we're using
-     * a game cartridge with predefined data. (DEBUG_GAME, DEBUG_VERS, DEBUG_LANG)
-     * We won't show game sprites either.
+     * @brief If this option is set, we won't try to access a game cartridge.
+     * Instead, we'll pretend we're using a game cartridge with predefined data.
+     * (DEBUG_GAME, DEBUG_VERS, DEBUG_LANG) We won't show game sprites either.
      *
-     * This is useful for testing our code in an emulator or without a game cartridge.
+     * This is useful for testing our code in an emulator or without a game
+     * cartridge.
      */
     bool ignore_game_pak;
 
     /**
-     * @brief If this option is set, we won't try to show sprites that are stored on the game cartridge.
-     * This is useful for testing our code in an emulator or without a game cartridge.
+     * @brief If this option is set, we won't try to show sprites that are
+     * stored on the game cartridge. This is useful for testing our code in an
+     * emulator or without a game cartridge.
      */
     bool ignore_game_pak_sprites;
 
     /**
      * @brief If this flag is set, we won't actually do a link cable connection.
-     * Instead, we pretend the connection was successful and use gen1_rb_debug_box_data or gen2_debug_box_data.
+     * Instead, we pretend the connection was successful and use
+     * gen1_rb_debug_box_data or gen2_debug_box_data.
      */
     bool ignore_link_cable;
 
     /**
-     * @brief If this option is set, we won't block the user from proceeding if he/she hasn't beat the E4 or
-     * hasn't activated Mystery Gift yet. This is mostly useful for debug purposes.
+     * @brief If this option is set, we won't block the user from proceeding if
+     * he/she hasn't beat the E4 or hasn't activated Mystery Gift yet. This is
+     * mostly useful for debug purposes.
      */
     bool ignore_mg_e4_flags;
 
     /**
-     * @brief If this option is set, we won't block the transfer from finishing if the player hasn't collected
-     * the pokémon from previous transfers. Instead those will get overwritten. This does make you lose those pokémon.
-     * But it can be useful for debugging. (because you wouldn't need to boot into the game everytime between transfer attempts)
+     * @brief If this option is set, we won't block the transfer from finishing
+     * if the player hasn't collected the pokémon from previous transfers.
+     * Instead those will get overwritten. This does make you lose those
+     * pokémon. But it can be useful for debugging. (because you wouldn't need
+     * to boot into the game everytime between transfer attempts)
      */
     bool ignore_unreceived_pkmn;
 
     /**
-     * @brief This option will make PTGB show the tutorial even if the tutorial completion flag was already set before.
-     * Useful for debugging purposes.
+     * @brief This option will make PTGB show the tutorial even if the tutorial
+     * completion flag was already set before. Useful for debugging purposes.
      */
     bool force_tutorial;
 
     /**
-     * @brief This option will show the pokémon even if not a single one is valid.
-     * Once again, this can be useful for debugging purposes.
+     * @brief This option will show the pokémon even if not a single one is
+     * valid. Once again, this can be useful for debugging purposes.
      */
     bool dont_hide_invalid_pkmn;
 
     /**
-     * @brief This option will avoid blocking the transfer if the player hasn't caught enough pokémon yet.
+     * @brief This option will avoid blocking the transfer if the player hasn't
+     * caught enough pokémon yet.
      */
     bool ignore_dex_completion;
 
     /**
-     * @brief This option will pretend as if the player caught all pokémon. This is useful to get past the dex completion check
+     * @brief This option will pretend as if the player caught all pokémon. This
+     * is useful to get past the dex completion check
      */
     bool force_all_caught;
 
     /**
-     * @brief If this option is set, we will write the data received over the link cable to SRAM.
-     * Please make sure to only use this with loader.gba/Poke_Transporter_GB_standalone.gba and
-     * make sure to ignore_game_pak and ignore_game_pak_sprites too!
+     * @brief If this option is set, we will write the data received over the
+     * link cable to SRAM. Please make sure to only use this with
+     * loader.gba/Poke_Transporter_GB_standalone.gba and make sure to
+     * ignore_game_pak and ignore_game_pak_sprites too!
      *
-     * Also: you may need to reboot to your flashcart menu to make it update the .sav file.
+     * Also: you may need to reboot to your flashcart menu to make it update the
+     * .sav file.
      */
     u8 write_cable_data_to_save;
 
     /**
-     * @brief If this option is set, we will load the data -written by write_cable_data_to_save- from the SRAM
-     * instead of actually communicating over the link cable.
+     * @brief If this option is set, we will load the data -written by
+     * write_cable_data_to_save- from the SRAM instead of actually communicating
+     * over the link cable.
      */
     u8 load_cable_data_from_save;
 
     /**
-     * @brief If this option is enabled, we will show control characters in the text.
+     * @brief If this option is enabled, we will show control characters in the
+     * text.
      */
     bool display_control_char;
 } debug_options;
@@ -143,12 +158,13 @@ extern debug_options g_debug_options;
 // needs to be a value divisible by 4
 #define CUSTOM_MALLOC_POOL_SIZE 8192
 
-// This option enables PTGB_MGBA_XYZ() log messages. These get printed to the mgba log window.
-// This option can only be enabled in debug builds because it relies on mgba_printf,
-// which will only get included in debug builds for licensing reasons.
-// Compiling with this option enabled in release builds will cause a static_assert failure.
-// But the && DEBUG_MODE check will already prevent this from being enabled in release builds accidentally,
-// so as long as no-one removes that, it should be fine.
+// This option enables PTGB_MGBA_XYZ() log messages. These get printed to the
+// mgba log window. This option can only be enabled in debug builds because it
+// relies on mgba_printf, which will only get included in debug builds for
+// licensing reasons. Compiling with this option enabled in release builds will
+// cause a static_assert failure. But the && DEBUG_MODE check will already
+// prevent this from being enabled in release builds accidentally, so as long as
+// no-one removes that, it should be fine.
 #define DEBUG_USE_MGBA_PRINT (true && DEBUG_MODE)
 
 #endif
\ No newline at end of file
diff --git a/include/dbg/eon_ticket_rs.h b/include/dbg/eon_ticket_rs.h
index 6d90f0c..6067d16 100644
--- a/include/dbg/eon_ticket_rs.h
+++ b/include/dbg/eon_ticket_rs.h
@@ -2,69 +2,88 @@
 
 // array size is 1012
 // Downloaded from the projectpokemon.org website
-static const u8 RS_Item_Eon_Ticket_e_Card_ENG_US_[]  = {
-  0x10, 0xea, 0x00, 0x00, 0x33, 0x08, 0x01, 0x01, 0xb8, 0x61, 0x00, 0x00, 0x02, 0x47, 0x13, 0x01, 
-  0x01, 0x00, 0x21, 0x0d, 0x80, 0x01, 0x00, 0xbb, 0x01, 0xbf, 0x00, 0x00, 0x02, 0x4a, 0x13, 0x01, 
-  0x01, 0x00, 0x21, 0x0d, 0x80, 0x01, 0x00, 0xbb, 0x01, 0xbf, 0x00, 0x00, 0x02, 0x2b, 0xce, 0x00, 
-  0xbb, 0x01, 0xbf, 0x00, 0x00, 0x02, 0x6a, 0x5a, 0xbd, 0xc9, 0x00, 0x00, 0x02, 0x66, 0x6d, 0x46, 
-  0x13, 0x01, 0x01, 0x00, 0x21, 0x0d, 0x80, 0x00, 0x00, 0xbb, 0x01, 0xc0, 0x00, 0x00, 0x02, 0x1a, 
-  0x00, 0x80, 0x13, 0x01, 0x1a, 0x01, 0x80, 0x01, 0x00, 0x09, 0x00, 0x29, 0x53, 0x08, 0xbd, 0x04, 
-  0x01, 0x00, 0x02, 0x66, 0x6d, 0x6c, 0x0d, 0xbd, 0x83, 0x01, 0x00, 0x02, 0x66, 0x6d, 0x6c, 0x02, 
-  0xbe, 0xbb, 0xbe, 0xb1, 0xfd, 0x01, 0xab, 0x00, 0xc1, 0xe3, 0xe3, 0xd8, 0x00, 0xe8, 0xe3, 0x00, 
-  0xe7, 0xd9, 0xd9, 0x00, 0xed, 0xe3, 0xe9, 0xab, 0xfe, 0xce, 0xdc, 0xd9, 0xe6, 0xd9, 0xb4, 0xe7, 
-  0x00, 0xd5, 0x00, 0xe0, 0xd9, 0xe8, 0xe8, 0xd9, 0xe6, 0x00, 0xdc, 0xd9, 0xe6, 0xd9, 0x00, 0xda, 
-  0xe3, 0xe6, 0x00, 0xed, 0xe3, 0xe9, 0xb8, 0xfd, 0x01, 0xad, 0xff, 0xbe, 0xbb, 0xbe, 0xb1, 0xc3, 
-  0xe8, 0x00, 0xd5, 0xe4, 0xe4, 0xd9, 0xd5, 0xe6, 0xe7, 0x00, 0xe8, 0xe3, 0x00, 0xd6, 0xd9, 0x00, 
-  0xd5, 0x00, 0xda, 0xd9, 0xe6, 0xe6, 0xed, 0x00, 0xce, 0xc3, 0xbd, 0xc5, 0xbf, 0xce, 0xad, 0xfe, 
-  0xd6, 0xe9, 0xe8, 0x00, 0xc3, 0xb4, 0xea, 0xd9, 0x00, 0xe2, 0xd9, 0xea, 0xd9, 0xe6, 0x00, 0xe7, 
-  0xd9, 0xd9, 0xe2, 0x00, 0xe3, 0xe2, 0xd9, 0x00, 0xe0, 0xdd, 0xdf, 0xd9, 0x00, 0xdd, 0xe8, 0x00, 
-  0xd6, 0xd9, 0xda, 0xe3, 0xe6, 0xd9, 0xad, 0xfa, 0xd3, 0xe3, 0xe9, 0x00, 0xe7, 0xdc, 0xe3, 0xe9, 
-  0xe0, 0xd8, 0x00, 0xea, 0xdd, 0xe7, 0xdd, 0xe8, 0x00, 0xc6, 0xc3, 0xc6, 0xd3, 0xbd, 0xc9, 0xd0, 
-  0xbf, 0x00, 0xd5, 0xe2, 0xd8, 0x00, 0xd5, 0xe7, 0xdf, 0xfe, 0xd5, 0xd6, 0xe3, 0xe9, 0xe8, 0x00, 
-  0xdd, 0xe8, 0x00, 0xe8, 0xdc, 0xd9, 0xe6, 0xd9, 0xad, 0xff, 0xbe, 0xbb, 0xbe, 0xb1, 0xfd, 0x01, 
-  0xb4, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xc5, 0xbf, 0xd3, 0x00, 0xc3, 0xce, 0xbf, 0xc7, 0xcd, 0x00, 
-  0xca, 0xc9, 0xbd, 0xc5, 0xbf, 0xce, 0x00, 0xdd, 0xe2, 0xfe, 0xed, 0xe3, 0xe9, 0xe6, 0x00, 0xbc, 
-  0xbb, 0xc1, 0x00, 0xdd, 0xe7, 0x00, 0xda, 0xe9, 0xe0, 0xe0, 0xad, 0xfb, 0xc7, 0xe3, 0xea, 0xd9, 
-  0x00, 0xe7, 0xe3, 0xe1, 0xd9, 0x00, 0xdf, 0xd9, 0xed, 0x00, 0xdd, 0xe8, 0xd9, 0xe1, 0xe7, 0x00, 
-  0xda, 0xe3, 0xe6, 0x00, 0xe7, 0xd5, 0xda, 0xd9, 0xdf, 0xd9, 0xd9, 0xe4, 0xdd, 0xe2, 0xdb, 0xfe, 
-  0xdd, 0xe2, 0x00, 0xed, 0xe3, 0xe9, 0xe6, 0x00, 0xca, 0xbd, 0xb4, 0x00, 0xe8, 0xdc, 0xd9, 0xe2, 
-  0x00, 0xd7, 0xe3, 0xe1, 0xd9, 0x00, 0xe7, 0xd9, 0xd9, 0x00, 0xe1, 0xd9, 0xad, 0xff, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 
-  0x01, 0x1e, 0x13, 0x01
-};
\ No newline at end of file
+static const u8 RS_Item_Eon_Ticket_e_Card_ENG_US_[] = {0x10, 0xea, 0x00, 0x00,
+    0x33, 0x08, 0x01, 0x01, 0xb8, 0x61, 0x00, 0x00, 0x02, 0x47, 0x13, 0x01,
+    0x01, 0x00, 0x21, 0x0d, 0x80, 0x01, 0x00, 0xbb, 0x01, 0xbf, 0x00, 0x00,
+    0x02, 0x4a, 0x13, 0x01, 0x01, 0x00, 0x21, 0x0d, 0x80, 0x01, 0x00, 0xbb,
+    0x01, 0xbf, 0x00, 0x00, 0x02, 0x2b, 0xce, 0x00, 0xbb, 0x01, 0xbf, 0x00,
+    0x00, 0x02, 0x6a, 0x5a, 0xbd, 0xc9, 0x00, 0x00, 0x02, 0x66, 0x6d, 0x46,
+    0x13, 0x01, 0x01, 0x00, 0x21, 0x0d, 0x80, 0x00, 0x00, 0xbb, 0x01, 0xc0,
+    0x00, 0x00, 0x02, 0x1a, 0x00, 0x80, 0x13, 0x01, 0x1a, 0x01, 0x80, 0x01,
+    0x00, 0x09, 0x00, 0x29, 0x53, 0x08, 0xbd, 0x04, 0x01, 0x00, 0x02, 0x66,
+    0x6d, 0x6c, 0x0d, 0xbd, 0x83, 0x01, 0x00, 0x02, 0x66, 0x6d, 0x6c, 0x02,
+    0xbe, 0xbb, 0xbe, 0xb1, 0xfd, 0x01, 0xab, 0x00, 0xc1, 0xe3, 0xe3, 0xd8,
+    0x00, 0xe8, 0xe3, 0x00, 0xe7, 0xd9, 0xd9, 0x00, 0xed, 0xe3, 0xe9, 0xab,
+    0xfe, 0xce, 0xdc, 0xd9, 0xe6, 0xd9, 0xb4, 0xe7, 0x00, 0xd5, 0x00, 0xe0,
+    0xd9, 0xe8, 0xe8, 0xd9, 0xe6, 0x00, 0xdc, 0xd9, 0xe6, 0xd9, 0x00, 0xda,
+    0xe3, 0xe6, 0x00, 0xed, 0xe3, 0xe9, 0xb8, 0xfd, 0x01, 0xad, 0xff, 0xbe,
+    0xbb, 0xbe, 0xb1, 0xc3, 0xe8, 0x00, 0xd5, 0xe4, 0xe4, 0xd9, 0xd5, 0xe6,
+    0xe7, 0x00, 0xe8, 0xe3, 0x00, 0xd6, 0xd9, 0x00, 0xd5, 0x00, 0xda, 0xd9,
+    0xe6, 0xe6, 0xed, 0x00, 0xce, 0xc3, 0xbd, 0xc5, 0xbf, 0xce, 0xad, 0xfe,
+    0xd6, 0xe9, 0xe8, 0x00, 0xc3, 0xb4, 0xea, 0xd9, 0x00, 0xe2, 0xd9, 0xea,
+    0xd9, 0xe6, 0x00, 0xe7, 0xd9, 0xd9, 0xe2, 0x00, 0xe3, 0xe2, 0xd9, 0x00,
+    0xe0, 0xdd, 0xdf, 0xd9, 0x00, 0xdd, 0xe8, 0x00, 0xd6, 0xd9, 0xda, 0xe3,
+    0xe6, 0xd9, 0xad, 0xfa, 0xd3, 0xe3, 0xe9, 0x00, 0xe7, 0xdc, 0xe3, 0xe9,
+    0xe0, 0xd8, 0x00, 0xea, 0xdd, 0xe7, 0xdd, 0xe8, 0x00, 0xc6, 0xc3, 0xc6,
+    0xd3, 0xbd, 0xc9, 0xd0, 0xbf, 0x00, 0xd5, 0xe2, 0xd8, 0x00, 0xd5, 0xe7,
+    0xdf, 0xfe, 0xd5, 0xd6, 0xe3, 0xe9, 0xe8, 0x00, 0xdd, 0xe8, 0x00, 0xe8,
+    0xdc, 0xd9, 0xe6, 0xd9, 0xad, 0xff, 0xbe, 0xbb, 0xbe, 0xb1, 0xfd, 0x01,
+    0xb4, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xc5, 0xbf, 0xd3, 0x00, 0xc3, 0xce,
+    0xbf, 0xc7, 0xcd, 0x00, 0xca, 0xc9, 0xbd, 0xc5, 0xbf, 0xce, 0x00, 0xdd,
+    0xe2, 0xfe, 0xed, 0xe3, 0xe9, 0xe6, 0x00, 0xbc, 0xbb, 0xc1, 0x00, 0xdd,
+    0xe7, 0x00, 0xda, 0xe9, 0xe0, 0xe0, 0xad, 0xfb, 0xc7, 0xe3, 0xea, 0xd9,
+    0x00, 0xe7, 0xe3, 0xe1, 0xd9, 0x00, 0xdf, 0xd9, 0xed, 0x00, 0xdd, 0xe8,
+    0xd9, 0xe1, 0xe7, 0x00, 0xda, 0xe3, 0xe6, 0x00, 0xe7, 0xd5, 0xda, 0xd9,
+    0xdf, 0xd9, 0xd9, 0xe4, 0xdd, 0xe2, 0xdb, 0xfe, 0xdd, 0xe2, 0x00, 0xed,
+    0xe3, 0xe9, 0xe6, 0x00, 0xca, 0xbd, 0xb4, 0x00, 0xe8, 0xdc, 0xd9, 0xe2,
+    0x00, 0xd7, 0xe3, 0xe1, 0xd9, 0x00, 0xe7, 0xd9, 0xd9, 0x00, 0xe1, 0xd9,
+    0xad, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x01, 0x1e, 0x13, 0x01};
\ No newline at end of file
diff --git a/include/dbg/old_sea_map.h b/include/dbg/old_sea_map.h
index 1339a78..1d6f6d8 100644
--- a/include/dbg/old_sea_map.h
+++ b/include/dbg/old_sea_map.h
@@ -1,95 +1,124 @@
 #include "typeDefs.h"
 
 // array size is 1420
-// Taken from WC3Tool 0.1f: https://github.com/projectpokemon/Gen3-WCTool/releases/tag/0.1f
-static const u8 OldSeaMap_E_custom[]  = {
-  0xcf, 0xa6, 0x00, 0x00, 0xba, 0xb4, 0xbe, 0xb9, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0xb1, 0xc9, 0xc6, 0xbe, 0x00, 0xcd, 0xbf, 0xbb, 0x00, 0xc7, 0xbb, 
-  0xca, 0xb2, 0x00, 0xbd, 0xe9, 0xe7, 0xe8, 0xe3, 0xe1, 0x00, 0xbd, 0xd5, 0xe6, 0xd8, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xce, 0xdc, 0xdd, 0xe7, 0x00, 0xd1, 0xe3, 0xe2, 
-  0xd8, 0xd9, 0xe6, 0xd7, 0xd5, 0xe6, 0xd8, 0x00, 0xdd, 0xe7, 0x00, 0xdd, 0xe0, 0xe0, 0xd9, 0xdb, 
-  0xd5, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc1, 0xe3, 
-  0x00, 0xe8, 0xe3, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xe7, 0xd9, 0xd7, 0xe3, 0xe2, 0xd8, 0x00, 0xda, 
-  0xe0, 0xe3, 0xe3, 0xe6, 0x00, 0xe3, 0xda, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xca, 0xc9, 0xc5, 0x1b, 
-  0xc7, 0xc9, 0xc8, 0x00, 0x00, 0x00, 0xbd, 0xbf, 0xc8, 0xce, 0xbf, 0xcc, 0x00, 0xd5, 0xe2, 0xd8, 
-  0x00, 0xe1, 0xd9, 0xd9, 0xe8, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xd8, 0xd9, 0xe0, 0xdd, 0xea, 0xd9, 
-  0xe6, 0xed, 0x00, 0xe4, 0xd9, 0xe6, 0xe7, 0xe3, 0xe2, 0x00, 0xdd, 0xe2, 0x00, 0x00, 0xdb, 0xe6, 
-  0xd9, 0xd9, 0xe2, 0xad, 0x00, 0xcc, 0xd9, 0xd7, 0xd9, 0xdd, 0xea, 0xd9, 0x00, 0xe8, 0xdc, 0xd9, 
-  0x00, 0xc9, 0xc6, 0xbe, 0x00, 0xcd, 0xbf, 0xbb, 0x00, 0xc7, 0xbb, 0xca, 0x00, 0xd5, 0xe2, 0xd8, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe8, 0xdc, 0xd9, 0xe2, 0x00, 0xe7, 0xd5, 0xea, 0xd9, 0x00, 
-  0xe8, 0xdc, 0xd9, 0x00, 0xdb, 0xd5, 0xe1, 0xd9, 0xab, 0xab, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbe, 0xe3, 
-  0x00, 0xe2, 0xe3, 0xe8, 0x00, 0xe8, 0xe3, 0xe7, 0xe7, 0x00, 0xe8, 0xdc, 0xdd, 0xe7, 0x00, 0xbf, 
-  0xec, 0xd7, 0xdc, 0xd5, 0xe2, 0xdb, 0xd9, 0x00, 0xbd, 0xd5, 0xe6, 0xd8, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd6, 0xd9, 0xda, 0xe3, 0xe6, 0xd9, 0x00, 0xe6, 0xd9, 0xd7, 
-  0xd9, 0xdd, 0xea, 0xdd, 0xe2, 0xdb, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xc9, 0xc6, 0xbe, 0x00, 0xcd, 
-  0xbf, 0xbb, 0x00, 0xc7, 0xbb, 0xca, 0xab, 0xab, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x88, 0x37, 0x00, 0x00, 0x33, 0xff, 0xff, 0xff, 0xb8, 0xf4, 0x57, 0x67, 0x08, 0x6a, 0x5a, 0x2b, 
-  0x3c, 0x01, 0xbb, 0x01, 0x58, 0x58, 0x67, 0x08, 0x2b, 0xca, 0x01, 0xbb, 0x01, 0x58, 0x58, 0x67, 
-  0x08, 0x47, 0x78, 0x01, 0x01, 0x00, 0x21, 0x0d, 0x80, 0x01, 0x00, 0xbb, 0x01, 0x58, 0x58, 0x67, 
-  0x08, 0xbd, 0x61, 0x58, 0x67, 0x08, 0x66, 0x6d, 0x46, 0x78, 0x01, 0x01, 0x00, 0x21, 0x0d, 0x80, 
-  0x00, 0x00, 0xbb, 0x01, 0x4f, 0x58, 0x67, 0x08, 0x1a, 0x00, 0x80, 0x78, 0x01, 0x1a, 0x01, 0x80, 
-  0x01, 0x00, 0x09, 0x00, 0x29, 0xd6, 0x08, 0x29, 0x3c, 0x01, 0xbd, 0xd9, 0x58, 0x67, 0x08, 0x66, 
-  0x6d, 0x6c, 0x02, 0xbd, 0x6a, 0x59, 0x67, 0x08, 0x66, 0x6d, 0x6c, 0x02, 0xbd, 0x3d, 0x59, 0x67, 
-  0x08, 0x66, 0x6d, 0x6c, 0x02, 0xce, 0xdc, 0xd5, 0xe2, 0xdf, 0x00, 0xed, 0xe3, 0xe9, 0x00, 0xda, 
-  0xe3, 0xe6, 0x00, 0xe9, 0xe7, 0xdd, 0xe2, 0xdb, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xc7, 0xd3, 0xcd, 
-  0xce, 0xbf, 0xcc, 0xd3, 0xfe, 0xc1, 0xc3, 0xc0, 0xce, 0x00, 0xcd, 0xed, 0xe7, 0xe8, 0xd9, 0xe1, 
-  0xad, 0xfb, 0xc6, 0xd9, 0xe8, 0x00, 0xe1, 0xd9, 0x00, 0xd7, 0xe3, 0xe2, 0xda, 0xdd, 0xe6, 0xe1, 
-  0xae, 0xae, 0xed, 0xe3, 0xe9, 0x00, 0xd5, 0xe6, 0xd9, 0x00, 0xfd, 0x01, 0xac, 0xfb, 0xd1, 0xd9, 
-  0x00, 0xe6, 0xd9, 0xd7, 0xd9, 0xdd, 0xea, 0xd9, 0xd8, 0x00, 0xe8, 0xdc, 0xdd, 0xe7, 0x00, 0xc9, 
-  0xc6, 0xbe, 0x00, 0xcd, 0xbf, 0xbb, 0x00, 0xc7, 0xbb, 0xca, 0xfe, 0xd5, 0xd8, 0xd8, 0xe6, 0xd9, 
-  0xe7, 0xe7, 0xd9, 0xd8, 0x00, 0xe8, 0xe3, 0x00, 0xed, 0xe3, 0xe9, 0xad, 0xff, 0xc3, 0xe8, 0x00, 
-  0xd5, 0xe4, 0xe4, 0xd9, 0xd5, 0xe6, 0xe7, 0x00, 0xe8, 0xe3, 0x00, 0xd6, 0xd9, 0x00, 0xda, 0xe3, 
-  0xe6, 0x00, 0xe9, 0xe7, 0xd9, 0x00, 0xd5, 0xe8, 0x00, 0xe8, 0xdc, 0xd9, 0xfe, 0xc6, 0xc3, 0xc6, 
-  0xd3, 0xbd, 0xc9, 0xd0, 0xbf, 0x00, 0xbd, 0xc3, 0xce, 0xd3, 0x00, 0xe4, 0xe3, 0xe6, 0xe8, 0xad, 
-  0xfb, 0xd1, 0xdc, 0xed, 0x00, 0xe2, 0xe3, 0xe8, 0x00, 0xdb, 0xdd, 0xea, 0xd9, 0x00, 0xdd, 0xe8, 
-  0x00, 0xd5, 0x00, 0xe8, 0xe6, 0xed, 0x00, 0xd5, 0xe2, 0xd8, 0x00, 0xe7, 0xd9, 0xd9, 0x00, 0xeb, 
-  0xdc, 0xd5, 0xe8, 0xfe, 0xdd, 0xe8, 0x00, 0xdd, 0xe7, 0x00, 0xd5, 0xd6, 0xe3, 0xe9, 0xe8, 0xac, 
-  0xff, 0xce, 0xdc, 0xd5, 0xe2, 0xdf, 0x00, 0xed, 0xe3, 0xe9, 0x00, 0xda, 0xe3, 0xe6, 0x00, 0xe9, 
-  0xe7, 0xdd, 0xe2, 0xdb, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xc7, 0xd3, 0xcd, 0xce, 0xbf, 0xcc, 0xd3, 
-  0xfe, 0xc1, 0xc3, 0xc0, 0xce, 0x00, 0xcd, 0xed, 0xe7, 0xe8, 0xd9, 0xe1, 0xad, 0xff, 0xc9, 0xdc, 
-  0xb8, 0x00, 0xc3, 0xb4, 0xe1, 0x00, 0xe7, 0xe3, 0xe6, 0xe6, 0xed, 0xb8, 0x00, 0xfd, 0x01, 0xad, 
-  0xfe, 0xd3, 0xe3, 0xe9, 0xe6, 0x00, 0xbc, 0xbb, 0xc1, 0xb4, 0xe7, 0x00, 0xc5, 0xbf, 0xd3, 0x00, 
-  0xc3, 0xce, 0xbf, 0xc7, 0xcd, 0x00, 0xca, 0xc9, 0xbd, 0xc5, 0xbf, 0xce, 0x00, 0xdd, 0xe7, 0x00, 
-  0xda, 0xe9, 0xe0, 0xe0, 0xad, 0xfb, 0xca, 0xe0, 0xd9, 0xd5, 0xe7, 0xd9, 0x00, 0xe7, 0xe8, 0xe3, 
-  0xe6, 0xd9, 0x00, 0xe7, 0xe3, 0xe1, 0xd9, 0xe8, 0xdc, 0xdd, 0xe2, 0xdb, 0x00, 0xe3, 0xe2, 0x00, 
-  0xed, 0xe3, 0xe9, 0xe6, 0x00, 0xca, 0xbd, 0xb8, 0xfe, 0xe8, 0xdc, 0xd9, 0xe2, 0x00, 0xd7, 0xe3, 
-  0xe1, 0xd9, 0x00, 0xd6, 0xd5, 0xd7, 0xdf, 0x00, 0xda, 0xe3, 0xe6, 0x00, 0xe8, 0xdc, 0xdd, 0xe7, 
-  0xad, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
\ No newline at end of file
+// Taken from WC3Tool 0.1f:
+// https://github.com/projectpokemon/Gen3-WCTool/releases/tag/0.1f
+static const u8 OldSeaMap_E_custom[] = {0xcf, 0xa6, 0x00, 0x00, 0xba, 0xb4,
+    0xbe, 0xb9, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xb1, 0xc9, 0xc6, 0xbe, 0x00, 0xcd, 0xbf, 0xbb, 0x00,
+    0xc7, 0xbb, 0xca, 0xb2, 0x00, 0xbd, 0xe9, 0xe7, 0xe8, 0xe3, 0xe1, 0x00,
+    0xbd, 0xd5, 0xe6, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xce, 0xdc, 0xdd, 0xe7, 0x00, 0xd1, 0xe3, 0xe2, 0xd8, 0xd9,
+    0xe6, 0xd7, 0xd5, 0xe6, 0xd8, 0x00, 0xdd, 0xe7, 0x00, 0xdd, 0xe0, 0xe0,
+    0xd9, 0xdb, 0xd5, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xc1, 0xe3, 0x00, 0xe8, 0xe3, 0x00, 0xe8, 0xdc,
+    0xd9, 0x00, 0xe7, 0xd9, 0xd7, 0xe3, 0xe2, 0xd8, 0x00, 0xda, 0xe0, 0xe3,
+    0xe3, 0xe6, 0x00, 0xe3, 0xda, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xca, 0xc9,
+    0xc5, 0x1b, 0xc7, 0xc9, 0xc8, 0x00, 0x00, 0x00, 0xbd, 0xbf, 0xc8, 0xce,
+    0xbf, 0xcc, 0x00, 0xd5, 0xe2, 0xd8, 0x00, 0xe1, 0xd9, 0xd9, 0xe8, 0x00,
+    0xe8, 0xdc, 0xd9, 0x00, 0xd8, 0xd9, 0xe0, 0xdd, 0xea, 0xd9, 0xe6, 0xed,
+    0x00, 0xe4, 0xd9, 0xe6, 0xe7, 0xe3, 0xe2, 0x00, 0xdd, 0xe2, 0x00, 0x00,
+    0xdb, 0xe6, 0xd9, 0xd9, 0xe2, 0xad, 0x00, 0xcc, 0xd9, 0xd7, 0xd9, 0xdd,
+    0xea, 0xd9, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xc9, 0xc6, 0xbe, 0x00, 0xcd,
+    0xbf, 0xbb, 0x00, 0xc7, 0xbb, 0xca, 0x00, 0xd5, 0xe2, 0xd8, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xe8, 0xdc, 0xd9, 0xe2, 0x00, 0xe7, 0xd5, 0xea,
+    0xd9, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xdb, 0xd5, 0xe1, 0xd9, 0xab, 0xab,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbe, 0xe3, 0x00, 0xe2,
+    0xe3, 0xe8, 0x00, 0xe8, 0xe3, 0xe7, 0xe7, 0x00, 0xe8, 0xdc, 0xdd, 0xe7,
+    0x00, 0xbf, 0xec, 0xd7, 0xdc, 0xd5, 0xe2, 0xdb, 0xd9, 0x00, 0xbd, 0xd5,
+    0xe6, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xd6, 0xd9, 0xda, 0xe3, 0xe6, 0xd9, 0x00, 0xe6, 0xd9, 0xd7, 0xd9, 0xdd,
+    0xea, 0xdd, 0xe2, 0xdb, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xc9, 0xc6, 0xbe,
+    0x00, 0xcd, 0xbf, 0xbb, 0x00, 0xc7, 0xbb, 0xca, 0xab, 0xab, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x88, 0x37, 0x00, 0x00, 0x33, 0xff, 0xff, 0xff, 0xb8, 0xf4,
+    0x57, 0x67, 0x08, 0x6a, 0x5a, 0x2b, 0x3c, 0x01, 0xbb, 0x01, 0x58, 0x58,
+    0x67, 0x08, 0x2b, 0xca, 0x01, 0xbb, 0x01, 0x58, 0x58, 0x67, 0x08, 0x47,
+    0x78, 0x01, 0x01, 0x00, 0x21, 0x0d, 0x80, 0x01, 0x00, 0xbb, 0x01, 0x58,
+    0x58, 0x67, 0x08, 0xbd, 0x61, 0x58, 0x67, 0x08, 0x66, 0x6d, 0x46, 0x78,
+    0x01, 0x01, 0x00, 0x21, 0x0d, 0x80, 0x00, 0x00, 0xbb, 0x01, 0x4f, 0x58,
+    0x67, 0x08, 0x1a, 0x00, 0x80, 0x78, 0x01, 0x1a, 0x01, 0x80, 0x01, 0x00,
+    0x09, 0x00, 0x29, 0xd6, 0x08, 0x29, 0x3c, 0x01, 0xbd, 0xd9, 0x58, 0x67,
+    0x08, 0x66, 0x6d, 0x6c, 0x02, 0xbd, 0x6a, 0x59, 0x67, 0x08, 0x66, 0x6d,
+    0x6c, 0x02, 0xbd, 0x3d, 0x59, 0x67, 0x08, 0x66, 0x6d, 0x6c, 0x02, 0xce,
+    0xdc, 0xd5, 0xe2, 0xdf, 0x00, 0xed, 0xe3, 0xe9, 0x00, 0xda, 0xe3, 0xe6,
+    0x00, 0xe9, 0xe7, 0xdd, 0xe2, 0xdb, 0x00, 0xe8, 0xdc, 0xd9, 0x00, 0xc7,
+    0xd3, 0xcd, 0xce, 0xbf, 0xcc, 0xd3, 0xfe, 0xc1, 0xc3, 0xc0, 0xce, 0x00,
+    0xcd, 0xed, 0xe7, 0xe8, 0xd9, 0xe1, 0xad, 0xfb, 0xc6, 0xd9, 0xe8, 0x00,
+    0xe1, 0xd9, 0x00, 0xd7, 0xe3, 0xe2, 0xda, 0xdd, 0xe6, 0xe1, 0xae, 0xae,
+    0xed, 0xe3, 0xe9, 0x00, 0xd5, 0xe6, 0xd9, 0x00, 0xfd, 0x01, 0xac, 0xfb,
+    0xd1, 0xd9, 0x00, 0xe6, 0xd9, 0xd7, 0xd9, 0xdd, 0xea, 0xd9, 0xd8, 0x00,
+    0xe8, 0xdc, 0xdd, 0xe7, 0x00, 0xc9, 0xc6, 0xbe, 0x00, 0xcd, 0xbf, 0xbb,
+    0x00, 0xc7, 0xbb, 0xca, 0xfe, 0xd5, 0xd8, 0xd8, 0xe6, 0xd9, 0xe7, 0xe7,
+    0xd9, 0xd8, 0x00, 0xe8, 0xe3, 0x00, 0xed, 0xe3, 0xe9, 0xad, 0xff, 0xc3,
+    0xe8, 0x00, 0xd5, 0xe4, 0xe4, 0xd9, 0xd5, 0xe6, 0xe7, 0x00, 0xe8, 0xe3,
+    0x00, 0xd6, 0xd9, 0x00, 0xda, 0xe3, 0xe6, 0x00, 0xe9, 0xe7, 0xd9, 0x00,
+    0xd5, 0xe8, 0x00, 0xe8, 0xdc, 0xd9, 0xfe, 0xc6, 0xc3, 0xc6, 0xd3, 0xbd,
+    0xc9, 0xd0, 0xbf, 0x00, 0xbd, 0xc3, 0xce, 0xd3, 0x00, 0xe4, 0xe3, 0xe6,
+    0xe8, 0xad, 0xfb, 0xd1, 0xdc, 0xed, 0x00, 0xe2, 0xe3, 0xe8, 0x00, 0xdb,
+    0xdd, 0xea, 0xd9, 0x00, 0xdd, 0xe8, 0x00, 0xd5, 0x00, 0xe8, 0xe6, 0xed,
+    0x00, 0xd5, 0xe2, 0xd8, 0x00, 0xe7, 0xd9, 0xd9, 0x00, 0xeb, 0xdc, 0xd5,
+    0xe8, 0xfe, 0xdd, 0xe8, 0x00, 0xdd, 0xe7, 0x00, 0xd5, 0xd6, 0xe3, 0xe9,
+    0xe8, 0xac, 0xff, 0xce, 0xdc, 0xd5, 0xe2, 0xdf, 0x00, 0xed, 0xe3, 0xe9,
+    0x00, 0xda, 0xe3, 0xe6, 0x00, 0xe9, 0xe7, 0xdd, 0xe2, 0xdb, 0x00, 0xe8,
+    0xdc, 0xd9, 0x00, 0xc7, 0xd3, 0xcd, 0xce, 0xbf, 0xcc, 0xd3, 0xfe, 0xc1,
+    0xc3, 0xc0, 0xce, 0x00, 0xcd, 0xed, 0xe7, 0xe8, 0xd9, 0xe1, 0xad, 0xff,
+    0xc9, 0xdc, 0xb8, 0x00, 0xc3, 0xb4, 0xe1, 0x00, 0xe7, 0xe3, 0xe6, 0xe6,
+    0xed, 0xb8, 0x00, 0xfd, 0x01, 0xad, 0xfe, 0xd3, 0xe3, 0xe9, 0xe6, 0x00,
+    0xbc, 0xbb, 0xc1, 0xb4, 0xe7, 0x00, 0xc5, 0xbf, 0xd3, 0x00, 0xc3, 0xce,
+    0xbf, 0xc7, 0xcd, 0x00, 0xca, 0xc9, 0xbd, 0xc5, 0xbf, 0xce, 0x00, 0xdd,
+    0xe7, 0x00, 0xda, 0xe9, 0xe0, 0xe0, 0xad, 0xfb, 0xca, 0xe0, 0xd9, 0xd5,
+    0xe7, 0xd9, 0x00, 0xe7, 0xe8, 0xe3, 0xe6, 0xd9, 0x00, 0xe7, 0xe3, 0xe1,
+    0xd9, 0xe8, 0xdc, 0xdd, 0xe2, 0xdb, 0x00, 0xe3, 0xe2, 0x00, 0xed, 0xe3,
+    0xe9, 0xe6, 0x00, 0xca, 0xbd, 0xb8, 0xfe, 0xe8, 0xdc, 0xd9, 0xe2, 0x00,
+    0xd7, 0xe3, 0xe1, 0xd9, 0x00, 0xd6, 0xd5, 0xd7, 0xdf, 0x00, 0xda, 0xe3,
+    0xe6, 0x00, 0xe8, 0xdc, 0xdd, 0xe7, 0xad, 0xff, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
\ No newline at end of file
diff --git a/include/dbg/ptgb_mgba_print.h b/include/dbg/ptgb_mgba_print.h
index 0621aab..0128577 100644
--- a/include/dbg/ptgb_mgba_print.h
+++ b/include/dbg/ptgb_mgba_print.h
@@ -2,7 +2,8 @@
 #define _PTGB_MGBA_PRINT_H_
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 #define PTGB_MGBA_LOG_FATAL 0
@@ -17,10 +18,10 @@ extern "C" {
 #define PTGB_MGBA_INFO(...) ptgb_mgba_print(PTGB_MGBA_LOG_INFO, __VA_ARGS__)
 #define PTGB_MGBA_DEBUG(...) ptgb_mgba_print(PTGB_MGBA_LOG_DEBUG, __VA_ARGS__)
 
-void ptgb_mgba_init(void);
-void ptgb_mgba_deinit(void);
+    void ptgb_mgba_init(void);
+    void ptgb_mgba_deinit(void);
 
-void ptgb_mgba_print(int level, const char *format_str, ...);
+    void ptgb_mgba_print(int level, const char *format_str, ...);
 
 #ifdef __cplusplus
 }
diff --git a/include/dex_handler.h b/include/dex_handler.h
index feccb22..e4f305d 100644
--- a/include/dex_handler.h
+++ b/include/dex_handler.h
@@ -5,14 +5,14 @@
 
 class Dex
 {
-public:
+  public:
     Dex();
     Dex(OBJ_ATTR *L, OBJ_ATTR *M, OBJ_ATTR *R);
     void set_location(int x, int y);
     void hide();
     void show();
 
-private:
+  private:
     int x;
     int y;
     bool highlighted;
diff --git a/include/flash_mem.h b/include/flash_mem.h
index a0e9b16..89d9aff 100644
--- a/include/flash_mem.h
+++ b/include/flash_mem.h
@@ -1,13 +1,13 @@
 #ifndef MIRROR_H
 #define MIRROR_H
-#include <tonc.h>
 #include "rom_data.h"
+#include <tonc.h>
 
-#define SAVE_A_OFFSET       0x00000000 // Offset of Game Save A
-#define SAVE_B_OFFSET       0x0000E000 // Offset of Game Save B
+#define SAVE_A_OFFSET 0x00000000 // Offset of Game Save A
+#define SAVE_B_OFFSET 0x0000E000 // Offset of Game Save B
 
-#define SECTION_ID_OFFSET   0x00000FF4
-#define SAVE_INDEX_OFFSET   0x00000FFC
+#define SECTION_ID_OFFSET 0x00000FF4
+#define SAVE_INDEX_OFFSET 0x00000FFC
 
 extern vu32 newest_save_offset;
 extern vu32 memory_section_array[];
@@ -16,24 +16,27 @@ extern u8 global_memory_buffer[0x1000];
 extern rom_data curr_GBA_rom;
 
 /**
- * @brief Given that the save sections within a save slot are not saved in a fixed order,
- * This function will walk through the save slot to fill the memory_section_array map.
- * 
- * After calling this, memory_section_array will point to the save offset by each section ID. 
- * So memory_section_array[0] will point to the save offset of section 0, etc.
+ * @brief Given that the save sections within a save slot are not saved in a
+ * fixed order, This function will walk through the save slot to fill the
+ * memory_section_array map.
+ *
+ * After calling this, memory_section_array will point to the save offset by
+ * each section ID. So memory_section_array[0] will point to the save offset of
+ * section 0, etc.
  */
 void initialize_memory_locations();
 
 void print_mem_section();
-//bool insert_pokemon(Pokemon party_array[], int num);
+// bool insert_pokemon(Pokemon party_array[], int num);
 void reverse_endian(u8 *data, size_t size);
 
 /**
  * @brief This function will update the checksum in the given sector buffer.
  * It assumes that the sector buffer contains one of the save data sections.
- * 
+ *
  * @param sector_buffer The buffer containing the save data section.
- * @param hall_of_fame This is needed to indicate if you're trying to save the hall of fame section. The checksum offset is slightly different there.
+ * @param hall_of_fame This is needed to indicate if you're trying to save the
+ * hall of fame section. The checksum offset is slightly different there.
  */
 void update_memory_buffer_checksum(u8 *sector_buffer, bool hall_of_fame);
 bool read_flag(u16 flag_id);
diff --git a/include/gb_link.h b/include/gb_link.h
index df15cd7..0f8faf4 100644
--- a/include/gb_link.h
+++ b/include/gb_link.h
@@ -1,4 +1,4 @@
-//Created by StevenChaulk https://github.com/stevenchaulk/arduino-poke-gen2
+// Created by StevenChaulk https://github.com/stevenchaulk/arduino-poke-gen2
 
 #ifndef GB_LINK_H
 
diff --git a/include/gb_rom_values/base_gb_rom_struct.h b/include/gb_rom_values/base_gb_rom_struct.h
index 3763390..b3913ed 100644
--- a/include/gb_rom_values/base_gb_rom_struct.h
+++ b/include/gb_rom_values/base_gb_rom_struct.h
@@ -44,21 +44,26 @@ extern "C"
 
 #define GB_TILE_WIDTH 20
 
-// TODO? : Since we moved payload_builder into data-generator, we no longer need most of the fields of GB_ROM in our PTGB rom.
-// It might be better to split it up into a struct that contains everything for data-generator and a separate one that gets
-// included into the ptgb rom, which only includes whatever PTGB needs at runtime. (which is probably a fraction of the data)
-// However, right now the compressed gb_rom_values_eng file is only 353 bytes and the gb_rom_values_fre is only 351 bytes.
-// Therefore we'd save at most about 0,5 KB if we do this optimization. So it might not be worth it right now.
-// If we expand the data at some point, however, it might be!
+// TODO? : Since we moved payload_builder into data-generator, we no longer need
+// most of the fields of GB_ROM in our PTGB rom. It might be better to split it
+// up into a struct that contains everything for data-generator and a separate
+// one that gets included into the ptgb rom, which only includes whatever PTGB
+// needs at runtime. (which is probably a fraction of the data) However, right
+// now the compressed gb_rom_values_eng file is only 353 bytes and the
+// gb_rom_values_fre is only 351 bytes. Therefore we'd save at most about 0,5 KB
+// if we do this optimization. So it might not be worth it right now. If we
+// expand the data at some point, however, it might be!
 
-// WARNING: We must be explicit in the type declarations of the struct members here.
-// After all: data-generator runs on x86 and the structs will be read by the GBA's ARM processor.
-// So we must ensure the sizes of the struct members, as well as padding, remains consistent across platforms.
-// So please make sure to use data types which are explicit in their size. (such as uint32_t, uint8_t, etc.)
-// Because the regular "int", "bool", "char" etc are platform-dependent in size.
+// WARNING: We must be explicit in the type declarations of the struct members
+// here. After all: data-generator runs on x86 and the structs will be read by
+// the GBA's ARM processor. So we must ensure the sizes of the struct members,
+// as well as padding, remains consistent across platforms. So please make sure
+// to use data types which are explicit in their size. (such as uint32_t,
+// uint8_t, etc.) Because the regular "int", "bool", "char" etc are
+// platform-dependent in size.
 struct GB_ROM
 {
-public:
+  public:
     int32_t language;
     int32_t version;
     int32_t generation;
@@ -67,25 +72,30 @@ public:
     int32_t box_data_size;
 
     u16 print_string_start;       // Start of where text is written in VRAM
-    u16 stack_overwrite_location; // The part of the stack that we're overwriting
-    u8 short_pkmn_name;           // The name of the Pokemon that moves us through RAM
-    u8 pointer_pkmn_name;         // The name of the Pokemon that overwrites the stack
+    u16 stack_overwrite_location; // The part of the stack that we're
+                                  // overwriting
+    u8 short_pkmn_name;   // The name of the Pokemon that moves us through RAM
+    u8 pointer_pkmn_name; // The name of the Pokemon that overwrites the stack
     u16 padding_1;
 
-    u32 clearScreen;             // location of the clearScreen function in the ROM
-    u32 CableClub_TextBoxBorder; // location of the CableClub_TextBoxBorder function in the ROM
-    u32 placeString;             // location of the placeString function in the ROM
-    u32 Serial_ExchangeBytes;    // location of the Serial_ExchangeBytes function in the ROM
-    u32 _RemovePokemon;          // location of the _RemovePokemon function in the ROM
-    u32 SaveSAVtoSRAM1;          // location of the SaveSAVtoSRAM1 function in the ROM
-    u32 SaveSAVtoSRAM2;          // location of the SaveSAVtoSRAM2 function in the ROM
-    u32 LoadCurrentBoxData;      // location of the LoadCurrentBoxData function in the ROM
-    u32 OpenSRAM;                // location of the OpenSRAM function in the ROM
-    u32 SaveBox;                 // location of the SaveBox function in the ROM
-    u32 Bankswitch;              // location of the BankswitchCommon function in the ROM
-    u32 SoftReset;               // location of the SoftReset function in the ROM
-    u32 CloseSRAM;               // location of the OpenSRAM function in the ROM
-    u32 garbageDataLocation;     // location of random data starting with 0xFD in the ROM
+    u32 clearScreen; // location of the clearScreen function in the ROM
+    u32 CableClub_TextBoxBorder; // location of the CableClub_TextBoxBorder
+                                 // function in the ROM
+    u32 placeString;          // location of the placeString function in the ROM
+    u32 Serial_ExchangeBytes; // location of the Serial_ExchangeBytes function
+                              // in the ROM
+    u32 _RemovePokemon; // location of the _RemovePokemon function in the ROM
+    u32 SaveSAVtoSRAM1; // location of the SaveSAVtoSRAM1 function in the ROM
+    u32 SaveSAVtoSRAM2; // location of the SaveSAVtoSRAM2 function in the ROM
+    u32 LoadCurrentBoxData; // location of the LoadCurrentBoxData function in
+                            // the ROM
+    u32 OpenSRAM;           // location of the OpenSRAM function in the ROM
+    u32 SaveBox;            // location of the SaveBox function in the ROM
+    u32 Bankswitch; // location of the BankswitchCommon function in the ROM
+    u32 SoftReset;  // location of the SoftReset function in the ROM
+    u32 CloseSRAM;  // location of the OpenSRAM function in the ROM
+    u32 garbageDataLocation; // location of random data starting with 0xFD in
+                             // the ROM
 
     u32 wRemoveMonFromBox;     // location of wRemoveMonFromBox in RAM
     u32 wCurrentBoxNum;        // location of wCurrentBoxNum in RAM
@@ -96,14 +106,19 @@ public:
     u32 wSerialEnemyDataBlock; // location of wSerialEnemyDataBlock in RAM
     u32 wEnemyMonSpecies;      // location of wEnemyMonSpecies in RAM
 
-    u32 wSerialEnemyMonsPatchList;                // location of wSerialEnemyMonsPatchList in RAM
-    u32 wSerialOtherGameboyRandomNumberListBlock; // location of wSerialOtherGameboyRandomNumberListBlock in RAM
-    u32 hSerialConnectionStatus;                  // location of hSerialConnectionStatus in RAM
+    u32 wSerialEnemyMonsPatchList; // location of wSerialEnemyMonsPatchList in
+                                   // RAM
+    u32 wSerialOtherGameboyRandomNumberListBlock; // location of
+                                                  // wSerialOtherGameboyRandomNumberListBlock
+                                                  // in RAM
+    u32 hSerialConnectionStatus; // location of hSerialConnectionStatus in RAM
 
-    u16 transferStringLocation; // location in VRAM to start writing the transfer string to
-    u16 textBorderUppLeft;      // location in VRAM to put the upper left corner of the border
-    u8 textBorderWidth;         // the width of the text box border
-    u8 textBorderHeight;        // the height of the text box border
+    u16 transferStringLocation; // location in VRAM to start writing the
+                                // transfer string to
+    u16 textBorderUppLeft; // location in VRAM to put the upper left corner of
+                           // the border
+    u8 textBorderWidth;    // the width of the text box border
+    u8 textBorderHeight;   // the height of the text box border
     u16 padding_2;
 };
 
diff --git a/include/global_frame_controller.h b/include/global_frame_controller.h
index afcdde2..43a9742 100644
--- a/include/global_frame_controller.h
+++ b/include/global_frame_controller.h
@@ -2,6 +2,7 @@
 #define GLOBAL_FRAME_CONTROLLER_H
 
 #include <cstring>
+#include <tonc.h>
 
 enum LinkAnimationState
 {
diff --git a/include/interrupt.h b/include/interrupt.h
index 47c5b27..2dc9190 100644
--- a/include/interrupt.h
+++ b/include/interrupt.h
@@ -1,22 +1,23 @@
 #ifndef INTERRUPT_H
 #define INTERRUPT_H
 
-typedef enum {
-  INTR_VBLANK = 0,
-  INTR_HBLANK = 1,
-  INTR_VCOUNT = 2,
-  INTR_TIMER0 = 3,
-  INTR_TIMER1 = 4,
-  INTR_TIMER2 = 5,
-  INTR_TIMER3 = 6,
-  INTR_SERIAL = 7,
-  INTR_DMA0 = 8,
-  INTR_DMA1 = 9,
-  INTR_DMA2 = 10,
-  INTR_DMA3 = 11,
-  INTR_KEYPAD = 12,
-  INTR_GAMEPAK = 13,
-  INTR_NUMBER
+typedef enum
+{
+    INTR_VBLANK = 0,
+    INTR_HBLANK = 1,
+    INTR_VCOUNT = 2,
+    INTR_TIMER0 = 3,
+    INTR_TIMER1 = 4,
+    INTR_TIMER2 = 5,
+    INTR_TIMER3 = 6,
+    INTR_SERIAL = 7,
+    INTR_DMA0 = 8,
+    INTR_DMA1 = 9,
+    INTR_DMA2 = 10,
+    INTR_DMA3 = 11,
+    INTR_KEYPAD = 12,
+    INTR_GAMEPAK = 13,
+    INTR_NUMBER
 } interrupt_index;
 
 typedef void (*interrupt_vector)(void);
@@ -27,4 +28,4 @@ void interrupt_enable(interrupt_index index);
 void interrupt_disable(interrupt_index index);
 void interrupt_set_reference_vcount(unsigned long y);
 
-#endif  // INTERRUPT_H
\ No newline at end of file
+#endif // INTERRUPT_H
\ No newline at end of file
diff --git a/include/libstd_replacements.h b/include/libstd_replacements.h
index 14fec28..ae0641e 100644
--- a/include/libstd_replacements.h
+++ b/include/libstd_replacements.h
@@ -1,8 +1,8 @@
 #ifndef _LIBSTD_REPLACEMENTS_H
 #define _LIBSTD_REPLACEMENTS_H
 
-#include <inttypes.h>
 #include <cstring>
+#include <inttypes.h>
 #include <new>
 #include <utility>
 
@@ -13,213 +13,191 @@
 
 namespace ptgb
 {
-    /**
-     * This utility/convenience function converts the given value to a string.
-     * WARNING: it AND its other variants always use the same buffer.
-     * So calling it more than once will overwrite the previously returned string!
-     * 
-     * Be careful!
-     * In case you want to convert more than one int to string within the same call,
-     * consider using npf_snprintf instead!
-     * 
-     * Also: if you want to hold on to the converted value, consider copying the returned string
-     */
-    const char* to_string(int intVal);
-    
-    
-    /**
-     * This utility/convenience function converts the given value to a string.
-     * WARNING: it AND its other variants always use the same buffer.
-     * So calling it more than once will overwrite the previously returned string!
-     * 
-     * Be careful!
-     * In case you want to convert more than one int to string within the same call,
-     * consider using npf_snprintf instead!
-     * 
-     * Also: if you want to hold on to the converted value, consider copying the returned string
-     */
-    const char* to_string(unsigned int wordVal);
+/**
+ * This utility/convenience function converts the given value to a string.
+ * WARNING: it AND its other variants always use the same buffer.
+ * So calling it more than once will overwrite the previously returned string!
+ *
+ * Be careful!
+ * In case you want to convert more than one int to string within the same call,
+ * consider using npf_snprintf instead!
+ *
+ * Also: if you want to hold on to the converted value, consider copying the
+ * returned string
+ */
+const char *to_string(int intVal);
 
-    template <class ValueType>
-    class vector
+/**
+ * This utility/convenience function converts the given value to a string.
+ * WARNING: it AND its other variants always use the same buffer.
+ * So calling it more than once will overwrite the previously returned string!
+ *
+ * Be careful!
+ * In case you want to convert more than one int to string within the same call,
+ * consider using npf_snprintf instead!
+ *
+ * Also: if you want to hold on to the converted value, consider copying the
+ * returned string
+ */
+const char *to_string(unsigned int wordVal);
+
+template <class ValueType> class vector
+{
+  public:
+    static constexpr uint16_t default_capacity = 2;
+
+    vector() : buffer_(), capacity_(default_capacity), count_(0)
     {
-    public:
-        static constexpr uint16_t default_capacity = 2;
-
-        vector()
-            : buffer_()
-            , capacity_(default_capacity)
-            , count_(0)
+        buffer_ = static_cast<ValueType *>(
+            ::operator new(sizeof(ValueType) * capacity_));
+        if (!buffer_)
         {
-            buffer_ = static_cast<ValueType*>(::operator new(sizeof(ValueType) * capacity_));
-            if(!buffer_)
+            return; // allocation failed
+        }
+    }
+
+    vector(const ValueType *valueList, uint16_t listSize)
+        : buffer_(), capacity_(listSize), count_(0)
+    {
+        buffer_ = static_cast<ValueType *>(
+            ::operator new(sizeof(ValueType) * capacity_));
+        if (!buffer_)
+        {
+            return; // allocation failed
+        }
+        insert(valueList, listSize);
+    }
+
+    vector(const vector<ValueType> &otherList)
+        : buffer_(), capacity_(otherList.capacity_), count_(0)
+    {
+        buffer_ = static_cast<ValueType *>(
+            ::operator new(sizeof(ValueType) * capacity_));
+        if (!buffer_)
+        {
+            return; // allocation failed
+        }
+        insert(otherList);
+    }
+
+    ~vector()
+    {
+        clear();
+        ::operator delete(buffer_);
+    }
+
+    void reserve(uint16_t newSize)
+    {
+        if (newSize <= capacity_)
+        {
+            return;
+        }
+        ValueType *new_buffer = static_cast<ValueType *>(
+            ::operator new(sizeof(ValueType) * newSize));
+        if (!new_buffer)
+        {
+            return; // allocation failed, keep the old buffer
+        }
+
+        // copy data from the old buffer to the new one
+        for (uint16_t i = 0; i < count_; ++i)
+        {
+            new (new_buffer + i) ValueType(std::move(buffer_[i]));
+            buffer_[i].~ValueType();
+        }
+
+        ::operator delete(buffer_);
+
+        buffer_ = new_buffer;
+        capacity_ = newSize;
+    }
+
+    void resize(uint16_t newSize) { resize(newSize, ValueType()); }
+
+    void resize(uint16_t newSize, const ValueType &value)
+    {
+        if (newSize < count_)
+        {
+            const uint16_t num_erase = (count_ - newSize);
+            for (uint16_t i = 0; i < num_erase; ++i)
             {
-                return; // allocation failed
+                pop_back();
             }
         }
-
-        vector(const ValueType* valueList, uint16_t listSize)
-            : buffer_()
-            , capacity_(listSize)
-            , count_(0)
+        else if (newSize > count_)
         {
-            buffer_ = static_cast<ValueType*>(::operator new(sizeof(ValueType) * capacity_));
-            if(!buffer_)
+            reserve(newSize);
+            const uint16_t num_fill = (newSize - count_);
+            for (uint16_t i = 0; i < num_fill; ++i)
             {
-                return; // allocation failed
-            }
-            insert(valueList, listSize);
-        }
-
-        vector(const vector<ValueType>& otherList)
-            : buffer_()
-            , capacity_(otherList.capacity_)
-            , count_(0)
-        {
-            buffer_ = static_cast<ValueType*>(::operator new(sizeof(ValueType) * capacity_));
-            if(!buffer_)
-            {
-                return; // allocation failed
-            }
-            insert(otherList);
-        }
-
-        ~vector()
-        {
-            clear();
-            ::operator delete(buffer_);
-        }
-
-        void reserve(uint16_t newSize)
-        {
-            if(newSize <= capacity_)
-            {
-                return;
-            }
-            ValueType* new_buffer = static_cast<ValueType*>(::operator new(sizeof(ValueType) * newSize));
-            if(!new_buffer)
-            {
-                return; // allocation failed, keep the old buffer
-            }
-
-            // copy data from the old buffer to the new one
-            for (uint16_t i = 0; i < count_; ++i)
-            {
-                new (new_buffer + i) ValueType(std::move(buffer_[i]));
-                buffer_[i].~ValueType();
-            }
-
-            ::operator delete(buffer_);
-
-            buffer_ = new_buffer;
-            capacity_ = newSize;
-        }
-
-        void resize(uint16_t newSize)
-        {
-            resize(newSize, ValueType());
-        }
-
-        void resize(uint16_t newSize, const ValueType& value)
-        {
-            if(newSize < count_)
-            {
-                const uint16_t num_erase = (count_ - newSize);
-                for(uint16_t i=0; i < num_erase; ++i)
-                {
-                    pop_back();
-                }
-            }
-            else if(newSize > count_)
-            {
-                reserve(newSize);
-                const uint16_t num_fill = (newSize - count_);
-                for(uint16_t i=0; i < num_fill; ++i)
-                {
-                    push_back(value);
-                }
+                push_back(value);
             }
         }
+    }
 
-        void push_back(const ValueType& value)
+    void push_back(const ValueType &value)
+    {
+        if (count_ == capacity_)
         {
-            if(count_ == capacity_)
-            {
-                reserve(capacity_ * 2);
-            }
-            new(buffer_ + count_) ValueType(value);
-            ++count_;
+            reserve(capacity_ * 2);
         }
+        new (buffer_ + count_) ValueType(value);
+        ++count_;
+    }
 
-        void pop_back()
-        {
-            if (count_ == 0) return;
-            ValueType *value = buffer_ + (count_ - 1);
-            value->~ValueType();
-            --count_;
-        }
+    void pop_back()
+    {
+        if (count_ == 0)
+            return;
+        ValueType *value = buffer_ + (count_ - 1);
+        value->~ValueType();
+        --count_;
+    }
 
-        void insert(const vector<ValueType>& otherList)
-        {
-            reserve(count_ + otherList.size());
+    void insert(const vector<ValueType> &otherList)
+    {
+        reserve(count_ + otherList.size());
 
-            for(uint16_t i=0; i < otherList.size(); ++i)
-            {
-                push_back(otherList.at(i));
-            }
+        for (uint16_t i = 0; i < otherList.size(); ++i)
+        {
+            push_back(otherList.at(i));
         }
+    }
 
-        void insert(const ValueType* list, uint16_t listSize)
+    void insert(const ValueType *list, uint16_t listSize)
+    {
+        reserve(count_ + listSize);
+        for (size_t i = 0; i < listSize; ++i)
         {
-            reserve(count_ + listSize);
-            for(size_t i=0; i < listSize; ++i)
-            {
-                push_back(list[i]);
-            }
+            push_back(list[i]);
         }
+    }
 
-        void clear()
-        {
-            resize(0);
-        }
+    void clear() { resize(0); }
 
-        uint16_t size() const { return count_; }
-        uint16_t capacity() const { return capacity_; }
+    uint16_t size() const { return count_; }
+    uint16_t capacity() const { return capacity_; }
 
-        ValueType* data() const
-        {
-            return buffer_;
-        }
+    ValueType *data() const { return buffer_; }
 
-        ValueType* data()
-        {
-            return buffer_;
-        }
+    ValueType *data() { return buffer_; }
 
-        ValueType& at(uint16_t index)
-        {
-            return operator[](index);
-        }
+    ValueType &at(uint16_t index) { return operator[](index); }
 
-        const ValueType& at(uint16_t index) const
-        {
-            return operator[](index);
-        }
-        
-        ValueType& operator[](uint16_t index)
-        {
-            return *(buffer_ + index);
-        }
-        
-        const ValueType& operator[](uint16_t index) const
-        {
-            return *(buffer_ + index);
-        }
-    private:
-        ValueType *buffer_;
-        uint16_t capacity_;
-        uint16_t count_;
-    };
-}
+    const ValueType &at(uint16_t index) const { return operator[](index); }
+
+    ValueType &operator[](uint16_t index) { return *(buffer_ + index); }
+
+    const ValueType &operator[](uint16_t index) const
+    {
+        return *(buffer_ + index);
+    }
+
+  private:
+    ValueType *buffer_;
+    uint16_t capacity_;
+    uint16_t count_;
+};
+} // namespace ptgb
 
 #endif
\ No newline at end of file
diff --git a/include/link_handler.h b/include/link_handler.h
index ccc1d43..dd87a36 100644
--- a/include/link_handler.h
+++ b/include/link_handler.h
@@ -1,11 +1,11 @@
 #ifndef LINK_HANDLER_H_
 #define LINK_HANDLER_H_
 
-#include <tonc.h>
-#include "libraries/gba-link-connection/LinkSPI.hpp"
 #include "GB_Payloads.h"
-#include "typeDefs.h"
 #include "gb_rom_values/base_gb_rom_struct.h"
+#include "libraries/gba-link-connection/LinkSPI.hpp"
+#include "typeDefs.h"
+#include <tonc.h>
 
 #define SPI_TEXT_OUT_ARRAY_ELEMENT_SIZE 64
 
@@ -64,161 +64,158 @@ enum GameBoyROM
     GB_ROM_ERROR,
 };
 
-const GB_PayloadsFiles GameBoyROMPayloads[] =
-    {
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_R,    // RED_JP_v0
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_R11,  // RED_JP_v1
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_EN_R,    // RED_EN
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_FR_R,    // RED_FR
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_IT_R,    // RED_IT
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_DE_R,    // RED_DE
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_SP_R,    // RED_SP
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_GR,   // GREEN_JP_v0
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_GR11, // GREEN_JP_v1
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_B,    // BLUE_JP
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_EN_B,    // BLUE_EN
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_FR_B,    // BLUE_FR
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_IT_B,    // BLUE_IT
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_DE_B,    // BLUE_DE
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_SP_B,    // BLUE_SP
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_Y,    // YELLOW_JP_v0
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_Y11,  // YELLOW_JP_v1
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_Y12,  // YELLOW_JP_v2
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_Y13,  // YELLOW_JP_v3
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_EN_Y,    // YELLOW_EN
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_FR_Y,    // YELLOW_FR
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_IT_Y,    // YELLOW_IT
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_DE_Y,    // YELLOW_DE
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN1_SP_Y,    // YELLOW_SP
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_JP_G,    // GOLD_JP_v0
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_JP_G11,  // GOLD_JP_v1
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_EN_G,    // GOLD_EN
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_FR_G,    // GOLD_FR
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_IT_G,    // GOLD_IT
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_DE_G,    // GOLD_DE
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_SP_G,    // GOLD_SP
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_KOR_G,   // GOLD_KOR
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_JP_S,    // SILVER_JP_v0
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_JP_S11,  // SILVER_JP_v1
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_EN_S,    // SILVER_EN
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_FR_S,    // SILVER_FR
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_IT_S,    // SILVER_IT
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_DE_S,    // SILVER_DE
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_SP_S,    // SILVER_SP
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_KOR_S,   // SILVER_KOR
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_JP_C,    // CRYSTAL_JP
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_EN_C,    // CRYSTAL_EN_v0
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_EN_C11,  // CRYSTAL_EN_v1
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_EN_CAU,  // CRYSTAL_EN_vA
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_FR_C,    // CRYSTAL_FR
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_IT_C,    // CRYSTAL_IT
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_DE_C,    // CRYSTAL_DE
-        GB_PayloadsFiles::SPECIFICPAYLOADGEN2_SP_C,    // CRYSTAL_SP
+const GB_PayloadsFiles GameBoyROMPayloads[] = {
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_R,    // RED_JP_v0
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_R11,  // RED_JP_v1
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_EN_R,    // RED_EN
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_FR_R,    // RED_FR
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_IT_R,    // RED_IT
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_DE_R,    // RED_DE
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_SP_R,    // RED_SP
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_GR,   // GREEN_JP_v0
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_GR11, // GREEN_JP_v1
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_B,    // BLUE_JP
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_EN_B,    // BLUE_EN
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_FR_B,    // BLUE_FR
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_IT_B,    // BLUE_IT
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_DE_B,    // BLUE_DE
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_SP_B,    // BLUE_SP
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_Y,    // YELLOW_JP_v0
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_Y11,  // YELLOW_JP_v1
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_Y12,  // YELLOW_JP_v2
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_JP_Y13,  // YELLOW_JP_v3
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_EN_Y,    // YELLOW_EN
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_FR_Y,    // YELLOW_FR
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_IT_Y,    // YELLOW_IT
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_DE_Y,    // YELLOW_DE
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN1_SP_Y,    // YELLOW_SP
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_JP_G,    // GOLD_JP_v0
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_JP_G11,  // GOLD_JP_v1
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_EN_G,    // GOLD_EN
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_FR_G,    // GOLD_FR
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_IT_G,    // GOLD_IT
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_DE_G,    // GOLD_DE
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_SP_G,    // GOLD_SP
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_KOR_G,   // GOLD_KOR
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_JP_S,    // SILVER_JP_v0
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_JP_S11,  // SILVER_JP_v1
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_EN_S,    // SILVER_EN
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_FR_S,    // SILVER_FR
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_IT_S,    // SILVER_IT
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_DE_S,    // SILVER_DE
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_SP_S,    // SILVER_SP
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_KOR_S,   // SILVER_KOR
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_JP_C,    // CRYSTAL_JP
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_EN_C,    // CRYSTAL_EN_v0
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_EN_C11,  // CRYSTAL_EN_v1
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_EN_CAU,  // CRYSTAL_EN_vA
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_FR_C,    // CRYSTAL_FR
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_IT_C,    // CRYSTAL_IT
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_DE_C,    // CRYSTAL_DE
+    GB_PayloadsFiles::SPECIFICPAYLOADGEN2_SP_C,    // CRYSTAL_SP
 };
 
-const Language GameBoyROMLanguages[] =
-    {
-        JAPANESE, // RED_JP_v0
-        JAPANESE, // RED_JP_v1
-        ENGLISH,  // RED_EN
-        FRENCH,   // RED_FR
-        ITALIAN,  // RED_IT
-        GERMAN,   // RED_DE
-        SPANISH,  // RED_SP
-        JAPANESE, // GREEN_JP_v0
-        JAPANESE, // GREEN_JP_v1
-        JAPANESE, // BLUE_JP
-        ENGLISH,  // BLUE_EN
-        FRENCH,   // BLUE_FR
-        ITALIAN,  // BLUE_IT
-        GERMAN,   // BLUE_DE
-        SPANISH,  // BLUE_SP
-        JAPANESE, // YELLOW_JP_v0
-        JAPANESE, // YELLOW_JP_v1
-        JAPANESE, // YELLOW_JP_v2
-        JAPANESE, // YELLOW_JP_v3
-        ENGLISH,  // YELLOW_EN
-        FRENCH,   // YELLOW_FR
-        ITALIAN,  // YELLOW_IT
-        GERMAN,   // YELLOW_DE
-        SPANISH,  // YELLOW_SP
-        JAPANESE, // GOLD_JP_v0
-        JAPANESE, // GOLD_JP_v1
-        ENGLISH,  // GOLD_EN
-        FRENCH,   // GOLD_FR
-        ITALIAN,  // GOLD_IT
-        GERMAN,   // GOLD_DE
-        SPANISH,  // GOLD_SP
-        KOREAN,   // GOLD_KOR
-        JAPANESE, // SILVER_JP_v0
-        JAPANESE, // SILVER_JP_v1
-        ENGLISH,  // SILVER_EN
-        FRENCH,   // SILVER_FR
-        ITALIAN,  // SILVER_IT
-        GERMAN,   // SILVER_DE
-        SPANISH,  // SILVER_SP
-        KOREAN,   // SILVER_KOR
-        JAPANESE, // CRYSTAL_JP
-        ENGLISH,  // CRYSTAL_EN_v0
-        ENGLISH,  // CRYSTAL_EN_v1
-        ENGLISH,  // CRYSTAL_EN_vA
-        FRENCH,   // CRYSTAL_FR
-        ITALIAN,  // CRYSTAL_IT
-        GERMAN,   // CRYSTAL_DE
-        SPANISH,  // CRYSTAL_SP
+const Language GameBoyROMLanguages[] = {
+    JAPANESE, // RED_JP_v0
+    JAPANESE, // RED_JP_v1
+    ENGLISH,  // RED_EN
+    FRENCH,   // RED_FR
+    ITALIAN,  // RED_IT
+    GERMAN,   // RED_DE
+    SPANISH,  // RED_SP
+    JAPANESE, // GREEN_JP_v0
+    JAPANESE, // GREEN_JP_v1
+    JAPANESE, // BLUE_JP
+    ENGLISH,  // BLUE_EN
+    FRENCH,   // BLUE_FR
+    ITALIAN,  // BLUE_IT
+    GERMAN,   // BLUE_DE
+    SPANISH,  // BLUE_SP
+    JAPANESE, // YELLOW_JP_v0
+    JAPANESE, // YELLOW_JP_v1
+    JAPANESE, // YELLOW_JP_v2
+    JAPANESE, // YELLOW_JP_v3
+    ENGLISH,  // YELLOW_EN
+    FRENCH,   // YELLOW_FR
+    ITALIAN,  // YELLOW_IT
+    GERMAN,   // YELLOW_DE
+    SPANISH,  // YELLOW_SP
+    JAPANESE, // GOLD_JP_v0
+    JAPANESE, // GOLD_JP_v1
+    ENGLISH,  // GOLD_EN
+    FRENCH,   // GOLD_FR
+    ITALIAN,  // GOLD_IT
+    GERMAN,   // GOLD_DE
+    SPANISH,  // GOLD_SP
+    KOREAN,   // GOLD_KOR
+    JAPANESE, // SILVER_JP_v0
+    JAPANESE, // SILVER_JP_v1
+    ENGLISH,  // SILVER_EN
+    FRENCH,   // SILVER_FR
+    ITALIAN,  // SILVER_IT
+    GERMAN,   // SILVER_DE
+    SPANISH,  // SILVER_SP
+    KOREAN,   // SILVER_KOR
+    JAPANESE, // CRYSTAL_JP
+    ENGLISH,  // CRYSTAL_EN_v0
+    ENGLISH,  // CRYSTAL_EN_v1
+    ENGLISH,  // CRYSTAL_EN_vA
+    FRENCH,   // CRYSTAL_FR
+    ITALIAN,  // CRYSTAL_IT
+    GERMAN,   // CRYSTAL_DE
+    SPANISH,  // CRYSTAL_SP
 };
 
 // This would probably make more sense as a "greater than less than" check.
-const Version GameBoyROMVersions[] =
-    {
-            RED,     // RED_JP_v0
-            RED,     // RED_JP_v1
-            RED,     // RED_EN
-            RED,     // RED_FR
-            RED,     // RED_IT
-            RED,     // RED_DE
-            RED,     // RED_SP
-            GREEN,   // GREEN_JP_v0
-            GREEN,   // GREEN_JP_v1
-            BLUE,    // BLUE_JP
-            BLUE,    // BLUE_EN
-            BLUE,    // BLUE_FR
-            BLUE,    // BLUE_IT
-            BLUE,    // BLUE_DE
-            BLUE,    // BLUE_SP
-            YELLOW,  // YELLOW_JP_v0
-            YELLOW,  // YELLOW_JP_v1
-            YELLOW,  // YELLOW_JP_v2
-            YELLOW,  // YELLOW_JP_v3
-            YELLOW,  // YELLOW_EN
-            YELLOW,  // YELLOW_FR
-            YELLOW,  // YELLOW_IT
-            YELLOW,  // YELLOW_DE
-            YELLOW,  // YELLOW_SP
-            GOLD,    // GOLD_JP_v0
-            GOLD,    // GOLD_JP_v1
-            GOLD,    // GOLD_EN
-            GOLD,    // GOLD_FR
-            GOLD,    // GOLD_IT
-            GOLD,    // GOLD_DE
-            GOLD,    // GOLD_SP
-            GOLD,    // GOLD_KOR
-            SILVER,  // SILVER_JP_v0
-            SILVER,  // SILVER_JP_v1
-            SILVER,  // SILVER_EN
-            SILVER,  // SILVER_FR
-            SILVER,  // SILVER_IT
-            SILVER,  // SILVER_DE
-            SILVER,  // SILVER_SP
-            SILVER,  // SILVER_KOR
-            CRYSTAL, // CRYSTAL_JP
-            CRYSTAL, // CRYSTAL_EN_v0
-            CRYSTAL, // CRYSTAL_EN_v1
-            CRYSTAL, // CRYSTAL_EN_vA
-            CRYSTAL, // CRYSTAL_FR
-            CRYSTAL, // CRYSTAL_IT
-            CRYSTAL, // CRYSTAL_DE
-            CRYSTAL, // CRYSTAL_SP
+const Version GameBoyROMVersions[] = {
+    RED,     // RED_JP_v0
+    RED,     // RED_JP_v1
+    RED,     // RED_EN
+    RED,     // RED_FR
+    RED,     // RED_IT
+    RED,     // RED_DE
+    RED,     // RED_SP
+    GREEN,   // GREEN_JP_v0
+    GREEN,   // GREEN_JP_v1
+    BLUE,    // BLUE_JP
+    BLUE,    // BLUE_EN
+    BLUE,    // BLUE_FR
+    BLUE,    // BLUE_IT
+    BLUE,    // BLUE_DE
+    BLUE,    // BLUE_SP
+    YELLOW,  // YELLOW_JP_v0
+    YELLOW,  // YELLOW_JP_v1
+    YELLOW,  // YELLOW_JP_v2
+    YELLOW,  // YELLOW_JP_v3
+    YELLOW,  // YELLOW_EN
+    YELLOW,  // YELLOW_FR
+    YELLOW,  // YELLOW_IT
+    YELLOW,  // YELLOW_DE
+    YELLOW,  // YELLOW_SP
+    GOLD,    // GOLD_JP_v0
+    GOLD,    // GOLD_JP_v1
+    GOLD,    // GOLD_EN
+    GOLD,    // GOLD_FR
+    GOLD,    // GOLD_IT
+    GOLD,    // GOLD_DE
+    GOLD,    // GOLD_SP
+    GOLD,    // GOLD_KOR
+    SILVER,  // SILVER_JP_v0
+    SILVER,  // SILVER_JP_v1
+    SILVER,  // SILVER_EN
+    SILVER,  // SILVER_FR
+    SILVER,  // SILVER_IT
+    SILVER,  // SILVER_DE
+    SILVER,  // SILVER_SP
+    SILVER,  // SILVER_KOR
+    CRYSTAL, // CRYSTAL_JP
+    CRYSTAL, // CRYSTAL_EN_v0
+    CRYSTAL, // CRYSTAL_EN_v1
+    CRYSTAL, // CRYSTAL_EN_vA
+    CRYSTAL, // CRYSTAL_FR
+    CRYSTAL, // CRYSTAL_IT
+    CRYSTAL, // CRYSTAL_DE
+    CRYSTAL, // CRYSTAL_SP
 };
 
 // This table has the 3 checksums, followed by the enum value
@@ -316,14 +313,48 @@ enum LinkConnectionError
 
 enum PayloadCommand
 {
-    CMD_NONE = 0x7F,             // Using 0x7F instead of -1, since that ends up being 0xFE.
-    CMD_ReloadCurrentBox = 0,    // no arguments used. Reloads the current box from SRAM. Use this as the first command byte before performing other commands.
-    CMD_TransferPokemon,         // 1st argument = secondary payload size, 2nd argument = box that should be transferred from. This command uses a secondary payload. The size of this secondary payload needs to be declared beforehand. Prior to requesting a secondary payload, the program will use the second argument to load a specific box from SRAM. Box numbers are 0-indexed and range from 0x00 (box 1) to 0x0B(box 12). This load procedure currently cannot be skipped. Once the secondary payload arrives, the program will verify its integrity and align the payload. Afterwards, it will use the information within this payload to remove pokémon from the current box. Once all transferred pokémon have been removed, the program will save the current box.
-    CMD_SoftReset,               // no arguments used. Instantly soft resets the game.
-    CMD_ModifySRAMAccess,        // 1st argument = SRAM dis/enable. set to 0x0A to open access, set to 0x00 to close access. Second argument = SRAM bank. When closing SRAM access, set to 0x00. SRAM remains open until closed by this command or until closed by CMD_TransferPokemon/CMD_ReloadCurrentBox.
-    CMD_RunSecondaryPayload,     // 1st argument = secondary payload size. This command uses a secondary payload. The size of this secondary payload needs to be declared beforehand. Once the secondary payload arrives, the program will verify its integrity and align the payload. Afterwards, it will jump to the secondary payload and execute it. IMPORTANT: if you want to report an error when executing this secondary payload, return with carry flag set. IMPORTANT: if you want to report that the payload was executed safely, return with carry flag reset.*/
-    CMD_ReadDataRequest,         // a request to read data starting from the address defined by the 16-bit pointer.
-    CMD_SecondaryPayload = 0xFF, // Used whenever a packet is for a secondary payload.
+    CMD_NONE = 0x7F, // Using 0x7F instead of -1, since that ends up being 0xFE.
+    CMD_ReloadCurrentBox =
+        0, // no arguments used. Reloads the current box from SRAM. Use this as
+           // the first command byte before performing other commands.
+    CMD_TransferPokemon, // 1st argument = secondary payload size, 2nd argument
+                         // = box that should be transferred from. This command
+                         // uses a secondary payload. The size of this secondary
+                         // payload needs to be declared beforehand. Prior to
+                         // requesting a secondary payload, the program will use
+                         // the second argument to load a specific box from
+                         // SRAM. Box numbers are 0-indexed and range from 0x00
+                         // (box 1) to 0x0B(box 12). This load procedure
+                         // currently cannot be skipped. Once the secondary
+                         // payload arrives, the program will verify its
+                         // integrity and align the payload. Afterwards, it will
+                         // use the information within this payload to remove
+                         // pokémon from the current box. Once all transferred
+                         // pokémon have been removed, the program will save the
+                         // current box.
+    CMD_SoftReset,        // no arguments used. Instantly soft resets the game.
+    CMD_ModifySRAMAccess, // 1st argument = SRAM dis/enable. set to 0x0A to open
+                          // access, set to 0x00 to close access. Second
+                          // argument = SRAM bank. When closing SRAM access, set
+                          // to 0x00. SRAM remains open until closed by this
+                          // command or until closed by
+                          // CMD_TransferPokemon/CMD_ReloadCurrentBox.
+    CMD_RunSecondaryPayload, // 1st argument = secondary payload size. This
+                             // command uses a secondary payload. The size of
+                             // this secondary payload needs to be declared
+                             // beforehand. Once the secondary payload arrives,
+                             // the program will verify its integrity and align
+                             // the payload. Afterwards, it will jump to the
+                             // secondary payload and execute it. IMPORTANT: if
+                             // you want to report an error when executing this
+                             // secondary payload, return with carry flag set.
+                             // IMPORTANT: if you want to report that the
+                             // payload was executed safely, return with carry
+                             // flag reset.*/
+    CMD_ReadDataRequest,     // a request to read data starting from the address
+                             // defined by the 16-bit pointer.
+    CMD_SecondaryPayload =
+        0xFF, // Used whenever a packet is for a secondary payload.
 };
 
 #define OUTP_PREAMBLE_INDEX 0
@@ -361,7 +392,9 @@ struct LinkPacket
     byte *secondaryPayloadData = nullptr;
     int secondaryPayloadDataSize = 0;
     byte secondaryPayloadSizeChecksum = 0;
-#define SECONDARY_PAYLOAD_HEADER_SIZE 4 // The size of a secondary packet, not including the data bytes or checksum
+#define SECONDARY_PAYLOAD_HEADER_SIZE                                          \
+    4 // The size of a secondary packet, not including the data bytes or
+      // checksum
 
     LinkPacket() {};
     LinkPacket(PayloadCommand cmd, byte arg1, byte arg2, u16 addr);
@@ -370,7 +403,7 @@ struct LinkPacket
 
 class LinkConnection
 {
-public:
+  public:
     LinkState enterState;
     LinkState exitState;
     bool subStateChanged = false;
@@ -381,14 +414,17 @@ public:
     uint8_t outData = 0xFF;
     uint8_t nextOutData = 0xFF;
 
-    int globalStateCounter = 0; // The counter for the total number of bytes sent
-    int subStateCounter = 0;    // The counter for the total number of bytes sent in this substate
+    int globalStateCounter =
+        0; // The counter for the total number of bytes sent
+    int subStateCounter =
+        0; // The counter for the total number of bytes sent in this substate
 
     int gen = 0;                      // The generation we are trading with
     Language lang = LANGUAGE_UNKNOWN; // The language we are trading with
     Version vers = VERSION_UNKNOWN;   // The version we are trading with
-    GameBoyROM currROM = NO_GB_ROM;   // The GameBoy ROM we're communicating with
-    const GB_ROM *pccsROMptr = nullptr;     // A pointer to the ROM data for the game we're communicating with
+    GameBoyROM currROM = NO_GB_ROM; // The GameBoy ROM we're communicating with
+    const GB_ROM *pccsROMptr = nullptr; // A pointer to the ROM data for the
+                                        // game we're communicating with
     byte boxNum = 0;                    // The current box the user has selected
 
     int FF_count = 0;   // The number of 0xFF bytes that have been in a row
@@ -396,7 +432,7 @@ public:
 
     byte payloadBuffer[0x2A0];
     int curr_payload_size = 0;
-    #define DATA_OUT_BUFFER_SIZE 16
+#define DATA_OUT_BUFFER_SIZE 16
     byte dataOutBuffer[DATA_OUT_BUFFER_SIZE];
     int dataOutBufferCurrIndex = 0;
 
@@ -410,15 +446,18 @@ public:
     LinkPacket *currOutgoingPacket;
     LinkPacket *currIncomingPacket;
     LinkPacket dummyPacket = LinkPacket();
-    byte linkPacketArrIndex = LINK_PACKET_ARRAY_SIZE; // We want to avoid starting at zero, since that is a common value sent back in error.
+    byte linkPacketArrIndex =
+        LINK_PACKET_ARRAY_SIZE; // We want to avoid starting at zero, since that
+                                // is a common value sent back in error.
     u16 linkPacketDataAddr = 0;
     u16 linkPacketDataStart = 0;
     int linkPacketDataSize = 0;
     byte *outDataArrayPtr;
 
-    bool pauseOnByte = false;   // Used for pausing and sending one byte at a time
-    bool pauseOnPacket = false; // Used for pausing and sending one packet at a time
-    bool skipPrint = false;     // Skips printing to the screen
+    bool pauseOnByte = false; // Used for pausing and sending one byte at a time
+    bool pauseOnPacket =
+        false;              // Used for pausing and sending one packet at a time
+    bool skipPrint = false; // Skips printing to the screen
 
     void setup(const u16 *debug_charset);
     void startConnection(LinkState startState);
@@ -433,17 +472,22 @@ public:
     // These are all the Link Commands
     bool LinkCommand_InitalizeConnection(bool waitForCompletion = true);
     bool LinkCommand_ReloadCurrentBox(bool waitForCompletion = true);
-    bool LinkCommand_TransferPokemon(int boxNumber, byte removalArray[], int removalArrayLength, bool waitForCompletion = true);
+    bool LinkCommand_TransferPokemon(int boxNumber, byte removalArray[],
+        int removalArrayLength, bool waitForCompletion = true);
     bool LinkCommand_SoftReset(bool waitForCompletion = true);
-    bool LinkCommand_ModifySRAMAccess(bool enableSRAM, byte SRAMbank, bool waitForCompletion = true);
-    bool LinkCommand_RunSecondaryPayload(byte payload[], int payloadLength, bool waitForCompletion = true);
-    bool LinkCommand_ReadMemorySection(u32 dataPointer, byte outArray[], int outArraySize, bool waitForCompletion = true);
+    bool LinkCommand_ModifySRAMAccess(
+        bool enableSRAM, byte SRAMbank, bool waitForCompletion = true);
+    bool LinkCommand_RunSecondaryPayload(
+        byte payload[], int payloadLength, bool waitForCompletion = true);
+    bool LinkCommand_ReadMemorySection(u32 dataPointer, byte outArray[],
+        int outArraySize, bool waitForCompletion = true);
 
     // Some operations are too long to be done within the IRQ.
-    // So we need to handle them in the main loop instead to avoid data corruption.
+    // So we need to handle them in the main loop instead to avoid data
+    // corruption.
     void handleCartIO();
 
-private:
+  private:
     void loadPayload(GB_PayloadsFiles payload);
     void loadPayloadByROM(GameBoyROM rom);
     void loadCurrGameFromChecksum();
diff --git a/include/multiboot_upload.h b/include/multiboot_upload.h
index 45d86e6..0466fd9 100644
--- a/include/multiboot_upload.h
+++ b/include/multiboot_upload.h
@@ -4,7 +4,8 @@
 /**
  * @brief Shows the multiboot upload screen.
  * If the user presses A in this screen/popup,
- * the GBA will upload the whole EWRAM as a multiboot rom to another GBA over the link cable.
+ * the GBA will upload the whole EWRAM as a multiboot rom to another GBA over
+ * the link cable.
  */
 void multiboot_upload_screen();
 
diff --git a/include/mystery_gift_injector.h b/include/mystery_gift_injector.h
index 4d83c50..38f9de0 100644
--- a/include/mystery_gift_injector.h
+++ b/include/mystery_gift_injector.h
@@ -4,6 +4,6 @@
 #include "PokeBox.h"
 #include "pokemon_data.h"
 
-bool inject_mystery(PokeBox* box, bool isFirstTime);
+bool inject_mystery(PokeBox *box, bool isFirstTime);
 
 #endif
\ No newline at end of file
diff --git a/include/ptgb_save_data_manager.h b/include/ptgb_save_data_manager.h
index b2849b4..5a597d0 100644
--- a/include/ptgb_save_data_manager.h
+++ b/include/ptgb_save_data_manager.h
@@ -6,17 +6,20 @@
 #define HALL_OF_FAME 0x01C000
 #define HOF_SECTION 2032
 
-// NOTE: This module doesn't manage the _game_ save. It manages Poke_Transporter's specific save data.
-// This save data is stored at an unused section (HOF_SECTION) of the HALL OF FAME save section.
+// NOTE: This module doesn't manage the _game_ save. It manages
+// Poke_Transporter's specific save data. This save data is stored at an unused
+// section (HOF_SECTION) of the HALL OF FAME save section.
 
 // Data map:
 // There are 1936 (0x790) unused bytes starting at 0x1D7F0
 
 //                                | Offset  | Size  | Contents
 //                                --------------------------
-#define CAUGHT_DATA 0x00      //  | 0x0     | 32    | Flags for each Pokemon species
-#define TUTORIAL_FLAG 0x20    //  | 0x21    | 1     | Has made it through the tutorial
-#define DEFAULT_LANGUAGE 0x21 //  | 0x22    | 1     | Default international language
+#define CAUGHT_DATA 0x00 //  | 0x0     | 32    | Flags for each Pokemon species
+#define TUTORIAL_FLAG                                                          \
+    0x20 //  | 0x21    | 1     | Has made it through the tutorial
+#define DEFAULT_LANGUAGE                                                       \
+    0x21 //  | 0x22    | 1     | Default international language
 #define SAVE_DATA_SIZE 0x22
 
 extern rom_data curr_GBA_rom;
diff --git a/include/rom_data.h b/include/rom_data.h
index 581a9cb..1e45604 100644
--- a/include/rom_data.h
+++ b/include/rom_data.h
@@ -1,8 +1,8 @@
 #ifndef ROM_POINTERS_H
 #define ROM_POINTERS_H
 
-#include <tonc.h>
 #include "gba_rom_values/base_gba_rom_struct.h"
+#include <tonc.h>
 
 #define RUBY_ID 0x415856      // AXV
 #define SAPPHIRE_ID 0x415850  // AXP
@@ -23,7 +23,7 @@
 
 class rom_data
 {
-public:
+  public:
     rom_data();
     bool load_rom(bool debug);
     bool is_hoenn();
@@ -44,27 +44,34 @@ public:
     int loc_gMonShinyPaletteTable;
     int loc_gMonIconTable;
     int loc_gMonIconPaletteIndices;
-    int offset_flags;     // Flag offset as found within the SaveBlock1 struct in global.h
+    int offset_flags; // Flag offset as found within the SaveBlock1 struct in
+                      // global.h
     int offset_wondercard;
     int offset_script;
 
-    // PKHeX's list of flags is useful for making sure the detection is accurate: https://github.com/kwsch/PKHeX/blob/78a557c3cdaa6f48b42cc96df8ccb4d20b897937/PKHeX.Core/Resources/text/other/flags_rs.txt
-    int e4_flag;                   // The flag that is set when you become champion. Often listed as "GAME_CLEAR"
-    int mg_flag;                   // The flag that is set when you enable Mystery Gift. Known as "EXDATA_ENABLE" in RS
-    int unused_flag_start;         // The start of the unused flags and must have 31 open flags in a row
-    int all_collected_flag;        // The flag for if everything has been collected
-    int pkmn_collected_flag_start; // The beginning of the flags for each of the Pokemon
+    // PKHeX's list of flags is useful for making sure the detection is
+    // accurate:
+    // https://github.com/kwsch/PKHeX/blob/78a557c3cdaa6f48b42cc96df8ccb4d20b897937/PKHeX.Core/Resources/text/other/flags_rs.txt
+    int e4_flag; // The flag that is set when you become champion. Often listed
+                 // as "GAME_CLEAR"
+    int mg_flag; // The flag that is set when you enable Mystery Gift. Known as
+                 // "EXDATA_ENABLE" in RS
+    int unused_flag_start;  // The start of the unused flags and must have 31
+                            // open flags in a row
+    int all_collected_flag; // The flag for if everything has been collected
+    int pkmn_collected_flag_start; // The beginning of the flags for each of the
+                                   // Pokemon
 
     u8 map_bank;
     u8 map_id;
     u8 npc_id;
 
-    #define MGSCRIPT_MAGIC_VALUE 0x33
+#define MGSCRIPT_MAGIC_VALUE 0x33
     u8 def_map_bank;
     u8 def_map_id;
     u8 def_npc_id;
 
-private:
+  private:
     void fill_values(const ROM_DATA *rom_values);
 };
 
diff --git a/include/script_array.h b/include/script_array.h
index b2a9414..09ba691 100644
--- a/include/script_array.h
+++ b/include/script_array.h
@@ -1,17 +1,19 @@
 #ifndef SCRIPT_ARRAY_H
 #define SCRIPT_ARRAY_H
 
-#include "script_obj.h"
 #include "rom_data.h"
+#include "script_obj.h"
 #include "translated_text.h"
 
-extern bool newPkmn; // This is stupid and dumb and stupid but we're storing it like this until this whole mess gets rewritten.
+extern bool newPkmn; // This is stupid and dumb and stupid but we're storing it
+                     // like this until this whole mess gets rewritten.
 
 // Commands
 #define T_SCRIPT_START DIA_END + 0
 #define E_SCRIPT_START DIA_END + 1
 #define CMD_START_LINK DIA_END + 2
-#define CMD_IMPORT_POKEMON DIA_END + 3 // This one is special because it can be true or false
+#define CMD_IMPORT_POKEMON                                                     \
+    DIA_END + 3 // This one is special because it can be true or false
 #define CMD_BACK_TO_MENU DIA_END + 4
 #define CMD_SHOW_PROF DIA_END + 5
 #define CMD_HIDE_PROF DIA_END + 6
@@ -32,11 +34,16 @@ extern bool newPkmn; // This is stupid and dumb and stupid but we're storing it
 #define CMDS_END DIA_END + CMD_SIZE
 
 // Conditionals
-#define COND_ERROR_TIMEOUT_ONE CMDS_END + 0 // Didn't talk to the Cable Club attendant fast enough or cable not connected
-#define COND_ERROR_DISCONNECT CMDS_END + 1  // If you unplug the cable after starting SPI
+#define COND_ERROR_TIMEOUT_ONE                                                 \
+    CMDS_END + 0 // Didn't talk to the Cable Club attendant fast enough or cable
+                 // not connected
+#define COND_ERROR_DISCONNECT                                                  \
+    CMDS_END + 1 // If you unplug the cable after starting SPI
 #define COND_ERROR_COM_ENDED CMDS_END + 2   // If you don't save the game
 #define COND_ERROR_TIMEOUT_TWO CMDS_END + 3 // ???
-#define COND_ERROR_COLOSSEUM CMDS_END + 4   // If the player selects the battle colosseum (shouldn't be possible)
+#define COND_ERROR_COLOSSEUM                                                   \
+    CMDS_END + 4 // If the player selects the battle colosseum (shouldn't be
+                 // possible)
 #define COND_BEAT_E4 CMDS_END + 5
 #define COND_MG_ENABLED CMDS_END + 6
 #define COND_TUTORIAL_COMPLETE CMDS_END + 7
@@ -68,143 +75,207 @@ bool run_conditional(int index);
 
 // These should be removed eventually, or added to PCCS.
 
-static const byte gen1_rb_debug_box_data[0x462] = {
-	// Num of Pokemon
-	0x14,
-	// Pokemon 1-20
-	0x02, 0x1F, 0x70, 0x70, 0x71, 0x71, 0x70, 0x71, 0x7B, 0x71, 0x71, 0x7C, 0x71, 0x71, 0x71, 0x94, 0x24, 0x24, 0xA5, 0x15, 0xFF,
-	// Pokemon list
-	0x02, 0x00, 0x11, 0x64, 0x00, 0x07, 0x03, 0xFF, 0x28, 0x51, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE6, 0xDE, 0x23, 0x28, 0x00, 0x00,
-	0x1F, 0x00, 0x12, 0x04, 0x00, 0x07, 0x03, 0xFF, 0x28, 0x51, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5D, 0xD8, 0x23, 0x28, 0x00, 0x00,
-	0x70, 0x00, 0x12, 0x04, 0x00, 0x07, 0x03, 0xFF, 0x28, 0x51, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x13, 0x23, 0x28, 0x00, 0x00,
-	0x70, 0x00, 0x0F, 0x03, 0x00, 0x07, 0x03, 0xFF, 0x28, 0x51, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xDA, 0x81, 0x23, 0x28, 0x00, 0x00,
-	0x71, 0x00, 0x14, 0x05, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD6, 0x80, 0x1E, 0x00, 0x00, 0x00,
-	0x71, 0x00, 0x15, 0x05, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF7, 0x95, 0x1E, 0x00, 0x00, 0x00,
-	0x70, 0x00, 0x13, 0x05, 0x00, 0x07, 0x03, 0xFF, 0x28, 0x51, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC9, 0xCC, 0x23, 0x28, 0x00, 0x00,
-	0x71, 0x00, 0x11, 0x04, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x7A, 0x1E, 0x00, 0x00, 0x00,
-	0x7B, 0x00, 0x10, 0x03, 0x00, 0x07, 0x07, 0xFF, 0x21, 0x51, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5C, 0x84, 0x23, 0x28, 0x00, 0x00,
-	0x71, 0x00, 0x15, 0x06, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0xD8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAC, 0x64, 0x1E, 0x00, 0x00, 0x00,
-	0x71, 0x00, 0x13, 0x05, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC4, 0x1D, 0x1E, 0x00, 0x00, 0x00,
-	0x7C, 0x00, 0x12, 0x04, 0x00, 0x07, 0x07, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x31, 0x1E, 0x00, 0x00, 0x00,
-	0x71, 0x00, 0x12, 0x04, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6, 0x40, 0x1E, 0x00, 0x00, 0x00,
-	0x71, 0x00, 0x16, 0x06, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0xD8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x97, 0xAA, 0x1E, 0x00, 0x00, 0x00,
-	0x71, 0x00, 0x12, 0x04, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0xE9, 0x1E, 0x00, 0x00, 0x00,
-	0x94, 0x00, 0x14, 0x05, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFB, 0xEC, 0x1E, 0x00, 0x00, 0x00,
-	0x24, 0x00, 0x12, 0x04, 0x00, 0x00, 0x02, 0xFF, 0x10, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0xC2, 0x23, 0x00, 0x00, 0x00,
-	0x24, 0x00, 0x11, 0x04, 0x00, 0x00, 0x02, 0xFF, 0x10, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4D, 0x2A, 0x23, 0x00, 0x00, 0x00,
-	0xA5, 0x00, 0x0E, 0x03, 0x00, 0x00, 0x00, 0xFF, 0x21, 0x27, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0xBE, 0x23, 0x1E, 0x00, 0x00,
-	0x15, 0x00, 0x0F, 0x03, 0x00, 0x00, 0x02, 0xFF, 0x10, 0x00, 0x39, 0x3B, 0x6F, 0xC6, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0xE6, 0x23, 0x00, 0x00, 0x00,
-	// Trainer names
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	// Nicknames
-	0x96, 0x84, 0x84, 0x83, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x96, 0x84, 0x84, 0x83, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x96, 0x84, 0x84, 0x83, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x96, 0x84, 0x84, 0x83, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x96, 0x84, 0x84, 0x83, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x82, 0x80, 0x93, 0x84, 0x91, 0x8F, 0x88, 0x84, 0x50, 0x50, 0x50,
-	0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x8C, 0x84, 0x93, 0x80, 0x8F, 0x8E, 0x83, 0x50, 0x50, 0x50, 0x50,
-	0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x8F, 0x88, 0x83, 0x86, 0x84, 0x98, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x8F, 0x88, 0x83, 0x86, 0x84, 0x98, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x91, 0x80, 0x93, 0x93, 0x80, 0x93, 0x80, 0x50, 0x50, 0x50, 0x50,
-	0x8F, 0x88, 0x83, 0x86, 0x84, 0x98, 0x50, 0x50, 0x50, 0x50, 0x50};
-
-static const byte gen2_debug_box_data[0x44E] = {
-	// Num of Pokemon
-	0x14,
-	// Pokemon 1-20
-	0xD5, 0x7B, 0xE3, 0x9D, 0xC3, 0xD5, 0xD5, 0xC9, 0xC9, 0x2E, 0xFA, 0xFA, 0xD5, 0xD5, 0xD5, 0xD5, 0xD5, 0xD5, 0xD5, 0xFC, 0xFF,
-	// Pokemon list
-	0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0x7B, 0x00, 0x62, 0x2B, 0x74, 0xE4, 0xBB, 0x4C, 0x00, 0x08, 0x95, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBA, 0xF9, 0x1E, 0x1E, 0x1E, 0x14, 0x46, 0x00, 0x00, 0x00, 0x0D,
-	0xE3, 0x00, 0x13, 0xA8, 0x81, 0x61, 0xBB, 0x4C, 0x01, 0xC5, 0x71, 0x17, 0x99, 0x1D, 0x33, 0x1B, 0x77, 0x19, 0x7F, 0x18, 0xB9, 0xDF, 0x87, 0x0F, 0x0A, 0x14, 0x1E, 0xFF, 0x00, 0x00, 0x00, 0x2D,
-	0x9D, 0x00, 0xAC, 0x09, 0x59, 0x46, 0xBB, 0x4C, 0x01, 0xAA, 0xDE, 0x23, 0xE8, 0x2C, 0xCF, 0x29, 0x00, 0x2C, 0xD4, 0x28, 0x55, 0xF6, 0xD7, 0x19, 0x0F, 0x0A, 0x0F, 0xFF, 0x00, 0x00, 0x00, 0x30,
-	0xC3, 0x1B, 0xD6, 0x27, 0x15, 0x37, 0xBB, 0x4C, 0x00, 0x1F, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x10, 0x0A, 0x1E, 0x14, 0x19, 0x4C, 0x00, 0x00, 0x00, 0x14,
-	0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x2A, 0xAA, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xC9, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x22, 0x22, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xC9, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x44, 0x44, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0x2E, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xFA, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x2A, 0xAA, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xFA, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	0xFC, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
-	// Trainer names
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
-	// Nicknames
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x80, 0x81, 0x82,
-	0x92, 0x82, 0x98, 0x93, 0x87, 0x84, 0x91, 0x50, 0x50, 0x50, 0x50,
-	0x82, 0x80, 0x8C, 0x84, 0x8B, 0x8E, 0x93, 0x50, 0x50, 0x50, 0x50,
-	0x93, 0x88, 0x8C, 0x8D, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50,
-	0x90, 0xF3, 0x80, 0x9B, 0xE6, 0x9C, 0x91, 0x9E, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
-	0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50};
+static const byte gen1_rb_debug_box_data[0x462] = {// Num of Pokemon
+    0x14,
+    // Pokemon 1-20
+    0x02, 0x1F, 0x70, 0x70, 0x71, 0x71, 0x70, 0x71, 0x7B, 0x71, 0x71, 0x7C,
+    0x71, 0x71, 0x71, 0x94, 0x24, 0x24, 0xA5, 0x15, 0xFF,
+    // Pokemon list
+    0x02, 0x00, 0x11, 0x64, 0x00, 0x07, 0x03, 0xFF, 0x28, 0x51, 0x00, 0x00,
+    0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xE6, 0xDE, 0x23, 0x28, 0x00, 0x00, 0x1F, 0x00, 0x12,
+    0x04, 0x00, 0x07, 0x03, 0xFF, 0x28, 0x51, 0x00, 0x00, 0x6F, 0xC6, 0x00,
+    0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x5D, 0xD8, 0x23, 0x28, 0x00, 0x00, 0x70, 0x00, 0x12, 0x04, 0x00, 0x07,
+    0x03, 0xFF, 0x28, 0x51, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x13, 0x23,
+    0x28, 0x00, 0x00, 0x70, 0x00, 0x0F, 0x03, 0x00, 0x07, 0x03, 0xFF, 0x28,
+    0x51, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xDA, 0x81, 0x23, 0x28, 0x00, 0x00,
+    0x71, 0x00, 0x14, 0x05, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00,
+    0x6F, 0xC6, 0x00, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xD6, 0x80, 0x1E, 0x00, 0x00, 0x00, 0x71, 0x00, 0x15,
+    0x05, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00,
+    0x00, 0x7D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xF7, 0x95, 0x1E, 0x00, 0x00, 0x00, 0x70, 0x00, 0x13, 0x05, 0x00, 0x07,
+    0x03, 0xFF, 0x28, 0x51, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x7D, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC9, 0xCC, 0x23,
+    0x28, 0x00, 0x00, 0x71, 0x00, 0x11, 0x04, 0x00, 0x07, 0x03, 0x78, 0x6A,
+    0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCE, 0x7A, 0x1E, 0x00, 0x00, 0x00,
+    0x7B, 0x00, 0x10, 0x03, 0x00, 0x07, 0x07, 0xFF, 0x21, 0x51, 0x00, 0x00,
+    0x6F, 0xC6, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x5C, 0x84, 0x23, 0x28, 0x00, 0x00, 0x71, 0x00, 0x15,
+    0x06, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00,
+    0x00, 0xD8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xAC, 0x64, 0x1E, 0x00, 0x00, 0x00, 0x71, 0x00, 0x13, 0x05, 0x00, 0x07,
+    0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x7D, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC4, 0x1D, 0x1E,
+    0x00, 0x00, 0x00, 0x7C, 0x00, 0x12, 0x04, 0x00, 0x07, 0x07, 0x78, 0x6A,
+    0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x31, 0x1E, 0x00, 0x00, 0x00,
+    0x71, 0x00, 0x12, 0x04, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00,
+    0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xF6, 0x40, 0x1E, 0x00, 0x00, 0x00, 0x71, 0x00, 0x16,
+    0x06, 0x00, 0x07, 0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00,
+    0x00, 0xD8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x97, 0xAA, 0x1E, 0x00, 0x00, 0x00, 0x71, 0x00, 0x12, 0x04, 0x00, 0x07,
+    0x03, 0x78, 0x6A, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x40, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0xE9, 0x1E,
+    0x00, 0x00, 0x00, 0x94, 0x00, 0x14, 0x05, 0x00, 0x07, 0x03, 0x78, 0x6A,
+    0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFB, 0xEC, 0x1E, 0x00, 0x00, 0x00,
+    0x24, 0x00, 0x12, 0x04, 0x00, 0x00, 0x02, 0xFF, 0x10, 0x00, 0x00, 0x00,
+    0x6F, 0xC6, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x35, 0xC2, 0x23, 0x00, 0x00, 0x00, 0x24, 0x00, 0x11,
+    0x04, 0x00, 0x00, 0x02, 0xFF, 0x10, 0x00, 0x00, 0x00, 0x6F, 0xC6, 0x00,
+    0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x4D, 0x2A, 0x23, 0x00, 0x00, 0x00, 0xA5, 0x00, 0x0E, 0x03, 0x00, 0x00,
+    0x00, 0xFF, 0x21, 0x27, 0x00, 0x00, 0x6F, 0xC6, 0x00, 0x00, 0x1B, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0xBE, 0x23,
+    0x1E, 0x00, 0x00, 0x15, 0x00, 0x0F, 0x03, 0x00, 0x00, 0x02, 0xFF, 0x10,
+    0x00, 0x39, 0x3B, 0x6F, 0xC6, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x67, 0xE6, 0x23, 0x00, 0x00, 0x00,
+    // Trainer names
+    0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+    0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x50,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x50, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x50, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x50, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x50, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+    0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x50,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x50, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x50, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x50, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x50, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00,
+    // Nicknames
+    0x96, 0x84, 0x84, 0x83, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x50, 0x96,
+    0x84, 0x84, 0x83, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x50, 0x96, 0x84,
+    0x84, 0x83, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x50, 0x96, 0x84, 0x84,
+    0x83, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x50, 0x8A, 0x80, 0x8A, 0x94,
+    0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50, 0x8A, 0x80, 0x8A, 0x94, 0x8D,
+    0x80, 0x50, 0x50, 0x50, 0x50, 0x50, 0x96, 0x84, 0x84, 0x83, 0x8B, 0x84,
+    0x50, 0x50, 0x50, 0x50, 0x50, 0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50,
+    0x50, 0x50, 0x50, 0x50, 0x82, 0x80, 0x93, 0x84, 0x91, 0x8F, 0x88, 0x84,
+    0x50, 0x50, 0x50, 0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50,
+    0x50, 0x50, 0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50,
+    0x50, 0x8C, 0x84, 0x93, 0x80, 0x8F, 0x8E, 0x83, 0x50, 0x50, 0x50, 0x50,
+    0x8A, 0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50, 0x8A,
+    0x80, 0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50, 0x8A, 0x80,
+    0x8A, 0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50, 0x8A, 0x80, 0x8A,
+    0x94, 0x8D, 0x80, 0x50, 0x50, 0x50, 0x50, 0x50, 0x8F, 0x88, 0x83, 0x86,
+    0x84, 0x98, 0x50, 0x50, 0x50, 0x50, 0x50, 0x8F, 0x88, 0x83, 0x86, 0x84,
+    0x98, 0x50, 0x50, 0x50, 0x50, 0x50, 0x91, 0x80, 0x93, 0x93, 0x80, 0x93,
+    0x80, 0x50, 0x50, 0x50, 0x50, 0x8F, 0x88, 0x83, 0x86, 0x84, 0x98, 0x50,
+    0x50, 0x50, 0x50, 0x50};
 
+static const byte gen2_debug_box_data[0x44E] = {// Num of Pokemon
+    0x14,
+    // Pokemon 1-20
+    0xD5, 0x7B, 0xE3, 0x9D, 0xC3, 0xD5, 0xD5, 0xC9, 0xC9, 0x2E, 0xFA, 0xFA,
+    0xD5, 0xD5, 0xD5, 0xD5, 0xD5, 0xD5, 0xD5, 0xFC, 0xFF,
+    // Pokemon list
+    0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00,
+    0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23,
+    0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10, 0x7B, 0x00, 0x62, 0x2B,
+    0x74, 0xE4, 0xBB, 0x4C, 0x00, 0x08, 0x95, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xBA, 0xF9, 0x1E, 0x1E, 0x1E, 0x14, 0x46,
+    0x00, 0x00, 0x00, 0x0D, 0xE3, 0x00, 0x13, 0xA8, 0x81, 0x61, 0xBB, 0x4C,
+    0x01, 0xC5, 0x71, 0x17, 0x99, 0x1D, 0x33, 0x1B, 0x77, 0x19, 0x7F, 0x18,
+    0xB9, 0xDF, 0x87, 0x0F, 0x0A, 0x14, 0x1E, 0xFF, 0x00, 0x00, 0x00, 0x2D,
+    0x9D, 0x00, 0xAC, 0x09, 0x59, 0x46, 0xBB, 0x4C, 0x01, 0xAA, 0xDE, 0x23,
+    0xE8, 0x2C, 0xCF, 0x29, 0x00, 0x2C, 0xD4, 0x28, 0x55, 0xF6, 0xD7, 0x19,
+    0x0F, 0x0A, 0x0F, 0xFF, 0x00, 0x00, 0x00, 0x30, 0xC3, 0x1B, 0xD6, 0x27,
+    0x15, 0x37, 0xBB, 0x4C, 0x00, 0x1F, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x10, 0x0A, 0x1E, 0x14, 0x19, 0x4C,
+    0x00, 0x00, 0x00, 0x14, 0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C,
+    0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00,
+    0x28, 0x2A, 0xAA, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
+    0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00,
+    0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23,
+    0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10, 0xC9, 0x00, 0x84, 0x6E,
+    0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00,
+    0x23, 0x00, 0x34, 0x00, 0x28, 0x22, 0x22, 0x23, 0x28, 0x14, 0x05, 0x58,
+    0x00, 0x00, 0x00, 0x10, 0xC9, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C,
+    0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00,
+    0x28, 0x44, 0x44, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
+    0x2E, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00,
+    0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23,
+    0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10, 0xFA, 0x00, 0x84, 0x6E,
+    0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00,
+    0x23, 0x00, 0x34, 0x00, 0x28, 0x2A, 0xAA, 0x23, 0x28, 0x14, 0x05, 0x58,
+    0x00, 0x00, 0x00, 0x10, 0xFA, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C,
+    0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00,
+    0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
+    0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00,
+    0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23,
+    0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10, 0xD5, 0x00, 0x84, 0x6E,
+    0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00,
+    0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58,
+    0x00, 0x00, 0x00, 0x10, 0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C,
+    0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00,
+    0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
+    0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00,
+    0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23,
+    0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10, 0xD5, 0x00, 0x84, 0x6E,
+    0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00,
+    0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58,
+    0x00, 0x00, 0x00, 0x10, 0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C,
+    0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00,
+    0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10,
+    0xD5, 0x00, 0x84, 0x6E, 0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00,
+    0x20, 0x00, 0x32, 0x00, 0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23,
+    0x28, 0x14, 0x05, 0x58, 0x00, 0x00, 0x00, 0x10, 0xFC, 0x00, 0x84, 0x6E,
+    0x23, 0xE3, 0xBB, 0x4C, 0x00, 0x0A, 0x4E, 0x00, 0x20, 0x00, 0x32, 0x00,
+    0x23, 0x00, 0x34, 0x00, 0x28, 0x9C, 0x90, 0x23, 0x28, 0x14, 0x05, 0x58,
+    0x00, 0x00, 0x00, 0x10,
+    // Trainer names
+    0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00, 0x80,
+    0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00, 0x80, 0x94,
+    0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00, 0x80, 0x94, 0x92,
+    0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00, 0x80, 0x94, 0x92, 0x93,
+    0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00, 0x80, 0x94, 0x92, 0x93, 0x88,
+    0x8D, 0x50, 0x50, 0x00, 0x00, 0x00, 0x80, 0x94, 0x92, 0x93, 0x88, 0x8D,
+    0x50, 0x50, 0x00, 0x00, 0x00, 0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50,
+    0x50, 0x00, 0x00, 0x00, 0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50,
+    0x00, 0x00, 0x00, 0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00,
+    0x00, 0x00, 0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00,
+    0x00, 0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00,
+    0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00, 0x80,
+    0x94, 0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00, 0x80, 0x94,
+    0x92, 0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00, 0x80, 0x94, 0x92,
+    0x93, 0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00, 0x80, 0x94, 0x92, 0x93,
+    0x88, 0x8D, 0x50, 0x50, 0x00, 0x00, 0x00, 0x80, 0x94, 0x92, 0x93, 0x88,
+    0x8D, 0x50, 0x50, 0x00, 0x00, 0x00, 0x80, 0x94, 0x92, 0x93, 0x88, 0x8D,
+    0x50, 0x50, 0x00, 0x00, 0x00, 0x80, 0x94, 0x92, 0x93, 0x88, 0x8D, 0x50,
+    0x50, 0x00, 0x00, 0x00,
+    // Nicknames
+    0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x80, 0x81, 0x82, 0x92,
+    0x82, 0x98, 0x93, 0x87, 0x84, 0x91, 0x50, 0x50, 0x50, 0x50, 0x82, 0x80,
+    0x8C, 0x84, 0x8B, 0x8E, 0x93, 0x50, 0x50, 0x50, 0x50, 0x93, 0x88, 0x8C,
+    0x8D, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x90, 0xF3, 0x80, 0x9B,
+    0xE6, 0x9C, 0x91, 0x9E, 0x50, 0x50, 0x50, 0x92, 0x87, 0x94, 0x82, 0x8A,
+    0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B,
+    0x84, 0x50, 0x50, 0x50, 0x50, 0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84,
+    0x50, 0x50, 0x50, 0x50, 0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50,
+    0x50, 0x50, 0x50, 0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50,
+    0x50, 0x50, 0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50,
+    0x50, 0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50,
+    0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x92,
+    0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x92, 0x87,
+    0x94, 0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x92, 0x87, 0x94,
+    0x82, 0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x92, 0x87, 0x94, 0x82,
+    0x8A, 0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x92, 0x87, 0x94, 0x82, 0x8A,
+    0x8B, 0x84, 0x50, 0x50, 0x50, 0x50, 0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B,
+    0x84, 0x50, 0x50, 0x50, 0x50, 0x92, 0x87, 0x94, 0x82, 0x8A, 0x8B, 0x84,
+    0x50, 0x50, 0x50, 0x50};
 
 #endif
\ No newline at end of file
diff --git a/include/script_obj.h b/include/script_obj.h
index 2476ed3..73bb98e 100644
--- a/include/script_obj.h
+++ b/include/script_obj.h
@@ -12,7 +12,7 @@ typedef struct
 
 class script_obj
 {
-public:
+  public:
     script_obj();
     script_obj(const script_obj_params &params);
 
@@ -22,7 +22,7 @@ public:
     u16 get_false_index() const;
     u16 get_cond_id() const;
 
-private:
+  private:
     script_obj_params params_;
 };
 
diff --git a/include/select_menu.h b/include/select_menu.h
index 64822d4..7deb53f 100644
--- a/include/select_menu.h
+++ b/include/select_menu.h
@@ -7,20 +7,24 @@
 #define LANG_MENU 1
 #define CART_MENU 2
 
-class Select_Menu : public vertical_menu_cursor_handler, public i_run_cycle_handler
+class Select_Menu : public vertical_menu_cursor_handler,
+                    public i_run_cycle_handler
 {
-public:
-    Select_Menu(bool enable_cancel, u8 nMenu_type, unsigned nStartX, unsigned nStartY);
+  public:
+    Select_Menu(
+        bool enable_cancel, u8 nMenu_type, unsigned nStartX, unsigned nStartY);
     int select_menu_main();
     void add_option(const u8 option, u8 return_value);
     void clear_options();
     void set_lang(u8 nLang);
 
     void on_hide() override;
-    void on_selection_changed(unsigned new_index, unsigned x, unsigned y) override;
+    void on_selection_changed(
+        unsigned new_index, unsigned x, unsigned y) override;
 
     void on_run_cycle() override;
-private:
+
+  private:
     vertical_menu menu_widget_;
     u8 menu_type;
     u8 lang;
diff --git a/include/sound.h b/include/sound.h
index cda4a93..5ad8d49 100644
--- a/include/sound.h
+++ b/include/sound.h
@@ -6,86 +6,95 @@
 #include "soundbank.h"
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-typedef unsigned short PTGBSFXHandle;
+    typedef unsigned short PTGBSFXHandle;
 
-/**
- * @brief The API's defined here are a thin abstraction layer over the sound engine functions.
- * This allows the underlying sound engine to be swapped out without affecting the rest of the codebase.
- */
+    /**
+     * @brief The API's defined here are a thin abstraction layer over the sound
+     * engine functions. This allows the underlying sound engine to be swapped
+     * out without affecting the rest of the codebase.
+     */
 
-/**
- * @brief This function initializes the sound engine and sets up a VBLANK handler
- * to process audio every frame. It should be called during the initialization phase of the program.
- */
-bool sound_init(void);
+    /**
+     * @brief This function initializes the sound engine and sets up a VBLANK
+     * handler to process audio every frame. It should be called during the
+     * initialization phase of the program.
+     */
+    bool sound_init(void);
 
-/**
- * @brief This function starts playing the song at the given index. 
- * If loop is true, the song will loop indefinitely until stopped or another song is played.
- * 
- * @param song_index The index of the song to play.
- * @param loop Whether the song should loop indefinitely.
- */
-void play_song(u32 song_index, bool loop);
+    /**
+     * @brief This function starts playing the song at the given index.
+     * If loop is true, the song will loop indefinitely until stopped or another
+     * song is played.
+     *
+     * @param song_index The index of the song to play.
+     * @param loop Whether the song should loop indefinitely.
+     */
+    void play_song(u32 song_index, bool loop);
 
-/**
- * @brief This function checks if a song is currently playing.
- * 
- * @return true if a song is playing, false otherwise.
- */
-bool is_song_playing(void);
+    /**
+     * @brief This function checks if a song is currently playing.
+     *
+     * @return true if a song is playing, false otherwise.
+     */
+    bool is_song_playing(void);
 
-/**
- * @brief This function stops the currently playing song.
- */
-void stop_song(void);
+    /**
+     * @brief This function stops the currently playing song.
+     */
+    void stop_song(void);
 
-/**
- * @brief This function plays the sound effect at the given index. 
- * Sound effects are typically short audio clips that play in response to specific events in the game, 
- * such as button presses or character actions.
- * These are usually raw PCM samples (e.g., WAV files)
- * 
- * To play a MOD- S3M- XM- or IT format based sound effect,
- * use the play_jingle function instead.
- */
-PTGBSFXHandle play_sound_effect(u32 sound_effect_index);
+    /**
+     * @brief This function plays the sound effect at the given index.
+     * Sound effects are typically short audio clips that play in response to
+     * specific events in the game, such as button presses or character actions.
+     * These are usually raw PCM samples (e.g., WAV files)
+     *
+     * To play a MOD- S3M- XM- or IT format based sound effect,
+     * use the play_jingle function instead.
+     */
+    PTGBSFXHandle play_sound_effect(u32 sound_effect_index);
 
-/**
- * @brief This function stops the given sound effect from playing and invalidates the handle
- */
-void stop_sound_effect(PTGBSFXHandle handle);
+    /**
+     * @brief This function stops the given sound effect from playing and
+     * invalidates the handle
+     */
+    void stop_sound_effect(PTGBSFXHandle handle);
 
-/**
- * @brief This function stops all currently playing sound effects and resets 
- */
-void stop_all_sound_effects(void);
+    /**
+     * @brief This function stops all currently playing sound effects and resets
+     */
+    void stop_all_sound_effects(void);
 
-/**
- * @brief This function marks the sound effect as unimportant,
- * allowing the sound engine to stop it if it needs to free up channels for new sound effects.
- * 
- * It also invalidates the handle, so it should not be used after calling this function.
- */
-void release_sound_effect(PTGBSFXHandle handle);
+    /**
+     * @brief This function marks the sound effect as unimportant,
+     * allowing the sound engine to stop it if it needs to free up channels for
+     * new sound effects.
+     *
+     * It also invalidates the handle, so it should not be used after calling
+     * this function.
+     */
+    void release_sound_effect(PTGBSFXHandle handle);
 
-/**
- * @brief This function plays a jingle at the given index.
- * A jingle is a sound effect that is based on a tracker format like MOD, S3M, XM, or IT.
- * They can be played simultaneously with songs.
- * If you want to play PCM-based sound effects (e.g., WAV files), use the play_sound_effect function instead.
- * 
- * Note that jingles must be limited to 4 channels only. (https://blocksds.skylyrac.net/maxmod/group__gba__jingle__playback.html)
- */
-void play_jingle(u32 jingle_index);
+    /**
+     * @brief This function plays a jingle at the given index.
+     * A jingle is a sound effect that is based on a tracker format like MOD,
+     * S3M, XM, or IT. They can be played simultaneously with songs. If you want
+     * to play PCM-based sound effects (e.g., WAV files), use the
+     * play_sound_effect function instead.
+     *
+     * Note that jingles must be limited to 4 channels only.
+     * (https://blocksds.skylyrac.net/maxmod/group__gba__jingle__playback.html)
+     */
+    void play_jingle(u32 jingle_index);
 
-/**
- * @brief Checks if a jingle is actively playing.
- */
-bool is_jingle_playing(void);
+    /**
+     * @brief Checks if a jingle is actively playing.
+     */
+    bool is_jingle_playing(void);
 
 #ifdef __cplusplus
 }
diff --git a/include/sprite_data.h b/include/sprite_data.h
index 297018d..a81cba4 100644
--- a/include/sprite_data.h
+++ b/include/sprite_data.h
@@ -1,10 +1,10 @@
 #ifndef SPRITE_DATA_H
 #define SPRITE_DATA_H
 
-#include <tonc.h>
-#include "rom_data.h"
 #include "box_menu.h"
 #include "link_handler.h"
+#include "rom_data.h"
+#include <tonc.h>
 
 #define FENNEL_SHIFT 4
 
@@ -21,28 +21,28 @@ extern OBJ_ATTR *button_no;
 #include "types.h"
 extern OBJ_ATTR *type_sprites[14];
 
-#include "flag_jpn.h"
 #include "flag_eng.h"
 #include "flag_fre.h"
-#include "flag_ita.h"
 #include "flag_ger.h"
-#include "flag_spa.h"
+#include "flag_ita.h"
+#include "flag_jpn.h"
 #include "flag_kor.h"
+#include "flag_spa.h"
 extern OBJ_ATTR *gb_flag;
 extern OBJ_ATTR *gba_flag;
+#include "Label_Blue.h"
+#include "Label_Crystal.h"
+#include "Label_Gold.h"
 #include "Label_Green.h"
 #include "Label_Red.h"
-#include "Label_Blue.h"
-#include "Label_Yellow.h"
-#include "Label_Gold.h"
 #include "Label_Silver.h"
-#include "Label_Crystal.h"
 #include "Label_Unknown.h"
+#include "Label_Yellow.h"
 extern OBJ_ATTR *cart_label;
-#include "GB_Shell.h"
+#include "GBCS_Shell.h"
 #include "GBC_Shell.h"
 #include "GBS_Shell.h"
-#include "GBCS_Shell.h"
+#include "GB_Shell.h"
 extern OBJ_ATTR *cart_shell;
 
 #include "arrows.h"
@@ -68,11 +68,11 @@ extern OBJ_ATTR *ptgb_logo_l;
 #include "ptgb_logo_r.h"
 extern OBJ_ATTR *ptgb_logo_r;
 
-#include "ruby_cart.h"
-#include "sapphire_cart.h"
+#include "emerald_cart.h"
 #include "fr_cart.h"
 #include "lg_cart.h"
-#include "emerald_cart.h"
+#include "ruby_cart.h"
+#include "sapphire_cart.h"
 extern OBJ_ATTR *gba_cart;
 
 #include "link_frame1.h"
@@ -144,29 +144,31 @@ enum FlexBackground
 #define TILESET_PTGB 0
 #define TILESET_TEXT 1
 
-#define TILESET_OFFSET_BACKDROP  0
-#define TILESET_OFFSET_TEXTBOX  38
-#define TILESET_OFFSET_FLEXBG   64
+#define TILESET_OFFSET_BACKDROP 0
+#define TILESET_OFFSET_TEXTBOX 38
+#define TILESET_OFFSET_FLEXBG 64
 
 #define TILEMAP_BACKDROP 4
-#define TILEMAP_FLEXBG   5
-#define TILEMAP_TEXTBOX  6
-#define TILEMAP_TEXT     7
+#define TILEMAP_FLEXBG 5
+#define TILEMAP_TEXTBOX 6
+#define TILEMAP_TEXT 7
 
 extern rom_data curr_GBA_rom;
 
-void load_sprite(OBJ_ATTR *sprite, const unsigned int objTiles[], int objTilesLen,
-                 u32 &tile_id, u32 pal_bank, int attr0, int attr1, u32 priority);
+void load_sprite(OBJ_ATTR *sprite, const unsigned int objTiles[],
+    int objTilesLen, u32 &tile_id, u32 pal_bank, int attr0, int attr1,
+    u32 priority);
 
 void load_sprite_compressed(OBJ_ATTR *sprite, const unsigned int objTiles[],
-                 u32 &tile_id, u32 pal_bank, int attr0, int attr1, u32 priority);
+    u32 &tile_id, u32 pal_bank, int attr0, int attr1, u32 priority);
 void load_background();
 void set_background_pal(int curr_rom_id, bool dark, bool fade);
 void load_textbox_background();
 void load_flex_background(FlexBackground background_id, int layer);
 void load_eternal_sprites();
-void load_temp_box_sprites(PokeBox* box);
-void load_type_sprites(const u8* pkmn_type_table, int pkmn_index, int dex_offset, bool is_caught);
+void load_temp_box_sprites(PokeBox *box);
+void load_type_sprites(
+    const u8 *pkmn_type_table, int pkmn_index, int dex_offset, bool is_caught);
 void add_menu_box(int options, int startTileX, int startTileY);
 void add_menu_box(int startTileX, int startTileY, int width, int height);
 void reload_textbox_background();
@@ -177,5 +179,5 @@ int get_curr_flex_background();
 void update_y_offset();
 void erase_textbox_tiles();
 void update_front_box_sprite(Pokemon *curr_pkmn, bool make_greyscale);
-void update_menu_sprite(PokeBox* box, int index, int frame);
+void update_menu_sprite(PokeBox *box, int index, int frame);
 #endif
\ No newline at end of file
diff --git a/include/text_engine.h b/include/text_engine.h
index 9af6e83..ca94547 100644
--- a/include/text_engine.h
+++ b/include/text_engine.h
@@ -11,7 +11,7 @@
 #define INK_ROM_COLOR 14
 #define INK_DARK_GREY 13
 
-#define SCRIPT_DEBUG 0 
+#define SCRIPT_DEBUG 0
 #define SCRIPT_TRANSFER 1
 #define SCRIPT_EVENT 2
 
@@ -19,11 +19,13 @@ void init_text_engine();
 int text_loop(int script);
 int text_next_obj_id(script_obj current_line);
 void set_text_exit();
-int ptgb_write_textbox(const byte *text, bool instant, bool waitForUser, int text_section, int text_key, bool eraseMainBox);
+int ptgb_write_textbox(const byte *text, bool instant, bool waitForUser,
+    int text_section, int text_key, bool eraseMainBox);
 int ptgb_write_simple(const byte *text, bool instant);
 int ptgb_write(const byte *text, bool instant, int length, int box_type);
-int ptgb_write_debug(const u16* charset, const char *text, bool instant);
+int ptgb_write_debug(const u16 *charset, const char *text, bool instant);
 void wait_for_user_to_continue(int right, int bottom);
-void scroll_text(bool instant, TTC *tc, bool scrollUp, int left, int top, int right, int bottom);
+void scroll_text(bool instant, TTC *tc, bool scrollUp, int left, int top,
+    int right, int bottom);
 
 #endif
\ No newline at end of file
diff --git a/include/text_tables.h b/include/text_tables.h
index cea6531..a6e7f11 100644
--- a/include/text_tables.h
+++ b/include/text_tables.h
@@ -6,11 +6,12 @@
 extern "C"
 {
 
-/**
- * @brief This function returns a list of pointers to the text table chunks and the number of chunks.
- */
-void get_text_table_chunks(u32 tableIndex, const u8 ***chunkList, u32 *numChunks, u32 *chunkSize);
-
+    /**
+     * @brief This function returns a list of pointers to the text table chunks
+     * and the number of chunks.
+     */
+    void get_text_table_chunks(
+        u32 tableIndex, const u8 ***chunkList, u32 *numChunks, u32 *chunkSize);
 }
 
 #endif
\ No newline at end of file
diff --git a/include/vertical_menu.h b/include/vertical_menu.h
index 782b32b..8f15258 100644
--- a/include/vertical_menu.h
+++ b/include/vertical_menu.h
@@ -1,9 +1,9 @@
 #ifndef _VERTICAL_MENU_H
 #define _VERTICAL_MENU_H
 
-#include "typeDefs.h"
-#include "libstd_replacements.h"
 #include "FileContainerReader.h"
+#include "libstd_replacements.h"
+#include "typeDefs.h"
 
 enum class MenuInputHandleState
 {
@@ -16,13 +16,14 @@ enum class MenuInputHandleState
      */
     HANDLED,
     /**
-     * @brief Same as HANDLED, but also indicates that the viewport should be updated.
-     * degrades to HANDLED after passing through vertical_menu::handle_input()
+     * @brief Same as HANDLED, but also indicates that the viewport should be
+     * updated. degrades to HANDLED after passing through
+     * vertical_menu::handle_input()
      */
     HANDLED_UPDATE_VIEWPORT,
     /**
      * @brief This value means that a choice was made.
-     * This means that if the vertical_menu is running with ::run(), 
+     * This means that if the vertical_menu is running with ::run(),
      * it should exit and return that choice.
      */
     CHOICE_MADE,
@@ -39,12 +40,14 @@ enum class MenuInputHandleState
  */
 class i_item_widget
 {
-public:
+  public:
     virtual ~i_item_widget();
-    virtual void render_item(FileContainerReader &text_table, unsigned x, unsigned y, bool is_focused) = 0;
+    virtual void render_item(FileContainerReader &text_table, unsigned x,
+        unsigned y, bool is_focused) = 0;
     virtual MenuInputHandleState handle_input() = 0;
-protected:
-private:
+
+  protected:
+  private:
 };
 
 /**
@@ -54,14 +57,16 @@ private:
  */
 class i_vertical_menu_state_changed_handler
 {
-public:
+  public:
     virtual ~i_vertical_menu_state_changed_handler();
 
     virtual void on_show() = 0;
     virtual void on_hide() = 0;
-    virtual void on_selection_changed(unsigned new_index, unsigned x, unsigned y) = 0;
-protected:
-private:
+    virtual void on_selection_changed(
+        unsigned new_index, unsigned x, unsigned y) = 0;
+
+  protected:
+  private:
 };
 
 /**
@@ -71,11 +76,12 @@ private:
  */
 class i_run_cycle_handler
 {
-public:
+  public:
     virtual ~i_run_cycle_handler();
     virtual void on_run_cycle() = 0;
-protected:
-private:
+
+  protected:
+  private:
 };
 
 typedef struct vertical_menu_settings
@@ -87,12 +93,14 @@ typedef struct vertical_menu_settings
     unsigned height;
 
     /**
-     * @brief The top margin (in pixels) after which we start rendering the first menu item.
+     * @brief The top margin (in pixels) after which we start rendering the
+     * first menu item.
      */
     unsigned margin_top;
 
     /**
-     * @brief The bottom margin (in pixels) after which we stop rendering the last menu item.
+     * @brief The bottom margin (in pixels) after which we stop rendering the
+     * last menu item.
      */
     unsigned margin_bottom;
 
@@ -102,7 +110,8 @@ typedef struct vertical_menu_settings
     unsigned initial_focus_index;
 
     /**
-     * @brief The height of each menu item in pixels. Will be used to position the items.
+     * @brief The height of each menu item in pixels. Will be used to position
+     * the items.
      */
     unsigned item_height;
 
@@ -112,7 +121,7 @@ typedef struct vertical_menu_settings
     int text_table_index;
 
     /**
-     * @brief This boolean indicates whether the menu 
+     * @brief This boolean indicates whether the menu
      * can be "cancelled with the B button."
      */
     bool allow_cancel;
@@ -121,7 +130,7 @@ typedef struct vertical_menu_settings
      * @brief This boolean indicates whether the menu should take
      * ownership of its item widgets.
      * That means that if this boolean is true,
-     * the destructor of vertical_menu will delete/free all of its 
+     * the destructor of vertical_menu will delete/free all of its
      * item widgets.
      */
     bool should_delete_item_widgets_on_destruct;
@@ -135,7 +144,7 @@ typedef struct vertical_menu_settings
 
 class vertical_menu
 {
-public:
+  public:
     vertical_menu(const vertical_menu_settings &settings);
     ~vertical_menu();
 
@@ -145,7 +154,7 @@ public:
     /**
      * @brief Get the current settings of this widget
      */
-    const vertical_menu_settings& get_settings() const;
+    const vertical_menu_settings &get_settings() const;
 
     /**
      * @brief Replace the settings of this widget.
@@ -155,16 +164,17 @@ public:
     /**
      * @brief This function is a way to bulk add item widgets to the menu.
      * The main difference between calling this function and add_item_widget()
-     * multiple times is that this function will reserve() enough space in the 
+     * multiple times is that this function will reserve() enough space in the
      * vector first, to avoid multiple resizes.
      */
     void add_item_widgets(i_item_widget **item_widgets, unsigned num_widgets);
 
     /**
-     * @brief This function adds an item widget to the menu. 
+     * @brief This function adds an item widget to the menu.
      * The menu will take ownership of the pointer, if
-     * settings_.should_delete_item_widgets_on_destruct is true. 
-     * Otherwise, the caller is responsible for managing the memory of the item widgets.
+     * settings_.should_delete_item_widgets_on_destruct is true.
+     * Otherwise, the caller is responsible for managing the memory of the item
+     * widgets.
      */
     void add_item_widget(i_item_widget *item_widget);
 
@@ -179,7 +189,7 @@ public:
      * @brief This function gets the item widget
      * at the given index.
      */
-    i_item_widget* get_item_widget_at(unsigned index) const;
+    i_item_widget *get_item_widget_at(unsigned index) const;
 
     /**
      * @brief Sets whether the menu is focused or not.
@@ -204,14 +214,14 @@ public:
      * @brief This function can be used to manage a blocking call
      * to vertical_menu, in which you want vertical_menu
      * to handle everything.
-     * 
+     *
      * This can be useful during one of those script_array commands.
      * Alternatively, you can just call handle_input() and manage the loop
      * manually.
-     * 
+     *
      * @return Will return the index of the chosen item if a choice was made,
-     * or UINT32_MAX if no choice was made and the menu was exited in some other way 
-     * (ex: B button).
+     * or UINT32_MAX if no choice was made and the menu was exited in some other
+     * way (ex: B button).
      */
     unsigned run();
 
@@ -219,17 +229,19 @@ public:
      * @brief Sets the optional state changed handler.
      * This is useful for managing external components, such as a cursor.
      */
-    void set_state_changed_handler(i_vertical_menu_state_changed_handler *handler);
+    void set_state_changed_handler(
+        i_vertical_menu_state_changed_handler *handler);
 
     /**
      * @brief This function sets a handler that will run on every
      * cycle in the run() function.
-     * 
+     *
      * It's only relevant if you use ::run() though.
      */
     void set_run_cycle_handler(i_run_cycle_handler *handler);
-protected:
-private:
+
+  protected:
+  private:
     void handle_selection_change(unsigned new_index, unsigned x, unsigned y);
 
     vertical_menu_settings settings_;
@@ -237,7 +249,7 @@ private:
     i_run_cycle_handler *run_cycle_handler_;
     unsigned focused_index_;
     unsigned viewport_start_index_;
-    ptgb::vector<i_item_widget*> items_;
+    ptgb::vector<i_item_widget *> items_;
     bool is_focused_;
 };
 
@@ -252,7 +264,8 @@ typedef struct simple_item_widget_data
     struct
     {
         /**
-         * @brief The index of the text table (see vertical_menu_settings) entry to use as the label of this item.
+         * @brief The index of the text table (see vertical_menu_settings) entry
+         * to use as the label of this item.
          */
         unsigned text_table_index;
 
@@ -267,35 +280,40 @@ typedef struct simple_item_widget_data
     } text;
 
     /**
-     * @brief The value this widget represents. This is useful for choice/input handling.
-     * But it won't be used if an on_execute_callback is set.
+     * @brief The value this widget represents. This is useful for choice/input
+     * handling. But it won't be used if an on_execute_callback is set.
      */
     unsigned value;
 
     /**
-     * @brief Optional execute callback. This will be executed when the user presses A while this item is focused.
-     * If this is nullptr, then MenuInputHandleState::CHOICE_MADE will be returned when the user presses A,
-     * and the caller can check the value field to know what choice was made.
+     * @brief Optional execute callback. This will be executed when the user
+     * presses A while this item is focused. If this is nullptr, then
+     * MenuInputHandleState::CHOICE_MADE will be returned when the user presses
+     * A, and the caller can check the value field to know what choice was made.
      */
     void (*on_execute_callback)(void *context);
 } simple_item_widget_data;
 
 /**
- * @brief This is the simplest possible item widget, which will just render a single line of text for a single item
- * and allow you to press A to execute a callback. It's useful for simple menus that don't require toggles or multiple options.
+ * @brief This is the simplest possible item widget, which will just render a
+ * single line of text for a single item and allow you to press A to execute a
+ * callback. It's useful for simple menus that don't require toggles or multiple
+ * options.
  */
 class simple_item_renderer : public i_item_widget
 {
-public:
+  public:
     simple_item_renderer(const simple_item_widget_data &data);
     virtual ~simple_item_renderer();
 
-    const simple_item_widget_data& get_data() const;
+    const simple_item_widget_data &get_data() const;
 
-    void render_item(FileContainerReader &text_table, unsigned x, unsigned y, bool is_focused) override;
+    void render_item(FileContainerReader &text_table, unsigned x, unsigned y,
+        bool is_focused) override;
     MenuInputHandleState handle_input() override;
-protected:
-private:
+
+  protected:
+  private:
     simple_item_widget_data data_;
 };
 
diff --git a/include/vertical_menu_cursor_handler.h b/include/vertical_menu_cursor_handler.h
index b973013..60ba6c7 100644
--- a/include/vertical_menu_cursor_handler.h
+++ b/include/vertical_menu_cursor_handler.h
@@ -6,17 +6,20 @@
 /**
  * @brief This class handles the cursor behavior for a vertical menu.
  */
-class vertical_menu_cursor_handler : public i_vertical_menu_state_changed_handler
+class vertical_menu_cursor_handler
+    : public i_vertical_menu_state_changed_handler
 {
-public:
+  public:
     vertical_menu_cursor_handler(s16 cursor_offset_x, s16 cursor_offset_y);
     virtual ~vertical_menu_cursor_handler();
 
     void on_show() override;
     void on_hide() override;
-    void on_selection_changed(unsigned new_index, unsigned x, unsigned y) override;
-protected:
-private:
+    void on_selection_changed(
+        unsigned new_index, unsigned x, unsigned y) override;
+
+  protected:
+  private:
     const s16 cursor_offset_x_;
     const s16 cursor_offset_y_;
 };
diff --git a/source/FileContainerReader.cpp b/source/FileContainerReader.cpp
index c028a3a..4174405 100644
--- a/source/FileContainerReader.cpp
+++ b/source/FileContainerReader.cpp
@@ -6,17 +6,11 @@
 #define FILE_CONTAINER_HEADER_SIZE 4
 #define FILE_INDEX_ENTRY_SIZE 2
 
-FileContainerReader::FileContainerReader(const u8 **chunkList, u32 chunkCount, u32 chunkSize)
-    : fileNameBuffer_()
-    , decompressionBuffer_(nullptr)
-    , chunkList_(chunkList)
-    , chunkCount_(chunkCount)
-    , chunkSize_(chunkSize)
-    , fileIndex_(nullptr)
-    , curChunkIndex_(0)
-    , curPos_(0)
-    , fileCount_(0)
-    , hasNames_(false)
+FileContainerReader::FileContainerReader(
+    const u8 **chunkList, u32 chunkCount, u32 chunkSize)
+    : fileNameBuffer_(), decompressionBuffer_(nullptr), chunkList_(chunkList),
+      chunkCount_(chunkCount), chunkSize_(chunkSize), fileIndex_(nullptr),
+      curChunkIndex_(0), curPos_(0), fileCount_(0), hasNames_(false)
 {
 }
 
@@ -29,9 +23,10 @@ FileContainerReader::~FileContainerReader()
     }
 }
 
-bool FileContainerReader::init(u8 *decompressionBuffer, u32 decompressionBufferSize)
+bool FileContainerReader::init(
+    u8 *decompressionBuffer, u32 decompressionBufferSize)
 {
-    if(decompressionBufferSize < chunkSize_)
+    if (decompressionBufferSize < chunkSize_)
     {
         return false;
     }
@@ -51,31 +46,30 @@ bool FileContainerReader::init(u8 *decompressionBuffer, u32 decompressionBufferS
     // We can calculate the file offset based on them.
     const u32 indexSize = fileCount_ * FILE_INDEX_ENTRY_SIZE;
     fileIndex_ = new u16[fileCount_];
-    read((u8*)fileIndex_, indexSize);
+    read((u8 *)fileIndex_, indexSize);
 
     return true;
 }
 
-u32 FileContainerReader::getNumberOfFiles() const
-{
-    return fileCount_;
-}
+u32 FileContainerReader::getNumberOfFiles() const { return fileCount_; }
 
-const char* FileContainerReader::getFileName(u32 fileIndex)
+const char *FileContainerReader::getFileName(u32 fileIndex)
 {
-    if(!hasNames_)
+    if (!hasNames_)
     {
         return nullptr;
     }
 
-    // the file names are stored right after the file index, and each name is 16 bytes long.
+    // the file names are stored right after the file index, and each name is 16
+    // bytes long.
     const u32 indexSize = fileCount_ * FILE_INDEX_ENTRY_SIZE;
     const u32 nameTableStartPos = FILE_CONTAINER_HEADER_SIZE + indexSize;
     seek(nameTableStartPos + (fileIndex * FILE_NAME_LENGTH));
 
     // Now copy the file name to a local buffer.
-    // the reason is that not every string is necessarily null terminated in the fileocontainer data.
-    read((u8*)fileNameBuffer_, FILE_NAME_LENGTH);
+    // the reason is that not every string is necessarily null terminated in the
+    // fileocontainer data.
+    read((u8 *)fileNameBuffer_, FILE_NAME_LENGTH);
     fileNameBuffer_[FILE_NAME_LENGTH] = '\0';
     return fileNameBuffer_;
 }
@@ -97,9 +91,9 @@ void FileContainerReader::read(u8 *buffer, u32 size)
 {
     u32 bytesRemaining = size;
 
-    while(bytesRemaining > 0)
+    while (bytesRemaining > 0)
     {
-        if(curPos_ == chunkSize_)
+        if (curPos_ == chunkSize_)
         {
             // we need to decompress a different chunk
             ++curChunkIndex_;
@@ -107,7 +101,9 @@ void FileContainerReader::read(u8 *buffer, u32 size)
         }
 
         const u32 bytesRemainingInChunk = chunkSize_ - curPos_;
-        const u32 bytesToRead = bytesRemaining < bytesRemainingInChunk ? bytesRemaining : bytesRemainingInChunk;
+        const u32 bytesToRead = bytesRemaining < bytesRemainingInChunk
+                                    ? bytesRemaining
+                                    : bytesRemainingInChunk;
 
         memcpy(buffer, decompressionBuffer_ + curPos_, bytesToRead);
         bytesRemaining -= bytesToRead;
@@ -141,14 +137,15 @@ u32 FileContainerReader::getFileOffset(u32 entryIndex) const
     // - file index (fileCount * 2 bytes)
     // - optional name table (fileCount * 16 bytes)
     //
-    u32 offset = FILE_CONTAINER_HEADER_SIZE + (fileCount_ * FILE_INDEX_ENTRY_SIZE);
-    if(hasNames_)
+    u32 offset =
+        FILE_CONTAINER_HEADER_SIZE + (fileCount_ * FILE_INDEX_ENTRY_SIZE);
+    if (hasNames_)
     {
         offset += fileCount_ * FILE_NAME_LENGTH;
     }
 
     // accumulate the sizes of all previous entries to get the file offset
-    for(u32 i = 0; i < entryIndex; ++i)
+    for (u32 i = 0; i < entryIndex; ++i)
     {
         offset += getFileSize(i);
     }
@@ -160,7 +157,7 @@ void FileContainerReader::seek(u32 offset)
 {
     const u32 targetChunkIndex = offset / chunkSize_;
 
-    if(curChunkIndex_ != targetChunkIndex)
+    if (curChunkIndex_ != targetChunkIndex)
     {
         // we need to decompress a different chunk
         uncompressChunk(targetChunkIndex);
diff --git a/source/Gen3CartridgeSaveReader.cpp b/source/Gen3CartridgeSaveReader.cpp
index d5ea6c7..d585eca 100644
--- a/source/Gen3CartridgeSaveReader.cpp
+++ b/source/Gen3CartridgeSaveReader.cpp
@@ -1,22 +1,18 @@
 #include "Gen3CartridgeSaveReader.h"
-#include "libraries/Pokemon-Gen3-to-Gen-X/include/save.h"
 #include "flash_mem.h"
+#include "libraries/Pokemon-Gen3-to-Gen-X/include/save.h"
 #include <cstring>
 
 #define HALL_OF_FAME 0x01C000
 
 Gen3CartridgeSaveReader::Gen3CartridgeSaveReader(u8 *sector_buffer)
-    : sector_start_(0xFFFFFFFF)
-    , sector_buffer_(sector_buffer)
-    , cur_(sector_buffer)
-    , dirty_(false)
+    : sector_start_(0xFFFFFFFF), sector_buffer_(sector_buffer),
+      cur_(sector_buffer), dirty_(false)
 {
     seek(0);
 }
 
-Gen3CartridgeSaveReader::~Gen3CartridgeSaveReader()
-{
-}
+Gen3CartridgeSaveReader::~Gen3CartridgeSaveReader() {}
 
 void Gen3CartridgeSaveReader::read(u8 *buffer, u32 size)
 {
@@ -24,31 +20,31 @@ void Gen3CartridgeSaveReader::read(u8 *buffer, u32 size)
     cur_ += size;
 }
 
-void Gen3CartridgeSaveReader::readUint8(u8& outByte)
+void Gen3CartridgeSaveReader::readUint8(u8 &outByte)
 {
     outByte = *cur_;
     ++cur_;
 }
 
-void Gen3CartridgeSaveReader::readUint16(u16& outWord, Endianness fieldEndianness)
+void Gen3CartridgeSaveReader::readUint16(
+    u16 &outWord, Endianness fieldEndianness)
 {
     // Right now we only support little endian (no need for big endian thus far)
     (void)fieldEndianness;
-    // The read is implemented this way to avoid any issues with unaligned reads.
-    // see writeUint16 for more details.
-    outWord = static_cast<u16>(cur_[0]) |
-              (static_cast<u16>(cur_[1]) << 8);
+    // The read is implemented this way to avoid any issues with unaligned
+    // reads. see writeUint16 for more details.
+    outWord = static_cast<u16>(cur_[0]) | (static_cast<u16>(cur_[1]) << 8);
     cur_ += sizeof(u16);
 }
 
-void Gen3CartridgeSaveReader::readUint32(u32& outDWord, Endianness fieldEndianness)
+void Gen3CartridgeSaveReader::readUint32(
+    u32 &outDWord, Endianness fieldEndianness)
 {
     // Right now we only support little endian (no need for big endian thus far)
     (void)fieldEndianness;
-    // The read is implemented this way to avoid any issues with unaligned reads.
-    // see writeUint16 for more details.
-    outDWord = static_cast<u32>(cur_[0]) |
-               (static_cast<u32>(cur_[1]) << 8) |
+    // The read is implemented this way to avoid any issues with unaligned
+    // reads. see writeUint16 for more details.
+    outDWord = static_cast<u32>(cur_[0]) | (static_cast<u32>(cur_[1]) << 8) |
                (static_cast<u32>(cur_[2]) << 16) |
                (static_cast<u32>(cur_[3]) << 24);
     cur_ += sizeof(u32);
@@ -59,7 +55,6 @@ void Gen3CartridgeSaveReader::write(const u8 *buffer, u32 size)
     memcpy(cur_, buffer, size);
     cur_ += size;
     dirty_ = true;
-
 }
 
 void Gen3CartridgeSaveReader::writeUint8(u8 value)
@@ -73,11 +68,12 @@ void Gen3CartridgeSaveReader::writeUint16(u16 value, Endianness fieldEndianness)
 {
     // Right now we only support little endian (no need for big endian thus far)
     (void)fieldEndianness;
-    // The write is implemented this way to avoid any issues with unaligned writes.
-    // I tried
+    // The write is implemented this way to avoid any issues with unaligned
+    // writes. I tried
     // *((u16*)cur_) = value;
-    // earlier, but when cur_ was set to 0x0019, this caused undefined behaviour.
-    // (specifically the word was written 1 byte earlier than it should've been)
+    // earlier, but when cur_ was set to 0x0019, this caused undefined
+    // behaviour. (specifically the word was written 1 byte earlier than it
+    // should've been)
     cur_[0] = static_cast<u8>(value & 0xFF);
     cur_[1] = static_cast<u8>(value >> 8);
     cur_ += sizeof(u16);
@@ -88,8 +84,8 @@ void Gen3CartridgeSaveReader::writeUint32(u32 value, Endianness fieldEndianness)
 {
     // Right now we only support little endian (no need for big endian thus far)
     (void)fieldEndianness;
-    // The write is implemented this way to avoid any issues with unaligned writes.
-    // see writeUint16 for more details.
+    // The write is implemented this way to avoid any issues with unaligned
+    // writes. see writeUint16 for more details.
     cur_[0] = static_cast<u8>(value & 0xFF);
     cur_[1] = static_cast<u8>((value >> 8) & 0xFF);
     cur_[2] = static_cast<u8>((value >> 16) & 0xFF);
@@ -102,7 +98,7 @@ void Gen3CartridgeSaveReader::seek(u32 offset)
 {
     const u32 sector_offset = offset % SECTOR_SIZE;
     const uintptr_t sector_start = offset - sector_offset;
-    if(sector_start != sector_start_)
+    if (sector_start != sector_start_)
     {
         // write any pending changes.
         flush();
@@ -125,7 +121,7 @@ void Gen3CartridgeSaveReader::advance(u32 numBytes)
 
 void Gen3CartridgeSaveReader::rewind(u32 numBytes)
 {
-    if(static_cast<uintptr_t>(cur_ - sector_buffer_) >= numBytes)
+    if (static_cast<uintptr_t>(cur_ - sector_buffer_) >= numBytes)
     {
         cur_ -= numBytes;
     }
@@ -137,13 +133,15 @@ void Gen3CartridgeSaveReader::rewind(u32 numBytes)
 
 void Gen3CartridgeSaveReader::flush()
 {
-    if(!dirty_)
+    if (!dirty_)
     {
         return;
     }
 
-    update_memory_buffer_checksum(sector_buffer_, (sector_start_ == HALL_OF_FAME));
-    // Real flash requires erase before rewriting bytes that may need 0->1 transitions.
+    update_memory_buffer_checksum(
+        sector_buffer_, (sector_start_ == HALL_OF_FAME));
+    // Real flash requires erase before rewriting bytes that may need 0->1
+    // transitions.
     erase_sector(sector_start_);
     copy_ram_to_save(sector_buffer_, sector_start_, SECTOR_SIZE);
     dirty_ = false;
diff --git a/source/background_engine.cpp b/source/background_engine.cpp
index 64c8d27..037d9da 100644
--- a/source/background_engine.cpp
+++ b/source/background_engine.cpp
@@ -1,7 +1,7 @@
-#include <tonc.h>
-#include "pokemon_data.h"
 #include "background_engine.h"
+#include "pokemon_data.h"
 #include "translated_text.h"
+#include <tonc.h>
 
 #define CBB 0
 #define SBB 24
@@ -9,53 +9,56 @@ int x, y;
 
 void background_frame(int global_frame_count)
 {
-        if (!get_missingno_enabled())
-        {
-                x++;
-                y++;
+    if (!get_missingno_enabled())
+    {
+        x++;
+        y++;
 
-                REG_BG0HOFS = x;
-                REG_BG0VOFS = y;
-        }
+        REG_BG0HOFS = x;
+        REG_BG0VOFS = y;
+    }
 }
 
-// This could honestly be an object... might want to do that in the future, depending on how complex using this gets
+// This could honestly be an object... might want to do that in the future,
+// depending on how complex using this gets
 void create_textbox(int text_section, int text_key, bool eraseMainBox)
 {
-        const u8 box_type = text_box_type_tables[text_section][text_key];
-        create_textbox(box_type, eraseMainBox);
+    const u8 box_type = text_box_type_tables[text_section][text_key];
+    create_textbox(box_type, eraseMainBox);
 }
 
 void create_textbox(u8 textbox_type, bool eraseMainBox)
 {
-        const int startTileX = box_type_info[textbox_type][BOX_TYPE_VAL_START_TILE_X];
-        const int startTileY = box_type_info[textbox_type][BOX_TYPE_VAL_START_TILE_Y];
-        const int text_space_width = box_type_info[textbox_type][BOX_TYPE_VAL_PIXELS_PER_LINE];
-        const int text_space_height = box_type_info[textbox_type][BOX_TYPE_VAL_NUM_OF_LINES] * 16;
+    const int startTileX =
+        box_type_info[textbox_type][BOX_TYPE_VAL_START_TILE_X];
+    const int startTileY =
+        box_type_info[textbox_type][BOX_TYPE_VAL_START_TILE_Y];
+    const int text_space_width =
+        box_type_info[textbox_type][BOX_TYPE_VAL_PIXELS_PER_LINE];
+    const int text_space_height =
+        box_type_info[textbox_type][BOX_TYPE_VAL_NUM_OF_LINES] * 16;
 
-        create_textbox(startTileX, startTileY, text_space_width, text_space_height, eraseMainBox);
+    create_textbox(startTileX, startTileY, text_space_width, text_space_height,
+        eraseMainBox);
 }
 
-void create_textbox(int startTileX, int startTileY, int text_space_width, int text_space_height, bool eraseMainBox)
+void create_textbox(int startTileX, int startTileY, int text_space_width,
+    int text_space_height, bool eraseMainBox)
 {
-        if (eraseMainBox)
-        {
-                erase_textbox_tiles();
-        }
-        add_menu_box(startTileX, startTileY, text_space_width + 16, text_space_height + 16);
-        tte_set_pos((startTileX + 1) * 8, (startTileY + 1) * 8);
-        tte_set_margins((startTileX + 1) * 8, (startTileY + 1) * 8,
-                        ((startTileX + 1) * 8) + text_space_width, ((startTileY + 1) * 8) + text_space_height);
-        tte_erase_rect(0, 0, H_MAX, V_MAX);
-        show_textbox();
+    if (eraseMainBox)
+    {
+        erase_textbox_tiles();
+    }
+    add_menu_box(
+        startTileX, startTileY, text_space_width + 16, text_space_height + 16);
+    tte_set_pos((startTileX + 1) * 8, (startTileY + 1) * 8);
+    tte_set_margins((startTileX + 1) * 8, (startTileY + 1) * 8,
+        ((startTileX + 1) * 8) + text_space_width,
+        ((startTileY + 1) * 8) + text_space_height);
+    tte_erase_rect(0, 0, H_MAX, V_MAX);
+    show_textbox();
 }
 
-void show_textbox()
-{
-        BG_TEXTBOX = (BG_TEXTBOX & ~BG_PRIO_MASK) | BG_PRIO(1);
-}
+void show_textbox() { BG_TEXTBOX = (BG_TEXTBOX & ~BG_PRIO_MASK) | BG_PRIO(1); }
 
-void hide_textbox()
-{
-        BG_TEXTBOX = (BG_TEXTBOX & ~BG_PRIO_MASK) | BG_PRIO(3);
-}
\ No newline at end of file
+void hide_textbox() { BG_TEXTBOX = (BG_TEXTBOX & ~BG_PRIO_MASK) | BG_PRIO(3); }
\ No newline at end of file
diff --git a/source/box_menu.cpp b/source/box_menu.cpp
index 82c25a9..22fe0de 100644
--- a/source/box_menu.cpp
+++ b/source/box_menu.cpp
@@ -1,21 +1,21 @@
-#include <tonc.h>
-#include "typeDefs.h"
-#include "button_menu.h"
-#include "button_handler.h"
-#include "ptgb_save_data_manager.h"
-#include "global_frame_controller.h"
-#include "string"
-#include "sprite_data.h"
 #include "box_menu.h"
-#include "text_engine.h"
-#include "translated_text.h"
 #include "FileContainerReader.h"
-#include "text_tables.h"
+#include "button_handler.h"
+#include "button_menu.h"
 #include "dbg/debug_mode.h"
+#include "global_frame_controller.h"
+#include "ptgb_save_data_manager.h"
+#include "sprite_data.h"
+#include "string"
+#include "text_engine.h"
+#include "text_tables.h"
+#include "translated_text.h"
+#include "typeDefs.h"
+#include <tonc.h>
 
 Box_Menu::Box_Menu() {};
 
-int Box_Menu::box_main(PokeBox* box, Version vers)
+int Box_Menu::box_main(PokeBox *box, Version vers)
 {
     PokemonTables pkmnTables;
     u8 names_decompression_buffer[2048];
@@ -28,14 +28,15 @@ int Box_Menu::box_main(PokeBox* box, Version vers)
     FileContainerReader namesReader(chunkList, numChunks, chunkSize);
 
     tte_erase_screen();
-    
+
     if (vers == VERSION_UNKNOWN)
     {
         load_flex_background(FBG_Box_Green, 2);
     }
     else
     {
-        load_flex_background((FlexBackground)((int)FBG_Box_Green + (int)vers), 2); // This is kinda gross, but it works
+        load_flex_background((FlexBackground)((int)FBG_Box_Green + (int)vers),
+            2); // This is kinda gross, but it works
     }
 
     REG_BG1VOFS = 0;
@@ -54,7 +55,8 @@ int Box_Menu::box_main(PokeBox* box, Version vers)
     obj_unhide(box_select, 0);
     int index = 0;
 
-    namesReader.init(names_decompression_buffer, sizeof(names_decompression_buffer));
+    namesReader.init(
+        names_decompression_buffer, sizeof(names_decompression_buffer));
 
     while (true)
     {
@@ -144,9 +146,11 @@ int Box_Menu::box_main(PokeBox* box, Version vers)
         if (update_pos)
         {
             index = x + (y * BOXMENU_HNUM);
-            obj_set_pos(box_select, BOXMENU_LEFT + (x * (BOXMENU_SPRITE_WIDTH + BOXMENU_HSPACE)), BOXMENU_TOP + (y * (BOXMENU_SPRITE_HEIGHT + BOXMENU_VSPACE)));
+            obj_set_pos(box_select,
+                BOXMENU_LEFT + (x * (BOXMENU_SPRITE_WIDTH + BOXMENU_HSPACE)),
+                BOXMENU_TOP + (y * (BOXMENU_SPRITE_HEIGHT + BOXMENU_VSPACE)));
             tte_erase_rect(6, 16, 80, 152);
-            GBPokemon* curr_pkmn = box->getGBPokemon(index);
+            GBPokemon *curr_pkmn = box->getGBPokemon(index);
             obj_hide(grabbed_front_sprite);
             if (index < box->getNumInBox() && curr_pkmn->isValid)
             {
@@ -155,10 +159,12 @@ int Box_Menu::box_main(PokeBox* box, Version vers)
 
                 tte_set_pos(6, 88);
                 if (
-                    // Only the name if the language is either both Japanese or neither is Japanese
-                    ((curr_pkmn->getLanguage() == JAPANESE) && (PTGB_BUILD_LANGUAGE == JPN_ID)) || 
-                    ((curr_pkmn->getLanguage() != JAPANESE) && (PTGB_BUILD_LANGUAGE != JPN_ID))
-                    )
+                    // Only the name if the language is either both Japanese or
+                    // neither is Japanese
+                    ((curr_pkmn->getLanguage() == JAPANESE) &&
+                        (PTGB_BUILD_LANGUAGE == JPN_ID)) ||
+                    ((curr_pkmn->getLanguage() != JAPANESE) &&
+                        (PTGB_BUILD_LANGUAGE != JPN_ID)))
                 {
                     curr_pkmn->externalConvertNickname(&pkmnTables, val);
                     ptgb_write_simple(val, true);
@@ -172,7 +178,7 @@ int Box_Menu::box_main(PokeBox* box, Version vers)
                 }
                 tte_set_pos(14, 98);
 
-                if(nameEntryIndex == MISSINGNO)
+                if (nameEntryIndex == MISSINGNO)
                 {
                     nameEntryIndex = 0;
                 }
@@ -186,7 +192,8 @@ int Box_Menu::box_main(PokeBox* box, Version vers)
                 val[3] = 0x00; // " "
                 val[4] = 0xFF; // endline
                 ptgb_write_simple(val, true);
-                convert_int_to_ptgb_str(curr_pkmn->getLevel(), val); // Val should never go out of bounds
+                convert_int_to_ptgb_str(curr_pkmn->getLevel(),
+                    val); // Val should never go out of bounds
                 ptgb_write_simple(val, true);
 
                 update_front_box_sprite(curr_pkmn, true);
diff --git a/source/button_handler.cpp b/source/button_handler.cpp
index 795354c..a04d777 100644
--- a/source/button_handler.cpp
+++ b/source/button_handler.cpp
@@ -1,9 +1,7 @@
 #include "button_handler.h"
 #include "sprite_data.h"
 
-Button::Button(){
-    
-}
+Button::Button() {}
 
 Button::Button(OBJ_ATTR *L, OBJ_ATTR *R, int nLeft_button_width)
 {
diff --git a/source/button_menu.cpp b/source/button_menu.cpp
index 56478f3..f1e7580 100644
--- a/source/button_menu.cpp
+++ b/source/button_menu.cpp
@@ -1,11 +1,12 @@
-#include <tonc.h>
 #include "button_menu.h"
 #include "button_handler.h"
-#include "ptgb_save_data_manager.h"
 #include "global_frame_controller.h"
+#include "ptgb_save_data_manager.h"
 #include "string"
+#include <tonc.h>
 
-Button_Menu::Button_Menu(int nRows, int nColumns, int nButton_width, int nButton_height, bool enable_cancel)
+Button_Menu::Button_Menu(int nRows, int nColumns, int nButton_width,
+    int nButton_height, bool enable_cancel)
 {
     columns = nColumns;
     rows = nRows;
@@ -60,7 +61,9 @@ int Button_Menu::button_main()
                 curr_x = get_x_from_pos(button_vector.size() - 1);
             }
         }
-        else if (key_hit(KEY_LEFT) && ((curr_x > 0) || ((curr_x == 0) && (curr_y == rows - 1) && (offset_value > 0))))
+        else if (key_hit(KEY_LEFT) &&
+                 ((curr_x > 0) || ((curr_x == 0) && (curr_y == rows - 1) &&
+                                      (offset_value > 0))))
         {
             if (curr_x == 0 && offset_value > 0)
             {
@@ -117,7 +120,7 @@ void Button_Menu::show_buttons()
 
 void Button_Menu::hide_buttons()
 {
-    for(size_t i=0; i < button_vector.size(); ++i)
+    for (size_t i = 0; i < button_vector.size(); ++i)
     {
         button_vector[i].hide();
     }
@@ -125,19 +128,24 @@ void Button_Menu::hide_buttons()
 
 void Button_Menu::organize_buttons()
 {
-    // Total space, minus the space taken up by the buttons, divided by the spaces between the buttons.
+    // Total space, minus the space taken up by the buttons, divided by the
+    // spaces between the buttons.
     int vertical_space =
         ((y_max - y_min) - (rows * button_height)) / (rows + 1);
     int horizontal_space =
         ((x_max - x_min) - (columns * button_width)) / (columns + 1);
-    bottom_offset = ((horizontal_space + button_width) * ((rows * columns) - button_vector.size()) / 2);
+    bottom_offset = ((horizontal_space + button_width) *
+                     ((rows * columns) - button_vector.size()) / 2);
     offset_value = (rows * columns) - button_vector.size();
     for (unsigned int i = 0; i < button_vector.size(); i++)
     {
         button_vector.at(i).set_location(
-            ((horizontal_space + button_width) * get_x_from_pos(i)) + horizontal_space + x_min +
-                (get_y_from_pos(i) == (unsigned int)(rows - 1) ? bottom_offset : 0),
-            ((vertical_space + button_height) * get_y_from_pos(i)) + vertical_space + y_min);
+            ((horizontal_space + button_width) * get_x_from_pos(i)) +
+                horizontal_space + x_min +
+                (get_y_from_pos(i) == (unsigned int)(rows - 1) ? bottom_offset
+                                                               : 0),
+            ((vertical_space + button_height) * get_y_from_pos(i)) +
+                vertical_space + y_min);
     }
 }
 
@@ -146,15 +154,9 @@ unsigned int Button_Menu::get_pos_from_xy(int nX, int nY)
     return (nY * columns) + nX;
 }
 
-unsigned int Button_Menu::get_x_from_pos(int nPos)
-{
-    return (nPos % columns);
-}
+unsigned int Button_Menu::get_x_from_pos(int nPos) { return (nPos % columns); }
 
-unsigned int Button_Menu::get_y_from_pos(int nPos)
-{
-    return (nPos / columns);
-}
+unsigned int Button_Menu::get_y_from_pos(int nPos) { return (nPos / columns); }
 
 void Button_Menu::set_rows_and_columns(int nRows, int nColumns)
 {
@@ -167,7 +169,4 @@ void Button_Menu::set_bottom_row_offset(int nBottom_offset)
     bottom_offset = nBottom_offset;
 }
 
-void Button_Menu::clear_vector()
-{
-    button_vector.clear();
-}
\ No newline at end of file
+void Button_Menu::clear_vector() { button_vector.clear(); }
\ No newline at end of file
diff --git a/source/custom_malloc.cpp b/source/custom_malloc.cpp
index 2c5079a..9ad0937 100644
--- a/source/custom_malloc.cpp
+++ b/source/custom_malloc.cpp
@@ -5,35 +5,37 @@
 #include <string.h>
 #include <tonc.h>
 ///
-/// This module is implemented to reduce the rom size and reduce IWRAM consumption (__malloc_av -> 1 KB)
-/// However, we need to be careful to make a heap available at the right times.
-/// This implementation stubs malloc_r, which is called by newlib c internally
-/// That means we MUST avoid using:
-/// printf, sprintf, fprintf, etc. (use iprintf from libtonc, nanoprintf or dprint alternatives)
-/// fopen, freopen
-/// strdup
-/// locale / setlocale
-/// atexit / exit / __cxa_atexit (especially in C++)
+/// This module is implemented to reduce the rom size and reduce IWRAM
+/// consumption (__malloc_av -> 1 KB) However, we need to be careful to make a
+/// heap available at the right times. This implementation stubs malloc_r, which
+/// is called by newlib c internally That means we MUST avoid using: printf,
+/// sprintf, fprintf, etc. (use iprintf from libtonc, nanoprintf or dprint
+/// alternatives) fopen, freopen strdup locale / setlocale atexit / exit /
+/// __cxa_atexit (especially in C++)
 ///
 
 /// This module implements a bitmap block allocator.
-/// We define a page size (mem_page_size), which is the minimum allocation unit for this malloc() implementation.
-/// The allocator has a bitmap (g_alloc_map) which tracks the allocation of each page in the pool as a single bit.
-/// 1 means allocated, 0 means free
-/// The alloc map is structured to have a list of 32 bit unsigned integers, as that is the native unit the ARM cpu and memory bus
-/// work with. So using these is the most efficient way to do it.
-/// The allocator keeps track of the last position it was at while scanning and wraps around to the beginning of the allocation map
-/// if necessary to find free space.
-
+/// We define a page size (mem_page_size), which is the minimum allocation unit
+/// for this malloc() implementation. The allocator has a bitmap (g_alloc_map)
+/// which tracks the allocation of each page in the pool as a single bit. 1
+/// means allocated, 0 means free The alloc map is structured to have a list of
+/// 32 bit unsigned integers, as that is the native unit the ARM cpu and memory
+/// bus work with. So using these is the most efficient way to do it. The
+/// allocator keeps track of the last position it was at while scanning and
+/// wraps around to the beginning of the allocation map if necessary to find
+/// free space.
 
 #define ALLOC_MAP_START_BIT 0x80000000
 #define MALLOC_MEM_POOL_PAGE_SIZE 4
 
 extern char __end__;
 
-// warning: this static allocation of g_alloc_map limits the maximum g_mem_pool size to 8192 bytes.
-// TODO: if this is not enough, we could change the code to allow a user to set their g_alloc_map with malloc_set_mem_pool()
-static EWRAM_DATA uint32_t g_alloc_map[CUSTOM_MALLOC_POOL_SIZE / (32 * MALLOC_MEM_POOL_PAGE_SIZE)];
+// warning: this static allocation of g_alloc_map limits the maximum g_mem_pool
+// size to 8192 bytes.
+// TODO: if this is not enough, we could change the code to allow a user to set
+// their g_alloc_map with malloc_set_mem_pool()
+static EWRAM_DATA uint32_t
+    g_alloc_map[CUSTOM_MALLOC_POOL_SIZE / (32 * MALLOC_MEM_POOL_PAGE_SIZE)];
 static uint32_t *g_alloc_map_ptr = g_alloc_map;
 static uint32_t g_alloc_map_bit = ALLOC_MAP_START_BIT;
 
@@ -41,307 +43,345 @@ static const uint32_t mem_page_size = MALLOC_MEM_POOL_PAGE_SIZE;
 
 // For some reason, __end__ only gives the right value if we use it directly.
 // We can't store it in a variable.
-// But if we create an inline function, then we're basically doing the same thing as using it directly.
-static inline uint8_t *get_heap_start(void)
+// But if we create an inline function, then we're basically doing the same
+// thing as using it directly.
+static inline uint8_t *get_heap_start(void) { return (uint8_t *)&__end__; }
+
+/// @brief This function calculates the absolute page offset/count from the
+/// start of the alloc_map until the specified position in the alloc map
+static uint16_t calculate_page_offset(
+    uint32_t *alloc_map_ptr, uint32_t alloc_map_bit)
 {
-    return (uint8_t *)&__end__;
+    uint16_t num_pages = (alloc_map_ptr - g_alloc_map) * 32;
+    uint32_t bit_check = ALLOC_MAP_START_BIT;
+
+    while (bit_check != alloc_map_bit)
+    {
+        ++num_pages;
+        bit_check >>= 1;
+    }
+
+    return num_pages;
 }
 
-/// @brief This function calculates the absolute page offset/count from the start of the alloc_map until
-/// the specified position in the alloc map
-static uint16_t calculate_page_offset(uint32_t *alloc_map_ptr, uint32_t alloc_map_bit)
+/// @brief This function converts a position in the alloc map into the
+/// associated pointer in the actual memory pool.
+static uint8_t *convert_alloc_map_position_into_mem_pool_ptr(
+    uint32_t *start, uint32_t bit_start)
 {
-	uint16_t num_pages = (alloc_map_ptr - g_alloc_map) * 32;
-	uint32_t bit_check = ALLOC_MAP_START_BIT;
-	
-	while(bit_check != alloc_map_bit)
-	{
-		++num_pages;
-		bit_check >>= 1;
-	}
-	
-	return num_pages;
+    const uint16_t page_offset = calculate_page_offset(start, bit_start);
+    return get_heap_start() + (page_offset * mem_page_size);
 }
 
-/// @brief This function converts a position in the alloc map into the associated pointer in the actual memory pool.
-static uint8_t* convert_alloc_map_position_into_mem_pool_ptr(uint32_t *start, uint32_t bit_start)
-{
-	const uint16_t page_offset = calculate_page_offset(start, bit_start);
-	return get_heap_start() + (page_offset * mem_page_size);
-}
-
-/// @brief This function converts a memory pool pointer into a position in the associated allocation map.
+/// @brief This function converts a memory pool pointer into a position in the
+/// associated allocation map.
 /// @param ptr pointer in the memory pool
-/// @param alloc_start output variable to indicate the start of the alloc map entry.
-/// @param bit_start output variable to indcate the specific bit position inside that alloc map entry.
-static void convert_mem_pool_ptr_into_alloc_map_position(uint8_t *ptr, uint32_t **alloc_start, uint32_t *bit_start)
+/// @param alloc_start output variable to indicate the start of the alloc map
+/// entry.
+/// @param bit_start output variable to indcate the specific bit position inside
+/// that alloc map entry.
+static void convert_mem_pool_ptr_into_alloc_map_position(
+    uint8_t *ptr, uint32_t **alloc_start, uint32_t *bit_start)
 {
-	const uint16_t page_offset = (ptr - get_heap_start()) / mem_page_size;
-	*alloc_start = g_alloc_map + (page_offset / 32);
-	*bit_start = ALLOC_MAP_START_BIT >> (page_offset % 32);
+    const uint16_t page_offset = (ptr - get_heap_start()) / mem_page_size;
+    *alloc_start = g_alloc_map + (page_offset / 32);
+    *bit_start = ALLOC_MAP_START_BIT >> (page_offset % 32);
 }
 
-/// @brief This function implements a speedup while scanning the allocation map for free space:
-/// If the current bit position is the first one, it will try to skip entire alloc map entries if all bits are set.
-/// This is much faster than walking through each bit individually.
-/// @param end_entry Since the function can loop, we need to provide an entry position as a stop condition
-/// to avoid an infinite loop
+/// @brief This function implements a speedup while scanning the allocation map
+/// for free space: If the current bit position is the first one, it will try to
+/// skip entire alloc map entries if all bits are set. This is much faster than
+/// walking through each bit individually.
+/// @param end_entry Since the function can loop, we need to provide an entry
+/// position as a stop condition to avoid an infinite loop
 static void skip_wholy_allocated_map_entries(uint32_t *end_entry)
 {
-	const uint32_t *g_alloc_map_end = g_alloc_map + (sizeof(g_alloc_map) / sizeof(uint32_t));
-	if(g_alloc_map_ptr == end_entry)
-	{
-		return;
-	}
+    const uint32_t *g_alloc_map_end =
+        g_alloc_map + (sizeof(g_alloc_map) / sizeof(uint32_t));
+    if (g_alloc_map_ptr == end_entry)
+    {
+        return;
+    }
 
-	while(*g_alloc_map_ptr == 0xFFFFFFFF)
-	{
-		++g_alloc_map_ptr;
-		if(g_alloc_map_ptr >= g_alloc_map_end)
-		{
-			g_alloc_map_ptr = g_alloc_map;
-		}
-		if(g_alloc_map_ptr == end_entry)
-		{
-			return;
-		}
-	}
+    while (*g_alloc_map_ptr == 0xFFFFFFFF)
+    {
+        ++g_alloc_map_ptr;
+        if (g_alloc_map_ptr >= g_alloc_map_end)
+        {
+            g_alloc_map_ptr = g_alloc_map;
+        }
+        if (g_alloc_map_ptr == end_entry)
+        {
+            return;
+        }
+    }
 }
 
-/// @brief This function advances the alloc_map_bit and possibly the alloc_map entry itself.
-/// It also takes care of wraparound when we reach the end with alloc_map_ptr
-static void advance_alloc_map_bit(uint32_t **alloc_map_ptr, uint32_t *alloc_map_bit, bool *looped)
+/// @brief This function advances the alloc_map_bit and possibly the alloc_map
+/// entry itself. It also takes care of wraparound when we reach the end with
+/// alloc_map_ptr
+static void advance_alloc_map_bit(
+    uint32_t **alloc_map_ptr, uint32_t *alloc_map_bit, bool *looped)
 {
-	(*alloc_map_bit) >>= 1;
-	if(!(*alloc_map_bit))
-	{
-		const uint32_t *g_alloc_map_end = g_alloc_map + (sizeof(g_alloc_map) / sizeof(uint32_t));
-		++(*alloc_map_ptr);
-		if((*alloc_map_ptr) >= g_alloc_map_end)
-		{
-			(*alloc_map_ptr) = g_alloc_map;
-			if(looped)
-			{
-				*looped = true;
-			}
-		}
-		
-		(*alloc_map_bit) = ALLOC_MAP_START_BIT;
-		
-	}
+    (*alloc_map_bit) >>= 1;
+    if (!(*alloc_map_bit))
+    {
+        const uint32_t *g_alloc_map_end =
+            g_alloc_map + (sizeof(g_alloc_map) / sizeof(uint32_t));
+        ++(*alloc_map_ptr);
+        if ((*alloc_map_ptr) >= g_alloc_map_end)
+        {
+            (*alloc_map_ptr) = g_alloc_map;
+            if (looped)
+            {
+                *looped = true;
+            }
+        }
+
+        (*alloc_map_bit) = ALLOC_MAP_START_BIT;
+    }
 }
 
-/// @brief This function checks for num_pages of free space at the specified alloc map position.
-static bool check_block_free(uint32_t **cur_entry, uint32_t *cur_bit, uint16_t num_pages, bool *looped)
+/// @brief This function checks for num_pages of free space at the specified
+/// alloc map position.
+static bool check_block_free(
+    uint32_t **cur_entry, uint32_t *cur_bit, uint16_t num_pages, bool *looped)
 {
-	while(num_pages)
-	{
-		if(((**cur_entry) & (*cur_bit)) == 0)
-		{
-			--num_pages;
-			advance_alloc_map_bit(cur_entry, cur_bit, looped);
-			if(*cur_entry == g_alloc_map && *cur_bit == ALLOC_MAP_START_BIT)
-			{
-				// we looped in the middle of a block. consider it allocated.
-				break;
-			}
-		}
-		else
-		{
-			// the page we're currently considering is already allocated.
-			// advance the bit position again for the next call, but the result of this function
-			// is that we didn't find a large enough free block
-			advance_alloc_map_bit(cur_entry, cur_bit, looped);
-			break;
-		}
-	}
-	return !num_pages;
+    while (num_pages)
+    {
+        if (((**cur_entry) & (*cur_bit)) == 0)
+        {
+            --num_pages;
+            advance_alloc_map_bit(cur_entry, cur_bit, looped);
+            if (*cur_entry == g_alloc_map && *cur_bit == ALLOC_MAP_START_BIT)
+            {
+                // we looped in the middle of a block. consider it allocated.
+                break;
+            }
+        }
+        else
+        {
+            // the page we're currently considering is already allocated.
+            // advance the bit position again for the next call, but the result
+            // of this function is that we didn't find a large enough free block
+            advance_alloc_map_bit(cur_entry, cur_bit, looped);
+            break;
+        }
+    }
+    return !num_pages;
 }
 
-/// @brief This function marks a block of pages as "allocated" in the allocation map at the specified map position
-static void mark_block_allocated(uint32_t *cur_entry, uint32_t cur_bit, size_t num_pages)
+/// @brief This function marks a block of pages as "allocated" in the allocation
+/// map at the specified map position
+static void mark_block_allocated(
+    uint32_t *cur_entry, uint32_t cur_bit, size_t num_pages)
 {
-	while(num_pages)
-	{
-		*cur_entry |= cur_bit;
-		--num_pages;
-		advance_alloc_map_bit(&cur_entry, &cur_bit, NULL);
-	}
+    while (num_pages)
+    {
+        *cur_entry |= cur_bit;
+        --num_pages;
+        advance_alloc_map_bit(&cur_entry, &cur_bit, NULL);
+    }
 }
 
-/// @brief This function marks a block of pages as "free" in the allocation map at the specified map position
-static void mark_block_free(uint32_t *cur_entry, uint32_t cur_bit, size_t num_pages)
+/// @brief This function marks a block of pages as "free" in the allocation map
+/// at the specified map position
+static void mark_block_free(
+    uint32_t *cur_entry, uint32_t cur_bit, size_t num_pages)
 {
-	while(num_pages)
-	{
-		// clear bit
-		*cur_entry &= ~cur_bit;
-		--num_pages;
-		advance_alloc_map_bit(&cur_entry, &cur_bit, NULL);
-	}
+    while (num_pages)
+    {
+        // clear bit
+        *cur_entry &= ~cur_bit;
+        --num_pages;
+        advance_alloc_map_bit(&cur_entry, &cur_bit, NULL);
+    }
 }
 
-/// @brief This function calculates the number of pages needed to allocate at least the requested size.
-/// It does add 1 additional page for storing the allocation size (in pages) and may add another one to ensure
-/// the returned allocation is aligned to mem_page_size
+/// @brief This function calculates the number of pages needed to allocate at
+/// least the requested size. It does add 1 additional page for storing the
+/// allocation size (in pages) and may add another one to ensure the returned
+/// allocation is aligned to mem_page_size
 static uint16_t get_num_pages_for_size(size_t size)
 {
-	// reserve 1 additional page for storing the number of pages (and use/waste a whole page because of alignment)
-	// we need this as a "header" to be able to know how many pages to free().
-	uint16_t num_pages = (size / mem_page_size) + 1;
-	if(size % mem_page_size)
-	{
-		++num_pages;
-	}
-	return num_pages;
+    // reserve 1 additional page for storing the number of pages (and use/waste
+    // a whole page because of alignment) we need this as a "header" to be able
+    // to know how many pages to free().
+    uint16_t num_pages = (size / mem_page_size) + 1;
+    if (size % mem_page_size)
+    {
+        ++num_pages;
+    }
+    return num_pages;
 }
 
 void malloc_init_default_pool(void)
 {
-	memset(g_alloc_map, 0, sizeof(g_alloc_map));  // Clear bitmap
+    memset(g_alloc_map, 0, sizeof(g_alloc_map)); // Clear bitmap
 }
 
 extern "C"
 {
 
-/// @brief The custom implementation of the bitmap allocator described at the top of this module.
-void* malloc(size_t size)
-{
-	uint32_t* const alloc_start = g_alloc_map_ptr;
-	const uint32_t alloc_bit_start = g_alloc_map_bit;
-	uint32_t *current_start;
-	uint32_t current_bit_start;
-	uint8_t *pool_ptr;
-	const uint16_t num_pages = get_num_pages_for_size(size);
-	bool looped = false;
-	
-	while(true)
-	{
-		current_start = g_alloc_map_ptr;
-		current_bit_start = g_alloc_map_bit;
-		if(check_block_free(&g_alloc_map_ptr, &g_alloc_map_bit, num_pages, &looped))
-		{
-			mark_block_allocated(current_start, current_bit_start, num_pages);
-			pool_ptr = convert_alloc_map_position_into_mem_pool_ptr(current_start, current_bit_start);
-			// store the number of pages as a header in the first page
-			*((uint16_t*)pool_ptr) = num_pages;
-			// return a pointer beyond the first page
-			return pool_ptr + mem_page_size;
-		}
-		else
-		{
-			if(looped && g_alloc_map_ptr == alloc_start && g_alloc_map_bit <= alloc_bit_start)
-			{
-				// we looped back to our start position. Ran out of memory I suppose
-				return NULL;
-			}
-			// if we're at the start of an alloc_map 32 bit entry then avoid walking through each bit one-by-one
-			// if all bits are set
-			skip_wholy_allocated_map_entries(alloc_start);
-		}
-	}
-}
+    /// @brief The custom implementation of the bitmap allocator described at
+    /// the top of this module.
+    void *malloc(size_t size)
+    {
+        uint32_t *const alloc_start = g_alloc_map_ptr;
+        const uint32_t alloc_bit_start = g_alloc_map_bit;
+        uint32_t *current_start;
+        uint32_t current_bit_start;
+        uint8_t *pool_ptr;
+        const uint16_t num_pages = get_num_pages_for_size(size);
+        bool looped = false;
 
-/// @brief The custom implementation of free() of the bitmap allocator described at the top of this module.
-void free(void *ptr)
-{
-	uint8_t* const pool_ptr = ((uint8_t*)ptr) - mem_page_size;
-	uint32_t *alloc_map_entry;
-	uint32_t alloc_map_bit;
-	const uint16_t num_pages = *((uint16_t*)pool_ptr);
+        while (true)
+        {
+            current_start = g_alloc_map_ptr;
+            current_bit_start = g_alloc_map_bit;
+            if (check_block_free(
+                    &g_alloc_map_ptr, &g_alloc_map_bit, num_pages, &looped))
+            {
+                mark_block_allocated(
+                    current_start, current_bit_start, num_pages);
+                pool_ptr = convert_alloc_map_position_into_mem_pool_ptr(
+                    current_start, current_bit_start);
+                // store the number of pages as a header in the first page
+                *((uint16_t *)pool_ptr) = num_pages;
+                // return a pointer beyond the first page
+                return pool_ptr + mem_page_size;
+            }
+            else
+            {
+                if (looped && g_alloc_map_ptr == alloc_start &&
+                    g_alloc_map_bit <= alloc_bit_start)
+                {
+                    // we looped back to our start position. Ran out of memory I
+                    // suppose
+                    return NULL;
+                }
+                // if we're at the start of an alloc_map 32 bit entry then avoid
+                // walking through each bit one-by-one if all bits are set
+                skip_wholy_allocated_map_entries(alloc_start);
+            }
+        }
+    }
 
-	convert_mem_pool_ptr_into_alloc_map_position(pool_ptr, &alloc_map_entry, &alloc_map_bit);
-	mark_block_free(alloc_map_entry, alloc_map_bit, num_pages);
-}
+    /// @brief The custom implementation of free() of the bitmap allocator
+    /// described at the top of this module.
+    void free(void *ptr)
+    {
+        uint8_t *const pool_ptr = ((uint8_t *)ptr) - mem_page_size;
+        uint32_t *alloc_map_entry;
+        uint32_t alloc_map_bit;
+        const uint16_t num_pages = *((uint16_t *)pool_ptr);
 
-/// @brief The custom implementation of realloc() of the bitmap allocator described at the top of this module.
-void* realloc(void *ptr, size_t new_size)
-{
-	if(!ptr)
-	{
-		return malloc(new_size);
-	}
-	
-	uint8_t* const pool_ptr = ((uint8_t*)ptr) - mem_page_size;
-	uint32_t *alloc_map_entry;
-	uint32_t alloc_map_bit;
-	const uint16_t original_num_pages = *((uint16_t*)pool_ptr);
-	const uint16_t new_num_pages = get_num_pages_for_size(new_size);
-	
-	convert_mem_pool_ptr_into_alloc_map_position(pool_ptr, &alloc_map_entry, &alloc_map_bit);
-	
-	// first mark the associated allocmap bits as free in order make sure the current block is correctly detected as free
-	mark_block_free(alloc_map_entry, alloc_map_bit, original_num_pages);
-	
-	if(check_block_free(&alloc_map_entry, &alloc_map_bit, new_num_pages, NULL))
-	{
-		// reset the entry and bit because check_block_free advanced it.
-		convert_mem_pool_ptr_into_alloc_map_position(pool_ptr, &alloc_map_entry, &alloc_map_bit);
-		
-		// allright, we can simply extend/contract the allocation because there's enough consecutive trailing space free
-		mark_block_allocated(alloc_map_entry, alloc_map_bit, new_num_pages);
-		
-		*((uint16_t*)pool_ptr) = new_num_pages;
-		// the original pointer is still valid.
-		return ptr;
-	}
-	else
-	{
-		// not enough space to extend the allocation. allocate a new block and copy the content
-		void *new_block = malloc(new_size);
-		uint16_t copy_pages = (original_num_pages < new_num_pages) ? original_num_pages : new_num_pages;
-		if(!new_block)
-		{
-			// even though we can't return the requested block, the old pointer should remain valid.
-			// but we already marked it as free. Let's correct that.
-			
-			// reset the entry and bit because check_block_free advanced it.
-			convert_mem_pool_ptr_into_alloc_map_position(pool_ptr, &alloc_map_entry, &alloc_map_bit);
-			mark_block_allocated(alloc_map_entry, alloc_map_bit, original_num_pages);
-			return NULL;
-		}
-		memcpy(new_block, ptr, (copy_pages - 1) * mem_page_size);
-		// Okay, the original block's data was copied over to a newly allocated block
-		// and the original block was marked as free.
-		return new_block;
-	}
-}
+        convert_mem_pool_ptr_into_alloc_map_position(
+            pool_ptr, &alloc_map_entry, &alloc_map_bit);
+        mark_block_free(alloc_map_entry, alloc_map_bit, num_pages);
+    }
 
-/// @brief Custom implementation of calloc based on our custom malloc()
-void* calloc(size_t num, size_t size)
-{
-	size_t actual_size = num * size;
-	void *result = malloc(actual_size);
-	if(result)
-	{
-		memset(result, 0, actual_size);
-	}
-	return result;
-}
+    /// @brief The custom implementation of realloc() of the bitmap allocator
+    /// described at the top of this module.
+    void *realloc(void *ptr, size_t new_size)
+    {
+        if (!ptr)
+        {
+            return malloc(new_size);
+        }
 
-/// dummy implementation to ensure the linker doesn't pull newlibs' malloc code (which also pulls in a 1 KB __malloc_av buffer)
-/// WARNING: Please consider the warning at the top of this module: We should avoid certain functionality in newlib as it may
-/// try to call this function to allocate memory. We don't want to establish a permanent heap in this project.
-void* _malloc_r(struct _reent *r, size_t size)
-{
-	(void)r;
-    return malloc(size);
-}
+        uint8_t *const pool_ptr = ((uint8_t *)ptr) - mem_page_size;
+        uint32_t *alloc_map_entry;
+        uint32_t alloc_map_bit;
+        const uint16_t original_num_pages = *((uint16_t *)pool_ptr);
+        const uint16_t new_num_pages = get_num_pages_for_size(new_size);
 
-/// dummy implementation to ensure the linker doesn't pull newlibs' malloc code (which also pulls in a 1 KB __malloc_av buffer)
-/// WARNING: Please consider the warning at the top of this module: We should avoid certain functionality in newlib as it may
-/// try to call this function to allocate memory. We don't want to establish a permanent heap in this project.
-void _free_r(struct _reent *r, void* ptr) {
-    (void)r;
-    return free(ptr);
-}
+        convert_mem_pool_ptr_into_alloc_map_position(
+            pool_ptr, &alloc_map_entry, &alloc_map_bit);
 
+        // first mark the associated allocmap bits as free in order make sure
+        // the current block is correctly detected as free
+        mark_block_free(alloc_map_entry, alloc_map_bit, original_num_pages);
+
+        if (check_block_free(
+                &alloc_map_entry, &alloc_map_bit, new_num_pages, NULL))
+        {
+            // reset the entry and bit because check_block_free advanced it.
+            convert_mem_pool_ptr_into_alloc_map_position(
+                pool_ptr, &alloc_map_entry, &alloc_map_bit);
+
+            // allright, we can simply extend/contract the allocation because
+            // there's enough consecutive trailing space free
+            mark_block_allocated(alloc_map_entry, alloc_map_bit, new_num_pages);
+
+            *((uint16_t *)pool_ptr) = new_num_pages;
+            // the original pointer is still valid.
+            return ptr;
+        }
+        else
+        {
+            // not enough space to extend the allocation. allocate a new block
+            // and copy the content
+            void *new_block = malloc(new_size);
+            uint16_t copy_pages = (original_num_pages < new_num_pages)
+                                      ? original_num_pages
+                                      : new_num_pages;
+            if (!new_block)
+            {
+                // even though we can't return the requested block, the old
+                // pointer should remain valid. but we already marked it as
+                // free. Let's correct that.
+
+                // reset the entry and bit because check_block_free advanced it.
+                convert_mem_pool_ptr_into_alloc_map_position(
+                    pool_ptr, &alloc_map_entry, &alloc_map_bit);
+                mark_block_allocated(
+                    alloc_map_entry, alloc_map_bit, original_num_pages);
+                return NULL;
+            }
+            memcpy(new_block, ptr, (copy_pages - 1) * mem_page_size);
+            // Okay, the original block's data was copied over to a newly
+            // allocated block and the original block was marked as free.
+            return new_block;
+        }
+    }
+
+    /// @brief Custom implementation of calloc based on our custom malloc()
+    void *calloc(size_t num, size_t size)
+    {
+        size_t actual_size = num * size;
+        void *result = malloc(actual_size);
+        if (result)
+        {
+            memset(result, 0, actual_size);
+        }
+        return result;
+    }
+
+    /// dummy implementation to ensure the linker doesn't pull newlibs' malloc
+    /// code (which also pulls in a 1 KB __malloc_av buffer) WARNING: Please
+    /// consider the warning at the top of this module: We should avoid certain
+    /// functionality in newlib as it may try to call this function to allocate
+    /// memory. We don't want to establish a permanent heap in this project.
+    void *_malloc_r(struct _reent *r, size_t size)
+    {
+        (void)r;
+        return malloc(size);
+    }
+
+    /// dummy implementation to ensure the linker doesn't pull newlibs' malloc
+    /// code (which also pulls in a 1 KB __malloc_av buffer) WARNING: Please
+    /// consider the warning at the top of this module: We should avoid certain
+    /// functionality in newlib as it may try to call this function to allocate
+    /// memory. We don't want to establish a permanent heap in this project.
+    void _free_r(struct _reent *r, void *ptr)
+    {
+        (void)r;
+        return free(ptr);
+    }
 }
 
 #else
 
-void malloc_init_default_pool(void)
-{	
-}
+void malloc_init_default_pool(void) {}
 #endif
-
diff --git a/source/dbg/debug_menu.cpp b/source/dbg/debug_menu.cpp
index 07868a5..bcebe26 100644
--- a/source/dbg/debug_menu.cpp
+++ b/source/dbg/debug_menu.cpp
@@ -1,12 +1,12 @@
 #include "dbg/debug_menu.h"
-#include "dbg/debug_menu_functions.h"
-#include "sprite_data.h"
 #include "background_engine.h"
-#include "vertical_menu_cursor_handler.h"
+#include "dbg/debug_menu_functions.h"
 #include "libraries/nanoprintf/nanoprintf.h"
+#include "sprite_data.h"
+#include "vertical_menu_cursor_handler.h"
 
-#include <tonc.h>
 #include <cstdlib>
+#include <tonc.h>
 
 static on_execute_callback delayed_execute_callback = nullptr;
 static void *delayed_execute_context = nullptr;
@@ -16,12 +16,10 @@ static unsigned delayed_execute_user_param = 0;
 static DebugMenuSection current_menu_section[MAX_MENU_LAYERS];
 static unsigned current_menu_section_stack_size;
 
-static void pop_submenu()
-{
-    --current_menu_section_stack_size;
-}
+static void pop_submenu() { --current_menu_section_stack_size; }
 
-static __attribute__((noinline)) void show_debug_menu_internal(DebugMenuSection sectionType)
+static __attribute__((noinline)) void show_debug_menu_internal(
+    DebugMenuSection sectionType)
 {
     u16 charset[256];
     const s16 cursor_offset_x = 3;
@@ -36,8 +34,7 @@ static __attribute__((noinline)) void show_debug_menu_internal(DebugMenuSection
 
     obj_unhide(toggle_arrow_left, 0);
 
-    const vertical_menu_settings menu_settings = {
-        .x = 20,
+    const vertical_menu_settings menu_settings = {.x = 20,
         .y = 0,
         .width = 208,
         .height = 155,
@@ -48,10 +45,10 @@ static __attribute__((noinline)) void show_debug_menu_internal(DebugMenuSection
         .text_table_index = INT32_MAX,
         .allow_cancel = true,
         .should_delete_item_widgets_on_destruct = true,
-        .should_hide_state_changed_handler_on_not_focused = true
-    };
+        .should_hide_state_changed_handler_on_not_focused = true};
 
-    vertical_menu_cursor_handler cursor_handler(cursor_offset_x, cursor_offset_y);
+    vertical_menu_cursor_handler cursor_handler(
+        cursor_offset_x, cursor_offset_y);
     vertical_menu debug_menu(menu_settings);
 
     debug_menu.set_state_changed_handler(&cursor_handler);
@@ -66,19 +63,21 @@ static __attribute__((noinline)) void show_debug_menu_internal(DebugMenuSection
     hide_textbox();
     tte_erase_rect(0, 0, H_MAX, V_MAX);
 
-    // execute any callback that was delayed by pressing the A button on an executable row.
-    // This is done to make sure the debug menu is fully hidden before executing the callback,
-    // to avoid rendering issues.
-    if(delayed_execute_callback)
+    // execute any callback that was delayed by pressing the A button on an
+    // executable row. This is done to make sure the debug menu is fully hidden
+    // before executing the callback, to avoid rendering issues.
+    if (delayed_execute_callback)
     {
-        delayed_execute_callback(delayed_execute_context, delayed_execute_user_param);
+        delayed_execute_callback(
+            delayed_execute_context, delayed_execute_user_param);
         delayed_execute_callback = nullptr;
         delayed_execute_context = nullptr;
         delayed_execute_user_param = 0;
     }
-    else if(ret == UINT32_MAX)
+    else if (ret == UINT32_MAX)
     {
-        // if the user cancelled out of the menu, we pop the submenu stack to go back to the previous menu.
+        // if the user cancelled out of the menu, we pop the submenu stack to go
+        // back to the previous menu.
         pop_submenu();
     }
 }
@@ -89,12 +88,12 @@ void show_debug_menu()
 
     current_menu_section_stack_size = 0;
     push_debug_menu_section(DebugMenuSection::MAIN);
-    while(current_menu_section_stack_size > 0)
+    while (current_menu_section_stack_size > 0)
     {
-        curr_section = current_menu_section[current_menu_section_stack_size - 1];
+        curr_section =
+            current_menu_section[current_menu_section_stack_size - 1];
         show_debug_menu_internal(curr_section);
     }
-    
 }
 
 debug_menu_row_widget::debug_menu_row_widget(const debug_menu_row_data &data)
@@ -104,14 +103,15 @@ debug_menu_row_widget::debug_menu_row_widget(const debug_menu_row_data &data)
 
 debug_menu_row_widget::~debug_menu_row_widget()
 {
-    if(data_.option_section.should_free_on_destruct)
+    if (data_.option_section.should_free_on_destruct)
     {
-        free(const_cast<option_data*>(data_.option_section.options));
+        free(const_cast<option_data *>(data_.option_section.options));
         data_.option_section.options = nullptr;
     }
 }
 
-void debug_menu_row_widget::render_item(FileContainerReader &text_table, unsigned x, unsigned y, bool is_focused)
+void debug_menu_row_widget::render_item(
+    FileContainerReader &text_table, unsigned x, unsigned y, bool is_focused)
 {
     const int label_margin_left = 12;
     const int margin_top = 2;
@@ -123,33 +123,43 @@ void debug_menu_row_widget::render_item(FileContainerReader &text_table, unsigne
     tte_set_pos(x + label_margin_left, y + margin_top);
     ptgb_write_debug(data_.charset, data_.labelText, true);
 
-    if(data_.option_section.num_options > 0)
+    if (data_.option_section.num_options > 0)
     {
-        const u8 selected_option_index = data_.option_section.selected_option_index;
+        const u8 selected_option_index =
+            data_.option_section.selected_option_index;
 
         tte_set_pos(x + option_margin_left, y + margin_top);
-        if(data_.option_section.options[selected_option_index].text)
+        if (data_.option_section.options[selected_option_index].text)
         {
-            ptgb_write_debug(data_.charset, data_.option_section.options[selected_option_index].text, true);
+            ptgb_write_debug(data_.charset,
+                data_.option_section.options[selected_option_index].text, true);
         }
         else
         {
             char buf[32];
-            npf_snprintf(buf, sizeof(buf), "%u", data_.option_section.options[selected_option_index].value);
+            npf_snprintf(buf, sizeof(buf), "%u",
+                data_.option_section.options[selected_option_index].value);
             ptgb_write_debug(data_.charset, buf, true);
         }
     }
 
-    if(is_focused)
+    if (is_focused)
     {
-        if(data_.option_section.num_options > 0)
+        if (data_.option_section.num_options > 0)
         {
-            const int toggle_arrow_left_x = static_cast<int>(x) + option_margin_left + toggle_arrow_left_offset_x;
-            const int toggle_arrow_right_x = static_cast<int>(x) + option_margin_left + toggle_arrow_right_offset_x;
-            const int toggle_arrows_y = static_cast<int>(y) + margin_top + toggle_arrows_offset_y;
+            const int toggle_arrow_left_x = static_cast<int>(x) +
+                                            option_margin_left +
+                                            toggle_arrow_left_offset_x;
+            const int toggle_arrow_right_x = static_cast<int>(x) +
+                                             option_margin_left +
+                                             toggle_arrow_right_offset_x;
+            const int toggle_arrows_y =
+                static_cast<int>(y) + margin_top + toggle_arrows_offset_y;
 
-            obj_set_pos(toggle_arrow_left, toggle_arrow_left_x, toggle_arrows_y);
-            obj_set_pos(toggle_arrow_right, toggle_arrow_right_x, toggle_arrows_y);
+            obj_set_pos(
+                toggle_arrow_left, toggle_arrow_left_x, toggle_arrows_y);
+            obj_set_pos(
+                toggle_arrow_right, toggle_arrow_right_x, toggle_arrows_y);
             obj_unhide(toggle_arrow_left, 0);
             obj_unhide(toggle_arrow_right, 0);
         }
@@ -163,50 +173,58 @@ void debug_menu_row_widget::render_item(FileContainerReader &text_table, unsigne
 
 MenuInputHandleState debug_menu_row_widget::handle_input()
 {
-    if(data_.option_section.num_options > 0)
+    if (data_.option_section.num_options > 0)
     {
         bool handled = false;
-        if(key_hit(KEY_RIGHT))
+        if (key_hit(KEY_RIGHT))
         {
-            data_.option_section.selected_option_index = (data_.option_section.selected_option_index + 1) % data_.option_section.num_options;
+            data_.option_section.selected_option_index =
+                (data_.option_section.selected_option_index + 1) %
+                data_.option_section.num_options;
             handled = true;
         }
-        if(key_hit(KEY_LEFT))
+        if (key_hit(KEY_LEFT))
         {
             --data_.option_section.selected_option_index;
-            if(data_.option_section.selected_option_index >= data_.option_section.num_options)
+            if (data_.option_section.selected_option_index >=
+                data_.option_section.num_options)
             {
-                data_.option_section.selected_option_index = data_.option_section.num_options - 1;
+                data_.option_section.selected_option_index =
+                    data_.option_section.num_options - 1;
             }
             handled = true;
         }
 
-        if(handled && data_.option_section.on_option_activate)
+        if (handled && data_.option_section.on_option_activate)
         {
-            data_.option_section.on_option_activate(data_.context, data_.option_section.options[data_.option_section.selected_option_index].value);
+            data_.option_section.on_option_activate(data_.context,
+                data_.option_section
+                    .options[data_.option_section.selected_option_index]
+                    .value);
         }
-        
-        if(handled)
+
+        if (handled)
         {
             return MenuInputHandleState::HANDLED_UPDATE_VIEWPORT;
         }
     }
 
-    if(key_hit(KEY_A) && data_.on_execute)
+    if (key_hit(KEY_A) && data_.on_execute)
     {
         delayed_execute_callback = data_.on_execute;
         delayed_execute_context = data_.context;
         delayed_execute_user_param = data_.user_param;
         return MenuInputHandleState::CHOICE_MADE;
     }
-    
+
     return MenuInputHandleState::NOT_HANDLED;
 }
 
 void push_debug_menu_section(DebugMenuSection section)
 {
-    constexpr size_t num_levels = sizeof(current_menu_section) / sizeof(current_menu_section[0]);
-    if(current_menu_section_stack_size < num_levels)
+    constexpr size_t num_levels =
+        sizeof(current_menu_section) / sizeof(current_menu_section[0]);
+    if (current_menu_section_stack_size < num_levels)
     {
         current_menu_section[current_menu_section_stack_size] = section;
         ++current_menu_section_stack_size;
diff --git a/source/dbg/debug_menu_entries.cpp b/source/dbg/debug_menu_entries.cpp
index b8c14b9..307643e 100644
--- a/source/dbg/debug_menu_entries.cpp
+++ b/source/dbg/debug_menu_entries.cpp
@@ -1,5 +1,5 @@
-#include "dbg/debug_menu.h"
 #include "dbg/debug_menu_entries.h"
+#include "dbg/debug_menu.h"
 #include "dbg/debug_menu_functions.h"
 #include "dbg/debug_mode.h"
 #include "soundbank.h"
@@ -8,185 +8,205 @@
 #include <cstdlib>
 
 #if ENABLE_MYSTERY_GIFT
-#include "dbg/old_sea_map.h"
 #include "dbg/eon_ticket_rs.h"
+#include "dbg/old_sea_map.h"
 #endif
 
 static const option_data toggle_options[] = {
-    {
-        .text = "Off",
-        .value = 0
-    },
-    {
-        .text = "On",
-        .value = 1
-    }
-};
+    {.text = "Off", .value = 0}, {.text = "On", .value = 1}};
 
-static void fill_debug_menu_with_main_menu_entries(vertical_menu &menu, u16 *charset);
-static void fill_debug_menu_with_injection_entries(vertical_menu &menu, u16 *charset);
+static void fill_debug_menu_with_main_menu_entries(
+    vertical_menu &menu, u16 *charset);
+static void fill_debug_menu_with_injection_entries(
+    vertical_menu &menu, u16 *charset);
 
 static const MenuSectionMapEntry menu_section_map[] = {
-    {
-        .section = DebugMenuSection::MAIN,
-        .fill_func = fill_debug_menu_with_main_menu_entries
-    },
-    {
-        .section = DebugMenuSection::INJECTION,
-        .fill_func = fill_debug_menu_with_injection_entries
-    }
-};
+    {.section = DebugMenuSection::MAIN,
+        .fill_func = fill_debug_menu_with_main_menu_entries},
+    {.section = DebugMenuSection::INJECTION,
+        .fill_func = fill_debug_menu_with_injection_entries}};
 
 static const option_data cbl_data_options[] = {
-    {
-        .text = "Off",
-        .value = WRITE_CABLE_DATA_MODE_OFF
-    },
-    {
-        .text = "SRAM",
-        .value = WRITE_CABLE_DATA_MODE_SRAM
-    },
-    {
-        .text = "CART",
-        .value = WRITE_CABLE_DATA_MODE_CART
-    }
-};
+    {.text = "Off", .value = WRITE_CABLE_DATA_MODE_OFF},
+    {.text = "SRAM", .value = WRITE_CABLE_DATA_MODE_SRAM},
+    {.text = "CART", .value = WRITE_CABLE_DATA_MODE_CART}};
 
 #define CBL_DATA_OPTIONS_COUNT (sizeof(cbl_data_options) / sizeof(option_data))
 
 /**
- * @brief This helper function makes it easy to define a multiple choice debug row.
+ * @brief This helper function makes it easy to define a multiple choice debug
+ * row.
  */
-static debug_menu_row_widget* __attribute__((noinline)) define_debug_choice_row(const u16 *charset, const char *labelText, on_execute_callback option_activate_callback, const option_data *options_metadata, u8 num_options, bool should_delete_options, u8 default_option_index, void *context)
+static debug_menu_row_widget *__attribute__((noinline)) define_debug_choice_row(
+    const u16 *charset, const char *labelText,
+    on_execute_callback option_activate_callback,
+    const option_data *options_metadata, u8 num_options,
+    bool should_delete_options, u8 default_option_index, void *context)
 {
-    const debug_menu_row_data row_data = {
-        .charset = charset,
+    const debug_menu_row_data row_data = {.charset = charset,
         .labelText = labelText,
-        .option_section = {
-            .num_options = num_options,
+        .option_section = {.num_options = num_options,
             .options = options_metadata,
             .on_option_activate = option_activate_callback,
             .selected_option_index = default_option_index,
-            .should_free_on_destruct = should_delete_options
-        },
+            .should_free_on_destruct = should_delete_options},
         .on_execute = nullptr,
         .context = context,
-        .user_param = 0
-    };
+        .user_param = 0};
     return new debug_menu_row_widget(row_data);
 }
 
 /**
  * @brief This helper function makes it easy to define a toggle row.
  */
-static debug_menu_row_widget* define_toggle_row(const u16 *charset, const char* labelText, on_execute_callback on_toggle_callback, bool default_value, void *context)
+static debug_menu_row_widget *define_toggle_row(const u16 *charset,
+    const char *labelText, on_execute_callback on_toggle_callback,
+    bool default_value, void *context)
 {
-    return define_debug_choice_row(charset, labelText, on_toggle_callback, toggle_options, 2, false, default_value ? 1 : 0, context);
+    return define_debug_choice_row(charset, labelText, on_toggle_callback,
+        toggle_options, 2, false, default_value ? 1 : 0, context);
 }
 
 /**
- * @brief This helper function will define the song row, which will let you toggle between any available maxmod song or None at all.
+ * @brief This helper function will define the song row, which will let you
+ * toggle between any available maxmod song or None at all.
  */
-[[maybe_unused]] static debug_menu_row_widget* __attribute__((noinline)) define_song_row(const u16 *charset, const char* labelText)
+[[maybe_unused]] static debug_menu_row_widget *__attribute__((noinline))
+define_song_row(const u16 *charset, const char *labelText)
 {
-    option_data *song_options = (option_data*)malloc(sizeof(option_data) * (MSL_NSONGS + 1));
-    song_options[0] = {
-        .text = "None",
-        .value = UINT32_MAX
-    };
+    option_data *song_options =
+        (option_data *)malloc(sizeof(option_data) * (MSL_NSONGS + 1));
+    song_options[0] = {.text = "None", .value = UINT32_MAX};
 
-    for(unsigned i = 0; i < MSL_NSONGS; ++i)
+    for (unsigned i = 0; i < MSL_NSONGS; ++i)
     {
-        song_options[i + 1] = {
-            .text = nullptr,
-            .value = i
-        };
+        song_options[i + 1] = {.text = nullptr, .value = i};
     }
 
-    return define_debug_choice_row(charset, labelText, dbg_play_song, song_options,  MSL_NSONGS + 1, true, 0, nullptr);
+    return define_debug_choice_row(charset, labelText, dbg_play_song,
+        song_options, MSL_NSONGS + 1, true, 0, nullptr);
 }
 
 /**
- * @brief This helper function makes it easy to define a row that executes a function when you select it and press A.
+ * @brief This helper function makes it easy to define a row that executes a
+ * function when you select it and press A.
  */
-static debug_menu_row_widget* __attribute__((noinline)) define_executable_row(const u16 *charset, const char* labelText, on_execute_callback on_execute, unsigned user_param, void *context)
+static debug_menu_row_widget *__attribute__((noinline)) define_executable_row(
+    const u16 *charset, const char *labelText, on_execute_callback on_execute,
+    unsigned user_param, void *context)
 {
-    const debug_menu_row_data row_data = {
-        .charset = charset,
+    const debug_menu_row_data row_data = {.charset = charset,
         .labelText = labelText,
-        .option_section = {
-            .num_options = 0,
+        .option_section = {.num_options = 0,
             .options = nullptr,
             .on_option_activate = nullptr,
             .selected_option_index = 0,
-            .should_free_on_destruct = false
-        },
+            .should_free_on_destruct = false},
         .on_execute = on_execute,
         .context = context,
-        .user_param = user_param
-    };
+        .user_param = user_param};
     return new debug_menu_row_widget(row_data);
 }
 
-/// Here we define the actual entries of the main debug menu, using the helper functions defined above.
-static void fill_debug_menu_with_main_menu_entries(vertical_menu &menu, u16 *charset)
+/// Here we define the actual entries of the main debug menu, using the helper
+/// functions defined above.
+static void fill_debug_menu_with_main_menu_entries(
+    vertical_menu &menu, u16 *charset)
 {
-    i_item_widget* item_widgets[] = {
+    i_item_widget *item_widgets[] = {
 #if ENABLE_TEXT_DEBUG_SCREEN
-        define_executable_row(charset, "Text Debug", show_text_debug_screen, 0, nullptr),
+        define_executable_row(
+            charset, "Text Debug", show_text_debug_screen, 0, nullptr),
 #endif
-        define_executable_row(charset, "Info", show_debug_info_screen, 0, nullptr),
-        define_executable_row(charset, "Injection", show_debug_menu_section, static_cast<unsigned>(DebugMenuSection::INJECTION), nullptr),
+        define_executable_row(
+            charset, "Info", show_debug_info_screen, 0, nullptr),
+        define_executable_row(charset, "Injection", show_debug_menu_section,
+            static_cast<unsigned>(DebugMenuSection::INJECTION), nullptr),
 #if ENABLE_MYSTERY_GIFT
-        define_executable_row(charset, "Unlock MystE", dbg_unlock_mystery, 0, nullptr),
-        define_executable_row(charset, "Unlock MystG", dbg_unlock_mystery, 1, nullptr),
+        define_executable_row(
+            charset, "Unlock MystE", dbg_unlock_mystery, 0, nullptr),
+        define_executable_row(
+            charset, "Unlock MystG", dbg_unlock_mystery, 1, nullptr),
 #endif
 #if ENABLE_SOUND
         define_song_row(charset, "Song"),
 #endif
-        define_toggle_row(charset, "Print Link", dbg_set_byte_val, g_debug_options.print_link_data, &g_debug_options.print_link_data),
-        define_toggle_row(charset, "Instant Text", dbg_set_byte_val, g_debug_options.instant_text_speed, &g_debug_options.instant_text_speed),
-        define_toggle_row(charset, "Ign Cart", dbg_set_byte_val, g_debug_options.ignore_game_pak, &g_debug_options.ignore_game_pak),
-        define_toggle_row(charset, "Ign Sprites", dbg_set_byte_val, g_debug_options.ignore_game_pak_sprites, &g_debug_options.ignore_game_pak_sprites),
-        define_toggle_row(charset, "Ign Link", dbg_set_byte_val, g_debug_options.ignore_link_cable, &g_debug_options.ignore_link_cable),
-        define_toggle_row(charset, "Ign MG/E4", dbg_set_byte_val, g_debug_options.ignore_mg_e4_flags, &g_debug_options.ignore_mg_e4_flags),
-        define_toggle_row(charset, "Ign Unrec PKMN", dbg_set_byte_val, g_debug_options.ignore_unreceived_pkmn, &g_debug_options.ignore_unreceived_pkmn),
-        define_toggle_row(charset, "Force Tut", dbg_set_byte_val, g_debug_options.force_tutorial, &g_debug_options.force_tutorial),
-        define_toggle_row(charset, "Show Invalid", dbg_set_byte_val, g_debug_options.dont_hide_invalid_pkmn, &g_debug_options.dont_hide_invalid_pkmn),
-        define_toggle_row(charset, "Ign Dex Compl", dbg_set_byte_val, g_debug_options.ignore_dex_completion, &g_debug_options.ignore_dex_completion),
-        define_toggle_row(charset, "Force Caught", dbg_set_byte_val, g_debug_options.force_all_caught, &g_debug_options.force_all_caught),
-        define_toggle_row(charset, "Write Cbl Data", dbg_set_byte_val, g_debug_options.write_cable_data_to_save, &g_debug_options.write_cable_data_to_save),
-        define_toggle_row(charset, "Disp CtrlChr", dbg_set_byte_val, g_debug_options.display_control_char, &g_debug_options.display_control_char)
-    };
+        define_toggle_row(charset, "Print Link", dbg_set_byte_val,
+            g_debug_options.print_link_data, &g_debug_options.print_link_data),
+        define_toggle_row(charset, "Instant Text", dbg_set_byte_val,
+            g_debug_options.instant_text_speed,
+            &g_debug_options.instant_text_speed),
+        define_toggle_row(charset, "Ign Cart", dbg_set_byte_val,
+            g_debug_options.ignore_game_pak, &g_debug_options.ignore_game_pak),
+        define_toggle_row(charset, "Ign Sprites", dbg_set_byte_val,
+            g_debug_options.ignore_game_pak_sprites,
+            &g_debug_options.ignore_game_pak_sprites),
+        define_toggle_row(charset, "Ign Link", dbg_set_byte_val,
+            g_debug_options.ignore_link_cable,
+            &g_debug_options.ignore_link_cable),
+        define_toggle_row(charset, "Ign MG/E4", dbg_set_byte_val,
+            g_debug_options.ignore_mg_e4_flags,
+            &g_debug_options.ignore_mg_e4_flags),
+        define_toggle_row(charset, "Ign Unrec PKMN", dbg_set_byte_val,
+            g_debug_options.ignore_unreceived_pkmn,
+            &g_debug_options.ignore_unreceived_pkmn),
+        define_toggle_row(charset, "Force Tut", dbg_set_byte_val,
+            g_debug_options.force_tutorial, &g_debug_options.force_tutorial),
+        define_toggle_row(charset, "Show Invalid", dbg_set_byte_val,
+            g_debug_options.dont_hide_invalid_pkmn,
+            &g_debug_options.dont_hide_invalid_pkmn),
+        define_toggle_row(charset, "Ign Dex Compl", dbg_set_byte_val,
+            g_debug_options.ignore_dex_completion,
+            &g_debug_options.ignore_dex_completion),
+        define_toggle_row(charset, "Force Caught", dbg_set_byte_val,
+            g_debug_options.force_all_caught,
+            &g_debug_options.force_all_caught),
+        define_toggle_row(charset, "Write Cbl Data", dbg_set_byte_val,
+            g_debug_options.write_cable_data_to_save,
+            &g_debug_options.write_cable_data_to_save),
+        define_toggle_row(charset, "Disp CtrlChr", dbg_set_byte_val,
+            g_debug_options.display_control_char,
+            &g_debug_options.display_control_char)};
 
-    menu.add_item_widgets(item_widgets, sizeof(item_widgets) / sizeof(item_widgets[0]));
+    menu.add_item_widgets(
+        item_widgets, sizeof(item_widgets) / sizeof(item_widgets[0]));
 }
 
 /// This function defines the entries of the injection submenu
-static void fill_debug_menu_with_injection_entries(vertical_menu &menu, u16 *charset)
+static void fill_debug_menu_with_injection_entries(
+    vertical_menu &menu, u16 *charset)
 {
-    i_item_widget* item_widgets[] = {
+    i_item_widget *item_widgets[] = {
 #if ENABLE_DEBUG_PKMN_INJECTION
-        define_executable_row(charset, "Inject Celebi", dbg_inject_pkmn, 0, nullptr),
+        define_executable_row(
+            charset, "Inject Celebi", dbg_inject_pkmn, 0, nullptr),
 #endif
 #if ENABLE_MYSTERY_GIFT
-        define_executable_row(charset, "Unlock MystE", dbg_unlock_mystery, 0, nullptr),
-        define_executable_row(charset, "Unlock MystG", dbg_unlock_mystery, 1, nullptr),
-        define_executable_row(charset, "Inj OldSeaMap(E)", dbg_inject_wc3, sizeof(OldSeaMap_E_custom), const_cast<u8*>(OldSeaMap_E_custom)),
-        define_executable_row(charset, "Inj Eon Ticket(RS)", dbg_inject_me3, sizeof(RS_Item_Eon_Ticket_e_Card_ENG_US_), const_cast<u8*>(RS_Item_Eon_Ticket_e_Card_ENG_US_)),
-        
+        define_executable_row(
+            charset, "Unlock MystE", dbg_unlock_mystery, 0, nullptr),
+        define_executable_row(
+            charset, "Unlock MystG", dbg_unlock_mystery, 1, nullptr),
+        define_executable_row(charset, "Inj OldSeaMap(E)", dbg_inject_wc3,
+            sizeof(OldSeaMap_E_custom), const_cast<u8 *>(OldSeaMap_E_custom)),
+        define_executable_row(charset, "Inj Eon Ticket(RS)", dbg_inject_me3,
+            sizeof(RS_Item_Eon_Ticket_e_Card_ENG_US_),
+            const_cast<u8 *>(RS_Item_Eon_Ticket_e_Card_ENG_US_)),
+
 #endif
     };
-    menu.add_item_widgets(item_widgets, sizeof(item_widgets) / sizeof(item_widgets[0]));
+    menu.add_item_widgets(
+        item_widgets, sizeof(item_widgets) / sizeof(item_widgets[0]));
 }
 
-void fill_debug_menu_with_entries(vertical_menu &menu, u16 *charset, DebugMenuSection section)
+void fill_debug_menu_with_entries(
+    vertical_menu &menu, u16 *charset, DebugMenuSection section)
 {
-    const size_t num_sections = sizeof(menu_section_map) / sizeof(menu_section_map[0]);
+    const size_t num_sections =
+        sizeof(menu_section_map) / sizeof(menu_section_map[0]);
     size_t i = 0;
-    while(i < num_sections)
+    while (i < num_sections)
     {
-        if(menu_section_map[i].section == section)
+        if (menu_section_map[i].section == section)
         {
             menu_section_map[i].fill_func(menu, charset);
             break;
diff --git a/source/dbg/debug_menu_functions.cpp b/source/dbg/debug_menu_functions.cpp
index 381426b..5dd28ce 100644
--- a/source/dbg/debug_menu_functions.cpp
+++ b/source/dbg/debug_menu_functions.cpp
@@ -1,22 +1,21 @@
 #include "dbg/debug_menu_functions.h"
-#include "dbg/debug_menu.h"
-#include "libraries/nanoprintf/nanoprintf.h"
-#include "text_engine.h"
-#include "pokemon_data.h"
-#include "sprite_data.h"
-#include "global_frame_controller.h"
-#include "flash_mem.h"
-#include "ptgb_save_data_manager.h"
-#include "background_engine.h"
-#include "libstd_replacements.h"
-#include "sound.h"
-#include "rom_data.h"
 #include "Gen3CartridgeSaveReader.h"
-#include "Gen3SaveManager.h"
 #include "Gen3Pokemon.h"
-#include "pokemon_data.h"
-#include "translated_text.h"
+#include "Gen3SaveManager.h"
+#include "background_engine.h"
+#include "dbg/debug_menu.h"
 #include "dbg/debug_mode.h"
+#include "flash_mem.h"
+#include "global_frame_controller.h"
+#include "libraries/nanoprintf/nanoprintf.h"
+#include "libstd_replacements.h"
+#include "pokemon_data.h"
+#include "ptgb_save_data_manager.h"
+#include "rom_data.h"
+#include "sound.h"
+#include "sprite_data.h"
+#include "text_engine.h"
+#include "translated_text.h"
 
 #define LEFT 8
 #define RIGHT (H_MAX - LEFT)
@@ -26,13 +25,14 @@
 extern rom_data curr_GBA_rom;
 extern u32 global_tile_id_end;
 
-static const byte RSEFL_10_ANIV_Celebi_0BF5_ENG_[]  = {
-  0xbe, 0x2b, 0x28, 0x78, 0x0a, 0x00, 0x00, 0x00, 0xbd, 0xbf, 0xc6, 0xbf, 0xbc, 0xc3, 0xff, 0x34, 
-  0x01, 0x31, 0x02, 0x02, 0xa2, 0xa1, 0x00, 0xbb, 0xc8, 0xc3, 0xd0, 0x00, 0x17, 0x35, 0x00, 0x00, 
-  0xfb, 0x00, 0x00, 0x00, 0x80, 0x43, 0x05, 0x00, 0x00, 0x64, 0x00, 0x00, 0xf6, 0x00, 0xf8, 0x00, 
-  0xe2, 0x00, 0xc3, 0x00, 0x05, 0x0f, 0x28, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-  0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x46, 0x21, 0xe2, 0x31, 0xaf, 0x22, 0x00, 0x00, 0x00, 0x00
-};
+static const byte RSEFL_10_ANIV_Celebi_0BF5_ENG_[] = {0xbe, 0x2b, 0x28, 0x78,
+    0x0a, 0x00, 0x00, 0x00, 0xbd, 0xbf, 0xc6, 0xbf, 0xbc, 0xc3, 0xff, 0x34,
+    0x01, 0x31, 0x02, 0x02, 0xa2, 0xa1, 0x00, 0xbb, 0xc8, 0xc3, 0xd0, 0x00,
+    0x17, 0x35, 0x00, 0x00, 0xfb, 0x00, 0x00, 0x00, 0x80, 0x43, 0x05, 0x00,
+    0x00, 0x64, 0x00, 0x00, 0xf6, 0x00, 0xf8, 0x00, 0xe2, 0x00, 0xc3, 0x00,
+    0x05, 0x0f, 0x28, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x46, 0x21, 0xe2, 0x31, 0xaf, 0x22,
+    0x00, 0x00, 0x00, 0x00};
 
 static Game convert_rom_game_id_to_ptgb_game(int game_id)
 {
@@ -49,7 +49,8 @@ static Game convert_rom_game_id_to_ptgb_game(int game_id)
     case EMERALD_ID:
         return EMERALD;
     default:
-        return GAME_UNKNOWN; // Default to unknown if the game ID is unrecognized
+        return GAME_UNKNOWN; // Default to unknown if the game ID is
+                             // unrecognized
     }
 }
 
@@ -70,15 +71,18 @@ static Language convert_rom_lang_to_ptgb_lang(int rom_lang)
     case LANG_SPA:
         return SPANISH;
     default:
-        return LANGUAGE_UNKNOWN; // Default to unknown if the language is unrecognized
+        return LANGUAGE_UNKNOWN; // Default to unknown if the language is
+                                 // unrecognized
     }
 }
 
 /**
  * The trainer OT is encoded in the gen3 proprietary charset.
- * But if we want to print it with npf_snprintf, we need to convert it to UTF-8 first.
+ * But if we want to print it with npf_snprintf, we need to convert it to UTF-8
+ * first.
  */
-static void convert_OT_to_utf8(const u8 *encoded_OT, u8 *output_buffer, const u16 *gen3_charset)
+static void convert_OT_to_utf8(
+    const u8 *encoded_OT, u8 *output_buffer, const u16 *gen3_charset)
 {
     u16 current_char;
     u32 num_bytes;
@@ -87,10 +91,12 @@ static void convert_OT_to_utf8(const u8 *encoded_OT, u8 *output_buffer, const u1
 
     for (u32 i = 0; i < 7 && encoded_OT[i] != 0xFF; ++i)
     {
-        // the charset maps each gen 3 character (represented as a byte) to a UTF-16 codepoint.
-        // So we first convert the encoded OT character to UTF-16, and then convert that UTF-16 codepoint to UTF-8.
+        // the charset maps each gen 3 character (represented as a byte) to a
+        // UTF-16 codepoint. So we first convert the encoded OT character to
+        // UTF-16, and then convert that UTF-16 codepoint to UTF-8.
         current_char = convert_gen_3_char_to_utf16(gen3_charset, encoded_OT[i]);
-        num_bytes = convert_utf16_to_utf8_char(current_char, utf8_codepoint_buffer);
+        num_bytes =
+            convert_utf16_to_utf8_char(current_char, utf8_codepoint_buffer);
 
         memcpy(cur_out, utf8_codepoint_buffer, num_bytes);
         cur_out += num_bytes;
@@ -101,7 +107,8 @@ static void convert_OT_to_utf8(const u8 *encoded_OT, u8 *output_buffer, const u1
 void show_debug_menu_section(void *context, unsigned user_param)
 {
     (void)context; // unused
-    const DebugMenuSection section_to_show = static_cast<DebugMenuSection>(user_param);
+    const DebugMenuSection section_to_show =
+        static_cast<DebugMenuSection>(user_param);
     push_debug_menu_section(section_to_show);
 }
 
@@ -138,7 +145,8 @@ void show_debug_info_screen(void *context, unsigned user_param)
     bool all_collected_flag = read_flag(curr_GBA_rom.all_collected_flag);
     for (int i = 0; i < 30; i++)
     {
-        pkmn_flags |= (read_flag(curr_GBA_rom.pkmn_collected_flag_start + i) << i);
+        pkmn_flags |=
+            (read_flag(curr_GBA_rom.pkmn_collected_flag_start + i) << i);
     }
 
     bool tutorial = get_tutorial_flag();
@@ -169,23 +177,14 @@ void show_debug_info_screen(void *context, unsigned user_param)
     n2hexstr(flags_hex_str, pkmn_flags);
     n2hexstr(def_lang_hex_str, def_lang);
 
-    //create_textbox(4, 1, 160, 80, true);
+    // create_textbox(4, 1, 160, 80, true);
     show_textbox();
 
     npf_snprintf(text_buffer, sizeof(text_buffer),
         "Debug info:\n\nG: %d%s%d\nF: %d%d%d-%s\nS:   %d-%s\n%s%s",
-        curr_GBA_rom.language,
-        game_code,
-        curr_GBA_rom.version,
-        e4_flag,
-        mg_flag,
-        all_collected_flag,
-        flags_hex_str,
-        tutorial,
-        def_lang_hex_str,
-        BUILD_INFO,
-        get_treecko_enabled() ? ".T" : ""
-    );
+        curr_GBA_rom.language, game_code, curr_GBA_rom.version, e4_flag,
+        mg_flag, all_collected_flag, flags_hex_str, tutorial, def_lang_hex_str,
+        BUILD_INFO, get_treecko_enabled() ? ".T" : "");
 
     ptgb_write_debug(charset, text_buffer, true);
 
@@ -203,13 +202,13 @@ void show_debug_info_screen(void *context, unsigned user_param)
 
 void dbg_set_byte_val(void *context, unsigned user_param)
 {
-    u8 *flag_ptr = (u8*)context;
+    u8 *flag_ptr = (u8 *)context;
     *flag_ptr = (u8)user_param;
 }
 
 void dbg_play_song(void *context, unsigned user_param)
 {
-    if(user_param == UINT32_MAX)
+    if (user_param == UINT32_MAX)
     {
         stop_song();
         return;
@@ -219,8 +218,10 @@ void dbg_play_song(void *context, unsigned user_param)
 
 void dbg_inject_pkmn(void *context, unsigned user_param)
 {
-    const Game game_type = convert_rom_game_id_to_ptgb_game(curr_GBA_rom.gamecode);
-    const Language game_lang = convert_rom_lang_to_ptgb_lang(curr_GBA_rom.language);
+    const Game game_type =
+        convert_rom_game_id_to_ptgb_game(curr_GBA_rom.gamecode);
+    const Language game_lang =
+        convert_rom_lang_to_ptgb_lang(curr_GBA_rom.language);
     u32 ret;
     char text_buffer[256];
     u8 encoded_OT[8];
@@ -237,10 +238,15 @@ void dbg_inject_pkmn(void *context, unsigned user_param)
     celebi.loadData(RSEFL_10_ANIV_Celebi_0BF5_ENG_, false);
 
     // front_sprite_tile_id is reserved behind the box sprites
-    if(!g_debug_options.ignore_game_pak && !g_debug_options.ignore_game_pak_sprites)
+    if (!g_debug_options.ignore_game_pak &&
+        !g_debug_options.ignore_game_pak_sprites)
     {
         u32 front_sprite_tile_id = global_tile_id_end + (30 * 16);
-        load_sprite_compressed(grabbed_front_sprite, (const unsigned int *)*(u32 *)(curr_GBA_rom.loc_gMonFrontPicTable + (0 * 8)), front_sprite_tile_id, PULLED_SPRITE_PAL, ATTR0_SQUARE, ATTR1_SIZE_64x64, 1);
+        load_sprite_compressed(grabbed_front_sprite,
+            (const unsigned int *)*(
+                u32 *)(curr_GBA_rom.loc_gMonFrontPicTable + (0 * 8)),
+            front_sprite_tile_id, PULLED_SPRITE_PAL, ATTR0_SQUARE,
+            ATTR1_SIZE_64x64, 1);
         update_front_box_sprite(&celebi, false);
         obj_set_pos(grabbed_front_sprite, 88, 16);
         obj_unhide(grabbed_front_sprite, 0);
@@ -251,7 +257,7 @@ void dbg_inject_pkmn(void *context, unsigned user_param)
     do
     {
         ret = save_manager.addPokemonToBox(boxIndex, celebi);
-        if(ret != UINT32_MAX)
+        if (ret != UINT32_MAX)
         {
             break;
         }
@@ -259,9 +265,10 @@ void dbg_inject_pkmn(void *context, unsigned user_param)
 
     } while (boxIndex < 14);
 
-    if(ret == UINT32_MAX)
+    if (ret == UINT32_MAX)
     {
-        // Failed to inject the Pokémon, all boxes are full. You can handle this case as needed (e.g., show an error message).
+        // Failed to inject the Pokémon, all boxes are full. You can handle this
+        // case as needed (e.g., show an error message).
         return;
     }
 
@@ -276,12 +283,15 @@ void dbg_inject_pkmn(void *context, unsigned user_param)
     tte_erase_rect(LEFT, TOP, RIGHT, BOTTOM);
 
     convert_OT_to_utf8(encoded_OT, decoded_OT_utf8, tables.gen3_charset);
-    npf_snprintf(text_buffer, sizeof(text_buffer), "%s received a Celebi!\n Celebi was sent to box %d!", decoded_OT_utf8, boxIndex);
+    npf_snprintf(text_buffer, sizeof(text_buffer),
+        "%s received a Celebi!\n Celebi was sent to box %d!", decoded_OT_utf8,
+        boxIndex);
     ptgb_write_debug(tables.gen3_charset, text_buffer, false);
 
     wait_for_user_to_continue(H_MAX, V_MAX);
 
-    if(!g_debug_options.ignore_game_pak && !g_debug_options.ignore_game_pak_sprites)
+    if (!g_debug_options.ignore_game_pak &&
+        !g_debug_options.ignore_game_pak_sprites)
     {
         obj_hide(grabbed_front_sprite);
     }
@@ -292,15 +302,17 @@ void dbg_inject_pkmn(void *context, unsigned user_param)
 
 void dbg_unlock_mystery(void *context, unsigned user_param)
 {
-    const Game game_type = convert_rom_game_id_to_ptgb_game(curr_GBA_rom.gamecode);
-    const Language game_lang = convert_rom_lang_to_ptgb_lang(curr_GBA_rom.language);
+    const Game game_type =
+        convert_rom_game_id_to_ptgb_game(curr_GBA_rom.gamecode);
+    const Language game_lang =
+        convert_rom_lang_to_ptgb_lang(curr_GBA_rom.language);
     Gen3CartridgeSaveReader reader(global_memory_buffer);
     Gen3SaveManager save_manager(game_type, game_lang, reader);
 
-    if(user_param == 0)
+    if (user_param == 0)
     {
         // mystery event not supported by fire red or leaf green
-        if(game_type == FIRERED || game_type == LEAFGREEN)
+        if (game_type == FIRERED || game_type == LEAFGREEN)
         {
             return;
         }
@@ -308,7 +320,7 @@ void dbg_unlock_mystery(void *context, unsigned user_param)
     else
     {
         // mystery gift not supported by ruby or sapphire
-        if(game_type == RUBY || game_type == SAPPHIRE)
+        if (game_type == RUBY || game_type == SAPPHIRE)
         {
             return;
         }
@@ -323,20 +335,22 @@ void dbg_unlock_mystery(void *context, unsigned user_param)
 
 void dbg_inject_wc3(void *context, unsigned user_param)
 {
-    const u8* wc3_data_ptr = reinterpret_cast<const u8*>(context);
+    const u8 *wc3_data_ptr = reinterpret_cast<const u8 *>(context);
     size_t wc3_data_size = user_param;
-    if(wc3_data_ptr == nullptr)
+    if (wc3_data_ptr == nullptr)
     {
         return;
     }
 
-    const Game game_type = convert_rom_game_id_to_ptgb_game(curr_GBA_rom.gamecode);
-    if(game_type != EMERALD)
+    const Game game_type =
+        convert_rom_game_id_to_ptgb_game(curr_GBA_rom.gamecode);
+    if (game_type != EMERALD)
     {
         return;
     }
 
-    const Language game_lang = convert_rom_lang_to_ptgb_lang(curr_GBA_rom.language);
+    const Language game_lang =
+        convert_rom_lang_to_ptgb_lang(curr_GBA_rom.language);
     Gen3CartridgeSaveReader reader(global_memory_buffer);
     Gen3SaveManager save_manager(game_type, game_lang, reader);
 
@@ -349,20 +363,22 @@ void dbg_inject_wc3(void *context, unsigned user_param)
 
 void dbg_inject_me3(void *context, unsigned user_param)
 {
-    const u8* me3_data_ptr = reinterpret_cast<const u8*>(context);
+    const u8 *me3_data_ptr = reinterpret_cast<const u8 *>(context);
     size_t me3_data_size = user_param;
-    if(me3_data_ptr == nullptr)
+    if (me3_data_ptr == nullptr)
     {
         return;
     }
 
-    const Game game_type = convert_rom_game_id_to_ptgb_game(curr_GBA_rom.gamecode);
-    if(game_type != RUBY && game_type != SAPPHIRE)
+    const Game game_type =
+        convert_rom_game_id_to_ptgb_game(curr_GBA_rom.gamecode);
+    if (game_type != RUBY && game_type != SAPPHIRE)
     {
         return;
     }
 
-    const Language game_lang = convert_rom_lang_to_ptgb_lang(curr_GBA_rom.language);
+    const Language game_lang =
+        convert_rom_lang_to_ptgb_lang(curr_GBA_rom.language);
     Gen3CartridgeSaveReader reader(global_memory_buffer);
     Gen3SaveManager save_manager(game_type, game_lang, reader);
 
diff --git a/source/dbg/debug_mode.cpp b/source/dbg/debug_mode.cpp
index ee7a5bf..efea75e 100644
--- a/source/dbg/debug_mode.cpp
+++ b/source/dbg/debug_mode.cpp
@@ -1,8 +1,6 @@
 #include "dbg/debug_mode.h"
 
-debug_options g_debug_options = 
-{
-    .print_link_data = (true && DEBUG_MODE),
+debug_options g_debug_options = {.print_link_data = (true && DEBUG_MODE),
     .print_link_packets = (true && DEBUG_MODE),
     .instant_text_speed = (true && DEBUG_MODE),
     .ignore_game_pak = (true && DEBUG_MODE),
@@ -16,5 +14,4 @@ debug_options g_debug_options =
     .force_all_caught = (false && DEBUG_MODE),
     .write_cable_data_to_save = (u8)WRITE_CABLE_DATA_MODE_OFF,
     .load_cable_data_from_save = (u8)WRITE_CABLE_DATA_MODE_OFF,
-    .display_control_char = (false && DEBUG_MODE)
-};
\ No newline at end of file
+    .display_control_char = (false && DEBUG_MODE)};
\ No newline at end of file
diff --git a/source/dbg/ptgb_mgba_print.cpp b/source/dbg/ptgb_mgba_print.cpp
index acaaed4..1ae9e77 100644
--- a/source/dbg/ptgb_mgba_print.cpp
+++ b/source/dbg/ptgb_mgba_print.cpp
@@ -9,15 +9,9 @@
 static_assert(false, "DEBUG_USE_MGBA_PRINT is only allowed for debug builds!");
 #endif
 
-void ptgb_mgba_init(void)
-{
-    mgba_console_open();
-}
+void ptgb_mgba_init(void) { mgba_console_open(); }
 
-void ptgb_mgba_deinit(void)
-{
-    mgba_close();
-}
+void ptgb_mgba_deinit(void) { mgba_close(); }
 
 void ptgb_mgba_print(int level, const char *format_str, ...)
 {
@@ -28,13 +22,9 @@ void ptgb_mgba_print(int level, const char *format_str, ...)
 }
 
 #else
-void ptgb_mgba_init(void)
-{
-}
+void ptgb_mgba_init(void) {}
 
-void ptgb_mgba_deinit(void)
-{
-}
+void ptgb_mgba_deinit(void) {}
 
 void ptgb_mgba_print(int level, const char *format_str, ...)
 {
diff --git a/source/dex_handler.cpp b/source/dex_handler.cpp
index 6849d89..a48a6bc 100644
--- a/source/dex_handler.cpp
+++ b/source/dex_handler.cpp
@@ -1,6 +1,6 @@
 #include "dex_handler.h"
 
-Dex::Dex(){}
+Dex::Dex() {}
 
 Dex::Dex(OBJ_ATTR *L, OBJ_ATTR *M, OBJ_ATTR *R)
 {
diff --git a/source/flash_mem.cpp b/source/flash_mem.cpp
index 2335d70..5dcc4c8 100644
--- a/source/flash_mem.cpp
+++ b/source/flash_mem.cpp
@@ -1,10 +1,10 @@
-#include <tonc.h>
-#include "libstd_replacements.h"
 #include "flash_mem.h"
+#include "libraries/Pokemon-Gen3-to-Gen-X/include/save.h"
+#include "libstd_replacements.h"
 #include "pokemon_data.h"
 #include "rom_data.h"
-#include "libraries/Pokemon-Gen3-to-Gen-X/include/save.h"
 #include "text_engine.h"
+#include <tonc.h>
 
 #define READ_SAVE_SECTIONS 14
 #define TOTAL_SAVE_SECTIONS 14
@@ -23,7 +23,8 @@ void initialize_memory_locations()
     copy_save_to_ram(SAVE_A_OFFSET + SAVE_INDEX_OFFSET, &save_A_index[0], 0x04);
     copy_save_to_ram(SAVE_B_OFFSET + SAVE_INDEX_OFFSET, &save_B_index[0], 0x04);
 
-    // Save indices are little-endian in-sector; decode directly without byte swapping.
+    // Save indices are little-endian in-sector; decode directly without byte
+    // swapping.
     const u32 saveAIndex = static_cast<u32>(save_A_index[0]) |
                            (static_cast<u32>(save_A_index[1]) << 8) |
                            (static_cast<u32>(save_A_index[2]) << 16) |
@@ -40,8 +41,9 @@ void initialize_memory_locations()
     }
 
     // Populates the memory_section_array with the correct pointer locations
-    // The sections within the save slot are rotated on every save. So it doesn't 
-    // start at the first section. However, the next sections follow sequentially.
+    // The sections within the save slot are rotated on every save. So it
+    // doesn't start at the first section. However, the next sections follow
+    // sequentially.
     // https://bulbapedia.bulbagarden.net/wiki/Save_data_structure_(Generation_III)#Section_ID
     copy_save_to_ram(newest_save_offset + SECTION_ID_OFFSET, &mem_id, 1);
     for (int i = 0; i < TOTAL_SAVE_SECTIONS; i++)
@@ -55,14 +57,17 @@ void initialize_memory_locations()
     // Bring the Memory ID back to the first one
     mem_id = (mem_id + 1) % TOTAL_SAVE_SECTIONS;
 
-    if (false) // This will print out a section of the FLASH mem for debugging purposes
+    if (false) // This will print out a section of the FLASH mem for debugging
+               // purposes
     {
         int mem_start = 0xF80;
         int mem_section = 1;
-        copy_save_to_ram(memory_section_array[mem_section], &global_memory_buffer[0], 0x1000);
+        copy_save_to_ram(memory_section_array[mem_section],
+            &global_memory_buffer[0], 0x1000);
         tte_set_pos(8, 0);
         tte_write("loc: ");
-        tte_write(ptgb::to_string(static_cast<unsigned>(memory_section_array[mem_section] + mem_start)));
+        tte_write(ptgb::to_string(static_cast<unsigned>(
+            memory_section_array[mem_section] + mem_start)));
         tte_write("\n");
         for (int i = mem_start; i < (128 + mem_start); i++)
         {
@@ -113,7 +118,8 @@ void print_mem_section()
 
     out[0] = get_char_from_charset(charset, mem_name);
     out[1] = get_char_from_charset(charset, '-');
-    out[2] = get_char_from_charset(charset, mem_id + 0xA1); // Kinda a dumb way to 
+    out[2] = get_char_from_charset(charset, mem_id + 0xA1); // Kinda a dumb way
+    to
     //tte_set_pos(0, 0);
     ptgb_write_simple(out, true);
     */
@@ -135,12 +141,15 @@ void update_memory_buffer_checksum(u8 *sector_buffer, bool hall_of_fame)
 {
     u32 checksum = 0x00;
 
-    // Section 13 is the last PC buffer (I) and that one only has 2000 bytes of data.
-    // source: https://bulbapedia.bulbagarden.net/wiki/Save_data_structure_(Generation_III)#Section_ID
-    const u32 num_of_bytes = (sector_buffer[SECTION_ID_OFFSET] != 13) ? 3968 : 2000;
+    // Section 13 is the last PC buffer (I) and that one only has 2000 bytes of
+    // data. source:
+    // https://bulbapedia.bulbagarden.net/wiki/Save_data_structure_(Generation_III)#Section_ID
+    const u32 num_of_bytes =
+        (sector_buffer[SECTION_ID_OFFSET] != 13) ? 3968 : 2000;
 
     // Assemble words manually to avoid alignment and aliasing issues when the
-    // sector buffer is only guaranteed to be byte-aligned. So not 32-bit aligned.
+    // sector buffer is only guaranteed to be byte-aligned. So not 32-bit
+    // aligned.
     for (u32 offset = 0; offset < num_of_bytes; offset += sizeof(u32))
     {
         const u32 cur = static_cast<u32>(sector_buffer[offset]) |
@@ -150,43 +159,56 @@ void update_memory_buffer_checksum(u8 *sector_buffer, bool hall_of_fame)
         checksum += cur;
     }
 
-    const u16 small_checksum = ((checksum & 0xFFFF0000) >> 16) + (checksum & 0x0000FFFF);
+    const u16 small_checksum =
+        ((checksum & 0xFFFF0000) >> 16) + (checksum & 0x0000FFFF);
     const u32 checksum_offset = hall_of_fame ? 0x0FF4 : 0x0FF6;
-    
+
     sector_buffer[checksum_offset] = small_checksum & 0x00FF;
     sector_buffer[checksum_offset + 1] = (small_checksum & 0xFF00) >> 8;
-
 }
 
 bool read_flag(u16 flag_id)
 {
     if (false)
     {
-        //tte_set_pos(0, 0);
+        // tte_set_pos(0, 0);
         tte_write("#{cx:0xD000}Attempting to read byte ");
-        tte_write(ptgb::to_string((curr_GBA_rom.offset_flags + (flag_id / 8)) % 0xF80));
+        tte_write(ptgb::to_string(
+            (curr_GBA_rom.offset_flags + (flag_id / 8)) % 0xF80));
         tte_write(" of memory section ");
-        tte_write(ptgb::to_string(1 + ((curr_GBA_rom.offset_flags + (flag_id / 8)) / 0xF80)));
+        tte_write(ptgb::to_string(
+            1 + ((curr_GBA_rom.offset_flags + (flag_id / 8)) / 0xF80)));
         tte_write(" for flag ");
         tte_write(ptgb::to_string(flag_id));
         tte_write(". Flag is ");
-        copy_save_to_ram(memory_section_array[1 + ((curr_GBA_rom.offset_flags + (flag_id / 8)) / 0xF80)], &global_memory_buffer[0], 0x1000);
-        u8 flags = global_memory_buffer[(curr_GBA_rom.offset_flags + (flag_id / 8)) % 0xF80];
+        copy_save_to_ram(
+            memory_section_array
+                [1 + ((curr_GBA_rom.offset_flags + (flag_id / 8)) / 0xF80)],
+            &global_memory_buffer[0], 0x1000);
+        u8 flags =
+            global_memory_buffer[(curr_GBA_rom.offset_flags + (flag_id / 8)) %
+                                 0xF80];
         tte_write(ptgb::to_string((flags >> (flag_id % 8)) & 0b1));
         while (true)
         {
         };
     }
 
-    copy_save_to_ram(memory_section_array[1 + ((curr_GBA_rom.offset_flags + (flag_id / 8)) / 0xF80)], &global_memory_buffer[0], 0x1000);
-    u8 flags = global_memory_buffer[(curr_GBA_rom.offset_flags + (flag_id / 8)) % 0xF80];
+    copy_save_to_ram(
+        memory_section_array[1 + ((curr_GBA_rom.offset_flags + (flag_id / 8)) /
+                                     0xF80)],
+        &global_memory_buffer[0], 0x1000);
+    u8 flags =
+        global_memory_buffer[(curr_GBA_rom.offset_flags + (flag_id / 8)) %
+                             0xF80];
     return (flags >> (flag_id % 8)) & 0b1;
 }
 
 bool compare_map_and_npc_data(int map_bank, int map_id, int npc_id)
 {
     copy_save_to_ram(memory_section_array[4], &global_memory_buffer[0], 0x1000);
-    return (global_memory_buffer[curr_GBA_rom.offset_script + 4] == MGSCRIPT_MAGIC_VALUE &&
+    return (global_memory_buffer[curr_GBA_rom.offset_script + 4] ==
+                MGSCRIPT_MAGIC_VALUE &&
             global_memory_buffer[curr_GBA_rom.offset_script + 5] == map_bank &&
             global_memory_buffer[curr_GBA_rom.offset_script + 6] == map_id &&
             global_memory_buffer[curr_GBA_rom.offset_script + 7] == npc_id);
diff --git a/source/global_frame_controller.cpp b/source/global_frame_controller.cpp
index 5d0b221..4594b08 100644
--- a/source/global_frame_controller.cpp
+++ b/source/global_frame_controller.cpp
@@ -1,16 +1,16 @@
-#include <tonc.h>
-#include <cmath>
-#include "libstd_replacements.h"
 #include "global_frame_controller.h"
-#include "random.h"
+#include "FileContainerReader.h"
 #include "background_engine.h"
-#include "text_engine.h"
+#include "dbg/debug_mode.h"
+#include "libstd_replacements.h"
+#include "random.h"
 #include "sprite_data.h"
 #include "string.h"
-#include "translated_text.h"
-#include "dbg/debug_mode.h"
-#include "FileContainerReader.h"
+#include "text_engine.h"
 #include "text_tables.h"
+#include "translated_text.h"
+#include <cmath>
+#include <tonc.h>
 
 int global_frame_count = 0;
 bool rand_enabled = true;
@@ -21,9 +21,10 @@ int fennel_blink_state = 0;
 bool missingno_enabled = false;
 bool treecko_enabled = false;
 
-// split off from global_next_frame to limit the stack usage of the general_text_table_buffer to
-// the execution of this function
-// the noinline attribute prevents the compiler from inlining this function back into the global_next_frame function
+// split off from global_next_frame to limit the stack usage of the
+// general_text_table_buffer to the execution of this function the noinline
+// attribute prevents the compiler from inlining this function back into the
+// global_next_frame function
 static void __attribute__((noinline)) show_pulled_cart_error()
 {
     u8 decompression_buffer[2048];
@@ -34,10 +35,13 @@ static void __attribute__((noinline)) show_pulled_cart_error()
     get_text_table_chunks(GENERAL_INDEX, &chunkList, &numChunks, &chunkSize);
 
     FileContainerReader general_text_reader(chunkList, numChunks, chunkSize);
-    general_text_reader.init(decompression_buffer, sizeof(decompression_buffer));
+    general_text_reader.init(
+        decompression_buffer, sizeof(decompression_buffer));
 
-    ptgb_write_textbox(general_text_reader.getPointerToFileInDecompressionBuffer(GENERAL_pulled_cart_error), true, true,
-                       GENERAL_INDEX, GENERAL_pulled_cart_error, true);
+    ptgb_write_textbox(
+        general_text_reader.getPointerToFileInDecompressionBuffer(
+            GENERAL_pulled_cart_error),
+        true, true, GENERAL_INDEX, GENERAL_pulled_cart_error, true);
 }
 
 void global_next_frame()
@@ -74,8 +78,11 @@ void global_next_frame()
         set_menu_sprite_pal(1);
     }
 
-    // This way of determining the animation speed is stupid and will be changed, but leaving it for now since the whole animation will be changing.
-    if (curr_link_animation_state != state_off && global_frame_count % (40 / curr_link_animation_state) == 0)
+    // This way of determining the animation speed is stupid and will be
+    // changed, but leaving it for now since the whole animation will be
+    // changing.
+    if (curr_link_animation_state != state_off &&
+        global_frame_count % (40 / curr_link_animation_state) == 0)
     {
         cable_frame = (cable_frame + 1) % 12;
         if (curr_link_animation_state != state_off)
@@ -86,27 +93,23 @@ void global_next_frame()
     global_frame_count++;
 };
 
-int get_frame_count()
-{
-    return global_frame_count;
-}
+int get_frame_count() { return global_frame_count; }
 
-void enable_auto_random()
-{
-    rand_enabled = true;
-}
+void enable_auto_random() { rand_enabled = true; }
 
-void disable_auto_random()
-{
-    rand_enabled = false;
-}
+void disable_auto_random() { rand_enabled = false; }
 
 const unsigned short MENU_PALS[5][4] = {
-    {RGB15(31, 31, 31), RGB15(31, 19, 10), RGB15(31, 7, 01), RGB15(00, 00, 00)},  // Red
-    {RGB15(31, 31, 31), RGB15(31, 19, 10), RGB15(10, 9, 31), RGB15(00, 00, 00)},  // Blue
-    {RGB15(31, 31, 31), RGB15(31, 19, 10), RGB15(07, 23, 03), RGB15(00, 00, 00)}, // Green
-    {RGB15(31, 31, 31), RGB15(31, 19, 10), RGB15(15, 10, 03), RGB15(00, 00, 00)}, // Brown
-    {RGB15(31, 31, 31), RGB15(31, 19, 10), RGB15(29, 5, 13), RGB15(00, 00, 00)},  // Pink
+    {RGB15(31, 31, 31), RGB15(31, 19, 10), RGB15(31, 7, 01),
+        RGB15(00, 00, 00)}, // Red
+    {RGB15(31, 31, 31), RGB15(31, 19, 10), RGB15(10, 9, 31),
+        RGB15(00, 00, 00)}, // Blue
+    {RGB15(31, 31, 31), RGB15(31, 19, 10), RGB15(07, 23, 03),
+        RGB15(00, 00, 00)}, // Green
+    {RGB15(31, 31, 31), RGB15(31, 19, 10), RGB15(15, 10, 03),
+        RGB15(00, 00, 00)}, // Brown
+    {RGB15(31, 31, 31), RGB15(31, 19, 10), RGB15(29, 5, 13),
+        RGB15(00, 00, 00)}, // Pink
 };
 
 void set_menu_sprite_pal(int frame)
@@ -137,7 +140,9 @@ void set_menu_sprite_pal(int frame)
     }
 }
 
-static const int path[12][2] = {{19, 18}, {19, 19}, {18, 19}, {17, 19}, {16, 19}, {15, 19}, {14, 19}, {13, 19}, {12, 19}, {11, 19}, {10, 19}, {24, 24}};
+static const int path[12][2] = {{19, 18}, {19, 19}, {18, 19}, {17, 19},
+    {16, 19}, {15, 19}, {14, 19}, {13, 19}, {12, 19}, {11, 19}, {10, 19},
+    {24, 24}};
 
 void run_link_cable_animation(int frame)
 {
@@ -265,20 +270,11 @@ void set_missingno(bool val)
     }
 }
 
-void set_treecko(bool val)
-{
-    treecko_enabled = val;
-}
+void set_treecko(bool val) { treecko_enabled = val; }
 
-bool get_missingno_enabled()
-{
-    return missingno_enabled;
-}
+bool get_missingno_enabled() { return missingno_enabled; }
 
-bool get_treecko_enabled()
-{
-    return treecko_enabled;
-}
+bool get_treecko_enabled() { return treecko_enabled; }
 
 int get_string_char_count(const byte *str)
 {
diff --git a/source/interrupt.cpp b/source/interrupt.cpp
index 72fdbbf..4516071 100644
--- a/source/interrupt.cpp
+++ b/source/interrupt.cpp
@@ -1,18 +1,13 @@
 #include "interrupt.h"
 #include "libraries/libugba/include/ugba.h"
 
-void interrupt_init(void) {
-  IRQ_Init();
+void interrupt_init(void) { IRQ_Init(); }
+
+void interrupt_set_handler(interrupt_index index, interrupt_vector function)
+{
+    IRQ_SetHandler((irq_index)index, function);
 }
 
-void interrupt_set_handler(interrupt_index index, interrupt_vector function) {
-  IRQ_SetHandler((irq_index)index, function);
-}
+void interrupt_enable(interrupt_index index) { IRQ_Enable((irq_index)index); }
 
-void interrupt_enable(interrupt_index index) {
-  IRQ_Enable((irq_index)index);
-}
-
-void interrupt_disable(interrupt_index index) {
-  IRQ_Disable((irq_index)index);
-}
+void interrupt_disable(interrupt_index index) { IRQ_Disable((irq_index)index); }
diff --git a/source/delays.cpp b/source/libraries/Pokemon-Gen3-to-Gen-X/source/delays.cpp
similarity index 100%
rename from source/delays.cpp
rename to source/libraries/Pokemon-Gen3-to-Gen-X/source/delays.cpp
diff --git a/source/save.cpp b/source/libraries/Pokemon-Gen3-to-Gen-X/source/save.cpp
similarity index 100%
rename from source/save.cpp
rename to source/libraries/Pokemon-Gen3-to-Gen-X/source/save.cpp
diff --git a/source/interrupts_gba.c b/source/libraries/libugba/source/interrupts_gba.c
similarity index 100%
rename from source/interrupts_gba.c
rename to source/libraries/libugba/source/interrupts_gba.c
diff --git a/source/memory.c b/source/libraries/libugba/source/memory.c
similarity index 100%
rename from source/memory.c
rename to source/libraries/libugba/source/memory.c
diff --git a/source/libstd_replacements.cpp b/source/libstd_replacements.cpp
index 27ff66f..24e44fc 100644
--- a/source/libstd_replacements.cpp
+++ b/source/libstd_replacements.cpp
@@ -8,34 +8,37 @@
 #define NANOPRINTF_USE_WRITEBACK_FORMAT_SPECIFIERS 0
 
 #include "libstd_replacements.h"
+#include "custom_malloc.h"
 #include "libraries/nanoprintf/nanoprintf.h"
 #include <cstdlib>
-#include <stdarg.h>
 #include <ctype.h>
-#include "custom_malloc.h"
+#include <stdarg.h>
 
 // recommended for a 32 bit system to have at least 33 bytes available
 // source: https://cplusplus.com/reference/cstdlib/itoa/
-// unfortunately itoa is not standardized, so we'll have to make do with snprintf
+// unfortunately itoa is not standardized, so we'll have to make do with
+// snprintf
 static char conversion_buffer[33];
 
-const char* ptgb::to_string(int intVal)
+const char *ptgb::to_string(int intVal)
 {
     npf_snprintf(conversion_buffer, sizeof(conversion_buffer), "%d", intVal);
     return conversion_buffer;
 }
 
-const char* ptgb::to_string(unsigned int wordVal)
+const char *ptgb::to_string(unsigned int wordVal)
 {
     npf_snprintf(conversion_buffer, sizeof(conversion_buffer), "%u", wordVal);
     return conversion_buffer;
 }
 
-// when compiling with -nostdlib++, we need to provide our own operator new and delete implementations
-// Regular operator new
-void* operator new(std::size_t size) {
-    void* ptr = malloc(size);
-    if (!ptr) {
+// when compiling with -nostdlib++, we need to provide our own operator new and
+// delete implementations Regular operator new
+void *operator new(std::size_t size)
+{
+    void *ptr = malloc(size);
+    if (!ptr)
+    {
         // mimic standard behavior: throw std::bad_alloc
         // but we can't use std::bad_alloc without libstdc++
         // so instead we can abort or return nullptr
@@ -46,52 +49,53 @@ void* operator new(std::size_t size) {
 }
 
 // nothrow version
-void* operator new(std::size_t size, const std::nothrow_t&) noexcept {
+void *operator new(std::size_t size, const std::nothrow_t &) noexcept
+{
     return malloc(size);
 }
 
 // regular array operator new
-void* operator new[](std::size_t size) {
-    void* ptr = malloc(size);
-    if (!ptr) {
+void *operator new[](std::size_t size)
+{
+    void *ptr = malloc(size);
+    if (!ptr)
+    {
         return NULL;
     }
     return ptr;
 }
 
 // nothrow array operator new
-void* operator new[](std::size_t size, const std::nothrow_t&) noexcept {
+void *operator new[](std::size_t size, const std::nothrow_t &) noexcept
+{
     return malloc(size);
 }
 
 // operator delete
-void operator delete(void* ptr) noexcept {
-    free(ptr);
-}
+void operator delete(void *ptr) noexcept { free(ptr); }
 
 // array operator delete
-void operator delete[](void* ptr) noexcept {
-    free(ptr);
-}
+void operator delete[](void *ptr) noexcept { free(ptr); }
 
 // nothrow delete
-void operator delete(void* ptr, const std::nothrow_t&) noexcept {
-    free(ptr);
-}
+void operator delete(void *ptr, const std::nothrow_t &) noexcept { free(ptr); }
 
 // nothrow array delete
-void operator delete[](void* ptr, const std::nothrow_t&) noexcept {
+void operator delete[](void *ptr, const std::nothrow_t &) noexcept
+{
     free(ptr);
 }
 
 // sized delete
-void operator delete(void* ptr, std::size_t size) noexcept {
+void operator delete(void *ptr, std::size_t size) noexcept
+{
     (void)size;
     free(ptr);
 }
 
 // sized array delete
-void operator delete[](void* ptr, std::size_t size) noexcept {
+void operator delete[](void *ptr, std::size_t size) noexcept
+{
     (void)size;
     free(ptr);
 }
\ No newline at end of file
diff --git a/source/link_handler.cpp b/source/link_handler.cpp
index 9b5c62d..0ed2258 100644
--- a/source/link_handler.cpp
+++ b/source/link_handler.cpp
@@ -1,31 +1,31 @@
-#include <tonc.h>
-#include <stdarg.h>
-#include <inttypes.h>
-#include "libraries/nanoprintf/nanoprintf.h"
-#include "libstd_replacements.h"
 #include "link_handler.h"
-#include "script_array.h"
+#include "FileContainerReader.h"
+#include "background_engine.h"
 #include "dbg/debug_mode.h"
 #include "dbg/ptgb_mgba_print.h"
-#include "interrupt.h"
-#include "text_engine.h"
-#include "global_frame_controller.h"
-#include "background_engine.h"
-#include "sprite_data.h"
-#include "libraries/Pokemon-Gen3-to-Gen-X/include/save.h"
 #include "flash_mem.h"
-#include "FileContainerReader.h"
-#include "text_tables.h"
-#include "translated_text.h"
 #include "gb_rom_values/base_gb_rom_struct.h"
 #include "gb_rom_values/gb_rom_values.h"
-#include "gb_rom_values_jpn_lz10_bin.h"
 #include "gb_rom_values_eng_lz10_bin.h"
 #include "gb_rom_values_fre_lz10_bin.h"
 #include "gb_rom_values_ger_lz10_bin.h"
 #include "gb_rom_values_ita_lz10_bin.h"
-#include "gb_rom_values_spa_lz10_bin.h"
+#include "gb_rom_values_jpn_lz10_bin.h"
 #include "gb_rom_values_kor_lz10_bin.h"
+#include "gb_rom_values_spa_lz10_bin.h"
+#include "global_frame_controller.h"
+#include "interrupt.h"
+#include "libraries/Pokemon-Gen3-to-Gen-X/include/save.h"
+#include "libraries/nanoprintf/nanoprintf.h"
+#include "libstd_replacements.h"
+#include "script_array.h"
+#include "sprite_data.h"
+#include "text_engine.h"
+#include "text_tables.h"
+#include "translated_text.h"
+#include <inttypes.h>
+#include <stdarg.h>
+#include <tonc.h>
 
 #include "compression_chunks.h"
 
@@ -40,8 +40,9 @@ LinkSPI *linkSPI = &linkSPIInstance;
 #define DISCOVERY_TIMEOUT_TRANSFERS 2048
 #define DISCOVERY_CONFIRM_TIMEOUT_TRANSFERS 180
 
-// Here's a compilation check to ensure that the size of these structs match our expectations.
-// Just update it if you changed the struct members. The data-generator process prints their actual sizes.
+// Here's a compilation check to ensure that the size of these structs match our
+// expectations. Just update it if you changed the struct members. The
+// data-generator process prints their actual sizes.
 static_assert(sizeof(struct GB_ROM) == 140);
 static_assert(sizeof(struct ROM_DATA) == 164);
 
@@ -50,1460 +51,1533 @@ LinkConnection globalLinkCable;
 /**
  * @brief This function determines the expected packet arrival address.
  *
- * PTGB sends packets with an additional read pointer. For packets intended to run commands,
- * this address is set to the address the packet is supposed to arrive at.
+ * PTGB sends packets with an additional read pointer. For packets intended to
+ * run commands, this address is set to the address the packet is supposed to
+ * arrive at.
  *
  * This address depends on the generation of the Game Boy ROM being used.
  */
 static u16 determinePacketArrivalAddress(int gen)
 {
-  return (gen == 1) ? 0xC6DC : 0xC8DC;
+    return (gen == 1) ? 0xC6DC : 0xC8DC;
 }
 
 void linkCableIRQ()
 {
-  /*
-  ----------------
-  This handshake process can be a bit weird, so let's break it down:
+    /*
+    ----------------
+    This handshake process can be a bit weird, so let's break it down:
 
-  First we exchange the bytes via handshake. inData will be set to the recieved byte, and the byte we send out will be outData.
+    First we exchange the bytes via handshake. inData will be set to the
+    recieved byte, and the byte we send out will be outData.
 
-  Then we determining what byte we will be sending out next, based on enterState and inByte in handleStateLogic().
-  This will set exitState and nextOutByte.
+    Then we determining what byte we will be sending out next, based on
+    enterState and inByte in handleStateLogic(). This will set exitState and
+    nextOutByte.
 
-  Then we print our information in the following format: globalCounter enterState:stateCounter:exitState inData outData
+    Then we print our information in the following format: globalCounter
+    enterState:stateCounter:exitState inData outData
 
-  We then prepare for the next cycle. Counters are incremented (or reset), enterState is set to exitState, and outByte is set to nextOutByte.
-  ----------------
-  */
-  if (!globalLinkCable.earlyExit())
-  {
-    globalLinkCable.exchangeBytes();
-
-    globalLinkCable.handleStateLogic();
-
-    if (g_debug_options.print_link_data || g_debug_options.print_link_packets)
+    We then prepare for the next cycle. Counters are incremented (or reset),
+    enterState is set to exitState, and outByte is set to nextOutByte.
+    ----------------
+    */
+    if (!globalLinkCable.earlyExit())
     {
-      globalLinkCable.printData();
-    }
+        globalLinkCable.exchangeBytes();
 
-    if (g_debug_options.write_cable_data_to_save)
-    {
-      globalLinkCable.writeData();
-    }
+        globalLinkCable.handleStateLogic();
 
-    globalLinkCable.prepareForNextCycle();
-  }
+        if (g_debug_options.print_link_data ||
+            g_debug_options.print_link_packets)
+        {
+            globalLinkCable.printData();
+        }
+
+        if (g_debug_options.write_cable_data_to_save)
+        {
+            globalLinkCable.writeData();
+        }
+
+        globalLinkCable.prepareForNextCycle();
+    }
 }
 
 LinkPacket::LinkPacket(PayloadCommand cmd, byte arg1, byte arg2, u16 addr)
 {
-  command = cmd;
-  argument[0] = arg1;
-  argument[1] = arg2;
-  pointer = addr;
-  inUse = true;
+    command = cmd;
+    argument[0] = arg1;
+    argument[1] = arg2;
+    pointer = addr;
+    inUse = true;
 };
 
 void LinkPacket::loadSecondaryPayload(byte *payload, int payloadSize)
 {
-  secondaryPayloadData = payload;
-  secondaryPayloadDataSize = payloadSize;
-  for (int i = 0; i < payloadSize; i++)
-  {
-    secondaryPayloadSizeChecksum += payload[i];
-  }
-  secondaryPayloadSizeChecksum = 0x100 - secondaryPayloadSizeChecksum;
+    secondaryPayloadData = payload;
+    secondaryPayloadDataSize = payloadSize;
+    for (int i = 0; i < payloadSize; i++)
+    {
+        secondaryPayloadSizeChecksum += payload[i];
+    }
+    secondaryPayloadSizeChecksum = 0x100 - secondaryPayloadSizeChecksum;
 
-  PTGB_MGBA_INFO("Secondary payload loaded: dataSize=%d packetSizeArg=%d checksum=%X",
-                 secondaryPayloadDataSize,
-                 secondaryPayloadDataSize + SECONDARY_PAYLOAD_HEADER_SIZE,
-                 secondaryPayloadSizeChecksum);
+    PTGB_MGBA_INFO(
+        "Secondary payload loaded: dataSize=%d packetSizeArg=%d checksum=%X",
+        secondaryPayloadDataSize,
+        secondaryPayloadDataSize + SECONDARY_PAYLOAD_HEADER_SIZE,
+        secondaryPayloadSizeChecksum);
 }
 
 void LinkConnection::setup(const u16 *debug_charset)
 {
-  link_cable_memory_section_index = 0;
-  link_cable_array_index = 0;
-  writeBufferOffset = 0;
-  pccsROMptr = nullptr;
-  dataOutBufferCurrIndex = 0;
+    link_cable_memory_section_index = 0;
+    link_cable_array_index = 0;
+    writeBufferOffset = 0;
+    pccsROMptr = nullptr;
+    dataOutBufferCurrIndex = 0;
 
-  linkSPI->activate(LinkSPI::Mode::MASTER_256KBPS);
-  linkSPI->setWaitModeActive(false);
+    linkSPI->activate(LinkSPI::Mode::MASTER_256KBPS);
+    linkSPI->setWaitModeActive(false);
 
-  this->debug_charset = debug_charset;
+    this->debug_charset = debug_charset;
 
-  lastError = NO_ERROR;
+    lastError = NO_ERROR;
 
-  if (g_debug_options.print_link_data == true)
-  {
-    create_textbox(0, 0, 138, 128, false);
-  }
-
-  if (g_debug_options.write_cable_data_to_save == WRITE_CABLE_DATA_MODE_SRAM)
-  {
-    // if we're writing the cable data to SRAM, we should clear the SRAM first to make sure there's no leftover data from previous transfers
-    volatile u8 *cur = SRAM_PTR;
-    volatile u8 *end = SRAM_PTR + 0x10000;
-    while (cur < end)
+    if (g_debug_options.print_link_data == true)
     {
-      (*cur) = 0;
-      ++cur;
+        create_textbox(0, 0, 138, 128, false);
+    }
+
+    if (g_debug_options.write_cable_data_to_save == WRITE_CABLE_DATA_MODE_SRAM)
+    {
+        // if we're writing the cable data to SRAM, we should clear the SRAM
+        // first to make sure there's no leftover data from previous transfers
+        volatile u8 *cur = SRAM_PTR;
+        volatile u8 *end = SRAM_PTR + 0x10000;
+        while (cur < end)
+        {
+            (*cur) = 0;
+            ++cur;
+        }
+    }
+    else if (g_debug_options.write_cable_data_to_save ==
+             WRITE_CABLE_DATA_MODE_CART)
+    {
+        // before each write, we need to erase the sector.
+        // so, let's do that for the first one before we start writing anything.
+        erase_sector(0);
     }
-  }
-  else if (g_debug_options.write_cable_data_to_save == WRITE_CABLE_DATA_MODE_CART)
-  {
-    // before each write, we need to erase the sector.
-    // so, let's do that for the first one before we start writing anything.
-    erase_sector(0);
-  }
 }
 
 void LinkConnection::loadPayload(GB_PayloadsFiles payload)
 {
-  u32 fileSize;
-  u8 decompressionBuffer[0x1000];
-  const u8 *chunkList[] = {
-      (const u8 *)GB_Payloads_chunk0_lz10_bin,
-      (const u8 *)GB_Payloads_chunk1_lz10_bin,
-      (const u8 *)GB_Payloads_chunk2_lz10_bin,
-      (const u8 *)GB_Payloads_chunk3_lz10_bin,
-      (const u8 *)GB_Payloads_chunk4_lz10_bin,
-      (const u8 *)GB_Payloads_chunk5_lz10_bin,
-      (const u8 *)GB_Payloads_chunk6_lz10_bin,
-  };
-  FileContainerReader reader(chunkList, 7);
-  const u32 fileIndex = (u32)payload;
+    u32 fileSize;
+    u8 decompressionBuffer[0x1000];
+    const u8 *chunkList[] = {
+        (const u8 *)GB_Payloads_chunk0_lz10_bin,
+        (const u8 *)GB_Payloads_chunk1_lz10_bin,
+        (const u8 *)GB_Payloads_chunk2_lz10_bin,
+        (const u8 *)GB_Payloads_chunk3_lz10_bin,
+        (const u8 *)GB_Payloads_chunk4_lz10_bin,
+        (const u8 *)GB_Payloads_chunk5_lz10_bin,
+        (const u8 *)GB_Payloads_chunk6_lz10_bin,
+    };
+    FileContainerReader reader(chunkList, 7);
+    const u32 fileIndex = (u32)payload;
 
-  reader.init(decompressionBuffer, sizeof(decompressionBuffer));
-  fileSize = reader.getFileSize(fileIndex);
-  reader.seekToFile(fileIndex);
-  reader.read(this->payloadBuffer, fileSize);
+    reader.init(decompressionBuffer, sizeof(decompressionBuffer));
+    fileSize = reader.getFileSize(fileIndex);
+    reader.seekToFile(fileIndex);
+    reader.read(this->payloadBuffer, fileSize);
 
-  this->curr_payload_size = fileSize;
+    this->curr_payload_size = fileSize;
 }
 
 void LinkConnection::loadPayloadByROM(GameBoyROM rom)
 {
-  loadPayload(GameBoyROMPayloads[rom]);
-  lang = GameBoyROMLanguages[rom];
-  vers = GameBoyROMVersions[rom];
+    loadPayload(GameBoyROMPayloads[rom]);
+    lang = GameBoyROMLanguages[rom];
+    vers = GameBoyROMVersions[rom];
 
-  static GB_ROM gb_rom_values_buffer[7];
-  const u8 *compressed_rom_values;
+    static GB_ROM gb_rom_values_buffer[7];
+    const u8 *compressed_rom_values;
 
-  switch (lang){
+    switch (lang)
+    {
     case JAPANESE:
-      compressed_rom_values = gb_rom_values_jpn_lz10_bin;
-      break;
+        compressed_rom_values = gb_rom_values_jpn_lz10_bin;
+        break;
     default:
     case ENGLISH:
-      compressed_rom_values = gb_rom_values_eng_lz10_bin;
-      break;
+        compressed_rom_values = gb_rom_values_eng_lz10_bin;
+        break;
     case FRENCH:
-      compressed_rom_values = gb_rom_values_fre_lz10_bin;
-      break;
+        compressed_rom_values = gb_rom_values_fre_lz10_bin;
+        break;
     case ITALIAN:
-      compressed_rom_values = gb_rom_values_ita_lz10_bin;
-      break;
+        compressed_rom_values = gb_rom_values_ita_lz10_bin;
+        break;
     case GERMAN:
-      compressed_rom_values = gb_rom_values_ger_lz10_bin;
-      break;
+        compressed_rom_values = gb_rom_values_ger_lz10_bin;
+        break;
     case SPANISH:
-      compressed_rom_values = gb_rom_values_spa_lz10_bin;
-      break;
+        compressed_rom_values = gb_rom_values_spa_lz10_bin;
+        break;
     case KOREAN:
-      compressed_rom_values = gb_rom_values_kor_lz10_bin;
-      break;
-  }
+        compressed_rom_values = gb_rom_values_kor_lz10_bin;
+        break;
+    }
 
-  LZ77UnCompWram(compressed_rom_values, gb_rom_values_buffer);
-  pccsROMptr = &gb_rom_values_buffer[vers];
+    LZ77UnCompWram(compressed_rom_values, gb_rom_values_buffer);
+    pccsROMptr = &gb_rom_values_buffer[vers];
 }
 
 void LinkConnection::loadCurrGameFromChecksum()
 {
-  if (((dataOutBuffer[0] + dataOutBuffer[1]) & 0x7F) != dataOutBuffer[2])
-  {
+    if (((dataOutBuffer[0] + dataOutBuffer[1]) & 0x7F) != dataOutBuffer[2])
+    {
+        currROM = GB_ROM_ERROR;
+        return;
+    };
+
+    int start = RED_JP_v0;
+    int end = GOLD_JP_v0;
+
+    if (gen == 2)
+    {
+        start = end;
+        end = NO_GB_ROM;
+    }
+
+    for (int i = start; i < end; i++)
+    {
+        if (dataOutBuffer[0] == GameBoyROMChecksumTable[i][1] &&
+            dataOutBuffer[1] == GameBoyROMChecksumTable[i][2])
+        {
+            currROM = (GameBoyROM)GameBoyROMChecksumTable[i][3];
+            return;
+        }
+    }
     currROM = GB_ROM_ERROR;
     return;
-  };
-
-  int start = RED_JP_v0;
-  int end = GOLD_JP_v0;
-
-  if (gen == 2)
-  {
-    start = end;
-    end = NO_GB_ROM;
-  }
-
-  for (int i = start; i < end; i++)
-  {
-    if (dataOutBuffer[0] == GameBoyROMChecksumTable[i][1] && dataOutBuffer[1] == GameBoyROMChecksumTable[i][2])
-    {
-      currROM = (GameBoyROM)GameBoyROMChecksumTable[i][3];
-      return;
-    }
-  }
-  currROM = GB_ROM_ERROR;
-  return;
 }
 
 void LinkConnection::exchangeBytes()
 {
-  /*
-  int timeout_frames = 10;
-  inData = linkSPI->transfer(outData, [&timeout_frames]()
-                             {
-      // In the mGBA Lua bridge, replies arrive via emulator callbacks between frames.
-      // Waiting here prevents valid bytes from being reported as timeouts.
-      global_next_frame();
-      return --timeout_frames <= 0; });
-  */
-  switch (g_debug_options.load_cable_data_from_save)
-  {
-  case WRITE_CABLE_DATA_MODE_OFF:
-    // Normal transfer :-)
-    inData = linkSPI->transfer(outData);
-    // PTGB_MGBA_INFO("in: %X, out: %X", inData, outData);
-    break;
-  case WRITE_CABLE_DATA_MODE_SRAM:
-    // Pretend transfer, by loading the bytes from SRAM (where we stored them with writeData() in a previous transfer)
-    inData = (*(SRAM_PTR + link_cable_array_index));
-    ++link_cable_array_index;
-    outData = (*(SRAM_PTR + link_cable_array_index));
-    ++link_cable_array_index;
-    break;
-  case WRITE_CABLE_DATA_MODE_CART:
-  {
-    // Pretend transfer, by loading the bytes from the cartridge save. (where we stored them with writeData() in a previous transfer)
-    // skip the first 6 bytes, which are for human consumption
-    link_cable_array_index += 6;
-
-    inData = read_byte_save((0x1000 * link_cable_memory_section_index) + link_cable_array_index);
-    ++link_cable_array_index;
-    outData = read_byte_save((0x1000 * link_cable_memory_section_index) + link_cable_array_index);
-    ++link_cable_array_index;
-
-    if (link_cable_array_index >= 0x1000)
+    /*
+    int timeout_frames = 10;
+    inData = linkSPI->transfer(outData, [&timeout_frames]()
+                               {
+        // In the mGBA Lua bridge, replies arrive via emulator callbacks between
+    frames.
+        // Waiting here prevents valid bytes from being reported as timeouts.
+        global_next_frame();
+        return --timeout_frames <= 0; });
+    */
+    switch (g_debug_options.load_cable_data_from_save)
     {
-      // if we reached the end of the section, we need to load the next section (if there is one)
-      ++link_cable_memory_section_index;
-      link_cable_array_index = 0;
+    case WRITE_CABLE_DATA_MODE_OFF:
+        // Normal transfer :-)
+        inData = linkSPI->transfer(outData);
+        // PTGB_MGBA_INFO("in: %X, out: %X", inData, outData);
+        break;
+    case WRITE_CABLE_DATA_MODE_SRAM:
+        // Pretend transfer, by loading the bytes from SRAM (where we stored
+        // them with writeData() in a previous transfer)
+        inData = (*(SRAM_PTR + link_cable_array_index));
+        ++link_cable_array_index;
+        outData = (*(SRAM_PTR + link_cable_array_index));
+        ++link_cable_array_index;
+        break;
+    case WRITE_CABLE_DATA_MODE_CART:
+    {
+        // Pretend transfer, by loading the bytes from the cartridge save.
+        // (where we stored them with writeData() in a previous transfer) skip
+        // the first 6 bytes, which are for human consumption
+        link_cable_array_index += 6;
+
+        inData = read_byte_save((0x1000 * link_cable_memory_section_index) +
+                                link_cable_array_index);
+        ++link_cable_array_index;
+        outData = read_byte_save((0x1000 * link_cable_memory_section_index) +
+                                 link_cable_array_index);
+        ++link_cable_array_index;
+
+        if (link_cable_array_index >= 0x1000)
+        {
+            // if we reached the end of the section, we need to load the next
+            // section (if there is one)
+            ++link_cable_memory_section_index;
+            link_cable_array_index = 0;
+        }
+        break;
+    }
     }
-    break;
-  }
-  }
 }
 
 void LinkConnection::startConnection(LinkState startState)
 {
-  switch (startState)
-  {
-  case INITIAL_CONNECTION:
-    // Start searching and make sure the first byte sent requests the external clock
-    irq_disable(II_TIMER3);
-    REG_TM3CNT = 0;
-    REG_IF = (1 << II_TIMER3);
-    linkSPI->activate(LinkSPI::Mode::MASTER_256KBPS);
+    switch (startState)
+    {
+    case INITIAL_CONNECTION:
+        // Start searching and make sure the first byte sent requests the
+        // external clock
+        irq_disable(II_TIMER3);
+        REG_TM3CNT = 0;
+        REG_IF = (1 << II_TIMER3);
+        linkSPI->activate(LinkSPI::Mode::MASTER_256KBPS);
 
-    inData = 0xFF;
-    outData = 0x01;
-    nextOutData = 0x01;
-    globalStateCounter = 0;
-    subStateCounter = 0;
-    subStateChanged = false;
-    enterState = CLOCK_ACQUIRE;
-    exitState = CLOCK_ACQUIRE;
+        inData = 0xFF;
+        outData = 0x01;
+        nextOutData = 0x01;
+        globalStateCounter = 0;
+        subStateCounter = 0;
+        subStateChanged = false;
+        enterState = CLOCK_ACQUIRE;
+        exitState = CLOCK_ACQUIRE;
 
-    REG_TM3D = -DISCOVERY_TIMER_MIN;
-    REG_TM3CNT = TM_FREQ_1024 | TM_IRQ | TM_ENABLE;
-    break;
-  case PACKET_EXCHANGE:
-    REG_TM3D = -0x0040;
-    // REG_TM3D = -0x4000 / 60;
-    REG_TM3CNT = TM_FREQ_1024 | TM_IRQ | TM_ENABLE;
-    break;
-  default:
-    break;
-  }
+        REG_TM3D = -DISCOVERY_TIMER_MIN;
+        REG_TM3CNT = TM_FREQ_1024 | TM_IRQ | TM_ENABLE;
+        break;
+    case PACKET_EXCHANGE:
+        REG_TM3D = -0x0040;
+        // REG_TM3D = -0x4000 / 60;
+        REG_TM3CNT = TM_FREQ_1024 | TM_IRQ | TM_ENABLE;
+        break;
+    default:
+        break;
+    }
 
-  if (startState != INITIAL_CONNECTION)
-  {
-    enterState = startState;
-  }
-  irq_enable(II_TIMER3);
+    if (startState != INITIAL_CONNECTION)
+    {
+        enterState = startState;
+    }
+    irq_enable(II_TIMER3);
 }
 
 void LinkConnection::printData()
 {
-  if (globalLinkCable.skipPrint)
-  {
-    tte_erase_rect(0, 0, H_MAX, V_MAX);
-  }
-  else
-  {
-    if (g_debug_options.print_link_data)
+    if (globalLinkCable.skipPrint)
     {
-      n2hexstr(&line[0], globalStateCounter & 0xFFFF, 4);
-      line[4] = '|';
-      n2hexstr(&line[5], enterState & 0xFF, 2);
-      line[7] = ':';
-      n2hexstr(&line[8], subStateCounter & 0xFFFF, 4);
-      line[12] = ':';
-      n2hexstr(&line[13], exitState & 0xFF, 2);
-      line[15] = '|';
-      line[16] = 'i';
-      n2hexstr(&line[17], inData & 0xFF, 2);
-      line[19] = '|';
-      line[20] = 'o';
-      n2hexstr(&line[21], outData & 0xFF, 2);
-      line[23] = '\0';
-      scroll_text(true, tte_get_context(), false, 8, 8, 138, 135);
-      ptgb_write_debug(this->debug_charset, line, true);
+        tte_erase_rect(0, 0, H_MAX, V_MAX);
     }
-
-    // TODO: This is pretty rough, but it's the best we can do until the text engine rewrite.
-    if (g_debug_options.print_link_packets && currIncomingPacket != nullptr)
+    else
     {
-      tte_erase_rect(160, 16, H_MAX, V_MAX);
-      for (int i = 0; i < 4; i++)
-      {
-        for (int j = 0; j < 4; j++)
+        if (g_debug_options.print_link_data)
         {
-          n2hexstr(&line[3 * j], dataOutBuffer[(4 * i) + j], 2);
-          line[(3 * j) + 2] = ' ';
+            n2hexstr(&line[0], globalStateCounter & 0xFFFF, 4);
+            line[4] = '|';
+            n2hexstr(&line[5], enterState & 0xFF, 2);
+            line[7] = ':';
+            n2hexstr(&line[8], subStateCounter & 0xFFFF, 4);
+            line[12] = ':';
+            n2hexstr(&line[13], exitState & 0xFF, 2);
+            line[15] = '|';
+            line[16] = 'i';
+            n2hexstr(&line[17], inData & 0xFF, 2);
+            line[19] = '|';
+            line[20] = 'o';
+            n2hexstr(&line[21], outData & 0xFF, 2);
+            line[23] = '\0';
+            scroll_text(true, tte_get_context(), false, 8, 8, 138, 135);
+            ptgb_write_debug(this->debug_charset, line, true);
         }
-        line[12] = '\0';
-        tte_set_pos(160, 16 * i);
-        ptgb_write_debug(this->debug_charset, line, true);
-      }
 
-      for (int i = 0; i < 4; i++)
-      {
-        byte tempBuffer[16];
-
-        tempBuffer[0] = currIncomingPacket->packetID;
-        tempBuffer[1] = currIncomingPacket->command;
-        tempBuffer[2] = currIncomingPacket->pointer >> 0;
-        tempBuffer[3] = currIncomingPacket->pointer >> 8;
-        memcpy(&tempBuffer[4], currIncomingPacket->argument, 2);
-        tempBuffer[6] = currIncomingPacket->latestError;
-        tempBuffer[7] = 0x00;
-        memcpy(&tempBuffer[8], currIncomingPacket->recievedData, 8);
-
-        for (int j = 0; j < 4; j++)
+        // TODO: This is pretty rough, but it's the best we can do until the
+        // text engine rewrite.
+        if (g_debug_options.print_link_packets && currIncomingPacket != nullptr)
         {
-          n2hexstr(&line[3 * j], tempBuffer[(4 * i) + j], 2);
-          line[(3 * j) + 2] = ' ';
+            tte_erase_rect(160, 16, H_MAX, V_MAX);
+            for (int i = 0; i < 4; i++)
+            {
+                for (int j = 0; j < 4; j++)
+                {
+                    n2hexstr(&line[3 * j], dataOutBuffer[(4 * i) + j], 2);
+                    line[(3 * j) + 2] = ' ';
+                }
+                line[12] = '\0';
+                tte_set_pos(160, 16 * i);
+                ptgb_write_debug(this->debug_charset, line, true);
+            }
+
+            for (int i = 0; i < 4; i++)
+            {
+                byte tempBuffer[16];
+
+                tempBuffer[0] = currIncomingPacket->packetID;
+                tempBuffer[1] = currIncomingPacket->command;
+                tempBuffer[2] = currIncomingPacket->pointer >> 0;
+                tempBuffer[3] = currIncomingPacket->pointer >> 8;
+                memcpy(&tempBuffer[4], currIncomingPacket->argument, 2);
+                tempBuffer[6] = currIncomingPacket->latestError;
+                tempBuffer[7] = 0x00;
+                memcpy(&tempBuffer[8], currIncomingPacket->recievedData, 8);
+
+                for (int j = 0; j < 4; j++)
+                {
+                    n2hexstr(&line[3 * j], tempBuffer[(4 * i) + j], 2);
+                    line[(3 * j) + 2] = ' ';
+                }
+                line[12] = '\0';
+                tte_set_pos(160, (16 * 5) + (16 * i));
+                ptgb_write_debug(this->debug_charset, line, true);
+            }
         }
-        line[12] = '\0';
-        tte_set_pos(160, (16 * 5) + (16 * i));
-        ptgb_write_debug(this->debug_charset, line, true);
-      }
     }
-  }
 }
 
 void LinkConnection::writeData()
 {
-  switch (g_debug_options.write_cable_data_to_save)
-  {
-  case WRITE_CABLE_DATA_MODE_OFF:
-    break;
-  case WRITE_CABLE_DATA_MODE_SRAM:
-  {
-    (*(SRAM_PTR + link_cable_array_index)) = inData;
-    ++link_cable_array_index;
+    switch (g_debug_options.write_cable_data_to_save)
+    {
+    case WRITE_CABLE_DATA_MODE_OFF:
+        break;
+    case WRITE_CABLE_DATA_MODE_SRAM:
+    {
+        (*(SRAM_PTR + link_cable_array_index)) = inData;
+        ++link_cable_array_index;
 
-    (*(SRAM_PTR + link_cable_array_index)) = outData;
-    ++link_cable_array_index;
-    break;
-  }
-  case WRITE_CABLE_DATA_MODE_CART:
-  {
-    // save the data to the cartridge in chunks of 4 KB
-    // WARNING: If you want to add or remove fields here,
-    // make sure to keep the number of bytes a clean divider of 4096 (global_memory_buffer_size)
+        (*(SRAM_PTR + link_cable_array_index)) = outData;
+        ++link_cable_array_index;
+        break;
+    }
+    case WRITE_CABLE_DATA_MODE_CART:
+    {
+        // save the data to the cartridge in chunks of 4 KB
+        // WARNING: If you want to add or remove fields here,
+        // make sure to keep the number of bytes a clean divider of 4096
+        // (global_memory_buffer_size)
 
-    // the next 6 bytes are for human consumption when viewed in a hex editor.
-    // they can be useful to correlate the current LinkConnection state with the data that was sent over the cable.
-    // but they're not needed for reconstructing the conversation with load_cable_data_from_save
-    global_memory_buffer[writeBufferOffset + 0] = (u8)(globalStateCounter >> 8) & 0xFF;
-    global_memory_buffer[writeBufferOffset + 1] = (u8)(globalStateCounter >> 0) & 0xFF;
-    global_memory_buffer[writeBufferOffset + 2] = (u8)enterState;
-    global_memory_buffer[writeBufferOffset + 3] = (u8)(subStateCounter >> 8) & 0xFF;
-    global_memory_buffer[writeBufferOffset + 4] = (u8)(subStateCounter >> 0) & 0xFF;
-    global_memory_buffer[writeBufferOffset + 5] = (u8)exitState;
+        // the next 6 bytes are for human consumption when viewed in a hex
+        // editor. they can be useful to correlate the current LinkConnection
+        // state with the data that was sent over the cable. but they're not
+        // needed for reconstructing the conversation with
+        // load_cable_data_from_save
+        global_memory_buffer[writeBufferOffset + 0] =
+            (u8)(globalStateCounter >> 8) & 0xFF;
+        global_memory_buffer[writeBufferOffset + 1] =
+            (u8)(globalStateCounter >> 0) & 0xFF;
+        global_memory_buffer[writeBufferOffset + 2] = (u8)enterState;
+        global_memory_buffer[writeBufferOffset + 3] =
+            (u8)(subStateCounter >> 8) & 0xFF;
+        global_memory_buffer[writeBufferOffset + 4] =
+            (u8)(subStateCounter >> 0) & 0xFF;
+        global_memory_buffer[writeBufferOffset + 5] = (u8)exitState;
 
-    // actual data bytes start here.
-    global_memory_buffer[writeBufferOffset + 6] = inData;
-    global_memory_buffer[writeBufferOffset + 7] = outData;
+        // actual data bytes start here.
+        global_memory_buffer[writeBufferOffset + 6] = inData;
+        global_memory_buffer[writeBufferOffset + 7] = outData;
 
-    writeBufferOffset += 8;
+        writeBufferOffset += 8;
 
-    break;
-  }
-  }
+        break;
+    }
+    }
 }
 
 void LinkConnection::handleStateLogic()
 {
-  switch (enterState)
-  {
-  case INITIAL_CONNECTION:
-    nextOutData = 0x01;
-    exitState = DISCOVERY_RESET;
-    break;
+    switch (enterState)
+    {
+    case INITIAL_CONNECTION:
+        nextOutData = 0x01;
+        exitState = DISCOVERY_RESET;
+        break;
 
-  case DISCOVERY_RESET:
-    // Reset and try a different timer phase
-    REG_TM3CNT = 0;
-    REG_IF = (1 << II_TIMER3);
-    linkSPI->activate(LinkSPI::Mode::MASTER_256KBPS);
-    outData = 0x01;
-    nextOutData = 0x01;
-    REG_TM3D = -(DISCOVERY_TIMER_MIN +
-                 (globalStateCounter & DISCOVERY_TIMER_PHASE_MASK));
-    REG_TM3CNT = TM_FREQ_1024 | TM_IRQ | TM_ENABLE;
-    exitState = CLOCK_ACQUIRE;
-    break;
+    case DISCOVERY_RESET:
+        // Reset and try a different timer phase
+        REG_TM3CNT = 0;
+        REG_IF = (1 << II_TIMER3);
+        linkSPI->activate(LinkSPI::Mode::MASTER_256KBPS);
+        outData = 0x01;
+        nextOutData = 0x01;
+        REG_TM3D = -(DISCOVERY_TIMER_MIN +
+                     (globalStateCounter & DISCOVERY_TIMER_PHASE_MASK));
+        REG_TM3CNT = TM_FREQ_1024 | TM_IRQ | TM_ENABLE;
+        exitState = CLOCK_ACQUIRE;
+        break;
 
-  case CLOCK_ACQUIRE:
-    nextOutData = 0x01;
+    case CLOCK_ACQUIRE:
+        nextOutData = 0x01;
 
-    if (inData == 0x02)
-    {
-      // Receiving 0x02 while sending 0x01 means the other Game Boy offered
-      // external-clock mode and should now have selected the GBA as master.
-      REG_TM3D = -INITIAL_LINK_TIMER;
-      exitState = CLOCK_CONFIRM;
-    }
-    else if (inData == 0xFE)
-    {
-      // Keep compatibility with an already-established connection where the
-      // role-selection byte was completed before discovery began.
-      REG_TM3D = -INITIAL_LINK_TIMER;
-      exitState = SAVE_SUCCESS;
-      nextOutData = 0x01;
-    }
-    else if (subStateCounter >= DISCOVERY_TIMEOUT_TRANSFERS)
-    {
-      exitState = DISCOVERY_RESET;
-    }
-    else
-    {
-      REG_TM3D = -(DISCOVERY_TIMER_MIN +
-                   (subStateCounter & DISCOVERY_TIMER_PHASE_MASK));
-    }
-    break;
+        if (inData == 0x02)
+        {
+            // Receiving 0x02 while sending 0x01 means the other Game Boy
+            // offered external-clock mode and should now have selected the GBA
+            // as master.
+            REG_TM3D = -INITIAL_LINK_TIMER;
+            exitState = CLOCK_CONFIRM;
+        }
+        else if (inData == 0xFE)
+        {
+            // Keep compatibility with an already-established connection where
+            // the role-selection byte was completed before discovery began.
+            REG_TM3D = -INITIAL_LINK_TIMER;
+            exitState = SAVE_SUCCESS;
+            nextOutData = 0x01;
+        }
+        else if (subStateCounter >= DISCOVERY_TIMEOUT_TRANSFERS)
+        {
+            exitState = DISCOVERY_RESET;
+        }
+        else
+        {
+            REG_TM3D = -(DISCOVERY_TIMER_MIN +
+                         (subStateCounter & DISCOVERY_TIMER_PHASE_MASK));
+        }
+        break;
 
-  case CLOCK_CONFIRM:
-    if (inData == 0xFE)
-    {
-      exitState = SAVE_SUCCESS;
-      nextOutData = 0x01;
-    }
-    else if (subStateCounter >= DISCOVERY_CONFIRM_TIMEOUT_TRANSFERS)
-    {
-      exitState = DISCOVERY_RESET;
-      nextOutData = 0x01;
-    }
-    else
-    {
-      nextOutData = 0x01;
-    }
-    break;
+    case CLOCK_CONFIRM:
+        if (inData == 0xFE)
+        {
+            exitState = SAVE_SUCCESS;
+            nextOutData = 0x01;
+        }
+        else if (subStateCounter >= DISCOVERY_CONFIRM_TIMEOUT_TRANSFERS)
+        {
+            exitState = DISCOVERY_RESET;
+            nextOutData = 0x01;
+        }
+        else
+        {
+            nextOutData = 0x01;
+        }
+        break;
 
-  case SAVE_SUCCESS:
-    nextOutData = 0x01;
+    case SAVE_SUCCESS:
+        nextOutData = 0x01;
 
-    if (inData == 0x02)
-    {
-      // Don't exit if we already set the GB as the follower
-    }
-    else if (inData == 0x60 || inData == 0x61)
-    {
-      exitState = MENU_OPEN;
-      nextOutData = inData;
-    }
-    break;
+        if (inData == 0x02)
+        {
+            // Don't exit if we already set the GB as the follower
+        }
+        else if (inData == 0x60 || inData == 0x61)
+        {
+            exitState = MENU_OPEN;
+            nextOutData = inData;
+        }
+        break;
 
-  case MENU_OPEN:
-    if (inData == 0xD0 || inData == 0x61)
-    {
-      if (inData == 0xD0)
-      {
-        gen = 1;
-        loadPayload(GB_PayloadsFiles::UNIVERSALPAYLOADGEN1);
-        nextOutData = 0xD4;
-      }
-      else if (inData == 0x61)
-      {
-        gen = 2;
-        loadPayload(GB_PayloadsFiles::UNIVERSALPAYLOADGEN2);
-        nextOutData = 0x61;
-      }
-      exitState = MENU_SUCCESS;
-    }
-    break;
+    case MENU_OPEN:
+        if (inData == 0xD0 || inData == 0x61)
+        {
+            if (inData == 0xD0)
+            {
+                gen = 1;
+                loadPayload(GB_PayloadsFiles::UNIVERSALPAYLOADGEN1);
+                nextOutData = 0xD4;
+            }
+            else if (inData == 0x61)
+            {
+                gen = 2;
+                loadPayload(GB_PayloadsFiles::UNIVERSALPAYLOADGEN2);
+                nextOutData = 0x61;
+            }
+            exitState = MENU_SUCCESS;
+        }
+        break;
 
-  case MENU_SUCCESS:
-    if (inData == 0xFE)
-    {
-      exitState = WAIT_FOR_TRADE;
-    }
-    nextOutData = inData;
-    break;
+    case MENU_SUCCESS:
+        if (inData == 0xFE)
+        {
+            exitState = WAIT_FOR_TRADE;
+        }
+        nextOutData = inData;
+        break;
 
-  case WAIT_FOR_TRADE:
-    if (inData == 0xFD)
-    {
-      REG_TM3D = -0x0040;
-      exitState = TRADE_PREAMBLE;
-      // nextOutData defaults to 0x00
-    }
-    else
-    {
-      nextOutData = inData;
-    }
-    break;
+    case WAIT_FOR_TRADE:
+        if (inData == 0xFD)
+        {
+            REG_TM3D = -0x0040;
+            exitState = TRADE_PREAMBLE;
+            // nextOutData defaults to 0x00
+        }
+        else
+        {
+            nextOutData = inData;
+        }
+        break;
 
-  case TRADE_PREAMBLE:
-    if (subStateCounter < 2)
-    {
-      // nextOutData defaults to 0x00
-    }
-    else if (subStateCounter < 9)
-    {
-      nextOutData = 0xFD;
-    }
-    else
-    {
-      exitState = TRADE;
-      nextOutData = 0xFD;
-    };
-    break;
+    case TRADE_PREAMBLE:
+        if (subStateCounter < 2)
+        {
+            // nextOutData defaults to 0x00
+        }
+        else if (subStateCounter < 9)
+        {
+            nextOutData = 0xFD;
+        }
+        else
+        {
+            exitState = TRADE;
+            nextOutData = 0xFD;
+        };
+        break;
 
-  case TRADE:
-    if (subStateCounter >= curr_payload_size)
-    {
-      if (this->gen == 2)
-      {
-        exitState = MAIL;
-      }
-      else
-      {
-        exitState = WAIT_FOR_CHECKSUM_PAYLOAD;
-      }
-    }
-      nextOutData = payloadBuffer[subStateCounter];
-    break;
+    case TRADE:
+        if (subStateCounter >= curr_payload_size)
+        {
+            if (this->gen == 2)
+            {
+                exitState = MAIL;
+            }
+            else
+            {
+                exitState = WAIT_FOR_CHECKSUM_PAYLOAD;
+            }
+        }
+        nextOutData = payloadBuffer[subStateCounter];
+        break;
 
-  case MAIL:
-    if (subStateCounter >= 0x186)
-    {
-      exitState = WAIT_FOR_CHECKSUM_PAYLOAD;
-    }
-    nextOutData = 0x00;
-    break;
+    case MAIL:
+        if (subStateCounter >= 0x186)
+        {
+            exitState = WAIT_FOR_CHECKSUM_PAYLOAD;
+        }
+        nextOutData = 0x00;
+        break;
 
-  case WAIT_FOR_CHECKSUM_PAYLOAD:
-    if (inData == 0xFD)
-    {
-      exitState = GET_CHECKSUM;
-    }
-    // nextOutData defaults to 0x00
-    break;
+    case WAIT_FOR_CHECKSUM_PAYLOAD:
+        if (inData == 0xFD)
+        {
+            exitState = GET_CHECKSUM;
+        }
+        // nextOutData defaults to 0x00
+        break;
 
-  case GET_CHECKSUM:
-    if (inData != 0xFD)
-    {
-      dataOutBuffer[dataOutBufferCurrIndex % DATA_OUT_BUFFER_SIZE] = inData;
-      dataOutBufferCurrIndex++;
-      nextOutData = 0x01;
-    }
-    else if (inData == 0xFD && dataOutBufferCurrIndex > 0)
-    {
-      loadCurrGameFromChecksum();
-      if (currROM == GB_ROM_ERROR)
-      {
-        while(true){}
-        // Add in an error message thrown here once we, ya know, rewrite the text engine to make that possible
-      }
-      loadPayloadByROM(currROM);
-      exitState = SEND_SPECIFIC_PAYLOAD;
-    }
-    else
-    {
-      nextOutData = 0xFD;
-    }
-    break;
+    case GET_CHECKSUM:
+        if (inData != 0xFD)
+        {
+            dataOutBuffer[dataOutBufferCurrIndex % DATA_OUT_BUFFER_SIZE] =
+                inData;
+            dataOutBufferCurrIndex++;
+            nextOutData = 0x01;
+        }
+        else if (inData == 0xFD && dataOutBufferCurrIndex > 0)
+        {
+            loadCurrGameFromChecksum();
+            if (currROM == GB_ROM_ERROR)
+            {
+                while (true)
+                {
+                }
+                // Add in an error message thrown here once we, ya know, rewrite
+                // the text engine to make that possible
+            }
+            loadPayloadByROM(currROM);
+            exitState = SEND_SPECIFIC_PAYLOAD;
+        }
+        else
+        {
+            nextOutData = 0xFD;
+        }
+        break;
 
-  case WAIT_FOR_SECOND_PAYLOAD:
-    if (inData == 0xFD)
-    {
-      exitState = SEND_SPECIFIC_PAYLOAD;
-    }
-    // nextOutData defaults to 0x00
-    break;
+    case WAIT_FOR_SECOND_PAYLOAD:
+        if (inData == 0xFD)
+        {
+            exitState = SEND_SPECIFIC_PAYLOAD;
+        }
+        // nextOutData defaults to 0x00
+        break;
 
-  case SEND_SPECIFIC_PAYLOAD:
-    if (subStateCounter >= 255) // The 255 comes from the Universal Payload
-    {
-      exitState = SEND_FIRST_PACKET;
-    }
-    if (subStateCounter < curr_payload_size)
-    {
-      nextOutData = payloadBuffer[subStateCounter];
-    }
-    else
-    {
-      nextOutData = 0x01;
-    }
-    break;
+    case SEND_SPECIFIC_PAYLOAD:
+        if (subStateCounter >= 255) // The 255 comes from the Universal Payload
+        {
+            exitState = SEND_FIRST_PACKET;
+        }
+        if (subStateCounter < curr_payload_size)
+        {
+            nextOutData = payloadBuffer[subStateCounter];
+        }
+        else
+        {
+            nextOutData = 0x01;
+        }
+        break;
 
-  case SEND_FIRST_PACKET:
-    // In order to make sure everything is set to go, we need to send a dummy packet.
-    currOutgoingPacket = &dummyPacket;
-    nextOutData = 0xFF;
-    exitState = STANDARD_PACKET_EXCHANGE;
-    break;
-
-  case PACKET_EXCHANGE:
-    nextOutData = 0xFF;
-    exitState = STANDARD_PACKET_EXCHANGE;
-    break;
-
-  case STANDARD_PACKET_EXCHANGE:
-  {
-    switch (subStateCounter)
-    {
-    case 0:
-      nextOutData = 0xFD;
-      break;
-    case 1:
-      nextOutData = linkPacketArrIndex;
-      currOutgoingPacket->packetID = linkPacketArrIndex;
-      break;
-    case 2:
-      nextOutData = currOutgoingPacket->command;
-      if (currOutgoingPacket->command == CMD_SoftReset)
-      {
-        // Immedaitely remove the Soft Reset packet from in use, it will not get a response.
-        currOutgoingPacket->inUse = false;
-      }
-      break;
-    case 3:
-      nextOutData = currOutgoingPacket->argument[0];
-      break;
-    case 4:
-      nextOutData = currOutgoingPacket->argument[1];
-      break;
-    case 5:
-      nextOutData = currOutgoingPacket->pointer >> 0;
-      break;
-    case 6:
-      nextOutData = currOutgoingPacket->pointer >> 8;
-      break;
-    case TOTAL_PACKET_LENGTH:
-      PTGB_MGBA_INFO("Sent packet: cmd=[%X], args=[%X, %X], ptr=[%X], ID=[%X], Data=[%X, %X, %X, %X, %X, %X, %X, %X]",
-      currOutgoingPacket->command,
-      currOutgoingPacket->argument[0],
-      currOutgoingPacket->argument[1],
-      currOutgoingPacket->pointer,
-      currOutgoingPacket->packetID,
-      currOutgoingPacket->recievedData[0],
-      currOutgoingPacket->recievedData[1],
-      currOutgoingPacket->recievedData[2],
-      currOutgoingPacket->recievedData[3],
-      currOutgoingPacket->recievedData[4],
-      currOutgoingPacket->recievedData[5],
-      currOutgoingPacket->recievedData[6],
-      currOutgoingPacket->recievedData[7]
-      );
-      exitState = RUNNING_CODE_DELAY;
-      nextOutData = 0xFF;
-      break;
-    default:
-      nextOutData = 0xFF;
-      break;
-    }
-  }
-    dataOutBuffer[subStateCounter] = inData;
-    break;
-  
-  case RUNNING_CODE_DELAY:
-  {
-    // We are currently processing something, we need to wait for that to finish.
-    if (inData == 0xFE)
-    {
-      nextOutData = 0xFF;
-    }
-    else
-    {
-      if (currOutgoingPacket->secondaryPayloadData != nullptr)
-      {
-        // We get our response after the GB gets the secondary payload, send that first.
-        exitState = SECONDARY_PACKET_EXCHANGE;
-      }
-      else
-      {
-        exitState = PROCESS_PACKET;
-      }
-    }
-  }
-  break;
-
-  case SECONDARY_PACKET_EXCHANGE:
-  {
-    switch (subStateCounter)
-    {
-    case 0:
-      nextOutData = 0xFD;
-      PTGB_MGBA_INFO("Secondary byte: sub=%d phase=preamble out=%X in=%X packet=%X cmd=%d",
-                     subStateCounter,
-                     nextOutData,
-                     inData,
-                     currOutgoingPacket->packetID,
-                     currOutgoingPacket->command);
-      break;
-    case 1:
-      nextOutData = linkPacketArrIndex;
-      currOutgoingPacket->packetID = linkPacketArrIndex;
-      PTGB_MGBA_INFO("Secondary byte: sub=%d phase=counter out=%X in=%X packet=%X cmd=%d",
-                     subStateCounter,
-                     nextOutData,
-                     inData,
-                     currOutgoingPacket->packetID,
-                     currOutgoingPacket->command);
-      break;
-    case 2:
-      // The command ID matches the saftey byte (0xFF)
-      nextOutData = 0xFF;
-      PTGB_MGBA_INFO("Secondary byte: sub=%d phase=safety out=%X in=%X packet=%X cmd=%d",
-                     subStateCounter,
-                     nextOutData,
-                     inData,
-                     currOutgoingPacket->packetID,
-                     currOutgoingPacket->command);
-      break;
-    case 3:
-      nextOutData = currOutgoingPacket->secondaryPayloadDataSize + 1; // We need to include the checksum value here as well
-      PTGB_MGBA_INFO("Secondary byte: sub=%d phase=dataSize out=%X in=%X dataSize=%d packetSizeArg=%d",
-                     subStateCounter,
-                     nextOutData,
-                     inData,
-                     currOutgoingPacket->secondaryPayloadDataSize,
-                     currOutgoingPacket->secondaryPayloadDataSize + SECONDARY_PAYLOAD_HEADER_SIZE);
-      break;
-    default:
-      // We're through all the constant values, let's do the rest.
-      if ((subStateCounter - SECONDARY_PAYLOAD_HEADER_SIZE) < currOutgoingPacket->secondaryPayloadDataSize)
-      {
-        nextOutData = currOutgoingPacket->secondaryPayloadData[subStateCounter - SECONDARY_PAYLOAD_HEADER_SIZE];
-        PTGB_MGBA_INFO("Secondary byte: sub=%d phase=data index=%d out=%X in=%X packet=%X",
-                       subStateCounter,
-                       subStateCounter - SECONDARY_PAYLOAD_HEADER_SIZE,
-                       nextOutData,
-                       inData,
-                       currOutgoingPacket->packetID);
-      }
-      else if ((subStateCounter - SECONDARY_PAYLOAD_HEADER_SIZE) == currOutgoingPacket->secondaryPayloadDataSize)
-      {
-        // Add the checksum and we're done with the packet.
-        nextOutData = currOutgoingPacket->secondaryPayloadSizeChecksum;
-        PTGB_MGBA_INFO("Secondary byte: sub=%d phase=checksum out=%X in=%X packet=%X",
-                       subStateCounter,
-                       nextOutData,
-                       inData,
-                       currOutgoingPacket->packetID);
-      }
-      else if (inData != currOutgoingPacket->packetID)
-      {
-        // We need to wait until the packet is ready to be recieved.
-        nextOutData = 0xFF;
-      }
-      else
-      {
-        PTGB_MGBA_INFO("Secondary response counter seen: sub=%d packet=%X cmd=%d in=%X",
-                       subStateCounter,
-                       currOutgoingPacket->packetID,
-                       currOutgoingPacket->command,
-                       inData);
-        // Great, the secondary payload has been processed and we are currently receiving the response.
-        // Let's log the first response byte and head back to the normal packet talk
-        exitState = STANDARD_PACKET_EXCHANGE;
-
-        // Use a dummy packet to flush it out
+    case SEND_FIRST_PACKET:
+        // In order to make sure everything is set to go, we need to send a
+        // dummy packet.
         currOutgoingPacket = &dummyPacket;
         nextOutData = 0xFF;
-      }
+        exitState = STANDARD_PACKET_EXCHANGE;
+        break;
+
+    case PACKET_EXCHANGE:
+        nextOutData = 0xFF;
+        exitState = STANDARD_PACKET_EXCHANGE;
+        break;
+
+    case STANDARD_PACKET_EXCHANGE:
+    {
+        switch (subStateCounter)
+        {
+        case 0:
+            nextOutData = 0xFD;
+            break;
+        case 1:
+            nextOutData = linkPacketArrIndex;
+            currOutgoingPacket->packetID = linkPacketArrIndex;
+            break;
+        case 2:
+            nextOutData = currOutgoingPacket->command;
+            if (currOutgoingPacket->command == CMD_SoftReset)
+            {
+                // Immedaitely remove the Soft Reset packet from in use, it will
+                // not get a response.
+                currOutgoingPacket->inUse = false;
+            }
+            break;
+        case 3:
+            nextOutData = currOutgoingPacket->argument[0];
+            break;
+        case 4:
+            nextOutData = currOutgoingPacket->argument[1];
+            break;
+        case 5:
+            nextOutData = currOutgoingPacket->pointer >> 0;
+            break;
+        case 6:
+            nextOutData = currOutgoingPacket->pointer >> 8;
+            break;
+        case TOTAL_PACKET_LENGTH:
+            PTGB_MGBA_INFO("Sent packet: cmd=[%X], args=[%X, %X], ptr=[%X], "
+                           "ID=[%X], Data=[%X, %X, %X, %X, %X, %X, %X, %X]",
+                currOutgoingPacket->command, currOutgoingPacket->argument[0],
+                currOutgoingPacket->argument[1], currOutgoingPacket->pointer,
+                currOutgoingPacket->packetID,
+                currOutgoingPacket->recievedData[0],
+                currOutgoingPacket->recievedData[1],
+                currOutgoingPacket->recievedData[2],
+                currOutgoingPacket->recievedData[3],
+                currOutgoingPacket->recievedData[4],
+                currOutgoingPacket->recievedData[5],
+                currOutgoingPacket->recievedData[6],
+                currOutgoingPacket->recievedData[7]);
+            exitState = RUNNING_CODE_DELAY;
+            nextOutData = 0xFF;
+            break;
+        default:
+            nextOutData = 0xFF;
+            break;
+        }
+    }
+        dataOutBuffer[subStateCounter] = inData;
+        break;
+
+    case RUNNING_CODE_DELAY:
+    {
+        // We are currently processing something, we need to wait for that to
+        // finish.
+        if (inData == 0xFE)
+        {
+            nextOutData = 0xFF;
+        }
+        else
+        {
+            if (currOutgoingPacket->secondaryPayloadData != nullptr)
+            {
+                // We get our response after the GB gets the secondary payload,
+                // send that first.
+                exitState = SECONDARY_PACKET_EXCHANGE;
+            }
+            else
+            {
+                exitState = PROCESS_PACKET;
+            }
+        }
     }
     break;
-  }
-  break;
 
-  case PROCESS_PACKET:
-    currIncomingPacket = &linkPacketArr[dataOutBuffer[INP_COUNTER_INDEX] % LINK_PACKET_ARRAY_SIZE];
-    if (allPacketsProcessed())
+    case SECONDARY_PACKET_EXCHANGE:
     {
-      // We have no valid responses that we are looking for, go to the end.
-      exitState = END;
+        switch (subStateCounter)
+        {
+        case 0:
+            nextOutData = 0xFD;
+            PTGB_MGBA_INFO("Secondary byte: sub=%d phase=preamble out=%X in=%X "
+                           "packet=%X cmd=%d",
+                subStateCounter, nextOutData, inData,
+                currOutgoingPacket->packetID, currOutgoingPacket->command);
+            break;
+        case 1:
+            nextOutData = linkPacketArrIndex;
+            currOutgoingPacket->packetID = linkPacketArrIndex;
+            PTGB_MGBA_INFO("Secondary byte: sub=%d phase=counter out=%X in=%X "
+                           "packet=%X cmd=%d",
+                subStateCounter, nextOutData, inData,
+                currOutgoingPacket->packetID, currOutgoingPacket->command);
+            break;
+        case 2:
+            // The command ID matches the saftey byte (0xFF)
+            nextOutData = 0xFF;
+            PTGB_MGBA_INFO("Secondary byte: sub=%d phase=safety out=%X in=%X "
+                           "packet=%X cmd=%d",
+                subStateCounter, nextOutData, inData,
+                currOutgoingPacket->packetID, currOutgoingPacket->command);
+            break;
+        case 3:
+            nextOutData =
+                currOutgoingPacket->secondaryPayloadDataSize +
+                1; // We need to include the checksum value here as well
+            PTGB_MGBA_INFO("Secondary byte: sub=%d phase=dataSize out=%X in=%X "
+                           "dataSize=%d packetSizeArg=%d",
+                subStateCounter, nextOutData, inData,
+                currOutgoingPacket->secondaryPayloadDataSize,
+                currOutgoingPacket->secondaryPayloadDataSize +
+                    SECONDARY_PAYLOAD_HEADER_SIZE);
+            break;
+        default:
+            // We're through all the constant values, let's do the rest.
+            if ((subStateCounter - SECONDARY_PAYLOAD_HEADER_SIZE) <
+                currOutgoingPacket->secondaryPayloadDataSize)
+            {
+                nextOutData =
+                    currOutgoingPacket
+                        ->secondaryPayloadData[subStateCounter -
+                                               SECONDARY_PAYLOAD_HEADER_SIZE];
+                PTGB_MGBA_INFO("Secondary byte: sub=%d phase=data index=%d "
+                               "out=%X in=%X packet=%X",
+                    subStateCounter,
+                    subStateCounter - SECONDARY_PAYLOAD_HEADER_SIZE,
+                    nextOutData, inData, currOutgoingPacket->packetID);
+            }
+            else if ((subStateCounter - SECONDARY_PAYLOAD_HEADER_SIZE) ==
+                     currOutgoingPacket->secondaryPayloadDataSize)
+            {
+                // Add the checksum and we're done with the packet.
+                nextOutData = currOutgoingPacket->secondaryPayloadSizeChecksum;
+                PTGB_MGBA_INFO("Secondary byte: sub=%d phase=checksum out=%X "
+                               "in=%X packet=%X",
+                    subStateCounter, nextOutData, inData,
+                    currOutgoingPacket->packetID);
+            }
+            else if (inData != currOutgoingPacket->packetID)
+            {
+                // We need to wait until the packet is ready to be recieved.
+                nextOutData = 0xFF;
+            }
+            else
+            {
+                PTGB_MGBA_INFO("Secondary response counter seen: sub=%d "
+                               "packet=%X cmd=%d in=%X",
+                    subStateCounter, currOutgoingPacket->packetID,
+                    currOutgoingPacket->command, inData);
+                // Great, the secondary payload has been processed and we are
+                // currently receiving the response. Let's log the first
+                // response byte and head back to the normal packet talk
+                exitState = STANDARD_PACKET_EXCHANGE;
+
+                // Use a dummy packet to flush it out
+                currOutgoingPacket = &dummyPacket;
+                nextOutData = 0xFF;
+            }
+        }
+        break;
     }
-    else if (processPacket())
-    {
-      // Processing succeeded, let's load the next one.
-      exitState = LOAD_NEXT_PACKET;
-    }
-    else
-    {
-      // The processing failed. Let's move on and try again later
-      prepareNextPacket();
-      exitState = PACKET_EXCHANGE;
-    }
-    nextOutData = 0xFF;
     break;
 
-  case LOAD_NEXT_PACKET:
-    consumePacket();
+    case PROCESS_PACKET:
+        currIncomingPacket = &linkPacketArr[dataOutBuffer[INP_COUNTER_INDEX] %
+                                            LINK_PACKET_ARRAY_SIZE];
+        if (allPacketsProcessed())
+        {
+            // We have no valid responses that we are looking for, go to the
+            // end.
+            exitState = END;
+        }
+        else if (processPacket())
+        {
+            // Processing succeeded, let's load the next one.
+            exitState = LOAD_NEXT_PACKET;
+        }
+        else
+        {
+            // The processing failed. Let's move on and try again later
+            prepareNextPacket();
+            exitState = PACKET_EXCHANGE;
+        }
+        nextOutData = 0xFF;
+        break;
 
-    if (allPacketsProcessed())
-    {
-      exitState = END;
+    case LOAD_NEXT_PACKET:
+        consumePacket();
+
+        if (allPacketsProcessed())
+        {
+            exitState = END;
+        }
+        else
+        {
+            prepareNextPacket();
+            exitState = PACKET_EXCHANGE;
+        }
+        nextOutData = 0xFF;
+        break;
+
+    case END:
+        irq_disable(II_TIMER3);
+        break;
+
+    default:
+        nextOutData = inData;
+        break;
     }
-    else
-    {
-      prepareNextPacket();
-      exitState = PACKET_EXCHANGE;
-    }
-    nextOutData = 0xFF;
-    break;
-
-  case END:
-    irq_disable(II_TIMER3);
-    break;
-
-  default:
-    nextOutData = inData;
-    break;
-  }
 }
 
 void LinkConnection::prepareForNextCycle()
 {
-  if (exitState != enterState)
-  {
-    subStateCounter = 0;
-    subStateChanged = true;
-  }
-  else
-  {
-    subStateCounter++;
-    subStateChanged = false;
-  }
+    if (exitState != enterState)
+    {
+        subStateCounter = 0;
+        subStateChanged = true;
+    }
+    else
+    {
+        subStateCounter++;
+        subStateChanged = false;
+    }
 
-  if (key_held(KEY_L) && key_held(KEY_R))
-  {
-    exitState = END;
-  }
+    if (key_held(KEY_L) && key_held(KEY_R))
+    {
+        exitState = END;
+    }
 
-  globalStateCounter++;
-  enterState = exitState;
-  outData = nextOutData;
+    globalStateCounter++;
+    enterState = exitState;
+    outData = nextOutData;
 }
 
 /*
  * So, dealing with writing to the cartridge in the IRQ handler was a no-go.
- * It just caused too many issues with data corruption, probably because the write and erase_sector
- * operation was taking too long.
+ * It just caused too many issues with data corruption, probably because the
+ * write and erase_sector operation was taking too long.
  *
  * So, I moved it to the main loop through this function.
- * However, we need to be aware that this function can get interrupted by the IRQ handler at any time.
+ * However, we need to be aware that this function can get interrupted by the
+ * IRQ handler at any time.
  *
- * We also need to take care to not have global_memory_buffer overflow as the IRQ handler just keeps adding to it.
+ * We also need to take care to not have global_memory_buffer overflow as the
+ * IRQ handler just keeps adding to it.
  */
 void LinkConnection::handleCartIO()
 {
-  u8 writeBuffer[0x1000];
-  unsigned curBufDepth = writeBufferOffset;
+    u8 writeBuffer[0x1000];
+    unsigned curBufDepth = writeBufferOffset;
 
-  // first copy the current data to a local buffer. Note: the IRQ handler could append new data to global_memory_buffer during this call!
-  memcpy(writeBuffer, global_memory_buffer, curBufDepth);
-  // by updating the writeBufferOffset already, we allow the IRQ handler to start writing at the new right position
-  // immediately.
-  writeBufferOffset -= curBufDepth;
-  // now move any data received during the memcpy to before writeBufferOffset, so it will be included in the next batch.
-  // Note: keep in mind, here too the IRQ handler may be appending new data to global_memory_buffer and increase writeBufferOffset.
-  // but it's harmless.
-  memmove(global_memory_buffer, global_memory_buffer + curBufDepth, writeBufferOffset);
+    // first copy the current data to a local buffer. Note: the IRQ handler
+    // could append new data to global_memory_buffer during this call!
+    memcpy(writeBuffer, global_memory_buffer, curBufDepth);
+    // by updating the writeBufferOffset already, we allow the IRQ handler to
+    // start writing at the new right position immediately.
+    writeBufferOffset -= curBufDepth;
+    // now move any data received during the memcpy to before writeBufferOffset,
+    // so it will be included in the next batch. Note: keep in mind, here too
+    // the IRQ handler may be appending new data to global_memory_buffer and
+    // increase writeBufferOffset. but it's harmless.
+    memmove(global_memory_buffer, global_memory_buffer + curBufDepth,
+        writeBufferOffset);
 
-  u8 *curWriteBuf = writeBuffer;
-  const u8 *const endWriteBuf = writeBuffer + curBufDepth;
+    u8 *curWriteBuf = writeBuffer;
+    const u8 *const endWriteBuf = writeBuffer + curBufDepth;
 
-  while (curWriteBuf < endWriteBuf)
-  {
-    // make sure not to write beyond the current flash sector's boundaries. We'll need an erase_sector() call before
-    // we write to the next sector.
-    const unsigned bytesRemainingInSector = 0x1000 - link_cable_array_index;
-    const unsigned bytesToWrite = (curBufDepth < bytesRemainingInSector) ? curBufDepth : bytesRemainingInSector;
-
-    copy_ram_to_save(curWriteBuf, (0x1000 * link_cable_memory_section_index) + link_cable_array_index, bytesToWrite);
-    curWriteBuf += bytesToWrite;
-    curBufDepth -= bytesToWrite;
-    link_cable_array_index += bytesToWrite;
-
-    if (link_cable_array_index >= 0x1000)
+    while (curWriteBuf < endWriteBuf)
     {
-      // we have reached the end of our current sector. Let's erase the next one.
-      link_cable_array_index = 0;
-      ++link_cable_memory_section_index;
-      erase_sector(0x1000 * link_cable_memory_section_index);
+        // make sure not to write beyond the current flash sector's boundaries.
+        // We'll need an erase_sector() call before we write to the next sector.
+        const unsigned bytesRemainingInSector = 0x1000 - link_cable_array_index;
+        const unsigned bytesToWrite = (curBufDepth < bytesRemainingInSector)
+                                          ? curBufDepth
+                                          : bytesRemainingInSector;
+
+        copy_ram_to_save(curWriteBuf,
+            (0x1000 * link_cable_memory_section_index) + link_cable_array_index,
+            bytesToWrite);
+        curWriteBuf += bytesToWrite;
+        curBufDepth -= bytesToWrite;
+        link_cable_array_index += bytesToWrite;
+
+        if (link_cable_array_index >= 0x1000)
+        {
+            // we have reached the end of our current sector. Let's erase the
+            // next one.
+            link_cable_array_index = 0;
+            ++link_cable_memory_section_index;
+            erase_sector(0x1000 * link_cable_memory_section_index);
+        }
     }
-  }
 }
 
 bool LinkConnection::earlyExit()
 {
-  if (g_debug_options.print_link_data && !skipPrint && key_held(KEY_LEFT))
-  {
-    pauseOnByte = true;
-    pauseOnPacket = false;
-  }
-  else if (g_debug_options.print_link_packets && !skipPrint && key_held(KEY_RIGHT))
-  {
-    pauseOnPacket = true;
-    pauseOnByte = false;
-  }
-  else if (g_debug_options.print_link_data && !skipPrint && key_held(KEY_SELECT))
-  {
-    pauseOnByte = false;
-  }
-  else if (g_debug_options.print_link_packets && !skipPrint && key_held(KEY_START))
-  {
-    pauseOnPacket = false;
-  }
-  else if ((g_debug_options.print_link_data || g_debug_options.print_link_packets) && key_held(KEY_UP))
-  {
-    skipPrint = true;
-    pauseOnPacket = false;
-    pauseOnByte = false;
-  }
-  else if ((g_debug_options.print_link_data || g_debug_options.print_link_packets) && key_held(KEY_DOWN))
-  {
-    skipPrint = false;
-  }
-
-  if (pauseOnByte && g_debug_options.print_link_data)
-  {
-    if (key_hit(KEY_B))
+    if (g_debug_options.print_link_data && !skipPrint && key_held(KEY_LEFT))
     {
-      return false; // Even if paused, run once
+        pauseOnByte = true;
+        pauseOnPacket = false;
     }
-  }
-
-  if (pauseOnPacket && (enterState == LOAD_NEXT_PACKET) && g_debug_options.print_link_packets)
-  {
-    if (key_hit(KEY_A))
+    else if (g_debug_options.print_link_packets && !skipPrint &&
+             key_held(KEY_RIGHT))
     {
-      return false; // Even if paused, run once5
+        pauseOnPacket = true;
+        pauseOnByte = false;
+    }
+    else if (g_debug_options.print_link_data && !skipPrint &&
+             key_held(KEY_SELECT))
+    {
+        pauseOnByte = false;
+    }
+    else if (g_debug_options.print_link_packets && !skipPrint &&
+             key_held(KEY_START))
+    {
+        pauseOnPacket = false;
+    }
+    else if ((g_debug_options.print_link_data ||
+                 g_debug_options.print_link_packets) &&
+             key_held(KEY_UP))
+    {
+        skipPrint = true;
+        pauseOnPacket = false;
+        pauseOnByte = false;
+    }
+    else if ((g_debug_options.print_link_data ||
+                 g_debug_options.print_link_packets) &&
+             key_held(KEY_DOWN))
+    {
+        skipPrint = false;
     }
-  }
 
-  return pauseOnByte || (pauseOnPacket && (enterState == LOAD_NEXT_PACKET));
+    if (pauseOnByte && g_debug_options.print_link_data)
+    {
+        if (key_hit(KEY_B))
+        {
+            return false; // Even if paused, run once
+        }
+    }
+
+    if (pauseOnPacket && (enterState == LOAD_NEXT_PACKET) &&
+        g_debug_options.print_link_packets)
+    {
+        if (key_hit(KEY_A))
+        {
+            return false; // Even if paused, run once5
+        }
+    }
+
+    return pauseOnByte || (pauseOnPacket && (enterState == LOAD_NEXT_PACKET));
 }
 
 bool LinkConnection::processPacket()
 {
 
-  PTGB_MGBA_INFO("Recieved raw data: Data=[%X, %X, %X, %X, %X, %X, %X, %X, %X, %X, %X, %X, %X, %X, %X, %X]",
-  dataOutBuffer[0],
-  dataOutBuffer[1],
-  dataOutBuffer[2],
-  dataOutBuffer[3],
-  dataOutBuffer[4],
-  dataOutBuffer[5],
-  dataOutBuffer[6],
-  dataOutBuffer[7],
-  dataOutBuffer[8],
-  dataOutBuffer[9],
-  dataOutBuffer[10],
-  dataOutBuffer[11],
-  dataOutBuffer[12],
-  dataOutBuffer[13],
-  dataOutBuffer[14],
-  dataOutBuffer[15]
-  );  
-  
-  int checksum = 0;
-  if (currIncomingPacket->packetID != dataOutBuffer[INP_COUNTER_INDEX])
-  {
-    // This packet is not the correct ID for the response, ignore it
-    PTGB_MGBA_INFO("Packet counter mismatch: expected=%u got=%u cmd=%d",
-                   currIncomingPacket->packetID,
-                   dataOutBuffer[INP_COUNTER_INDEX],
-                   currIncomingPacket->command);
-    return false;
-  }
+    PTGB_MGBA_INFO("Recieved raw data: Data=[%X, %X, %X, %X, %X, %X, %X, %X, "
+                   "%X, %X, %X, %X, %X, %X, %X, %X]",
+        dataOutBuffer[0], dataOutBuffer[1], dataOutBuffer[2], dataOutBuffer[3],
+        dataOutBuffer[4], dataOutBuffer[5], dataOutBuffer[6], dataOutBuffer[7],
+        dataOutBuffer[8], dataOutBuffer[9], dataOutBuffer[10],
+        dataOutBuffer[11], dataOutBuffer[12], dataOutBuffer[13],
+        dataOutBuffer[14], dataOutBuffer[15]);
 
-  for (int i = INP_COUNTER_INDEX; i < INP_LENGTH; i++)
-  {
-    if (i != INP_CHECKSUM_INDEX)
+    int checksum = 0;
+    if (currIncomingPacket->packetID != dataOutBuffer[INP_COUNTER_INDEX])
     {
-      checksum += dataOutBuffer[i];
+        // This packet is not the correct ID for the response, ignore it
+        PTGB_MGBA_INFO("Packet counter mismatch: expected=%u got=%u cmd=%d",
+            currIncomingPacket->packetID, dataOutBuffer[INP_COUNTER_INDEX],
+            currIncomingPacket->command);
+        return false;
     }
-  }
-  // Add the read pointer
-  checksum += ((currIncomingPacket->pointer + 8) >> 0) & 0xFF;
-  checksum += ((currIncomingPacket->pointer + 8) >> 8) & 0xFF;
 
-  checksum &= 0x7F;
-
-  byte lsbByte = dataOutBuffer[INP_LSB_INDEX] | dataOutBuffer[INP_LSB_INDEX + 1];
-  for (int i = 0; i < 8; i++)
-  {
-    currIncomingPacket->recievedData[i] =
-        (dataOutBuffer[INP_DATA_INDEX + i] << 1) | ((lsbByte >> (7 - i)) & 0b1);
-  }
-
-  PTGB_MGBA_INFO("Packet decoded: packet=%u cmd=%d lsb=%X/%X checksumExpected=%X checksumGot=%X recv=%X %X %X %X %X %X %X %X",
-                 currIncomingPacket->packetID,
-                 currIncomingPacket->command,
-                 dataOutBuffer[INP_LSB_INDEX],
-                 dataOutBuffer[INP_LSB_INDEX + 1],
-                 checksum,
-                 dataOutBuffer[INP_CHECKSUM_INDEX],
-                 currIncomingPacket->recievedData[0],
-                 currIncomingPacket->recievedData[1],
-                 currIncomingPacket->recievedData[2],
-                 currIncomingPacket->recievedData[3],
-                 currIncomingPacket->recievedData[4],
-                 currIncomingPacket->recievedData[5],
-                 currIncomingPacket->recievedData[6],
-                 currIncomingPacket->recievedData[7]);
-
-  if (checksum != dataOutBuffer[INP_CHECKSUM_INDEX])
-  {
-    // The checksum has to match in order for it to be valid, if we've made it this far down the line.
-    currIncomingPacket->latestError = CHECKSUM_MISMATCH;
-    PTGB_MGBA_INFO("Packet checksum mismatch: packet=%u cmd=%d expected=%X got=%X",
-                   currIncomingPacket->packetID,
-                   currIncomingPacket->command,
-                   checksum,
-                   dataOutBuffer[INP_CHECKSUM_INDEX]);
-    return false;
-  }
-
-  if ((currIncomingPacket->command != CMD_ReadDataRequest) && (dataOutBuffer[INP_DATA_INDEX] & 0x80))
-  {
-    currIncomingPacket->latestError = ERROR_FLAG;
-    PTGB_MGBA_INFO("Packet reports GB command failure: packet=%u cmd=%d encodedFirstData=%X decodedFirstData=%X",
-                   currIncomingPacket->packetID,
-                   currIncomingPacket->command,
-                   dataOutBuffer[INP_DATA_INDEX],
-                   currIncomingPacket->recievedData[0]);
-    return false;
-  }
-
-  if (currIncomingPacket->command != CMD_ReadDataRequest)
-  {
-    // These command types will echo the first 8 bytes of the packet back to verify they were recieved correctly. Make sure that's the case.
-    // This will also fail if a secondary packet fails
-    if (
-        currIncomingPacket->recievedData[0] != currIncomingPacket->packetID ||
-        currIncomingPacket->recievedData[1] != currIncomingPacket->command ||
-        currIncomingPacket->recievedData[2] != currIncomingPacket->argument[0] ||
-        currIncomingPacket->recievedData[3] != currIncomingPacket->argument[1] ||
-        currIncomingPacket->recievedData[4] != ((currIncomingPacket->pointer >> 0) & 0xFF) ||
-        currIncomingPacket->recievedData[5] != ((currIncomingPacket->pointer >> 8) & 0xFF) ||
-        currIncomingPacket->recievedData[6] != 0xFF ||
-        currIncomingPacket->recievedData[7] != 0xFF)
+    for (int i = INP_COUNTER_INDEX; i < INP_LENGTH; i++)
     {
-      currIncomingPacket->latestError = ECHO_MISMATCH;
-      PTGB_MGBA_INFO("Packet echo mismatch: packet=%u cmd=%d recv=%X %X %X %X %X %X %X %X",
-                     currIncomingPacket->packetID,
-                     currIncomingPacket->command,
-                     currIncomingPacket->recievedData[0],
-                     currIncomingPacket->recievedData[1],
-                     currIncomingPacket->recievedData[2],
-                     currIncomingPacket->recievedData[3],
-                     currIncomingPacket->recievedData[4],
-                     currIncomingPacket->recievedData[5],
-                     currIncomingPacket->recievedData[6],
-                     currIncomingPacket->recievedData[7]);
-      return false;
+        if (i != INP_CHECKSUM_INDEX)
+        {
+            checksum += dataOutBuffer[i];
+        }
     }
-  }
+    // Add the read pointer
+    checksum += ((currIncomingPacket->pointer + 8) >> 0) & 0xFF;
+    checksum += ((currIncomingPacket->pointer + 8) >> 8) & 0xFF;
 
-  currIncomingPacket->latestError = PACKET_SUCCESS;
-  PTGB_MGBA_INFO("Packet success: packet=%u cmd=%d recv=%X %X %X %X %X %X %X %X",
-                 currIncomingPacket->packetID,
-                 currIncomingPacket->command,
-                 currIncomingPacket->recievedData[0],
-                 currIncomingPacket->recievedData[1],
-                 currIncomingPacket->recievedData[2],
-                 currIncomingPacket->recievedData[3],
-                 currIncomingPacket->recievedData[4],
-                 currIncomingPacket->recievedData[5],
-                 currIncomingPacket->recievedData[6],
-                 currIncomingPacket->recievedData[7]);
-  return true;
+    checksum &= 0x7F;
+
+    byte lsbByte =
+        dataOutBuffer[INP_LSB_INDEX] | dataOutBuffer[INP_LSB_INDEX + 1];
+    for (int i = 0; i < 8; i++)
+    {
+        currIncomingPacket->recievedData[i] =
+            (dataOutBuffer[INP_DATA_INDEX + i] << 1) |
+            ((lsbByte >> (7 - i)) & 0b1);
+    }
+
+    PTGB_MGBA_INFO(
+        "Packet decoded: packet=%u cmd=%d lsb=%X/%X checksumExpected=%X "
+        "checksumGot=%X recv=%X %X %X %X %X %X %X %X",
+        currIncomingPacket->packetID, currIncomingPacket->command,
+        dataOutBuffer[INP_LSB_INDEX], dataOutBuffer[INP_LSB_INDEX + 1],
+        checksum, dataOutBuffer[INP_CHECKSUM_INDEX],
+        currIncomingPacket->recievedData[0],
+        currIncomingPacket->recievedData[1],
+        currIncomingPacket->recievedData[2],
+        currIncomingPacket->recievedData[3],
+        currIncomingPacket->recievedData[4],
+        currIncomingPacket->recievedData[5],
+        currIncomingPacket->recievedData[6],
+        currIncomingPacket->recievedData[7]);
+
+    if (checksum != dataOutBuffer[INP_CHECKSUM_INDEX])
+    {
+        // The checksum has to match in order for it to be valid, if we've made
+        // it this far down the line.
+        currIncomingPacket->latestError = CHECKSUM_MISMATCH;
+        PTGB_MGBA_INFO(
+            "Packet checksum mismatch: packet=%u cmd=%d expected=%X got=%X",
+            currIncomingPacket->packetID, currIncomingPacket->command, checksum,
+            dataOutBuffer[INP_CHECKSUM_INDEX]);
+        return false;
+    }
+
+    if ((currIncomingPacket->command != CMD_ReadDataRequest) &&
+        (dataOutBuffer[INP_DATA_INDEX] & 0x80))
+    {
+        currIncomingPacket->latestError = ERROR_FLAG;
+        PTGB_MGBA_INFO("Packet reports GB command failure: packet=%u cmd=%d "
+                       "encodedFirstData=%X decodedFirstData=%X",
+            currIncomingPacket->packetID, currIncomingPacket->command,
+            dataOutBuffer[INP_DATA_INDEX], currIncomingPacket->recievedData[0]);
+        return false;
+    }
+
+    if (currIncomingPacket->command != CMD_ReadDataRequest)
+    {
+        // These command types will echo the first 8 bytes of the packet back to
+        // verify they were recieved correctly. Make sure that's the case. This
+        // will also fail if a secondary packet fails
+        if (currIncomingPacket->recievedData[0] !=
+                currIncomingPacket->packetID ||
+            currIncomingPacket->recievedData[1] !=
+                currIncomingPacket->command ||
+            currIncomingPacket->recievedData[2] !=
+                currIncomingPacket->argument[0] ||
+            currIncomingPacket->recievedData[3] !=
+                currIncomingPacket->argument[1] ||
+            currIncomingPacket->recievedData[4] !=
+                ((currIncomingPacket->pointer >> 0) & 0xFF) ||
+            currIncomingPacket->recievedData[5] !=
+                ((currIncomingPacket->pointer >> 8) & 0xFF) ||
+            currIncomingPacket->recievedData[6] != 0xFF ||
+            currIncomingPacket->recievedData[7] != 0xFF)
+        {
+            currIncomingPacket->latestError = ECHO_MISMATCH;
+            PTGB_MGBA_INFO("Packet echo mismatch: packet=%u cmd=%d recv=%X %X "
+                           "%X %X %X %X %X %X",
+                currIncomingPacket->packetID, currIncomingPacket->command,
+                currIncomingPacket->recievedData[0],
+                currIncomingPacket->recievedData[1],
+                currIncomingPacket->recievedData[2],
+                currIncomingPacket->recievedData[3],
+                currIncomingPacket->recievedData[4],
+                currIncomingPacket->recievedData[5],
+                currIncomingPacket->recievedData[6],
+                currIncomingPacket->recievedData[7]);
+            return false;
+        }
+    }
+
+    currIncomingPacket->latestError = PACKET_SUCCESS;
+    PTGB_MGBA_INFO(
+        "Packet success: packet=%u cmd=%d recv=%X %X %X %X %X %X %X %X",
+        currIncomingPacket->packetID, currIncomingPacket->command,
+        currIncomingPacket->recievedData[0],
+        currIncomingPacket->recievedData[1],
+        currIncomingPacket->recievedData[2],
+        currIncomingPacket->recievedData[3],
+        currIncomingPacket->recievedData[4],
+        currIncomingPacket->recievedData[5],
+        currIncomingPacket->recievedData[6],
+        currIncomingPacket->recievedData[7]);
+    return true;
 }
 
 void LinkConnection::consumePacket()
 {
-  /*
-  ----------------
-  For this part, the LinkConnection has an array of 4 packets that it will send.
-  The current packet will be sent and a response will be recieved at the same time. If the recieved packet is
-  successful, the data will be moved to the outArray and the packet will be replaced by a packet asking for the next data section.
-  If the packet was not successful it will stay in the list and be ran again down the line. If packets have been sent for all the
-  data sections, a completed packet will be replaced with an empty packet. Once the array is full of empty packets, the data
-  has all been read and we are finished.
-  ----------------
-*/
-  if (currIncomingPacket->latestError == PACKET_SUCCESS)
-  {
-    // Packet was successful, Find which packet sent it and mark it.
-    // If this was data, then save the data and replace it with the next one in line
-    currIncomingPacket->latestError = PACKET_READ;
-    if (currIncomingPacket->command == CMD_ReadDataRequest)
+    /*
+    ----------------
+    For this part, the LinkConnection has an array of 4 packets that it will
+    send. The current packet will be sent and a response will be recieved at the
+    same time. If the recieved packet is successful, the data will be moved to
+    the outArray and the packet will be replaced by a packet asking for the next
+    data section. If the packet was not successful it will stay in the list and
+    be ran again down the line. If packets have been sent for all the data
+    sections, a completed packet will be replaced with an empty packet. Once the
+    array is full of empty packets, the data has all been read and we are
+    finished.
+    ----------------
+  */
+    if (currIncomingPacket->latestError == PACKET_SUCCESS)
     {
-      for (int i = 0; i < 8; i++)
-      {
-        if (((currIncomingPacket->pointer - linkPacketDataStart) + i) < linkPacketDataSize)
+        // Packet was successful, Find which packet sent it and mark it.
+        // If this was data, then save the data and replace it with the next one
+        // in line
+        currIncomingPacket->latestError = PACKET_READ;
+        if (currIncomingPacket->command == CMD_ReadDataRequest)
         {
-          outDataArrayPtr[(currIncomingPacket->pointer - linkPacketDataStart) + i] = currIncomingPacket->recievedData[i];
+            for (int i = 0; i < 8; i++)
+            {
+                if (((currIncomingPacket->pointer - linkPacketDataStart) + i) <
+                    linkPacketDataSize)
+                {
+                    outDataArrayPtr[(currIncomingPacket->pointer -
+                                        linkPacketDataStart) +
+                                    i] = currIncomingPacket->recievedData[i];
+                }
+            }
+            // Do we have more data to read?
+            if ((linkPacketDataAddr - linkPacketDataStart) < linkPacketDataSize)
+            {
+                *currIncomingPacket = LinkPacket(
+                    CMD_ReadDataRequest, 0x00, 0x00, linkPacketDataAddr);
+                linkPacketDataAddr += 8;
+            }
+            else
+            {
+                // Mark the packet as out of use, we've gotten all the data we
+                // need.
+                currIncomingPacket->inUse = false;
+            }
+        }
+        else
+        {
+            // Command was not a data request, don't do anything.
         }
-      }
-      // Do we have more data to read?
-      if ((linkPacketDataAddr - linkPacketDataStart) < linkPacketDataSize)
-      {
-        *currIncomingPacket = LinkPacket(CMD_ReadDataRequest, 0x00, 0x00, linkPacketDataAddr);
-        linkPacketDataAddr += 8;
-      }
-      else
-      {
-        // Mark the packet as out of use, we've gotten all the data we need.
-        currIncomingPacket->inUse = false;
-      }
     }
     else
     {
-      // Command was not a data request, don't do anything.
+        // Packet failed, don't remove it.
     }
-  }
-  else
-  {
-    // Packet failed, don't remove it.
-  }
 }
 
 bool LinkConnection::prepareNextPacket()
 {
-  for (int i = 0; i < LINK_PACKET_ARRAY_SIZE - 1; i++)
-  {
-    linkPacketArrIndex = (linkPacketArrIndex + 1) & LINK_PACKET_INDEX_MASK;
-
-    LinkPacket *candidate = &linkPacketArr[linkPacketArrIndex % LINK_PACKET_ARRAY_SIZE];
-
-    if (candidate->inUse && candidate->latestError != PACKET_READ)
+    for (int i = 0; i < LINK_PACKET_ARRAY_SIZE - 1; i++)
     {
-      currOutgoingPacket = candidate;
-      return true;
+        linkPacketArrIndex = (linkPacketArrIndex + 1) & LINK_PACKET_INDEX_MASK;
+
+        LinkPacket *candidate =
+            &linkPacketArr[linkPacketArrIndex % LINK_PACKET_ARRAY_SIZE];
+
+        if (candidate->inUse && candidate->latestError != PACKET_READ)
+        {
+            currOutgoingPacket = candidate;
+            return true;
+        }
     }
-  }
-  // We're back where we started. Send the dummy packet to get a response.
-  currOutgoingPacket = &dummyPacket;
-  return false;
+    // We're back where we started. Send the dummy packet to get a response.
+    currOutgoingPacket = &dummyPacket;
+    return false;
 }
 
 bool LinkConnection::allPacketsProcessed()
 {
-  for (int i = 0; i < LINK_PACKET_ARRAY_SIZE; i++)
-  {
-    if (linkPacketArr[i].inUse && linkPacketArr[i].latestError != PACKET_READ)
+    for (int i = 0; i < LINK_PACKET_ARRAY_SIZE; i++)
     {
-      return false;
+        if (linkPacketArr[i].inUse &&
+            linkPacketArr[i].latestError != PACKET_READ)
+        {
+            return false;
+        }
     }
-  }
-  return true;
+    return true;
 }
 
 void LinkConnection::resetLinkPackets()
 {
-  for (int i = 0; i < LINK_PACKET_ARRAY_SIZE; i++)
-  {
-    linkPacketArr[i] = LinkPacket();
-  }
+    for (int i = 0; i < LINK_PACKET_ARRAY_SIZE; i++)
+    {
+        linkPacketArr[i] = LinkPacket();
+    }
 
-  // Loop the packet index around back to 0
-  while (linkPacketArrIndex % LINK_PACKET_ARRAY_SIZE != 0)
-  {
-    linkPacketArrIndex = (linkPacketArrIndex + 1) & LINK_PACKET_INDEX_MASK;
-  }
+    // Loop the packet index around back to 0
+    while (linkPacketArrIndex % LINK_PACKET_ARRAY_SIZE != 0)
+    {
+        linkPacketArrIndex = (linkPacketArrIndex + 1) & LINK_PACKET_INDEX_MASK;
+    }
 
-  // Set the current outgoing packet to be the first in order.
-  currOutgoingPacket = &linkPacketArr[0];
-  // And set the incoming packet to nullptr since we don't know what that is yet.
-  currIncomingPacket = nullptr;
+    // Set the current outgoing packet to be the first in order.
+    currOutgoingPacket = &linkPacketArr[0];
+    // And set the incoming packet to nullptr since we don't know what that is
+    // yet.
+    currIncomingPacket = nullptr;
 
-  for (int i = 0; i < DATA_OUT_BUFFER_SIZE; i++)
-  {
-    dataOutBuffer[i] = 0;
-  }
+    for (int i = 0; i < DATA_OUT_BUFFER_SIZE; i++)
+    {
+        dataOutBuffer[i] = 0;
+    }
 }
 
 void LinkConnection::waitForEnd()
 {
-  while (enterState != END)
-  {
-    handleCartIO();
-    VBlankIntrWait();
-  }
+    while (enterState != END)
+    {
+        handleCartIO();
+        VBlankIntrWait();
+    }
 }
 
 bool LinkConnection::LinkCommand_InitalizeConnection(bool waitForCompletion)
 {
-  if (g_debug_options.ignore_link_cable)
-  {
+    if (g_debug_options.ignore_link_cable)
+    {
+        return true;
+    }
+    else if (!linkSPI->isActive())
+    {
+        return false;
+    }
+
+    PTGB_MGBA_INFO("Running command: InitalizeConnection");
+
+    globalLinkCable.startConnection(INITIAL_CONNECTION);
+
+    if (waitForCompletion)
+    {
+        waitForEnd();
+    }
+
     return true;
-  }
-  else if (!linkSPI->isActive())
-  {
-    return false;
-  }
-
-  PTGB_MGBA_INFO("Running command: InitalizeConnection");
-
-  globalLinkCable.startConnection(INITIAL_CONNECTION);
-
-  if (waitForCompletion)
-  {
-    waitForEnd();
-  }
-
-  return true;
 }
 
 bool LinkConnection::LinkCommand_ReloadCurrentBox(bool waitForCompletion)
 {
-  if (g_debug_options.ignore_link_cable)
-  {
+    if (g_debug_options.ignore_link_cable)
+    {
+        return true;
+    }
+    else if (!linkSPI->isActive())
+    {
+        return false;
+    }
+
+    PTGB_MGBA_INFO("Running command: ReloadCurrentBox");
+
+    resetLinkPackets();
+
+    linkPacketArr[0] = LinkPacket(
+        CMD_ReloadCurrentBox, 0x00, 0x00, determinePacketArrivalAddress(gen));
+
+    globalLinkCable.startConnection(PACKET_EXCHANGE);
+    if (waitForCompletion)
+    {
+        waitForEnd();
+    }
     return true;
-  }
-  else if (!linkSPI->isActive())
-  {
-    return false;
-  }
-  
-  PTGB_MGBA_INFO("Running command: ReloadCurrentBox");
-
-  resetLinkPackets();
-
-  linkPacketArr[0] = LinkPacket(CMD_ReloadCurrentBox, 0x00, 0x00, determinePacketArrivalAddress(gen));
-
-  globalLinkCable.startConnection(PACKET_EXCHANGE);
-  if (waitForCompletion)
-  {
-    waitForEnd();
-  }
-  return true;
 };
 
-bool LinkConnection::LinkCommand_TransferPokemon(int boxNumber, byte removalArray[], int removalArrayLength, bool waitForCompletion)
+bool LinkConnection::LinkCommand_TransferPokemon(int boxNumber,
+    byte removalArray[], int removalArrayLength, bool waitForCompletion)
 {
-  if (g_debug_options.ignore_link_cable)
-  {
-    return true;
-  }
-  else if (!linkSPI->isActive())
-  {
-    return false;
-  }
+    if (g_debug_options.ignore_link_cable)
+    {
+        return true;
+    }
+    else if (!linkSPI->isActive())
+    {
+        return false;
+    }
 
-  int maxBoxes = 0;
-  if (gen == 1)
-  {
-    if (lang == JAPANESE)
+    int maxBoxes = 0;
+    if (gen == 1)
     {
-      maxBoxes = 8;
-    }
-    else
-    {
-      maxBoxes = 12;
-    }
-  }
-  else
-  {
         if (lang == JAPANESE)
-    {
-      maxBoxes = 9;
+        {
+            maxBoxes = 8;
+        }
+        else
+        {
+            maxBoxes = 12;
+        }
     }
     else
     {
-      maxBoxes = 14;
+        if (lang == JAPANESE)
+        {
+            maxBoxes = 9;
+        }
+        else
+        {
+            maxBoxes = 14;
+        }
     }
-  }
 
-  if (boxNumber >= maxBoxes)
-  {
-    return false;
-  }
-  
-  PTGB_MGBA_INFO("Running command: TransferPokemon");
+    if (boxNumber >= maxBoxes)
+    {
+        return false;
+    }
 
-  resetLinkPackets();
+    PTGB_MGBA_INFO("Running command: TransferPokemon");
 
-  linkPacketArr[0] = LinkPacket(CMD_TransferPokemon, removalArrayLength + SECONDARY_PAYLOAD_HEADER_SIZE, boxNumber, determinePacketArrivalAddress(gen));
-  linkPacketArr[0].loadSecondaryPayload(removalArray, removalArrayLength);
+    resetLinkPackets();
 
-  // REG_TM3D = -0x4000 / 60;
+    linkPacketArr[0] = LinkPacket(CMD_TransferPokemon,
+        removalArrayLength + SECONDARY_PAYLOAD_HEADER_SIZE, boxNumber,
+        determinePacketArrivalAddress(gen));
+    linkPacketArr[0].loadSecondaryPayload(removalArray, removalArrayLength);
 
-  globalLinkCable.startConnection(PACKET_EXCHANGE);
-  if (waitForCompletion)
-  {
-    waitForEnd();
-  }
-  return true;
+    // REG_TM3D = -0x4000 / 60;
+
+    globalLinkCable.startConnection(PACKET_EXCHANGE);
+    if (waitForCompletion)
+    {
+        waitForEnd();
+    }
+    return true;
 };
 
 bool LinkConnection::LinkCommand_SoftReset(bool waitForCompletion)
 {
-  if (g_debug_options.ignore_link_cable)
-  {
-    return true;
-  }
-  else if (!linkSPI->isActive())
-  {
-    return false;
-  }
-
-  PTGB_MGBA_INFO("Running command: SoftReset");
-
-  resetLinkPackets();
-
-  linkPacketArr[0] = LinkPacket(CMD_SoftReset, 0x00, 0x00, determinePacketArrivalAddress(gen));
-
-  globalLinkCable.startConnection(PACKET_EXCHANGE);
-  if (waitForCompletion)
-  {
-    waitForEnd();
-  }
-  return true;
-};
-
-bool LinkConnection::LinkCommand_ModifySRAMAccess(bool enableSRAM, byte SRAMbank, bool waitForCompletion)
-{
-  if (g_debug_options.ignore_link_cable)
-  {
-    return true;
-  }
-  else if (!linkSPI->isActive())
-  {
-    return false;
-  }
-  
-  if (SRAMbank > 3)
-  {
-    return false;
-  }
-
-  PTGB_MGBA_INFO("Running command: ModifySRAMAccess");
-
-  resetLinkPackets();
-
-  if (enableSRAM)
-  {
-    linkPacketArr[0] = LinkPacket(CMD_ModifySRAMAccess, 0x0A, SRAMbank, determinePacketArrivalAddress(gen));
-  }
-  else
-  {
-    linkPacketArr[0] = LinkPacket(CMD_ModifySRAMAccess, 0x00, 0x00, determinePacketArrivalAddress(gen));
-  }
-
-  globalLinkCable.startConnection(PACKET_EXCHANGE);
-  if (waitForCompletion)
-  {
-    waitForEnd();
-  }
-  return true;
-};
-
-bool LinkConnection::LinkCommand_RunSecondaryPayload(byte payload[], int payloadLength, bool waitForCompletion)
-{
-  if (g_debug_options.ignore_link_cable)
-  {
-    return true;
-  }
-  else if (!linkSPI->isActive())
-  {
-    return false;
-  }
-
-  PTGB_MGBA_INFO("Running command: RunSecondaryPayload");
-
-  resetLinkPackets();
-
-  linkPacketArr[0] = LinkPacket(CMD_RunSecondaryPayload, payloadLength + SECONDARY_PAYLOAD_HEADER_SIZE, 0x00, determinePacketArrivalAddress(gen));
-  linkPacketArr[0].loadSecondaryPayload(payload, payloadLength);
-
-  globalLinkCable.startConnection(PACKET_EXCHANGE);
-  if (waitForCompletion)
-  {
-    waitForEnd();
-  }
-  return true;
-};
-
-bool LinkConnection::LinkCommand_ReadMemorySection(u32 dataPointer, byte outArray[], int outArraySize, bool waitForCompletion)
-{
-  if (g_debug_options.ignore_link_cable)
-  {
-    return true;
-  }
-  else if (!linkSPI->isActive())
-  {
-    return false;
-  }
-
-  if (dataPointer > 0xFFFF)
-  {
-    waitForCompletion = true; // We have to wait for completion with the SRAM bank loading, so we can close it
-    LinkCommand_ModifySRAMAccess(true, dataPointer >> 16);
-  }
-
-  PTGB_MGBA_INFO("Running command: ReadMemorySection");
-
-  resetLinkPackets();
-
-  linkPacketDataStart = dataPointer;
-  linkPacketDataSize = outArraySize;
-  linkPacketDataAddr = dataPointer & 0xFFFF;
-  outDataArrayPtr = outArray;
-
-  for (int i = 0; i < LINK_PACKET_ARRAY_SIZE; i++)
-  {
-    if ((i * 8) < linkPacketDataSize)
+    if (g_debug_options.ignore_link_cable)
     {
-      linkPacketArr[i] = LinkPacket(CMD_ReadDataRequest, 0x00, 0x00, linkPacketDataAddr);
-      linkPacketDataAddr += 8;
+        return true;
+    }
+    else if (!linkSPI->isActive())
+    {
+        return false;
+    }
+
+    PTGB_MGBA_INFO("Running command: SoftReset");
+
+    resetLinkPackets();
+
+    linkPacketArr[0] = LinkPacket(
+        CMD_SoftReset, 0x00, 0x00, determinePacketArrivalAddress(gen));
+
+    globalLinkCable.startConnection(PACKET_EXCHANGE);
+    if (waitForCompletion)
+    {
+        waitForEnd();
+    }
+    return true;
+};
+
+bool LinkConnection::LinkCommand_ModifySRAMAccess(
+    bool enableSRAM, byte SRAMbank, bool waitForCompletion)
+{
+    if (g_debug_options.ignore_link_cable)
+    {
+        return true;
+    }
+    else if (!linkSPI->isActive())
+    {
+        return false;
+    }
+
+    if (SRAMbank > 3)
+    {
+        return false;
+    }
+
+    PTGB_MGBA_INFO("Running command: ModifySRAMAccess");
+
+    resetLinkPackets();
+
+    if (enableSRAM)
+    {
+        linkPacketArr[0] = LinkPacket(CMD_ModifySRAMAccess, 0x0A, SRAMbank,
+            determinePacketArrivalAddress(gen));
     }
     else
     {
-      linkPacketArr[i] = dummyPacket;
+        linkPacketArr[0] = LinkPacket(CMD_ModifySRAMAccess, 0x00, 0x00,
+            determinePacketArrivalAddress(gen));
     }
-  }
 
-  globalLinkCable.startConnection(PACKET_EXCHANGE);
-  if (waitForCompletion)
-  {
-    waitForEnd();
-  }
+    globalLinkCable.startConnection(PACKET_EXCHANGE);
+    if (waitForCompletion)
+    {
+        waitForEnd();
+    }
+    return true;
+};
 
-  LinkCommand_ModifySRAMAccess(false, dataPointer >> 16);
+bool LinkConnection::LinkCommand_RunSecondaryPayload(
+    byte payload[], int payloadLength, bool waitForCompletion)
+{
+    if (g_debug_options.ignore_link_cable)
+    {
+        return true;
+    }
+    else if (!linkSPI->isActive())
+    {
+        return false;
+    }
 
-  return true;
+    PTGB_MGBA_INFO("Running command: RunSecondaryPayload");
+
+    resetLinkPackets();
+
+    linkPacketArr[0] = LinkPacket(CMD_RunSecondaryPayload,
+        payloadLength + SECONDARY_PAYLOAD_HEADER_SIZE, 0x00,
+        determinePacketArrivalAddress(gen));
+    linkPacketArr[0].loadSecondaryPayload(payload, payloadLength);
+
+    globalLinkCable.startConnection(PACKET_EXCHANGE);
+    if (waitForCompletion)
+    {
+        waitForEnd();
+    }
+    return true;
+};
+
+bool LinkConnection::LinkCommand_ReadMemorySection(
+    u32 dataPointer, byte outArray[], int outArraySize, bool waitForCompletion)
+{
+    if (g_debug_options.ignore_link_cable)
+    {
+        return true;
+    }
+    else if (!linkSPI->isActive())
+    {
+        return false;
+    }
+
+    if (dataPointer > 0xFFFF)
+    {
+        waitForCompletion = true; // We have to wait for completion with the
+                                  // SRAM bank loading, so we can close it
+        LinkCommand_ModifySRAMAccess(true, dataPointer >> 16);
+    }
+
+    PTGB_MGBA_INFO("Running command: ReadMemorySection");
+
+    resetLinkPackets();
+
+    linkPacketDataStart = dataPointer;
+    linkPacketDataSize = outArraySize;
+    linkPacketDataAddr = dataPointer & 0xFFFF;
+    outDataArrayPtr = outArray;
+
+    for (int i = 0; i < LINK_PACKET_ARRAY_SIZE; i++)
+    {
+        if ((i * 8) < linkPacketDataSize)
+        {
+            linkPacketArr[i] =
+                LinkPacket(CMD_ReadDataRequest, 0x00, 0x00, linkPacketDataAddr);
+            linkPacketDataAddr += 8;
+        }
+        else
+        {
+            linkPacketArr[i] = dummyPacket;
+        }
+    }
+
+    globalLinkCable.startConnection(PACKET_EXCHANGE);
+    if (waitForCompletion)
+    {
+        waitForEnd();
+    }
+
+    LinkCommand_ModifySRAMAccess(false, dataPointer >> 16);
+
+    return true;
 }
\ No newline at end of file
diff --git a/source/linker_optimizations.cpp b/source/linker_optimizations.cpp
index 5dcee85..4c90fbe 100644
--- a/source/linker_optimizations.cpp
+++ b/source/linker_optimizations.cpp
@@ -1,873 +1,886 @@
 #include <cstdarg>
-#include <ctype.h>
 #include <cstdlib>
+#include <ctype.h>
 #include <errno.h>
 
 #include <sys/iosupport.h>
 
 // Okay, let's go over the basics of this file for a moment.
-// By default, a lot of code is getting pulled in by the linker from static libraries such as newlibc and libtonc.
-// The problem is that everytime a single symbol/function is needed from one of the .o files inside one of these static libs,
-// the entire .o file is getting pulled in, alongside all of ITS dependencies. This cascades pretty quickly.
-// So this pulls in a lot of unnecessary code, but also (global) variables.
-// To solve that, we can try to override these functions by defining a custom version of them here.
-// But to avoid still pulling in the .o file, we have to define every symbol that could be referenced somehow in either our code or the static libraries themselves.
-// Worst case, this means we have to redefine every single function that is defined in that .o file.
-// But doing so, means we can modify the code slightly to avoid pulling in a lot of bloat. we don't need.
+// By default, a lot of code is getting pulled in by the linker from static
+// libraries such as newlibc and libtonc. The problem is that everytime a single
+// symbol/function is needed from one of the .o files inside one of these static
+// libs, the entire .o file is getting pulled in, alongside all of ITS
+// dependencies. This cascades pretty quickly. So this pulls in a lot of
+// unnecessary code, but also (global) variables. To solve that, we can try to
+// override these functions by defining a custom version of them here. But to
+// avoid still pulling in the .o file, we have to define every symbol that could
+// be referenced somehow in either our code or the static libraries themselves.
+// Worst case, this means we have to redefine every single function that is
+// defined in that .o file. But doing so, means we can modify the code slightly
+// to avoid pulling in a lot of bloat. we don't need.
 
-// HACK: Avoid pulling in a large handles buffer, which we don't need. Only define the minimum.
+// HACK: Avoid pulling in a large handles buffer, which we don't need. Only
+// define the minimum.
 
 #define MAX_HANDLES 3
 
-static __handle __stdin_handle  = {0, 1, NULL};
+static __handle __stdin_handle = {0, 1, NULL};
 static __handle __stdout_handle = {1, 1, NULL};
 static __handle __stderr_handle = {2, 1, NULL};
 
-static __handle* handles[MAX_HANDLES] = {
-	&__stdin_handle,
-	&__stdout_handle,
-	&__stderr_handle
-};
+static __handle *handles[MAX_HANDLES] = {
+    &__stdin_handle, &__stdout_handle, &__stderr_handle};
 
 extern "C"
 {
-// HACK:
-// Unfortunately, libtonc references siscanf, which in turn causes a "lot" of binary bloat from newlibc (in regards to locale support)
-// to be pulled in by the linker.
-// However, if you look at what it is actually used for (in libtonc's tte_iohook.c), is just to extract 1 or 2 integers from a string
-// by specifying a custom -extremely simplified- version, we can avoid pulling in the version from libc (alongside all the symbols IT references)
-// Obviously it doesn't support everything it should. Just enough to support libtonc's current iteration.
-//
-// Anyway, doing this optimizes away a lot of scanf related functions from newlib and locale support among which a 13KB "categories" symbol.
-int siscanf(const char *str, const char *format, ...)
-{
-    bool expectingFormatSpecifier = false;
-    va_list args;
-    int* resultVal;
-    int ret = 0;
-    va_start(args, format);
-
-    while(*format != '\0')
+    // HACK:
+    // Unfortunately, libtonc references siscanf, which in turn causes a "lot"
+    // of binary bloat from newlibc (in regards to locale support) to be pulled
+    // in by the linker. However, if you look at what it is actually used for
+    // (in libtonc's tte_iohook.c), is just to extract 1 or 2 integers from a
+    // string by specifying a custom -extremely simplified- version, we can
+    // avoid pulling in the version from libc (alongside all the symbols IT
+    // references) Obviously it doesn't support everything it should. Just
+    // enough to support libtonc's current iteration.
+    //
+    // Anyway, doing this optimizes away a lot of scanf related functions from
+    // newlib and locale support among which a 13KB "categories" symbol.
+    int siscanf(const char *str, const char *format, ...)
     {
-        if(*str == '\0')
-        {
-            //EOF encountered.
-            return -1;
-        }
+        bool expectingFormatSpecifier = false;
+        va_list args;
+        int *resultVal;
+        int ret = 0;
+        va_start(args, format);
 
-        if(expectingFormatSpecifier)
+        while (*format != '\0')
         {
-            if(*format == 'd')
+            if (*str == '\0')
             {
-                resultVal = va_arg(args, int*);
-                (*resultVal) = 0;
-                while(isdigit(*str))
-                {
-                    (*resultVal) *= 10;
-                    (*resultVal) += (*str) - '0';
-                    ++str;
-                }
-                // go back to the last character of the int, because we'll forward by one again at the end of the outer loop
-                --str;
-                ++ret;
+                // EOF encountered.
+                return -1;
             }
-            expectingFormatSpecifier = false;
-        }
-        else if((*format) == '%')
-        {
-            expectingFormatSpecifier = true;
+
+            if (expectingFormatSpecifier)
+            {
+                if (*format == 'd')
+                {
+                    resultVal = va_arg(args, int *);
+                    (*resultVal) = 0;
+                    while (isdigit(*str))
+                    {
+                        (*resultVal) *= 10;
+                        (*resultVal) += (*str) - '0';
+                        ++str;
+                    }
+                    // go back to the last character of the int, because we'll
+                    // forward by one again at the end of the outer loop
+                    --str;
+                    ++ret;
+                }
+                expectingFormatSpecifier = false;
+            }
+            else if ((*format) == '%')
+            {
+                expectingFormatSpecifier = true;
+            }
+
+            ++format;
+            ++str;
         }
 
-        ++format;
-        ++str;
+        va_end(args);
+        return ret;
     }
 
-    va_end(args);
-    return ret;
-}
+    // HACK: stub the libsysbase_libsysbase_a-handle_manager.o functions
+    // this, alongside the -Wl,--wrap linker options ensures that this object
+    // file and its 4KB IWRAM "handles" buffer is not getting pulled in by the
+    // linker. We don't need it and we could use the 4KB of extra IWRAM!
+    __handle *__wrap___get_handle(int fd)
+    {
+        if (fd < 0 || fd >= MAX_HANDLES)
+            return NULL;
 
-// HACK: stub the libsysbase_libsysbase_a-handle_manager.o functions
-// this, alongside the -Wl,--wrap linker options ensures that this object file
-// and its 4KB IWRAM "handles" buffer is not getting pulled in by the linker.
-// We don't need it and we could use the 4KB of extra IWRAM!
-__handle *__wrap___get_handle(int fd)
-{
-	if ( fd < 0 || fd >= MAX_HANDLES ) return NULL;
+        return handles[fd];
+    }
 
-	return handles[fd];
-}
+    int __wrap__close_r(struct _reent *ptr, int fd) { return 0; }
 
-int __wrap__close_r(struct _reent *ptr, int fd)
-{
-	return 0;
-}
-
-// HACK: The functions below were defined here to avoid pulling in the verdana9 font (4 KB) into the rom, which we're not using.
-// The original function in libtonc would use verdana9 as a default if the specified font was NULL.
+// HACK: The functions below were defined here to avoid pulling in the verdana9
+// font (4 KB) into the rom, which we're not using. The original function in
+// libtonc would use verdana9 as a default if the specified font was NULL.
+#include <string.h>
+#include <tonc_bios.h>
 #include <tonc_tte.h>
 #include <tonc_video.h>
-#include <tonc_bios.h>
-#include <string.h>
-
-//! Initialize text system for 4bpp tiled, column-major surfaces.
-/*!	
-	\param bgnr		Background number.
-	\param bgcnt	Background control flags.
-	\param se0		Base offset for screen-entries.
-	\param cattrs	Color attributes; one byte per attr.
-	\param clrs		ink(/shadow) colors.
-	\param font		Font to initialize with.
-	\param proc		Glyph renderer
-*/
-void tte_init_chr4c(int bgnr, u16 bgcnt, u16 se0, u32 cattrs, u32 clrs, 
-	const TFont *font, fnDrawg proc)
-{
-	if(proc==NULL)	proc= chr4c_drawg_default;
-
-	tte_init_base(font, proc, chr4c_erase);
-
-	TTC *tc= tte_get_context();
-	TSurface *srf= &tc->dst;
-
-	srf_init(srf, SRF_CHR4C, 
-		&tile_mem[BFN_GET(bgcnt, BG_CBB)][se0 & SE_ID_MASK], 
-		SCREEN_WIDTH, SCREEN_HEIGHT, 4, pal_bg_mem);
-	schr4c_prep_map(srf, se_mem[BFN_GET(bgcnt, BG_SBB)], se0);
-
-	tc->flags0= bgnr;
-	tc->ctrl= bgcnt;
-	REG_BGCNT[bgnr]= bgcnt;
-
-	// --- Init color attributes ---
-	u32 ink, shadow, paper; //spec;
-	ink=	 cattrs     & 15;
-	shadow=	(cattrs>> 8)& 15;
-	paper=	(cattrs>>16)& 15;
-	//spec=   (cattrs>>24)&255;
-
-	tc->cattr[TTE_INK]= ink;
-	tc->cattr[TTE_SHADOW]= shadow;
-	tc->cattr[TTE_PAPER]= paper;
-	//tc->cattr[TTE_SPECIAL]= 0;
-
-	srf->palData= pal_bg_bank[se0>>12];
-	srf->palData[ink]= clrs&0xFFFF;
-	srf->palData[shadow]= clrs>>16;
-}
-
-void chr4c_erase(int left, int top, int right, int bottom)
-{	
-	TTC *tc= tte_get_context();
-
-	//# Check for single sequence
-	schr4c_rect(&tc->dst, left, top, right, bottom, tc->cattr[TTE_PAPER]);
-}
-
-// HACK: We need to replace the entirety of tte_main.c in libtonc to avoid pulling in sys8font (because it's used as a default in tte_init_base() if the specified font is NULL)
-// So here's a modified version of tte_main.c (only tte_init_base() is really changed though):
-//////////////////////// tte_main.c ////////////////////////
-
-// --------------------------------------------------------------------
-// CONSTANTS
-// --------------------------------------------------------------------
-
-// --------------------------------------------------------------------
-// GLOBALS
-// --------------------------------------------------------------------
-
-TTC	__tte_main_context;
-TTC	*gp_tte_context= &__tte_main_context;
-
-
-// --------------------------------------------------------------------
-// INLINES
-// --------------------------------------------------------------------
-
-INLINE char *eatwhite(const char *str)
-{
-	while(isspace(*str))
-		str++;
-
-	return (char*)str;
-}
-
-// --------------------------------------------------------------------
-// OPERATIONS
-// --------------------------------------------------------------------
-
-//! Set the master context pointer.
-void tte_set_context(TTC *tc)
-{	
-	gp_tte_context= tc ? tc : &__tte_main_context;
-}
-
-
-//! Set color attribute of \a type to \a cattr.
-void tte_set_color_attr(eint type, u16 cattr)
-{
-	TTC *tc= tte_get_context();
-	tc->cattr[type]= cattr;
-}
-
-//! Load important color attribute data.
-void tte_set_color_attrs(const u16 cattrs[])
-{
-	int ii;
-	TTC *tc= tte_get_context();
-
-	for(ii=0; ii<4; ii++)
-		tc->cattr[ii]= cattrs[ii];
-}
-
-//! Set color attribute of \a type to \a cattr.
-void tte_set_color(eint type, u16 color)
-{
-	TTC *tc= tte_get_context();
-	
-	if(tc->dst.palData != NULL)
-		tc->dst.palData[tc->cattr[type]]= color;
-	else
-		tc->cattr[type]= color;
-}
-
-//! Load important color data.
-void tte_set_colors(const u16 colors[])
-{
-	int ii;
-	TTC *tc= tte_get_context();
-
-	if(tc->dst.palData != NULL)
-		for(ii=0; ii<4; ii++)
-			tc->dst.palData[tc->cattr[ii]]= colors[ii];
-	else
-		for(ii=0; ii<4; ii++)
-			tc->cattr[ii]= colors[ii];
-}
-
-
-//! Base initializer of a TTC.
-void tte_init_base(const TFont *font, fnDrawg drawProc, fnErase eraseProc)
-{
-	if(tte_get_context() == NULL)
-		tte_set_context(&__tte_main_context);
-	
-	TTC *tc= tte_get_context();
-	memset(tc, 0, sizeof(TTC));
-		
-	tc->font= (TFont*)font;
-	tc->drawgProc= drawProc;
-	tc->eraseProc= eraseProc;
-
-	// Default is SBB 0
-	const TSurface srf= { (u8*)se_mem, 32*2, 32, 32, 8, SRF_BMP16, 256, pal_bg_mem };
-	tc->dst = srf;
-
-	tc->cattr[TTE_INK]    = 0xF1;
-	tc->cattr[TTE_SHADOW] = 0xF2;
-	tc->cattr[TTE_PAPER]  = 0;
-	tc->cattr[TTE_SPECIAL]= 0;
-	
-	tc->marginRight= SCREEN_WIDTH;
-	tc->marginBottom= SCREEN_HEIGHT;	
-}
-
-
-// --------------------------------------------------------------------
-// String interpretations
-// --------------------------------------------------------------------
-
-
-//! Retrieve a single multibyte utf8 character.
-uint utf8_decode_char(const char *ptr, char **endptr)
-{
-	uchar *src= (uchar*)ptr;
-	uint ch8, ch32;
-
-	// Poor man's try-catch.
-	do
-	{
-		// UTF8 formats:
-		// 0aaaaaaa                            ->                   0aaaaaaa
-		// 110aaaaa 10bbbbbb                   ->          00000aaa aabbbbbb 
-		// 1110aaaa 10bbbbbb 10cccccc          ->          aaaabbbb bbcccccc
-		// 11110aaa 10bbbbbb 10cccccc 10dddddd -> 000aaabb bbbbcccc ccdddddd
-		// 
-		// Any invalid format will be returned as a single byte.
-
-		ch8= *src;
-		if(ch8 < 0x80)						// 7b
-		{
-			ch32= ch8;
-		}
-		else if(0xC0<=ch8 && ch8<0xE0)		// 11b
-		{
-			ch32  = (*src++&0x1F)<< 6;	if((*src>>6)!=2)	break;
-			ch32 |= (*src++&0x3F)<< 0;
-		}
-		else if(0xE0<=ch8 && ch8<0xF0)		// 16b
-		{
-			ch32  = (*src++&0x0F)<<12;	if((*src>>6)!=2)	break;
-			ch32 |= (*src++&0x3F)<< 6;	if((*src>>6)!=2)	break;
-			ch32 |= (*src++&0x3F)<< 0;
-		}
-		else if(0xF0<=ch8 && ch8<0xF8)		// 21b
-		{
-			ch32  = (*src++&0x0F)<<18;	if((*src>>6)!=2)	break;
-			ch32 |= (*src++&0x3F)<<12;	if((*src>>6)!=2)	break;
-			ch32 |= (*src++&0x3F)<< 6;	if((*src>>6)!=2)	break;
-			ch32 |= (*src++&0x3F)<< 0;
-		}
-		else
-			break;
-
-		// Proper UTF8 char: set endptr and return
-		if(endptr)
-			*endptr= (char*)src;
-
-		return ch32;
-
-	} while(0);
-
-
-	// Not really UTF: interpret as single byte.
-	src= (uchar*)ptr;
-	ch32= *src++;
-	if(endptr)
-		*endptr= (char*)src;
-
-	return ch32;
-}
-
-//! Find the string-position after the command.
-/*!
-	\param str	String to check.
-	\return		The string-pointer after the current/next command.
-		If there is no command-end, this moves to the end of the 
-		string.
-*/
-char *tte_cmd_skip(const char *str)
-{
-	int ch;
-
-	while( (ch= *str) != '\0')
-	{
-		str++;
-		if(ch == '}')
-			break;
-	}
-
-	return (char*)str;
-}
-
-//! Move to the next command in a sequence.
-/*!
-	\return	Position of EOS (\'0'), EOC ('}') or next cmd token (rest)
-*/
-char *tte_cmd_next(const char *str)
-{
-	int ch;
-
-	// Find EOC, separator or NULL
-	while(1)
-	{
-		ch= *str;
-		if(ch == '\0' || ch == '}')		// EOS/EOC
-			return (char*)str;
-		else if(ch == ';')				// More commands
-			break;
-
-		str++;
-	}
-
-	// More commands: try to find next token (or EOS/EOC again)
-	while(1)
-	{
-		ch= *++str;
-		if(ch == '\0' || !isspace(ch))
-			return (char*)str;
-	}
-}
-
-//!	Text command handler.
-/*!	Takes commands formatted as "#{[cmd]:[opt];[[cmd]:[opt];...]} and 
-	deals with them.<br>
-	<br>Command list:
-	- <b>P</b>				Set cursor to margin top-left.
-	- <b>Ps</b>				Save cursor position
-	- <b>Pr</b>				Restore cursor position.
-	- <b>P:\#x,\#y</b>		Set cursorX/Y to \e x, \e y.
-	- <b>X</b>				Set cursorX to margin left.
-	- <b>X:\#x</b>			Set cursorX to \e x.
-	- <b>Y</b>				Set cursorY to margin top.
-	- <b>Y:\#y</b>			Set cursorX to \e y.
-	- <b>c[ispx]:\#val</b>	Set ink/shadow/paper/special color to \e val.
-	- <b>e[slbfr]</b>		Erase screen/line/backward/forward/rect
-	- <b>m:\#l,\#t,\#r,\#b</b>	Set all margins
-	- <b>m[ltrb]:\#val</b>	Set margin to \e val.
-	- <b>p:\#x,\#y</b>		Move cursorX/Y by \e x, \e y.
-	- <b>w:\#val</b>		Wait \e val frame.
-	- <b>x:\#x</b>			Move cursorX by \e x.
-	- <b>y:\#y</b>			Move cursorX by \e y.
-	
-	Examples:<br>
-	- <b>#{X:32}</b>		Move to \e x = 32;
-	- <b>#{ci:0x7FFF}</b>	Set ink color to white.
-	- <b>#{w:120;es;P}</b>	Wait 120 frames, clear screen, return to top of screen.
-	\param str	Start of command. Assumes the initial "\{" is lobbed
-		off already.
-	\return pointer to after the parsed command.
-	\note	Routine does text wrapping. Make sure margins are set.
-	\note	This function involves heavy (yet necessary) 
-		switching. Leave your sanity at the door before viewing.
-	\todo	Scrolling and variables ?
-	\todo	Restructure for safety checks.
-*/
-char *tte_cmd_default(const char *str)
-{
-	int ch, val;
-	char *curr= (char*)str, *next;
-
-	TTC *tc= tte_get_context();
-
-	while(1)
-	{
-		// --- Get cmd char and act on it ---
-		// "Ew, double switches". Yes, I know. I'm not proud.
-		// That behaviour may change later
-
-		ch= *curr;
-		next= curr+1;
-
-		switch(ch)
-		{
-		// --- Absolute Positions ---
-		case 'X':
-			tc->cursorX= curr[1]==':' ? strtol(curr+2, &next, 0) : tc->marginLeft;
-			break;
-		case 'Y':
-			tc->cursorY= curr[1]==':' ? strtol(curr+2, &next, 0) : tc->marginTop;
-			break;
-		case 'P':
-			{
-				switch(curr[1])
-				{
-				case 's':	// Save position
-					tc->savedX= tc->cursorX;
-					tc->savedY= tc->cursorY;
-					break;				
-				case 'r':	// Restore position
-					tc->cursorX= tc->savedX;
-					tc->cursorY= tc->savedY;
-					break;
-				case ':':	// Set position
-					tc->cursorX= strtol(curr+2, &next, 0);
-					curr= eatwhite(next);
-					if(curr[0] == ',')
-						tc->cursorY= strtol(curr+1, &next, 0);
-					break;
-				default:	// Set to top-left of screen
-					tc->cursorX= tc->marginLeft;
-					tc->cursorY= tc->marginTop;
-				}
-			}
-			break;
-
-		// --- Relative Positions ---
-		case 'x':
-			tc->cursorX += strtol(curr+2, &next, 0);
-			break;
-		case 'y':
-			tc->cursorY += strtol(curr+2, &next, 0);
-			break;
-		case 'p':
-			tc->cursorX += strtol(curr+2, &next, 0);
-			curr= eatwhite(next);
-			if(curr[0] == ',')
-				tc->cursorY += strtol(curr+1, &next, 0);
-			break;
-
-		// --- Colors c[ispx]:# ---
-		case 'c':
-			{
-				ch= curr[1];	// index character ("ispx")
-				curr += 3;
-				switch(ch)
-				{
-				case 'i':
-					tc->cattr[TTE_INK]= strtol(curr, &next, 0);
-					break;
-				case 's':		
-					tc->cattr[TTE_SHADOW]= strtol(curr, &next, 0);
-					break;
-				case 'p':
-					tc->cattr[TTE_PAPER]= strtol(curr, &next, 0);
-					break;				
-				case 'x':
-					tc->cattr[TTE_SPECIAL]= strtol(curr, &next, 0);
-					break;
-				}
-				break;
-			}
-
-		// --- Erasing ---
-		case 'e':
-			{
-				switch(curr[1])
-				{
-				case 's':		// screen (within margins)
-					tte_erase_screen();
-					break;
-				case 'l':		// line (within margins)
-					tte_erase_line();
-					break;
-				case 'f':		// line up to cursorX
-					tte_erase_rect(tc->cursorX, tc->cursorY, 
-						tc->marginRight, tc->cursorY+tc->font->charH);
-					break;
-				case 'b':		// line from cursorX
-					tte_erase_rect(tc->marginLeft, tc->cursorY, 
-						tc->cursorX, tc->cursorY+tc->font->charH);
-					break;
-				case 'r':		// rectangle
-					{
-						int rect[4];
-						curr += 3;
-						rect[0]= strtol(curr+0, &next, 0);
-						curr= eatwhite(next);
-						if(curr[0] != ',')
-							break;
-
-						rect[1]= strtol(curr+1, &next, 0);
-						curr= eatwhite(next);
-						if(curr[0] != ',')
-							break;
-
-						rect[2]= strtol(curr+1, &next, 0);
-						curr= eatwhite(next);
-						if(curr[0] != ',')
-							break;
-
-						rect[3]= strtol(curr+1, &next, 0);
-						tte_erase_rect(rect[0], rect[1], rect[2], rect[3]);
-						break;
-					}
-				//# erase character / backspace.
-				}
-			}
-			break;	
-		
-		// --- Margins ---
-		case 'm':
-			{
-				ch= curr[1];	// index character ("ispx")
-				curr += 3;
-				switch(ch)
-				{
-				case 'l':
-					tc->marginLeft= strtol(curr, &next, 0);
-					break;
-				case 't':
-					tc->marginTop= strtol(curr, &next, 0);
-					break;
-				case 'r':
-					tc->marginRight= strtol(curr, &next, 0);
-					break;
-				case 'b':
-					tc->marginBottom= strtol(curr, &next, 0);
-					break;
-				case 's':	// To screen size
-					tc->marginLeft= 0;
-					tc->marginTop= 0;
-					tc->marginRight= SCREEN_WIDTH;
-					tc->marginBottom= SCREEN_HEIGHT;
-					break;
-				case ':':	// Set all margins
-					tc->marginLeft= strtol(curr-1, &next, 0);
-					curr= eatwhite(next);
-					if(curr[0] != ',')
-						break;
-
-					tc->marginTop= strtol(curr+1, &next, 0);
-					curr= eatwhite(next);
-					if(curr[0] != ',')
-						break;
-
-					tc->marginRight= strtol(curr+1, &next, 0);
-					curr= eatwhite(next);
-					if(curr[0] != ',')
-						break;
-
-					tc->marginBottom= strtol(curr+1, &next, 0);
-					break;				
-				}
-			}
-			break;
-
-		// --- Font ---
-		case 'f':
-			val= strtol(curr+2, &next, 0);
-			if(tc->fontTable && tc->fontTable[val])
-				tc->font= (TFont*)tc->fontTable[val];
-			break;
-
-		// --- String ---
-		case's':
-			val= strtol(curr+2, &next, 0);
-			if(tc->stringTable && tc->stringTable[val])
-				tte_write(tc->stringTable[val]);
-			break;
-
-		// --- Wait a few frames ---
-		case 'w':
-			val= strtol(curr+2, &next, 0);
-			VBlankIntrDelay(val);
-			break;
-
-		}	// /main switch
-
-		// Find EOS/EOC/token and act on it
-		curr= tte_cmd_next(next);
-
-		if(curr[0] == '\0')
-			return curr;
-		else if(curr[0] == '}')
-			return curr+1;	
-	}
-}
-
-
-//! Extended string writer, with positional and color info
-int tte_write_ex(int x0, int y0, const char *text, const u16 *cattrs)
-{
-	TTC *tc= tte_get_context();
-	tc->cursorX= x0;
-	tc->cursorY= y0;
-
-	if(cattrs)
-		tte_set_color_attrs(cattrs);
-
-	return tte_write(text);
-}
-
-// Generic TTE putc (to be tested later)
-// NOTE: the glyph inlines seem as fast as manual retrieval, 
-//   even though the former get the TTC and font again as well. 
-//	Yay.
-
-//! Plot a single character; does wrapping too.
-/*!
-	\param ch	Character to plot (not glyph-id).
-	\return		Character width.
-	\note		Overhead: ~70 cycles.
-*/
-int tte_putc(int ch)
-{
-	TTC *tc= tte_get_context();
-	TFont *font= tc->font;
-	
-	uint gid= tte_get_glyph_id(ch);
-	int charW= tte_get_glyph_width(gid);
-	
-	if(tc->cursorX+charW > tc->marginRight)
-	{
-		tc->cursorY += font->charH;
-		tc->cursorX  = tc->marginLeft;
-	}
-
-	// Draw and update position
-	tc->drawgProc(gid);
-	tc->cursorX += charW;
-
-	return charW;
-}
-
-
-//! Render a string.
-/*!
-	\param text	String to parse and write.
-	\return		Number of parsed characters.
-*/
-int	tte_write(const char *text)
-{
-	if(text == NULL)
-		return 0;
-
-	uint ch, gid;
-	char *str= (char*)text;
-	TTC *tc= tte_get_context();
-	TFont *font;
-
-	while( (ch=*str) != '\0' )
-	{
-		str++;
-		switch(ch)
-		{
-		// --- Newline/carriage return ---
-		case '\r':
-			if(str[0] == '\n')	// deal with CRLF pair
-				str++;
-			// FALLTHRU
-		case '\n':
-			tc->cursorY += tc->font->charH;
-			tc->cursorX  = tc->marginLeft;
-			break;
-		// --- Tab ---
-		case '\t':
-			tc->cursorX= (tc->cursorX/TTE_TAB_WIDTH+1)*TTE_TAB_WIDTH;
-			break;
-
-		// --- Normal char ---
-		default:
-			// Command sequence
-			if(ch=='#' && str[0]=='{')
-			{
-				str= tte_cmd_default(str+1);
-				break;
-			}
-			// Escaped command: skip '\\' and print '#'
-			else if(ch=='\\' && str[0]=='#')
-				ch= *str++;
-			// Check for UTF8 code
-			else if(ch>=0x80)
-				ch= utf8_decode_char(str-1, &str);
-
-			// Get glyph index and call renderer
-			font= tc->font;
-			gid= ch - font->charOffset;
-			if(tc->charLut)
-				gid= tc->charLut[gid];
-
-			// Character wrap
-			int charW= font->widths ? font->widths[gid] : font->charW;
-			if(tc->cursorX+charW > tc->marginRight)
-			{
-				tc->cursorY += font->charH;
-				tc->cursorX  = tc->marginLeft;
-			}
-
-			// Draw and update position
-			tc->drawgProc(gid);
-			tc->cursorX += charW;
-		}
-	}
-
-	// Return characters used (PONDER: is this really the right thing?)
-	return str - text;
-}
-
-//! Erase a porttion of the screen (ignores margins)
-void tte_erase_rect(int left, int top, int right, int bottom)
-{
-	TTC *tc= tte_get_context();
-
-	if(tc->eraseProc)
-		tc->eraseProc(left, top, right, bottom);
-}
-
-//! Erase the screen (within the margins).
-/*!
-	\note Ponder: set paper color?
-*/
-void tte_erase_screen()
-{
-	TTC *tc= tte_get_context();
-
-	if(tc->eraseProc)
-		tc->eraseProc(tc->marginLeft, tc->marginTop, 
-			tc->marginRight, tc->marginBottom);
-}
-
-
-//! Erase the whole line (within the margins).
-/*!
-	\note Ponder: set paper color?
-*/
-void tte_erase_line()
-{
-	TTC *tc= tte_get_context();
-	int height= tc->font->charH;
-
-	if(tc->eraseProc)
-		tc->eraseProc(tc->marginLeft, tc->cursorY, 
-			tc->marginRight, tc->cursorY+height);
-}
-
-
-//! Get the size taken up by a string.
-/*!
-	\param str	String to check.
-	\return	width and height, packed into a POINT16.
-	\note	This function \e ignores tte commands, so don't use
-		on strings that use commands.
-*/
-POINT16 tte_get_text_size(const char *str)
-{
-	TTC *tc= tte_get_context();
-
-	int charW, charH= tc->font->charH;
-
-	s16 x=0, width= 12, height= charH;
-	int ch;
-
-	while( (ch= *str++) != 0 )
-	{
-		switch(ch)
-		{
-		// --- Newline/carriage return ---
-		case '\r':
-			if(str[0] == '\n')	// deal with CRLF pair
-				str++;
-			// FALLTHRU
-		case '\n':
-			height += charH;
-			if(x > width)
-				width= x;
-			x= 0;
-			break;			
-
-		// --- Special char ---
-		case '\\':
-			//# Use cmd-functino
-			//# Take care of positioning commands.
-			if(str[0] == '{')
-				str= tte_cmd_skip(str);
-			break;
-
-		// --- Normal char ---
-		default:
-			charW= tc->font->cellW;
-			if(x+charW > tc->marginRight)
-			{
-				height += charH;		
-				if(x>width)
-					width= x;
-				x=0;			
-			}
-			else
-				x += tte_get_glyph_width(tte_get_glyph_id(ch));	
-		}
-	}
-
-	// One more to make sure we got it >_<
-	if(x>width)
-		width= x;
-
-	POINT16 pt= { width, height };
-	return pt;
-}
-
-void tte_set_margins(int left, int top, int right, int bottom)
-{
-	TTC *tc= tte_get_context();
-
-	tc->marginLeft  = left;
-	tc->marginTop   = top;
-	tc->marginRight = right;
-	tc->marginBottom= bottom;
-}
-
-
-// EOF
-////////////////////// end tte_main.c //////////////////////
 
+    //! Initialize text system for 4bpp tiled, column-major surfaces.
+    /*!
+        \param bgnr		Background number.
+        \param bgcnt	Background control flags.
+        \param se0		Base offset for screen-entries.
+        \param cattrs	Color attributes; one byte per attr.
+        \param clrs		ink(/shadow) colors.
+        \param font		Font to initialize with.
+        \param proc		Glyph renderer
+    */
+    void tte_init_chr4c(int bgnr, u16 bgcnt, u16 se0, u32 cattrs, u32 clrs,
+        const TFont *font, fnDrawg proc)
+    {
+        if (proc == NULL)
+            proc = chr4c_drawg_default;
+
+        tte_init_base(font, proc, chr4c_erase);
+
+        TTC *tc = tte_get_context();
+        TSurface *srf = &tc->dst;
+
+        srf_init(srf, SRF_CHR4C,
+            &tile_mem[BFN_GET(bgcnt, BG_CBB)][se0 & SE_ID_MASK], SCREEN_WIDTH,
+            SCREEN_HEIGHT, 4, pal_bg_mem);
+        schr4c_prep_map(srf, se_mem[BFN_GET(bgcnt, BG_SBB)], se0);
+
+        tc->flags0 = bgnr;
+        tc->ctrl = bgcnt;
+        REG_BGCNT[bgnr] = bgcnt;
+
+        // --- Init color attributes ---
+        u32 ink, shadow, paper; // spec;
+        ink = cattrs & 15;
+        shadow = (cattrs >> 8) & 15;
+        paper = (cattrs >> 16) & 15;
+        // spec=   (cattrs>>24)&255;
+
+        tc->cattr[TTE_INK] = ink;
+        tc->cattr[TTE_SHADOW] = shadow;
+        tc->cattr[TTE_PAPER] = paper;
+        // tc->cattr[TTE_SPECIAL]= 0;
+
+        srf->palData = pal_bg_bank[se0 >> 12];
+        srf->palData[ink] = clrs & 0xFFFF;
+        srf->palData[shadow] = clrs >> 16;
+    }
+
+    void chr4c_erase(int left, int top, int right, int bottom)
+    {
+        TTC *tc = tte_get_context();
+
+        // # Check for single sequence
+        schr4c_rect(&tc->dst, left, top, right, bottom, tc->cattr[TTE_PAPER]);
+    }
+
+    // HACK: We need to replace the entirety of tte_main.c in libtonc to avoid
+    // pulling in sys8font (because it's used as a default in tte_init_base() if
+    // the specified font is NULL) So here's a modified version of tte_main.c
+    // (only tte_init_base() is really changed though):
+    //////////////////////// tte_main.c ////////////////////////
+
+    // --------------------------------------------------------------------
+    // CONSTANTS
+    // --------------------------------------------------------------------
+
+    // --------------------------------------------------------------------
+    // GLOBALS
+    // --------------------------------------------------------------------
+
+    TTC __tte_main_context;
+    TTC *gp_tte_context = &__tte_main_context;
+
+    // --------------------------------------------------------------------
+    // INLINES
+    // --------------------------------------------------------------------
+
+    INLINE char *eatwhite(const char *str)
+    {
+        while (isspace(*str))
+            str++;
+
+        return (char *)str;
+    }
+
+    // --------------------------------------------------------------------
+    // OPERATIONS
+    // --------------------------------------------------------------------
+
+    //! Set the master context pointer.
+    void tte_set_context(TTC *tc)
+    {
+        gp_tte_context = tc ? tc : &__tte_main_context;
+    }
+
+    //! Set color attribute of \a type to \a cattr.
+    void tte_set_color_attr(eint type, u16 cattr)
+    {
+        TTC *tc = tte_get_context();
+        tc->cattr[type] = cattr;
+    }
+
+    //! Load important color attribute data.
+    void tte_set_color_attrs(const u16 cattrs[])
+    {
+        int ii;
+        TTC *tc = tte_get_context();
+
+        for (ii = 0; ii < 4; ii++)
+            tc->cattr[ii] = cattrs[ii];
+    }
+
+    //! Set color attribute of \a type to \a cattr.
+    void tte_set_color(eint type, u16 color)
+    {
+        TTC *tc = tte_get_context();
+
+        if (tc->dst.palData != NULL)
+            tc->dst.palData[tc->cattr[type]] = color;
+        else
+            tc->cattr[type] = color;
+    }
+
+    //! Load important color data.
+    void tte_set_colors(const u16 colors[])
+    {
+        int ii;
+        TTC *tc = tte_get_context();
+
+        if (tc->dst.palData != NULL)
+            for (ii = 0; ii < 4; ii++)
+                tc->dst.palData[tc->cattr[ii]] = colors[ii];
+        else
+            for (ii = 0; ii < 4; ii++)
+                tc->cattr[ii] = colors[ii];
+    }
+
+    //! Base initializer of a TTC.
+    void tte_init_base(const TFont *font, fnDrawg drawProc, fnErase eraseProc)
+    {
+        if (tte_get_context() == NULL)
+            tte_set_context(&__tte_main_context);
+
+        TTC *tc = tte_get_context();
+        memset(tc, 0, sizeof(TTC));
+
+        tc->font = (TFont *)font;
+        tc->drawgProc = drawProc;
+        tc->eraseProc = eraseProc;
+
+        // Default is SBB 0
+        const TSurface srf = {
+            (u8 *)se_mem, 32 * 2, 32, 32, 8, SRF_BMP16, 256, pal_bg_mem};
+        tc->dst = srf;
+
+        tc->cattr[TTE_INK] = 0xF1;
+        tc->cattr[TTE_SHADOW] = 0xF2;
+        tc->cattr[TTE_PAPER] = 0;
+        tc->cattr[TTE_SPECIAL] = 0;
+
+        tc->marginRight = SCREEN_WIDTH;
+        tc->marginBottom = SCREEN_HEIGHT;
+    }
+
+    // --------------------------------------------------------------------
+    // String interpretations
+    // --------------------------------------------------------------------
+
+    //! Retrieve a single multibyte utf8 character.
+    uint utf8_decode_char(const char *ptr, char **endptr)
+    {
+        uchar *src = (uchar *)ptr;
+        uint ch8, ch32;
+
+        // Poor man's try-catch.
+        do
+        {
+            // UTF8 formats:
+            // 0aaaaaaa                            ->                   0aaaaaaa
+            // 110aaaaa 10bbbbbb                   ->          00000aaa aabbbbbb
+            // 1110aaaa 10bbbbbb 10cccccc          ->          aaaabbbb bbcccccc
+            // 11110aaa 10bbbbbb 10cccccc 10dddddd -> 000aaabb bbbbcccc ccdddddd
+            //
+            // Any invalid format will be returned as a single byte.
+
+            ch8 = *src;
+            if (ch8 < 0x80) // 7b
+            {
+                ch32 = ch8;
+            }
+            else if (0xC0 <= ch8 && ch8 < 0xE0) // 11b
+            {
+                ch32 = (*src++ & 0x1F) << 6;
+                if ((*src >> 6) != 2)
+                    break;
+                ch32 |= (*src++ & 0x3F) << 0;
+            }
+            else if (0xE0 <= ch8 && ch8 < 0xF0) // 16b
+            {
+                ch32 = (*src++ & 0x0F) << 12;
+                if ((*src >> 6) != 2)
+                    break;
+                ch32 |= (*src++ & 0x3F) << 6;
+                if ((*src >> 6) != 2)
+                    break;
+                ch32 |= (*src++ & 0x3F) << 0;
+            }
+            else if (0xF0 <= ch8 && ch8 < 0xF8) // 21b
+            {
+                ch32 = (*src++ & 0x0F) << 18;
+                if ((*src >> 6) != 2)
+                    break;
+                ch32 |= (*src++ & 0x3F) << 12;
+                if ((*src >> 6) != 2)
+                    break;
+                ch32 |= (*src++ & 0x3F) << 6;
+                if ((*src >> 6) != 2)
+                    break;
+                ch32 |= (*src++ & 0x3F) << 0;
+            }
+            else
+                break;
+
+            // Proper UTF8 char: set endptr and return
+            if (endptr)
+                *endptr = (char *)src;
+
+            return ch32;
+
+        } while (0);
+
+        // Not really UTF: interpret as single byte.
+        src = (uchar *)ptr;
+        ch32 = *src++;
+        if (endptr)
+            *endptr = (char *)src;
+
+        return ch32;
+    }
+
+    //! Find the string-position after the command.
+    /*!
+        \param str	String to check.
+        \return		The string-pointer after the current/next command.
+            If there is no command-end, this moves to the end of the
+            string.
+    */
+    char *tte_cmd_skip(const char *str)
+    {
+        int ch;
+
+        while ((ch = *str) != '\0')
+        {
+            str++;
+            if (ch == '}')
+                break;
+        }
+
+        return (char *)str;
+    }
+
+    //! Move to the next command in a sequence.
+    /*!
+        \return	Position of EOS (\'0'), EOC ('}') or next cmd token (rest)
+    */
+    char *tte_cmd_next(const char *str)
+    {
+        int ch;
+
+        // Find EOC, separator or NULL
+        while (1)
+        {
+            ch = *str;
+            if (ch == '\0' || ch == '}') // EOS/EOC
+                return (char *)str;
+            else if (ch == ';') // More commands
+                break;
+
+            str++;
+        }
+
+        // More commands: try to find next token (or EOS/EOC again)
+        while (1)
+        {
+            ch = *++str;
+            if (ch == '\0' || !isspace(ch))
+                return (char *)str;
+        }
+    }
+
+    //!	Text command handler.
+    /*!	Takes commands formatted as "#{[cmd]:[opt];[[cmd]:[opt];...]} and
+        deals with them.<br>
+        <br>Command list:
+        - <b>P</b>				Set cursor to margin top-left.
+        - <b>Ps</b>				Save cursor position
+        - <b>Pr</b>				Restore cursor position.
+        - <b>P:\#x,\#y</b>		Set cursorX/Y to \e x, \e y.
+        - <b>X</b>				Set cursorX to margin left.
+        - <b>X:\#x</b>			Set cursorX to \e x.
+        - <b>Y</b>				Set cursorY to margin top.
+        - <b>Y:\#y</b>			Set cursorX to \e y.
+        - <b>c[ispx]:\#val</b>	Set ink/shadow/paper/special color to \e val.
+        - <b>e[slbfr]</b>		Erase screen/line/backward/forward/rect
+        - <b>m:\#l,\#t,\#r,\#b</b>	Set all margins
+        - <b>m[ltrb]:\#val</b>	Set margin to \e val.
+        - <b>p:\#x,\#y</b>		Move cursorX/Y by \e x, \e y.
+        - <b>w:\#val</b>		Wait \e val frame.
+        - <b>x:\#x</b>			Move cursorX by \e x.
+        - <b>y:\#y</b>			Move cursorX by \e y.
+
+        Examples:<br>
+        - <b>#{X:32}</b>		Move to \e x = 32;
+        - <b>#{ci:0x7FFF}</b>	Set ink color to white.
+        - <b>#{w:120;es;P}</b>	Wait 120 frames, clear screen, return to top of
+       screen.
+        \param str	Start of command. Assumes the initial "\{" is lobbed
+            off already.
+        \return pointer to after the parsed command.
+        \note	Routine does text wrapping. Make sure margins are set.
+        \note	This function involves heavy (yet necessary)
+            switching. Leave your sanity at the door before viewing.
+        \todo	Scrolling and variables ?
+        \todo	Restructure for safety checks.
+    */
+    char *tte_cmd_default(const char *str)
+    {
+        int ch, val;
+        char *curr = (char *)str, *next;
+
+        TTC *tc = tte_get_context();
+
+        while (1)
+        {
+            // --- Get cmd char and act on it ---
+            // "Ew, double switches". Yes, I know. I'm not proud.
+            // That behaviour may change later
+
+            ch = *curr;
+            next = curr + 1;
+
+            switch (ch)
+            {
+            // --- Absolute Positions ---
+            case 'X':
+                tc->cursorX = curr[1] == ':' ? strtol(curr + 2, &next, 0)
+                                             : tc->marginLeft;
+                break;
+            case 'Y':
+                tc->cursorY =
+                    curr[1] == ':' ? strtol(curr + 2, &next, 0) : tc->marginTop;
+                break;
+            case 'P':
+            {
+                switch (curr[1])
+                {
+                case 's': // Save position
+                    tc->savedX = tc->cursorX;
+                    tc->savedY = tc->cursorY;
+                    break;
+                case 'r': // Restore position
+                    tc->cursorX = tc->savedX;
+                    tc->cursorY = tc->savedY;
+                    break;
+                case ':': // Set position
+                    tc->cursorX = strtol(curr + 2, &next, 0);
+                    curr = eatwhite(next);
+                    if (curr[0] == ',')
+                        tc->cursorY = strtol(curr + 1, &next, 0);
+                    break;
+                default: // Set to top-left of screen
+                    tc->cursorX = tc->marginLeft;
+                    tc->cursorY = tc->marginTop;
+                }
+            }
+            break;
+
+            // --- Relative Positions ---
+            case 'x':
+                tc->cursorX += strtol(curr + 2, &next, 0);
+                break;
+            case 'y':
+                tc->cursorY += strtol(curr + 2, &next, 0);
+                break;
+            case 'p':
+                tc->cursorX += strtol(curr + 2, &next, 0);
+                curr = eatwhite(next);
+                if (curr[0] == ',')
+                    tc->cursorY += strtol(curr + 1, &next, 0);
+                break;
+
+            // --- Colors c[ispx]:# ---
+            case 'c':
+            {
+                ch = curr[1]; // index character ("ispx")
+                curr += 3;
+                switch (ch)
+                {
+                case 'i':
+                    tc->cattr[TTE_INK] = strtol(curr, &next, 0);
+                    break;
+                case 's':
+                    tc->cattr[TTE_SHADOW] = strtol(curr, &next, 0);
+                    break;
+                case 'p':
+                    tc->cattr[TTE_PAPER] = strtol(curr, &next, 0);
+                    break;
+                case 'x':
+                    tc->cattr[TTE_SPECIAL] = strtol(curr, &next, 0);
+                    break;
+                }
+                break;
+            }
+
+            // --- Erasing ---
+            case 'e':
+            {
+                switch (curr[1])
+                {
+                case 's': // screen (within margins)
+                    tte_erase_screen();
+                    break;
+                case 'l': // line (within margins)
+                    tte_erase_line();
+                    break;
+                case 'f': // line up to cursorX
+                    tte_erase_rect(tc->cursorX, tc->cursorY, tc->marginRight,
+                        tc->cursorY + tc->font->charH);
+                    break;
+                case 'b': // line from cursorX
+                    tte_erase_rect(tc->marginLeft, tc->cursorY, tc->cursorX,
+                        tc->cursorY + tc->font->charH);
+                    break;
+                case 'r': // rectangle
+                {
+                    int rect[4];
+                    curr += 3;
+                    rect[0] = strtol(curr + 0, &next, 0);
+                    curr = eatwhite(next);
+                    if (curr[0] != ',')
+                        break;
+
+                    rect[1] = strtol(curr + 1, &next, 0);
+                    curr = eatwhite(next);
+                    if (curr[0] != ',')
+                        break;
+
+                    rect[2] = strtol(curr + 1, &next, 0);
+                    curr = eatwhite(next);
+                    if (curr[0] != ',')
+                        break;
+
+                    rect[3] = strtol(curr + 1, &next, 0);
+                    tte_erase_rect(rect[0], rect[1], rect[2], rect[3]);
+                    break;
+                }
+                    // # erase character / backspace.
+                }
+            }
+            break;
+
+            // --- Margins ---
+            case 'm':
+            {
+                ch = curr[1]; // index character ("ispx")
+                curr += 3;
+                switch (ch)
+                {
+                case 'l':
+                    tc->marginLeft = strtol(curr, &next, 0);
+                    break;
+                case 't':
+                    tc->marginTop = strtol(curr, &next, 0);
+                    break;
+                case 'r':
+                    tc->marginRight = strtol(curr, &next, 0);
+                    break;
+                case 'b':
+                    tc->marginBottom = strtol(curr, &next, 0);
+                    break;
+                case 's': // To screen size
+                    tc->marginLeft = 0;
+                    tc->marginTop = 0;
+                    tc->marginRight = SCREEN_WIDTH;
+                    tc->marginBottom = SCREEN_HEIGHT;
+                    break;
+                case ':': // Set all margins
+                    tc->marginLeft = strtol(curr - 1, &next, 0);
+                    curr = eatwhite(next);
+                    if (curr[0] != ',')
+                        break;
+
+                    tc->marginTop = strtol(curr + 1, &next, 0);
+                    curr = eatwhite(next);
+                    if (curr[0] != ',')
+                        break;
+
+                    tc->marginRight = strtol(curr + 1, &next, 0);
+                    curr = eatwhite(next);
+                    if (curr[0] != ',')
+                        break;
+
+                    tc->marginBottom = strtol(curr + 1, &next, 0);
+                    break;
+                }
+            }
+            break;
+
+            // --- Font ---
+            case 'f':
+                val = strtol(curr + 2, &next, 0);
+                if (tc->fontTable && tc->fontTable[val])
+                    tc->font = (TFont *)tc->fontTable[val];
+                break;
+
+            // --- String ---
+            case 's':
+                val = strtol(curr + 2, &next, 0);
+                if (tc->stringTable && tc->stringTable[val])
+                    tte_write(tc->stringTable[val]);
+                break;
+
+            // --- Wait a few frames ---
+            case 'w':
+                val = strtol(curr + 2, &next, 0);
+                VBlankIntrDelay(val);
+                break;
+
+            } // /main switch
+
+            // Find EOS/EOC/token and act on it
+            curr = tte_cmd_next(next);
+
+            if (curr[0] == '\0')
+                return curr;
+            else if (curr[0] == '}')
+                return curr + 1;
+        }
+    }
+
+    //! Extended string writer, with positional and color info
+    int tte_write_ex(int x0, int y0, const char *text, const u16 *cattrs)
+    {
+        TTC *tc = tte_get_context();
+        tc->cursorX = x0;
+        tc->cursorY = y0;
+
+        if (cattrs)
+            tte_set_color_attrs(cattrs);
+
+        return tte_write(text);
+    }
+
+    // Generic TTE putc (to be tested later)
+    // NOTE: the glyph inlines seem as fast as manual retrieval,
+    //   even though the former get the TTC and font again as well.
+    //	Yay.
+
+    //! Plot a single character; does wrapping too.
+    /*!
+        \param ch	Character to plot (not glyph-id).
+        \return		Character width.
+        \note		Overhead: ~70 cycles.
+    */
+    int tte_putc(int ch)
+    {
+        TTC *tc = tte_get_context();
+        TFont *font = tc->font;
+
+        uint gid = tte_get_glyph_id(ch);
+        int charW = tte_get_glyph_width(gid);
+
+        if (tc->cursorX + charW > tc->marginRight)
+        {
+            tc->cursorY += font->charH;
+            tc->cursorX = tc->marginLeft;
+        }
+
+        // Draw and update position
+        tc->drawgProc(gid);
+        tc->cursorX += charW;
+
+        return charW;
+    }
+
+    //! Render a string.
+    /*!
+        \param text	String to parse and write.
+        \return		Number of parsed characters.
+    */
+    int tte_write(const char *text)
+    {
+        if (text == NULL)
+            return 0;
+
+        uint ch, gid;
+        char *str = (char *)text;
+        TTC *tc = tte_get_context();
+        TFont *font;
+
+        while ((ch = *str) != '\0')
+        {
+            str++;
+            switch (ch)
+            {
+            // --- Newline/carriage return ---
+            case '\r':
+                if (str[0] == '\n') // deal with CRLF pair
+                    str++;
+                // FALLTHRU
+            case '\n':
+                tc->cursorY += tc->font->charH;
+                tc->cursorX = tc->marginLeft;
+                break;
+            // --- Tab ---
+            case '\t':
+                tc->cursorX = (tc->cursorX / TTE_TAB_WIDTH + 1) * TTE_TAB_WIDTH;
+                break;
+
+            // --- Normal char ---
+            default:
+                // Command sequence
+                if (ch == '#' && str[0] == '{')
+                {
+                    str = tte_cmd_default(str + 1);
+                    break;
+                }
+                // Escaped command: skip '\\' and print '#'
+                else if (ch == '\\' && str[0] == '#')
+                    ch = *str++;
+                // Check for UTF8 code
+                else if (ch >= 0x80)
+                    ch = utf8_decode_char(str - 1, &str);
+
+                // Get glyph index and call renderer
+                font = tc->font;
+                gid = ch - font->charOffset;
+                if (tc->charLut)
+                    gid = tc->charLut[gid];
+
+                // Character wrap
+                int charW = font->widths ? font->widths[gid] : font->charW;
+                if (tc->cursorX + charW > tc->marginRight)
+                {
+                    tc->cursorY += font->charH;
+                    tc->cursorX = tc->marginLeft;
+                }
+
+                // Draw and update position
+                tc->drawgProc(gid);
+                tc->cursorX += charW;
+            }
+        }
+
+        // Return characters used (PONDER: is this really the right thing?)
+        return str - text;
+    }
+
+    //! Erase a porttion of the screen (ignores margins)
+    void tte_erase_rect(int left, int top, int right, int bottom)
+    {
+        TTC *tc = tte_get_context();
+
+        if (tc->eraseProc)
+            tc->eraseProc(left, top, right, bottom);
+    }
+
+    //! Erase the screen (within the margins).
+    /*!
+        \note Ponder: set paper color?
+    */
+    void tte_erase_screen()
+    {
+        TTC *tc = tte_get_context();
+
+        if (tc->eraseProc)
+            tc->eraseProc(tc->marginLeft, tc->marginTop, tc->marginRight,
+                tc->marginBottom);
+    }
+
+    //! Erase the whole line (within the margins).
+    /*!
+        \note Ponder: set paper color?
+    */
+    void tte_erase_line()
+    {
+        TTC *tc = tte_get_context();
+        int height = tc->font->charH;
+
+        if (tc->eraseProc)
+            tc->eraseProc(tc->marginLeft, tc->cursorY, tc->marginRight,
+                tc->cursorY + height);
+    }
+
+    //! Get the size taken up by a string.
+    /*!
+        \param str	String to check.
+        \return	width and height, packed into a POINT16.
+        \note	This function \e ignores tte commands, so don't use
+            on strings that use commands.
+    */
+    POINT16 tte_get_text_size(const char *str)
+    {
+        TTC *tc = tte_get_context();
+
+        int charW, charH = tc->font->charH;
+
+        s16 x = 0, width = 12, height = charH;
+        int ch;
+
+        while ((ch = *str++) != 0)
+        {
+            switch (ch)
+            {
+            // --- Newline/carriage return ---
+            case '\r':
+                if (str[0] == '\n') // deal with CRLF pair
+                    str++;
+                // FALLTHRU
+            case '\n':
+                height += charH;
+                if (x > width)
+                    width = x;
+                x = 0;
+                break;
+
+            // --- Special char ---
+            case '\\':
+                // # Use cmd-functino
+                // # Take care of positioning commands.
+                if (str[0] == '{')
+                    str = tte_cmd_skip(str);
+                break;
+
+            // --- Normal char ---
+            default:
+                charW = tc->font->cellW;
+                if (x + charW > tc->marginRight)
+                {
+                    height += charH;
+                    if (x > width)
+                        width = x;
+                    x = 0;
+                }
+                else
+                    x += tte_get_glyph_width(tte_get_glyph_id(ch));
+            }
+        }
+
+        // One more to make sure we got it >_<
+        if (x > width)
+            width = x;
+
+        POINT16 pt = {width, height};
+        return pt;
+    }
+
+    void tte_set_margins(int left, int top, int right, int bottom)
+    {
+        TTC *tc = tte_get_context();
+
+        tc->marginLeft = left;
+        tc->marginTop = top;
+        tc->marginRight = right;
+        tc->marginBottom = bottom;
+    }
+
+    // EOF
+    ////////////////////// end tte_main.c //////////////////////
 }
\ No newline at end of file
diff --git a/source/main.cpp b/source/main.cpp
index 2b08cf3..962016b 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -1,35 +1,35 @@
-#include <tonc.h>
-#include <cstdlib>
-#include "libstd_replacements.h"
-#include "flash_mem.h"
-#include "interrupt.h"
-#include "gb_link.h"
-#include "link_handler.h"
-#include "random.h"
-#include "text_engine.h"
+#include "FileContainerReader.h"
 #include "background_engine.h"
-#include "pokemon_data.h"
-#include "script_array.h"
-#include "sprite_data.h"
 #include "button_handler.h"
 #include "button_menu.h"
-#include "dbg/debug_mode.h"
+#include "custom_malloc.h"
 #include "dbg/debug_menu.h"
+#include "dbg/debug_mode.h"
 #include "dbg/ptgb_mgba_print.h"
 #include "dex_handler.h"
-#include "pokedex.h"
+#include "flash_mem.h"
+#include "gb_link.h"
 #include "global_frame_controller.h"
-#include "pkmn_font.h"
-#include "ptgb_save_data_manager.h"
-#include "mystery_gift_injector.h"
-#include "multiboot_upload.h"
-#include "rom_data.h"
+#include "interrupt.h"
 #include "libraries/Pokemon-Gen3-to-Gen-X/include/save.h"
-#include "FileContainerReader.h"
-#include "translated_text.h"
-#include "text_tables.h"
-#include "custom_malloc.h"
+#include "libstd_replacements.h"
+#include "link_handler.h"
+#include "multiboot_upload.h"
+#include "mystery_gift_injector.h"
+#include "pkmn_font.h"
+#include "pokedex.h"
+#include "pokemon_data.h"
+#include "ptgb_save_data_manager.h"
+#include "random.h"
+#include "rom_data.h"
+#include "script_array.h"
 #include "sound.h"
+#include "sprite_data.h"
+#include "text_engine.h"
+#include "text_tables.h"
+#include "translated_text.h"
+#include <cstdlib>
+#include <tonc.h>
 
 /*
 
@@ -58,490 +58,519 @@ Button_Menu yes_no_menu(1, 2, 40, 24, false);
 
 void load_graphics()
 {
-	//  Load opening background first so it hides everything else
-	load_flex_background(FBG_Opening, 1);
-	load_background();
-	load_textbox_background();
-	load_eternal_sprites();
+    //  Load opening background first so it hides everything else
+    load_flex_background(FBG_Opening, 1);
+    load_background();
+    load_textbox_background();
+    load_eternal_sprites();
 
-	// Set up global yes no button
-	yes_no_menu.clear_vector();
-	yes_no_menu.add_button(Button(button_yes), true);
-	yes_no_menu.add_button(Button(button_no), false);
+    // Set up global yes no button
+    yes_no_menu.clear_vector();
+    yes_no_menu.add_button(Button(button_yes), true);
+    yes_no_menu.add_button(Button(button_no), false);
 }
 
 void initialization_script(void)
 {
-	// Initializations
-	REG_DISPCNT = DCNT_BLANK | DCNT_MODE0 | DCNT_BG0 | DCNT_BG1 | DCNT_BG2 | DCNT_BG3 | DCNT_OBJ | DCNT_OBJ_1D;
+    // Initializations
+    REG_DISPCNT = DCNT_BLANK | DCNT_MODE0 | DCNT_BG0 | DCNT_BG1 | DCNT_BG2 |
+                  DCNT_BG3 | DCNT_OBJ | DCNT_OBJ_1D;
 
-	// Disable for save data read/write
-	REG_IME = 0;
-	REG_IE = 0;
+    // Disable for save data read/write
+    REG_IME = 0;
+    REG_IE = 0;
 
-	irq_init(&isr_master_nest);
+    irq_init(&isr_master_nest);
 
-	// Sound bank init
-	// irq_init(NULL);
-	// irq_enable(II_VBLANK);
-	// This currently crashes when you try to transfer a Pokemon:
-	// sound_init();
+    // Sound bank init
+    // irq_init(NULL);
+    // irq_enable(II_VBLANK);
+    // This currently crashes when you try to transfer a Pokemon:
+    // sound_init();
 
-	// Link Cable init
-  	irq_add(II_TIMER3, linkCableIRQ);
+    // Link Cable init
+    irq_add(II_TIMER3, linkCableIRQ);
 
-	// Graphics init
-	irq_add(II_VBLANK, global_next_frame);
-	irq_enable(II_VBLANK);
-	oam_init(obj_buffer, 128);
-	load_graphics();
+    // Graphics init
+    irq_add(II_VBLANK, global_next_frame);
+    irq_enable(II_VBLANK);
+    oam_init(obj_buffer, 128);
+    load_graphics();
 
-	// Prepare text engine for dialogue
-	init_text_engine();
-	ptgb_mgba_init();
+    // Prepare text engine for dialogue
+    init_text_engine();
+    ptgb_mgba_init();
 
-	// Set the random seed
-	rand_set_seed(0x1216);
+    // Set the random seed
+    rand_set_seed(0x1216);
 
-	// Clean up the main screen quick
+    // Clean up the main screen quick
 
-	VBlankIntrWait();
-	REG_DISPCNT &= ~DCNT_BLANK;
+    VBlankIntrWait();
+    REG_DISPCNT &= ~DCNT_BLANK;
 
-	PTGB_MGBA_INFO("Hello from PTGB!");
+    PTGB_MGBA_INFO("Hello from PTGB!");
 };
 
-// attribute noinline is used to make sure it doesn't get inlined and permanently use IWRAM for the decompression_buffer
+// attribute noinline is used to make sure it doesn't get inlined and
+// permanently use IWRAM for the decompression_buffer
 void __attribute__((noinline)) game_load_error(void)
 {
-	u8 general_text_buffer[2048];
-	u8 lineBuffer[1024];
-	const u8 **chunkList;
-	u32 numChunks;
-	u32 chunkSize;
+    u8 general_text_buffer[2048];
+    u8 lineBuffer[1024];
+    const u8 **chunkList;
+    u32 numChunks;
+    u32 chunkSize;
 
-	get_text_table_chunks(GENERAL_INDEX, &chunkList, &numChunks, &chunkSize);
-	FileContainerReader text_reader(chunkList, numChunks, chunkSize);
+    get_text_table_chunks(GENERAL_INDEX, &chunkList, &numChunks, &chunkSize);
+    FileContainerReader text_reader(chunkList, numChunks, chunkSize);
 
-	text_reader.init(general_text_buffer, sizeof(general_text_buffer));
+    text_reader.init(general_text_buffer, sizeof(general_text_buffer));
 
-	BG_TEXTBOX = (BG_TEXTBOX & ~BG_PRIO_MASK) | BG_PRIO(1);
-	text_reader.readFile(GENERAL_cart_load_error, lineBuffer);
-	ptgb_write_textbox(lineBuffer, true, false, GENERAL_INDEX, GENERAL_cart_load_error, false);
+    BG_TEXTBOX = (BG_TEXTBOX & ~BG_PRIO_MASK) | BG_PRIO(1);
+    text_reader.readFile(GENERAL_cart_load_error, lineBuffer);
+    ptgb_write_textbox(
+        lineBuffer, true, false, GENERAL_INDEX, GENERAL_cart_load_error, false);
 
-	// key_poll();
-	do
-	{
-		VBlankIntrWait();
-	} while (!key_hit(KEY_A) && !key_hit(KEY_SELECT));
+    // key_poll();
+    do
+    {
+        VBlankIntrWait();
+    } while (!key_hit(KEY_A) && !key_hit(KEY_SELECT));
 
-	tte_erase_rect(0, 0, H_MAX, V_MAX);
-	erase_textbox_tiles();
+    tte_erase_rect(0, 0, H_MAX, V_MAX);
+    erase_textbox_tiles();
 
-	if (key_hit(KEY_SELECT))
-	{
-		// We also want to give the option in this screen to upload the multiboot rom to another GBA.
-		// This can be useful when the user wants to work with a flashcart in single rom mode.
-		// The EZ Flash Omega (DE) for instance, triggers a reset of the gba if you insert it while the GBA is turned on.
-		// So the only way to work with it, is to boot Poke Transporter GB over multiboot and have the flashcart already inserted.
-		// It would be a shame not to support this flashcart, because it's awesome for pokémon fans. After all: it supports ds transfer
-		// and should support connecting with the gamecube games.
-		multiboot_upload_screen();
-		return;
-	}
-	delay_counter = 0;
+    if (key_hit(KEY_SELECT))
+    {
+        // We also want to give the option in this screen to upload the
+        // multiboot rom to another GBA. This can be useful when the user wants
+        // to work with a flashcart in single rom mode. The EZ Flash Omega (DE)
+        // for instance, triggers a reset of the gba if you insert it while the
+        // GBA is turned on. So the only way to work with it, is to boot Poke
+        // Transporter GB over multiboot and have the flashcart already
+        // inserted. It would be a shame not to support this flashcart, because
+        // it's awesome for pokémon fans. After all: it supports ds transfer and
+        // should support connecting with the gamecube games.
+        multiboot_upload_screen();
+        return;
+    }
+    delay_counter = 0;
 
-	while (delay_counter < 60)
-	{
-		delay_counter++;
-		VBlankIntrWait();
-	}
+    while (delay_counter < 60)
+    {
+        delay_counter++;
+        VBlankIntrWait();
+    }
 };
 
-// attribute noinline is used to make sure it doesn't get inlined and permanently use IWRAM for the decompression_buffer
+// attribute noinline is used to make sure it doesn't get inlined and
+// permanently use IWRAM for the decompression_buffer
 void __attribute__((noinline)) lang_mismatch_error(void)
 {
-	u8 general_text_buffer[2048];
-	u8 lineBuffer[1024];
-	const u8 **chunkList;
-	u32 numChunks;
-	u32 chunkSize;
+    u8 general_text_buffer[2048];
+    u8 lineBuffer[1024];
+    const u8 **chunkList;
+    u32 numChunks;
+    u32 chunkSize;
 
-	get_text_table_chunks(GENERAL_INDEX, &chunkList, &numChunks, &chunkSize);
-	FileContainerReader text_reader(chunkList, numChunks, chunkSize);
+    get_text_table_chunks(GENERAL_INDEX, &chunkList, &numChunks, &chunkSize);
+    FileContainerReader text_reader(chunkList, numChunks, chunkSize);
 
-	text_reader.init(general_text_buffer, sizeof(general_text_buffer));
+    text_reader.init(general_text_buffer, sizeof(general_text_buffer));
 
-	BG_TEXTBOX = (BG_TEXTBOX & ~BG_PRIO_MASK) | BG_PRIO(1);
-	text_reader.readFile(GENERAL_lang_mismatch_warning, lineBuffer);
-	ptgb_write_textbox(lineBuffer, true, false, GENERAL_INDEX, GENERAL_lang_mismatch_warning, false);
+    BG_TEXTBOX = (BG_TEXTBOX & ~BG_PRIO_MASK) | BG_PRIO(1);
+    text_reader.readFile(GENERAL_lang_mismatch_warning, lineBuffer);
+    ptgb_write_textbox(lineBuffer, true, false, GENERAL_INDEX,
+        GENERAL_lang_mismatch_warning, false);
 
-	// key_poll();
-	do
-	{
-		VBlankIntrWait();
-	} while (!key_hit(KEY_A) && !key_hit(KEY_SELECT));
+    // key_poll();
+    do
+    {
+        VBlankIntrWait();
+    } while (!key_hit(KEY_A) && !key_hit(KEY_SELECT));
 
-	tte_erase_rect(0, 0, H_MAX, V_MAX);
-	erase_textbox_tiles();
+    tte_erase_rect(0, 0, H_MAX, V_MAX);
+    erase_textbox_tiles();
 };
 
-// avoid inlining to avoid permanently storing the credits_decompression_buffer in IWRAM
+// avoid inlining to avoid permanently storing the credits_decompression_buffer
+// in IWRAM
 int __attribute__((noinline)) credits()
 {
-	u8 credits_decompression_buffer[2048];
-	u8 lineBuffer[1024];
-	const u8 **chunkList;
-	u32 numChunks;
-	u32 chunkSize;
+    u8 credits_decompression_buffer[2048];
+    u8 lineBuffer[1024];
+    const u8 **chunkList;
+    u32 numChunks;
+    u32 chunkSize;
 
-	get_text_table_chunks(CREDITS_INDEX, &chunkList, &numChunks, &chunkSize);
-	FileContainerReader creditsReader(chunkList, numChunks, chunkSize);
-	u32 curr_credits_num = 0;
+    get_text_table_chunks(CREDITS_INDEX, &chunkList, &numChunks, &chunkSize);
+    FileContainerReader creditsReader(chunkList, numChunks, chunkSize);
+    u32 curr_credits_num = 0;
 
-	creditsReader.init(credits_decompression_buffer, sizeof(credits_decompression_buffer));
-	bool update = true;
+    creditsReader.init(
+        credits_decompression_buffer, sizeof(credits_decompression_buffer));
+    bool update = true;
 
-	while (true)
-	{
-		if (update)
-		{
-			creditsReader.readFile(curr_credits_num, lineBuffer);
-			ptgb_write_textbox(lineBuffer, true, false, CREDITS_INDEX, curr_credits_num, false);
-			update = false;
-		}
+    while (true)
+    {
+        if (update)
+        {
+            creditsReader.readFile(curr_credits_num, lineBuffer);
+            ptgb_write_textbox(lineBuffer, true, false, CREDITS_INDEX,
+                curr_credits_num, false);
+            update = false;
+        }
 
-		if (key_hit(KEY_B))
-		{
-			tte_erase_rect(0, 0, H_MAX, V_MAX);
-			hide_textbox();
-			erase_textbox_tiles();
-			return 0;
-		}
-		if (key_hit(KEY_LEFT) && curr_credits_num > 0)
-		{
-			curr_credits_num--;
-			update = true;
-		}
-		if (key_hit(KEY_RIGHT) && curr_credits_num < (creditsReader.getNumberOfFiles() - 1))
-		{
-			curr_credits_num++;
-			update = true;
-		}
+        if (key_hit(KEY_B))
+        {
+            tte_erase_rect(0, 0, H_MAX, V_MAX);
+            hide_textbox();
+            erase_textbox_tiles();
+            return 0;
+        }
+        if (key_hit(KEY_LEFT) && curr_credits_num > 0)
+        {
+            curr_credits_num--;
+            update = true;
+        }
+        if (key_hit(KEY_RIGHT) &&
+            curr_credits_num < (creditsReader.getNumberOfFiles() - 1))
+        {
+            curr_credits_num++;
+            update = true;
+        }
 
-		VBlankIntrWait();
-	}
+        VBlankIntrWait();
+    }
 };
 
-// avoid inlining to avoid permanently storing the tutorial_decompression_buffer in IWRAM
+// avoid inlining to avoid permanently storing the tutorial_decompression_buffer
+// in IWRAM
 int __attribute__((noinline)) tutorial()
 {
 
-	u8 tutorial_decompression_buffer[2048];
-	u8 lineBuffer[1024];
-	const u8 **chunkList;
-	u32 numChunks;
-	u32 chunkSize;
+    u8 tutorial_decompression_buffer[2048];
+    u8 lineBuffer[1024];
+    const u8 **chunkList;
+    u32 numChunks;
+    u32 chunkSize;
 
-	get_text_table_chunks(TUTORIAL_INDEX, &chunkList, &numChunks, &chunkSize);
-	FileContainerReader tutorialReader(chunkList, numChunks, chunkSize);
-	u32 curr_tutorial_num = 0;
+    get_text_table_chunks(TUTORIAL_INDEX, &chunkList, &numChunks, &chunkSize);
+    FileContainerReader tutorialReader(chunkList, numChunks, chunkSize);
+    u32 curr_tutorial_num = 0;
 
-	tutorialReader.init(tutorial_decompression_buffer, sizeof(tutorial_decompression_buffer));
-	bool update = true;
+    tutorialReader.init(
+        tutorial_decompression_buffer, sizeof(tutorial_decompression_buffer));
+    bool update = true;
 
-	while (true)
-	{
-		if (update)
-		{
-			tutorialReader.readFile(curr_tutorial_num, lineBuffer);
-			ptgb_write_textbox(lineBuffer, true, false, TUTORIAL_INDEX, curr_tutorial_num, false);
-			update = false;
-		}
+    while (true)
+    {
+        if (update)
+        {
+            tutorialReader.readFile(curr_tutorial_num, lineBuffer);
+            ptgb_write_textbox(lineBuffer, true, false, TUTORIAL_INDEX,
+                curr_tutorial_num, false);
+            update = false;
+        }
 
-		if (key_hit(KEY_B))
-		{
-			tte_erase_rect(0, 0, H_MAX, V_MAX);
-			hide_textbox();
-			erase_textbox_tiles();
-			return 0;
-		}
-		if (key_hit(KEY_LEFT) && curr_tutorial_num > 0)
-		{
-			curr_tutorial_num--;
-			update = true;
-		}
-		if (key_hit(KEY_RIGHT) && curr_tutorial_num < (tutorialReader.getNumberOfFiles() - 1))
-		{
-			curr_tutorial_num++;
-			update = true;
-		}
+        if (key_hit(KEY_B))
+        {
+            tte_erase_rect(0, 0, H_MAX, V_MAX);
+            hide_textbox();
+            erase_textbox_tiles();
+            return 0;
+        }
+        if (key_hit(KEY_LEFT) && curr_tutorial_num > 0)
+        {
+            curr_tutorial_num--;
+            update = true;
+        }
+        if (key_hit(KEY_RIGHT) &&
+            curr_tutorial_num < (tutorialReader.getNumberOfFiles() - 1))
+        {
+            curr_tutorial_num++;
+            update = true;
+        }
 
-		VBlankIntrWait();
-	}
+        VBlankIntrWait();
+    }
 };
 
-// attribute noinline is used to avoid permanently storing the general_text_table_buffer in IWRAM
+// attribute noinline is used to avoid permanently storing the
+// general_text_table_buffer in IWRAM
 int __attribute__((noinline)) main_menu_loop()
 {
-	uint8_t general_text_table_buffer[2048];
-	u8 lineBuffer[1024];
+    uint8_t general_text_table_buffer[2048];
+    u8 lineBuffer[1024];
 #define NUM_MENU_OPTIONS 4
-	const uint8_t menu_options[NUM_MENU_OPTIONS] = {GENERAL_option_transfer, GENERAL_option_dreamdex, GENERAL_option_credits, GENERAL_option_tutorial};
-	int return_values[NUM_MENU_OPTIONS] = {BTN_TRANSFER, BTN_POKEDEX, BTN_CREDITS, BTN_TUTORIAL};
-	const u8 **chunkList;
-	u32 numChunks;
-	u32 chunkSize;
+    const uint8_t menu_options[NUM_MENU_OPTIONS] = {GENERAL_option_transfer,
+        GENERAL_option_dreamdex, GENERAL_option_credits,
+        GENERAL_option_tutorial};
+    int return_values[NUM_MENU_OPTIONS] = {
+        BTN_TRANSFER, BTN_POKEDEX, BTN_CREDITS, BTN_TUTORIAL};
+    const u8 **chunkList;
+    u32 numChunks;
+    u32 chunkSize;
 
-	get_text_table_chunks(GENERAL_INDEX, &chunkList, &numChunks, &chunkSize);
-	FileContainerReader text_reader(chunkList, numChunks, chunkSize);
-	bool update = true;
-	u16 test = 0;
+    get_text_table_chunks(GENERAL_INDEX, &chunkList, &numChunks, &chunkSize);
+    FileContainerReader text_reader(chunkList, numChunks, chunkSize);
+    bool update = true;
+    u16 test = 0;
 
-	text_reader.init(general_text_table_buffer, sizeof(general_text_table_buffer));
+    text_reader.init(
+        general_text_table_buffer, sizeof(general_text_table_buffer));
 
-	while (true)
-	{
-		if (update)
-		{
-			for (int i = 0; i < NUM_MENU_OPTIONS; i++)
-			{
-				text_reader.readFile(menu_options[i], lineBuffer);
-				int string_length = get_string_length(lineBuffer);
-				int x = ((240 - string_length) / 2);
-				tte_set_pos(x, ((i * (16 + 6)) + 70));
-				if (i == curr_selection)
-				{
-					tte_set_ink(INK_WHITE);
-				}
-				else
-				{
-					tte_set_ink(INK_ROM_COLOR);
-				}
-				ptgb_write_simple(lineBuffer, true);
-				test++;
-			}
-		}
+    while (true)
+    {
+        if (update)
+        {
+            for (int i = 0; i < NUM_MENU_OPTIONS; i++)
+            {
+                text_reader.readFile(menu_options[i], lineBuffer);
+                int string_length = get_string_length(lineBuffer);
+                int x = ((240 - string_length) / 2);
+                tte_set_pos(x, ((i * (16 + 6)) + 70));
+                if (i == curr_selection)
+                {
+                    tte_set_ink(INK_WHITE);
+                }
+                else
+                {
+                    tte_set_ink(INK_ROM_COLOR);
+                }
+                ptgb_write_simple(lineBuffer, true);
+                test++;
+            }
+        }
 
-		update = true;
-		if (key_hit(KEY_DOWN))
-		{
-			curr_selection = ((curr_selection + 1) % NUM_MENU_OPTIONS);
-		}
-		else if (key_hit(KEY_UP))
-		{
-			if (curr_selection == 0) {
-				curr_selection = NUM_MENU_OPTIONS - 1;
-			}
-			else {
-				curr_selection = ((curr_selection + (NUM_MENU_OPTIONS - 1)) % NUM_MENU_OPTIONS);
-			}
-		}
-		else if (key_hit(KEY_A))
-		{
-			tte_erase_rect(0, test, H_MAX, V_MAX);
-			return return_values[curr_selection];
-		}
-		else if ((key_held(KEY_L) && key_held(KEY_R)))
-		{
-			return BTN_DEBUG_MENU;
-		}
-		else
-		{
-			update = false;
-		}
-		VBlankIntrWait();
-	}
+        update = true;
+        if (key_hit(KEY_DOWN))
+        {
+            curr_selection = ((curr_selection + 1) % NUM_MENU_OPTIONS);
+        }
+        else if (key_hit(KEY_UP))
+        {
+            if (curr_selection == 0)
+            {
+                curr_selection = NUM_MENU_OPTIONS - 1;
+            }
+            else
+            {
+                curr_selection = ((curr_selection + (NUM_MENU_OPTIONS - 1)) %
+                                  NUM_MENU_OPTIONS);
+            }
+        }
+        else if (key_hit(KEY_A))
+        {
+            tte_erase_rect(0, test, H_MAX, V_MAX);
+            return return_values[curr_selection];
+        }
+        else if ((key_held(KEY_L) && key_held(KEY_R)))
+        {
+            return BTN_DEBUG_MENU;
+        }
+        else
+        {
+            update = false;
+        }
+        VBlankIntrWait();
+    }
 }
 
 // Gears of Progress
 static void show_gears_of_progress()
 {
-	REG_BG1VOFS = 0;
-	delay_counter = 0;
-	while (delay_counter < (15 * 60))
-	{
-		VBlankIntrWait();
-		delay_counter++;
-		if (key_hit(KEY_A))
-		{
-			delay_counter = (15 * 60);
-		}
-	}
+    REG_BG1VOFS = 0;
+    delay_counter = 0;
+    while (delay_counter < (15 * 60))
+    {
+        VBlankIntrWait();
+        delay_counter++;
+        if (key_hit(KEY_A))
+        {
+            delay_counter = (15 * 60);
+        }
+    }
 }
 
-// split off from the main function in order to keep the scope of the variables limited to the execution of this function
-// otherwise they stick around for the entire runtime of the program
-// the attribute noinline is used to prevent the compiler from inlining this function back into the main function
-// this decision was based on the output of build/main.su after adding the -fstack-usage compile flag
+// split off from the main function in order to keep the scope of the variables
+// limited to the execution of this function otherwise they stick around for the
+// entire runtime of the program the attribute noinline is used to prevent the
+// compiler from inlining this function back into the main function this
+// decision was based on the output of build/main.su after adding the
+// -fstack-usage compile flag
 static void __attribute__((noinline)) show_intro()
 {
-	u8 general_text_table_buffer[2048];
-	u8 lineBuffer[1024];
-	const u8 **chunkList;
-	u32 numChunks;
-	u32 chunkSize;
+    u8 general_text_table_buffer[2048];
+    u8 lineBuffer[1024];
+    const u8 **chunkList;
+    u32 numChunks;
+    u32 chunkSize;
 
-	get_text_table_chunks(GENERAL_INDEX, &chunkList, &numChunks, &chunkSize);
-	FileContainerReader general_text_reader(chunkList, numChunks, chunkSize);
-	bool start_pressed = false;
+    get_text_table_chunks(GENERAL_INDEX, &chunkList, &numChunks, &chunkSize);
+    FileContainerReader general_text_reader(chunkList, numChunks, chunkSize);
+    bool start_pressed = false;
 
-	general_text_reader.init(general_text_table_buffer, sizeof(general_text_table_buffer));
+    general_text_reader.init(
+        general_text_table_buffer, sizeof(general_text_table_buffer));
 
-	tte_set_ink(INK_ROM_COLOR);
-	general_text_reader.readFile(GENERAL_intro_legal, lineBuffer);
-	ptgb_write_textbox(lineBuffer, true, true, GENERAL_INDEX, GENERAL_intro_legal, true);
+    tte_set_ink(INK_ROM_COLOR);
+    general_text_reader.readFile(GENERAL_intro_legal, lineBuffer);
+    ptgb_write_textbox(
+        lineBuffer, true, true, GENERAL_INDEX, GENERAL_intro_legal, true);
 
-	show_gears_of_progress();
+    show_gears_of_progress();
 
-	BG_FLEX = BG_FLEX | BG_PRIO(3);
+    BG_FLEX = BG_FLEX | BG_PRIO(3);
 
-	// key_poll(); // Reset the keys
-	curr_GBA_rom.load_rom(false);
+    // key_poll(); // Reset the keys
+    curr_GBA_rom.load_rom(false);
 
-	obj_set_pos(ptgb_logo_l, 56, 12);
-	obj_set_pos(ptgb_logo_r, 56 + 64, 12);
-	obj_unhide_multi(ptgb_logo_l, 1, 2);
+    obj_set_pos(ptgb_logo_l, 56, 12);
+    obj_set_pos(ptgb_logo_r, 56 + 64, 12);
+    obj_unhide_multi(ptgb_logo_l, 1, 2);
 
-	REG_BLDCNT = BLD_BUILD(BLD_BG3, BLD_BG0, 1);
+    REG_BLDCNT = BLD_BUILD(BLD_BG3, BLD_BG0, 1);
 
-	general_text_reader.readFile(GENERAL_press_start, lineBuffer);
+    general_text_reader.readFile(GENERAL_press_start, lineBuffer);
 
-	tte_set_pos(0, 12 * 8);
-	tte_set_ink(INK_DARK_GREY);
-	ptgb_write_simple(lineBuffer, true);
+    tte_set_pos(0, 12 * 8);
+    tte_set_ink(INK_DARK_GREY);
+    ptgb_write_simple(lineBuffer, true);
 
-	int fade = 0;
-	while (!start_pressed)
-	{
-		fade = abs(((get_frame_count() / 6) % 24) - 12);
-		VBlankIntrWait();
-		start_pressed = key_hit(KEY_START) | key_hit(KEY_A);
-		REG_BLDALPHA = BLDA_BUILD(0b10000, fade);
-	}
+    int fade = 0;
+    while (!start_pressed)
+    {
+        fade = abs(((get_frame_count() / 6) % 24) - 12);
+        VBlankIntrWait();
+        start_pressed = key_hit(KEY_START) | key_hit(KEY_A);
+        REG_BLDALPHA = BLDA_BUILD(0b10000, fade);
+    }
 }
 
 int main(void)
 {
-	// Clear VRAM. We use it as extra BSS.
-	RegisterRamReset(RESET_VRAM);
-	malloc_init_default_pool();
-	initialization_script();
+    // Clear VRAM. We use it as extra BSS.
+    RegisterRamReset(RESET_VRAM);
+    malloc_init_default_pool();
+    initialization_script();
 
-	// Set colors based on current ROM
-	set_background_pal(0, false, false);
+    // Set colors based on current ROM
+    set_background_pal(0, false, false);
 
-	show_intro();
+    show_intro();
 
-	// key_poll();
-	tte_erase_rect(0, 0, H_MAX, V_MAX);
-	REG_BLDALPHA = BLDA_BUILD(0b10000, 0); // Reset fade
+    // key_poll();
+    tte_erase_rect(0, 0, H_MAX, V_MAX);
+    REG_BLDALPHA = BLDA_BUILD(0b10000, 0); // Reset fade
 
-	//  Check if the game has been loaded correctly.
-	bool debug = false;
-	while (!curr_GBA_rom.load_rom(debug))
-	{
-		if (g_debug_options.ignore_game_pak)
-		{
-			debug = true;
-		}
-		else
-		{
-			obj_hide_multi(ptgb_logo_l, 2);
-			VBlankIntrWait();
-			game_load_error();
-			// initialization_script();
-		}
-	}
+    //  Check if the game has been loaded correctly.
+    bool debug = false;
+    while (!curr_GBA_rom.load_rom(debug))
+    {
+        if (g_debug_options.ignore_game_pak)
+        {
+            debug = true;
+        }
+        else
+        {
+            obj_hide_multi(ptgb_logo_l, 2);
+            VBlankIntrWait();
+            game_load_error();
+            // initialization_script();
+        }
+    }
 
-	/*
-	// This isn't needed anymore
-	if ((curr_GBA_rom.language == LANG_JPN) != (PTGB_BUILD_LANGUAGE == JPN_ID))
-	{			
-		obj_hide_multi(ptgb_logo_l, 2);
-		VBlankIntrWait();
-		lang_mismatch_error();
-	}
-	*/
+    /*
+    // This isn't needed anymore
+    if ((curr_GBA_rom.language == LANG_JPN) != (PTGB_BUILD_LANGUAGE == JPN_ID))
+    {
+        obj_hide_multi(ptgb_logo_l, 2);
+        VBlankIntrWait();
+        lang_mismatch_error();
+    }
+    */
 
-	// Initialize memory and save data after loading the game
-	BG_TEXTBOX = BG_TEXTBOX | BG_PRIO(3);
-	init_bank();
-	initialize_memory_locations();
-	load_custom_save_data();
+    // Initialize memory and save data after loading the game
+    BG_TEXTBOX = BG_TEXTBOX | BG_PRIO(3);
+    init_bank();
+    initialize_memory_locations();
+    load_custom_save_data();
 
-	set_background_pal(curr_GBA_rom.gamecode, false, true);
+    set_background_pal(curr_GBA_rom.gamecode, false, true);
 
-	if (!get_tutorial_flag() || g_debug_options.force_tutorial)
-	{
-		obj_hide_multi(ptgb_logo_l, 2);
-		load_flex_background(FBG_Fennel, 2);
-		text_loop(BTN_TRANSFER);
-		initialize_save_data();
-		// TODO: We should be able to test for a Bootleg rom in here- if the save data isn't written, then it is bootleg.
-	}
+    if (!get_tutorial_flag() || g_debug_options.force_tutorial)
+    {
+        obj_hide_multi(ptgb_logo_l, 2);
+        load_flex_background(FBG_Fennel, 2);
+        text_loop(BTN_TRANSFER);
+        initialize_save_data();
+        // TODO: We should be able to test for a Bootleg rom in here- if the
+        // save data isn't written, then it is bootleg.
+    }
 
-	obj_unhide_multi(ptgb_logo_l, 1, 2);
+    obj_unhide_multi(ptgb_logo_l, 1, 2);
 
-	// MAIN LOOP
-	while (true)
-	{
-		if (DEBUG_MODE && false) // This isn't really needed anymore
-		{
-			print_mem_section();
-			curr_GBA_rom.print_rom_info();
-		}
-		load_flex_background(FBG_Main_Menu, 2);
+    // MAIN LOOP
+    while (true)
+    {
+        if (DEBUG_MODE && false) // This isn't really needed anymore
+        {
+            print_mem_section();
+            curr_GBA_rom.print_rom_info();
+        }
+        load_flex_background(FBG_Main_Menu, 2);
 
-		obj_unhide_multi(ptgb_logo_l, 1, 2);
-		obj_set_pos(ptgb_logo_l, 56, 12);
-		obj_set_pos(ptgb_logo_r, 56 + 64, 12);
+        obj_unhide_multi(ptgb_logo_l, 1, 2);
+        obj_set_pos(ptgb_logo_l, 56, 12);
+        obj_set_pos(ptgb_logo_r, 56 + 64, 12);
 
-		switch (main_menu_loop())
-		{
-		case (BTN_TRANSFER):
-			tte_set_ink(INK_DARK_GREY);
-			obj_hide_multi(ptgb_logo_l, 2);
-			load_flex_background(FBG_Fennel, 3);
-			text_loop(SCRIPT_TRANSFER);
-			break;
-		case (BTN_POKEDEX):
-			if (get_tutorial_flag())
-			{
-				obj_hide_multi(ptgb_logo_l, 2);
-				// global_next_frame();
-				load_flex_background(FBG_Dex, 2);
-				set_background_pal(curr_GBA_rom.gamecode, true, false);
-				pokedex_loop();
-				load_flex_background(FBG_Dex, 3);
-				set_background_pal(curr_GBA_rom.gamecode, false, false);
-			}
-			break;
-		case (BTN_CREDITS):
-			tte_set_ink(INK_DARK_GREY);
-			BG_FLEX = (BG_FLEX & ~BG_PRIO_MASK) | BG_PRIO(3);
-			obj_hide_multi(ptgb_logo_l, 2);
-			credits();
-			break;
-		case (BTN_TUTORIAL):
-			tte_set_ink(INK_DARK_GREY);
-			BG_FLEX = (BG_FLEX & ~BG_PRIO_MASK) | BG_PRIO(3);
-			obj_hide_multi(ptgb_logo_l, 2);
-			tutorial();
-			break;
-		case (BTN_EVENTS):
-			obj_hide_multi(ptgb_logo_l, 2);
-			text_loop(SCRIPT_EVENT);
-			break;
+        switch (main_menu_loop())
+        {
+        case (BTN_TRANSFER):
+            tte_set_ink(INK_DARK_GREY);
+            obj_hide_multi(ptgb_logo_l, 2);
+            load_flex_background(FBG_Fennel, 3);
+            text_loop(SCRIPT_TRANSFER);
+            break;
+        case (BTN_POKEDEX):
+            if (get_tutorial_flag())
+            {
+                obj_hide_multi(ptgb_logo_l, 2);
+                // global_next_frame();
+                load_flex_background(FBG_Dex, 2);
+                set_background_pal(curr_GBA_rom.gamecode, true, false);
+                pokedex_loop();
+                load_flex_background(FBG_Dex, 3);
+                set_background_pal(curr_GBA_rom.gamecode, false, false);
+            }
+            break;
+        case (BTN_CREDITS):
+            tte_set_ink(INK_DARK_GREY);
+            BG_FLEX = (BG_FLEX & ~BG_PRIO_MASK) | BG_PRIO(3);
+            obj_hide_multi(ptgb_logo_l, 2);
+            credits();
+            break;
+        case (BTN_TUTORIAL):
+            tte_set_ink(INK_DARK_GREY);
+            BG_FLEX = (BG_FLEX & ~BG_PRIO_MASK) | BG_PRIO(3);
+            obj_hide_multi(ptgb_logo_l, 2);
+            tutorial();
+            break;
+        case (BTN_EVENTS):
+            obj_hide_multi(ptgb_logo_l, 2);
+            text_loop(SCRIPT_EVENT);
+            break;
 #if ENABLE_DEBUG_MENU
-		case (BTN_DEBUG_MENU):
-			obj_hide_multi(ptgb_logo_l, 2);
-			load_flex_background(FBG_Fennel, 3);
-			show_debug_menu();
-			break;
+        case (BTN_DEBUG_MENU):
+            obj_hide_multi(ptgb_logo_l, 2);
+            load_flex_background(FBG_Fennel, 3);
+            show_debug_menu();
+            break;
 #endif
-		default:
-			VBlankIntrWait();
-		}
-	}
+        default:
+            VBlankIntrWait();
+        }
+    }
 }
\ No newline at end of file
diff --git a/source/multiboot_upload.cpp b/source/multiboot_upload.cpp
index 2d60fd2..a907254 100644
--- a/source/multiboot_upload.cpp
+++ b/source/multiboot_upload.cpp
@@ -1,71 +1,75 @@
 #include <tonc.h>
 
-#include "global_frame_controller.h"
+#include "FileContainerReader.h"
 #include "background_engine.h"
+#include "global_frame_controller.h"
 #include "libraries/gba-link-connection/LinkCableMultiboot.hpp"
 #include "text_engine.h"
-#include "translated_text.h"
-#include "FileContainerReader.h"
 #include "text_tables.h"
+#include "translated_text.h"
 
 void multiboot_upload_screen()
 {
-	u8 decompression_buffer[2048];
-	u8 lineBuffer[1024];
-	const u8 **chunkList;
-	u32 numChunks;
-	u32 chunkSize;
+    u8 decompression_buffer[2048];
+    u8 lineBuffer[1024];
+    const u8 **chunkList;
+    u32 numChunks;
+    u32 chunkSize;
 
-	get_text_table_chunks(GENERAL_INDEX, &chunkList, &numChunks, &chunkSize);
-	FileContainerReader general_text_reader(chunkList, numChunks, chunkSize);
-	LinkCableMultiboot linkCableMultiboot;
+    get_text_table_chunks(GENERAL_INDEX, &chunkList, &numChunks, &chunkSize);
+    FileContainerReader general_text_reader(chunkList, numChunks, chunkSize);
+    LinkCableMultiboot linkCableMultiboot;
 
-	general_text_reader.init(decompression_buffer, sizeof(decompression_buffer));
+    general_text_reader.init(
+        decompression_buffer, sizeof(decompression_buffer));
 
-	// multiboot_show_textbox();
-	general_text_reader.readFile(GENERAL_send_multiboot_instructions, lineBuffer);
-	ptgb_write_textbox(lineBuffer, true,
-					   false, GENERAL_INDEX, GENERAL_send_multiboot_instructions, false);
+    // multiboot_show_textbox();
+    general_text_reader.readFile(
+        GENERAL_send_multiboot_instructions, lineBuffer);
+    ptgb_write_textbox(lineBuffer, true, false, GENERAL_INDEX,
+        GENERAL_send_multiboot_instructions, false);
 
-	// wait for key press
-	do
-	{
-		VBlankIntrWait();
-	} while (!key_hit(KEY_A) && !key_hit(KEY_B));
+    // wait for key press
+    do
+    {
+        VBlankIntrWait();
+    } while (!key_hit(KEY_A) && !key_hit(KEY_B));
 
-	if (key_hit(KEY_B))
-	{
-		// cancel
-		return;
-	}
+    if (key_hit(KEY_B))
+    {
+        // cancel
+        return;
+    }
 
-	// start upload
-	// multiboot_show_textbox();
-	general_text_reader.readFile(GENERAL_send_multiboot_wait, lineBuffer);
-	ptgb_write_textbox(lineBuffer, true,
-					   false, GENERAL_INDEX, GENERAL_send_multiboot_wait, false);
-	VBlankIntrWait();
+    // start upload
+    // multiboot_show_textbox();
+    general_text_reader.readFile(GENERAL_send_multiboot_wait, lineBuffer);
+    ptgb_write_textbox(lineBuffer, true, false, GENERAL_INDEX,
+        GENERAL_send_multiboot_wait, false);
+    VBlankIntrWait();
 
-	const u32 romSize = 256 * 1024; // EWRAM = 256 KB
-	LinkCableMultiboot::Result multibootResult = linkCableMultiboot.sendRom(
-		((const u8 *)MEM_EWRAM),
-		romSize,
-		[]()
-		{
-			u16 keys = ~REG_KEYS & KEY_ANY;
-			return keys & KEY_B;
-			// (when this returns true, the transfer will be canceled)
-		});
-	// show result
-	// multiboot_show_textbox();
-	u32 fileIndex = (multibootResult == LinkCableMultiboot::Result::SUCCESS) ? GENERAL_send_multiboot_success : GENERAL_send_multiboot_failure;
-	general_text_reader.readFile(fileIndex, lineBuffer);
+    const u32 romSize = 256 * 1024; // EWRAM = 256 KB
+    LinkCableMultiboot::Result multibootResult =
+        linkCableMultiboot.sendRom(((const u8 *)MEM_EWRAM), romSize,
+            []()
+            {
+                u16 keys = ~REG_KEYS & KEY_ANY;
+                return keys & KEY_B;
+                // (when this returns true, the transfer will be canceled)
+            });
+    // show result
+    // multiboot_show_textbox();
+    u32 fileIndex = (multibootResult == LinkCableMultiboot::Result::SUCCESS)
+                        ? GENERAL_send_multiboot_success
+                        : GENERAL_send_multiboot_failure;
+    general_text_reader.readFile(fileIndex, lineBuffer);
 
-	ptgb_write_textbox(lineBuffer, true, false, GENERAL_INDEX, fileIndex, false);
+    ptgb_write_textbox(
+        lineBuffer, true, false, GENERAL_INDEX, fileIndex, false);
 
-	// wait for keypress again.
-	do
-	{
-		VBlankIntrWait();
-	} while (!key_hit(KEY_A));
+    // wait for keypress again.
+    do
+    {
+        VBlankIntrWait();
+    } while (!key_hit(KEY_A));
 }
\ No newline at end of file
diff --git a/source/mystery_gift_injector.cpp b/source/mystery_gift_injector.cpp
index bfd081f..5543407 100644
--- a/source/mystery_gift_injector.cpp
+++ b/source/mystery_gift_injector.cpp
@@ -1,22 +1,21 @@
-#include <tonc.h>
 #include "mystery_gift_injector.h"
-#include "pokemon_data.h"
+#include "FileContainerReader.h"
+#include "compression_chunks.h"
 #include "flash_mem.h"
-#include "rom_data.h"
+#include "global_frame_controller.h"
 #include "libraries/Pokemon-Gen3-to-Gen-X/include/save.h"
 #include "pokemon_data.h"
 #include "ptgb_save_data_manager.h"
-#include "FileContainerReader.h"
-#include "global_frame_controller.h"
-#include "translated_text.h"
+#include "rom_data.h"
 #include "script_patches.h"
-#include "section30_patches.h"
 #include "script_ruby_english_1_0_lz10_bin.h"
+#include "section30_patches.h"
 #include "section30_ruby_english_1_0_lz10_bin.h"
-#include "compression_chunks.h"
+#include "translated_text.h"
+#include <array>
 #include <cstdlib>
 #include <cstring>
-#include <array>
+#include <tonc.h>
 
 extern "C"
 {
@@ -29,7 +28,8 @@ extern "C"
 // These defines are there because rom_data defines values that
 // occupy more bytes/bits than needed.
 // We use these to create a table with a packed key below: patchFileTable
-// also refer to the comment on PACK_PATCH_KEY() for more details on how the key is packed.
+// also refer to the comment on PACK_PATCH_KEY() for more details on how the key
+// is packed.
 #define MAP_RUBY 0
 #define MAP_SAPPHIRE 1
 #define MAP_FIRERED 2
@@ -43,15 +43,15 @@ extern "C"
 #define MAP_ITALIAN 4
 #define MAP_SPANISH 5
 
-
-// So, we need to associate the rom_data values with a specific patch file to convert the
-// game-based payload to our specific language variant.
-// But we only have indexes and their enum namings.
-// So we need to map them.
-// The thing is: using the existing RUBY_ID and LANG_ENG defines, would make this table much larger than it needs to be.
-// There are 5 game variants (3 bits), and 6 languages (3 bits) and the highest version of those roms is 1.2 (2 bits)
-// So we can pack this data into a single byte.
-#define PACK_PATCH_KEY(game, lang, version) (((game) << 5) | ((lang) << 2) | (version))
+// So, we need to associate the rom_data values with a specific patch file to
+// convert the game-based payload to our specific language variant. But we only
+// have indexes and their enum namings. So we need to map them. The thing is:
+// using the existing RUBY_ID and LANG_ENG defines, would make this table much
+// larger than it needs to be. There are 5 game variants (3 bits), and 6
+// languages (3 bits) and the highest version of those roms is 1.2 (2 bits) So
+// we can pack this data into a single byte.
+#define PACK_PATCH_KEY(game, lang, version)                                    \
+    (((game) << 5) | ((lang) << 2) | (version))
 
 #define SKIP_PATCH_INDEX 0xFF
 
@@ -62,75 +62,144 @@ typedef struct PatchFileTableEntry
     u8 specificPatchIndex;
 } PatchFileTableEntry;
 
-// We only need to have a single map of the patch files, because the order and size of the section30 and script patches are exactly the same.
-static constexpr PatchFileTableEntry patchFileTable[] =
-{
+// We only need to have a single map of the patch files, because the order and
+// size of the section30 and script patches are exactly the same.
+static constexpr PatchFileTableEntry patchFileTable[] = {
     // english: game-specific transformation happens outside of this table
     // no language specific transformation required
     // only version-specific one
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_ENGLISH, VERS_1_0), SKIP_PATCH_INDEX, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_ENGLISH, VERS_1_1), SKIP_PATCH_INDEX, (u8)Script_patchesFiles::SCRIPT_RUBY_ENGLISH_1_1 },
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_ENGLISH, VERS_1_2), SKIP_PATCH_INDEX, (u8)Script_patchesFiles::SCRIPT_RUBY_ENGLISH_1_2 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_ENGLISH, VERS_1_0), SKIP_PATCH_INDEX, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_ENGLISH_1_0 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_ENGLISH, VERS_1_1), SKIP_PATCH_INDEX, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_ENGLISH_1_1 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_ENGLISH, VERS_1_2), SKIP_PATCH_INDEX, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_ENGLISH_1_2 },
-    { PACK_PATCH_KEY(MAP_EMERALD, MAP_ENGLISH, VERS_1_0), SKIP_PATCH_INDEX, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_FIRERED, MAP_ENGLISH, VERS_1_0), SKIP_PATCH_INDEX, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_FIRERED, MAP_ENGLISH, VERS_1_1), SKIP_PATCH_INDEX, (u8)Script_patchesFiles::SCRIPT_FIRERED_ENGLISH_1_1 },
-    { PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_ENGLISH, VERS_1_0), SKIP_PATCH_INDEX, (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_ENGLISH_1_0 },
-    { PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_ENGLISH, VERS_1_1), SKIP_PATCH_INDEX, (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_ENGLISH_1_1 },
-    // Other languages: game-specific transformation (e.g. english ruby -> english fire red) happens outside of this table
-    // language-specific transformation transforms the english game specific payload to the french one
-    // version-specific transformation transforms ruby->sapphire or 1.0->1.1 or both.
-    // French:
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_FRENCH, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_RUBY_FRENCH_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_FRENCH, VERS_1_1), (u8)Script_patchesFiles::SCRIPT_RUBY_FRENCH_1_0, (u8)Script_patchesFiles::SCRIPT_RUBY_FRENCH_1_1 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_FRENCH, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_RUBY_FRENCH_1_0, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_FRENCH_1_0 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_FRENCH, VERS_1_1), (u8)Script_patchesFiles::SCRIPT_RUBY_FRENCH_1_0, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_FRENCH_1_1 },
-    { PACK_PATCH_KEY(MAP_EMERALD, MAP_FRENCH, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_EMERALD_FRENCH_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_FIRERED, MAP_FRENCH, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_FIRERED_FRENCH_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_FRENCH, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_FIRERED_FRENCH_1_0, (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_FRENCH_1_0 },
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_ENGLISH, VERS_1_0), SKIP_PATCH_INDEX,
+        SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_ENGLISH, VERS_1_1), SKIP_PATCH_INDEX,
+        (u8)Script_patchesFiles::SCRIPT_RUBY_ENGLISH_1_1},
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_ENGLISH, VERS_1_2), SKIP_PATCH_INDEX,
+        (u8)Script_patchesFiles::SCRIPT_RUBY_ENGLISH_1_2},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_ENGLISH, VERS_1_0), SKIP_PATCH_INDEX,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_ENGLISH_1_0},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_ENGLISH, VERS_1_1), SKIP_PATCH_INDEX,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_ENGLISH_1_1},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_ENGLISH, VERS_1_2), SKIP_PATCH_INDEX,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_ENGLISH_1_2},
+    {PACK_PATCH_KEY(MAP_EMERALD, MAP_ENGLISH, VERS_1_0), SKIP_PATCH_INDEX,
+        SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_FIRERED, MAP_ENGLISH, VERS_1_0), SKIP_PATCH_INDEX,
+        SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_FIRERED, MAP_ENGLISH, VERS_1_1), SKIP_PATCH_INDEX,
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_ENGLISH_1_1},
+    {PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_ENGLISH, VERS_1_0), SKIP_PATCH_INDEX,
+        (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_ENGLISH_1_0},
+    {PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_ENGLISH, VERS_1_1), SKIP_PATCH_INDEX,
+        (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_ENGLISH_1_1},
+    // Other languages: game-specific transformation (e.g. english ruby ->
+    // english fire red) happens outside of this table language-specific
+    // transformation transforms the english game specific payload to the french
+    // one version-specific transformation transforms ruby->sapphire or 1.0->1.1
+    // or both. French:
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_FRENCH, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_FRENCH_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_FRENCH, VERS_1_1),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_FRENCH_1_0,
+        (u8)Script_patchesFiles::SCRIPT_RUBY_FRENCH_1_1},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_FRENCH, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_FRENCH_1_0,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_FRENCH_1_0},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_FRENCH, VERS_1_1),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_FRENCH_1_0,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_FRENCH_1_1},
+    {PACK_PATCH_KEY(MAP_EMERALD, MAP_FRENCH, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_EMERALD_FRENCH_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_FIRERED, MAP_FRENCH, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_FRENCH_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_FRENCH, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_FRENCH_1_0,
+        (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_FRENCH_1_0},
     // German:
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_GERMAN, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_RUBY_GERMAN_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_GERMAN, VERS_1_1), (u8)Script_patchesFiles::SCRIPT_RUBY_GERMAN_1_0, (u8)Script_patchesFiles::SCRIPT_RUBY_GERMAN_1_1 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_GERMAN, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_RUBY_GERMAN_1_0, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_GERMAN_1_0 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_GERMAN, VERS_1_1), (u8)Script_patchesFiles::SCRIPT_RUBY_GERMAN_1_0, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_GERMAN_1_1 },
-    { PACK_PATCH_KEY(MAP_EMERALD, MAP_GERMAN, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_EMERALD_GERMAN_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_FIRERED, MAP_GERMAN, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_FIRERED_GERMAN_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_GERMAN, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_FIRERED_GERMAN_1_0, (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_GERMAN_1_0 },
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_GERMAN, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_GERMAN_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_GERMAN, VERS_1_1),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_GERMAN_1_0,
+        (u8)Script_patchesFiles::SCRIPT_RUBY_GERMAN_1_1},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_GERMAN, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_GERMAN_1_0,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_GERMAN_1_0},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_GERMAN, VERS_1_1),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_GERMAN_1_0,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_GERMAN_1_1},
+    {PACK_PATCH_KEY(MAP_EMERALD, MAP_GERMAN, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_EMERALD_GERMAN_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_FIRERED, MAP_GERMAN, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_GERMAN_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_GERMAN, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_GERMAN_1_0,
+        (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_GERMAN_1_0},
     // Italian:
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_ITALIAN, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_RUBY_ITALIAN_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_ITALIAN, VERS_1_1), (u8)Script_patchesFiles::SCRIPT_RUBY_ITALIAN_1_0, (u8)Script_patchesFiles::SCRIPT_RUBY_ITALIAN_1_1 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_ITALIAN, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_RUBY_ITALIAN_1_0, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_ITALIAN_1_0 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_ITALIAN, VERS_1_1), (u8)Script_patchesFiles::SCRIPT_RUBY_ITALIAN_1_0, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_ITALIAN_1_1 },
-    { PACK_PATCH_KEY(MAP_EMERALD, MAP_ITALIAN, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_EMERALD_ITALIAN_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_FIRERED, MAP_ITALIAN, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_FIRERED_ITALIAN_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_ITALIAN, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_FIRERED_ITALIAN_1_0, (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_ITALIAN_1_0 },
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_ITALIAN, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_ITALIAN_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_ITALIAN, VERS_1_1),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_ITALIAN_1_0,
+        (u8)Script_patchesFiles::SCRIPT_RUBY_ITALIAN_1_1},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_ITALIAN, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_ITALIAN_1_0,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_ITALIAN_1_0},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_ITALIAN, VERS_1_1),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_ITALIAN_1_0,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_ITALIAN_1_1},
+    {PACK_PATCH_KEY(MAP_EMERALD, MAP_ITALIAN, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_EMERALD_ITALIAN_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_FIRERED, MAP_ITALIAN, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_ITALIAN_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_ITALIAN, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_ITALIAN_1_0,
+        (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_ITALIAN_1_0},
     // Japanese:
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_JAPANESE, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_RUBY_JAPANESE_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_JAPANESE, VERS_1_1), (u8)Script_patchesFiles::SCRIPT_RUBY_JAPANESE_1_0, (u8)Script_patchesFiles::SCRIPT_RUBY_JAPANESE_1_1 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_JAPANESE, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_RUBY_JAPANESE_1_0, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_JAPANESE_1_0 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_JAPANESE, VERS_1_1), (u8)Script_patchesFiles::SCRIPT_RUBY_JAPANESE_1_0, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_JAPANESE_1_1 },
-    { PACK_PATCH_KEY(MAP_EMERALD, MAP_JAPANESE, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_EMERALD_JAPANESE_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_FIRERED, MAP_JAPANESE, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_FIRERED_JAPANESE_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_FIRERED, MAP_JAPANESE, VERS_1_1), (u8)Script_patchesFiles::SCRIPT_FIRERED_JAPANESE_1_0, (u8)Script_patchesFiles::SCRIPT_FIRERED_JAPANESE_1_1 },
-    { PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_JAPANESE, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_FIRERED_JAPANESE_1_0, (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_JAPANESE_1_0 },
-    { PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_JAPANESE, VERS_1_1), (u8)Script_patchesFiles::SCRIPT_FIRERED_JAPANESE_1_0, (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_JAPANESE_1_1 },
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_JAPANESE, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_JAPANESE_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_JAPANESE, VERS_1_1),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_JAPANESE_1_0,
+        (u8)Script_patchesFiles::SCRIPT_RUBY_JAPANESE_1_1},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_JAPANESE, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_JAPANESE_1_0,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_JAPANESE_1_0},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_JAPANESE, VERS_1_1),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_JAPANESE_1_0,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_JAPANESE_1_1},
+    {PACK_PATCH_KEY(MAP_EMERALD, MAP_JAPANESE, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_EMERALD_JAPANESE_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_FIRERED, MAP_JAPANESE, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_JAPANESE_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_FIRERED, MAP_JAPANESE, VERS_1_1),
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_JAPANESE_1_0,
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_JAPANESE_1_1},
+    {PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_JAPANESE, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_JAPANESE_1_0,
+        (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_JAPANESE_1_0},
+    {PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_JAPANESE, VERS_1_1),
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_JAPANESE_1_0,
+        (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_JAPANESE_1_1},
     // Spanish:
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_SPANISH, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_RUBY_SPANISH_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_RUBY, MAP_SPANISH, VERS_1_1), (u8)Script_patchesFiles::SCRIPT_RUBY_SPANISH_1_0, (u8)Script_patchesFiles::SCRIPT_RUBY_SPANISH_1_1 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_SPANISH, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_RUBY_SPANISH_1_0, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_SPANISH_1_0 },
-    { PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_SPANISH, VERS_1_1), (u8)Script_patchesFiles::SCRIPT_RUBY_SPANISH_1_0, (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_SPANISH_1_1 },
-    { PACK_PATCH_KEY(MAP_EMERALD, MAP_SPANISH, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_EMERALD_SPANISH_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_FIRERED, MAP_SPANISH, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_FIRERED_SPANISH_1_0, SKIP_PATCH_INDEX },
-    { PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_SPANISH, VERS_1_0), (u8)Script_patchesFiles::SCRIPT_FIRERED_SPANISH_1_0, (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_SPANISH_1_0 }
-};
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_SPANISH, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_SPANISH_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_RUBY, MAP_SPANISH, VERS_1_1),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_SPANISH_1_0,
+        (u8)Script_patchesFiles::SCRIPT_RUBY_SPANISH_1_1},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_SPANISH, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_SPANISH_1_0,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_SPANISH_1_0},
+    {PACK_PATCH_KEY(MAP_SAPPHIRE, MAP_SPANISH, VERS_1_1),
+        (u8)Script_patchesFiles::SCRIPT_RUBY_SPANISH_1_0,
+        (u8)Script_patchesFiles::SCRIPT_SAPPHIRE_SPANISH_1_1},
+    {PACK_PATCH_KEY(MAP_EMERALD, MAP_SPANISH, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_EMERALD_SPANISH_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_FIRERED, MAP_SPANISH, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_SPANISH_1_0, SKIP_PATCH_INDEX},
+    {PACK_PATCH_KEY(MAP_LEAFGREEN, MAP_SPANISH, VERS_1_0),
+        (u8)Script_patchesFiles::SCRIPT_FIRERED_SPANISH_1_0,
+        (u8)Script_patchesFiles::SCRIPT_LEAFGREEN_SPANISH_1_0}};
 
 static constexpr std::pair<u16, u16> firstTimeTextEntryPairs[] = {
     {RSEFRLG_dia_textIAm_first_rs, RSEFRLG_dia_textIAm_second_rs},
     {RSEFRLG_dia_textIAm_first_frlge, RSEFRLG_dia_textIAm_second_frlge},
-    {RSEFRLG_dia_textYouMustBe_first, RSEFRLG_dia_textYouMustBe_second}
-};
+    {RSEFRLG_dia_textYouMustBe_first, RSEFRLG_dia_textYouMustBe_second}};
 
 #if BUILD_LANG == 7
 static const u8 **RSEFRLG_spanish_chunk_list = RSEFRLG_spanishLA_chunk_list;
@@ -139,12 +208,93 @@ static const u8 **RSEFRLG_spanish_chunk_list = RSEFRLG_spanishEU_chunk_list;
 #endif
 
 // This will need to be modified for the JP releases
-static constexpr u8 em_wonder_card[0x14E] = {
-    0x08, 0x6E, 0x00, 0x00, 0xBA, 0xB4, 0xBE, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xCA, 0xCC, 0xC9, 0xC0, 0xBF, 0xCD, 0xCD, 0xC9, 0xCC, 0x00, 0xC0, 0xBF, 0xC8, 0xC8, 0xBF, 0xC6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCE, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0x00, 0xBD, 0xD9, 0xE6, 0xE8, 0xDD, 0xDA, 0xDD, 0xD7, 0xD5, 0xE8, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD0, 0xDD, 0xE7, 0xDD, 0xE8, 0x00, 0xE8, 0xDC, 0xD9, 0x00, 0xDC, 0xE3, 0xE9, 0xE7, 0xD9, 0x00, 0xE7, 0xE3, 0xE9, 0xE8, 0xDC, 0xD9, 0xD5, 0xE7, 0xE8, 0x00, 0xE3, 0xDA, 0x00, 0xE8, 0xDC, 0xD9, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xBD, 0xBF, 0xC8, 0xCE, 0xBF, 0xCC, 0x00, 0xDD, 0xE2, 0x00, 0xCD, 0xE3, 0xE3, 0xE8, 0xE3, 0xE4, 0xE3, 0xE0, 0xDD, 0xE7, 0x00, 0xBD, 0xDD, 0xE8, 0xED, 0x00, 0xE8, 0xE3, 0x00, 0xE6, 0xD9, 0xD7, 0xDD, 0xD9, 0xEA, 0xD9, 0x00, 0x00, 0x00, 0x00, 0xED, 0xE3, 0xE9, 0xE6, 0x00, 0xE8, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0xD9, 0xD8, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBE, 0xE3, 0x00, 0xE2, 0xE3, 0xE8, 0x00, 0xE8, 0xE3, 0xE7, 0xE7, 0x00, 0xE8, 0xDC, 0xDD, 0xE7, 0x00, 0xBF, 0xEC, 0xD7, 0xDC, 0xD5, 0xE2, 0xDB, 0xD9, 0x00, 0xBD, 0xD5, 0xE6, 0xD8, 0x00, 0xD6, 0xD9, 0xDA, 0xE3, 0xE6, 0xD9, 0x00, 0x00, 0x00, 0xE6, 0xD9, 0xD7, 0xD9, 0xDD, 0xEA, 0xDD, 0xE2, 0xDB, 0x00, 0xED, 0xE3, 0xE9, 0xE6, 0x00, 0xE8, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0xD9, 0xD8, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+static constexpr u8 em_wonder_card[0x14E] = {0x08, 0x6E, 0x00, 0x00, 0xBA, 0xB4,
+    0xBE, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xCA, 0xCC,
+    0xC9, 0xC0, 0xBF, 0xCD, 0xCD, 0xC9, 0xCC, 0x00, 0xC0, 0xBF, 0xC8, 0xC8,
+    0xBF, 0xC6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xCE, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0x00, 0xBD,
+    0xD9, 0xE6, 0xE8, 0xDD, 0xDA, 0xDD, 0xD7, 0xD5, 0xE8, 0xD9, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xD0, 0xDD, 0xE7, 0xDD, 0xE8, 0x00, 0xE8, 0xDC,
+    0xD9, 0x00, 0xDC, 0xE3, 0xE9, 0xE7, 0xD9, 0x00, 0xE7, 0xE3, 0xE9, 0xE8,
+    0xDC, 0xD9, 0xD5, 0xE7, 0xE8, 0x00, 0xE3, 0xDA, 0x00, 0xE8, 0xDC, 0xD9,
+    0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xBD, 0xBF, 0xC8, 0xCE,
+    0xBF, 0xCC, 0x00, 0xDD, 0xE2, 0x00, 0xCD, 0xE3, 0xE3, 0xE8, 0xE3, 0xE4,
+    0xE3, 0xE0, 0xDD, 0xE7, 0x00, 0xBD, 0xDD, 0xE8, 0xED, 0x00, 0xE8, 0xE3,
+    0x00, 0xE6, 0xD9, 0xD7, 0xDD, 0xD9, 0xEA, 0xD9, 0x00, 0x00, 0x00, 0x00,
+    0xED, 0xE3, 0xE9, 0xE6, 0x00, 0xE8, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9,
+    0xE6, 0xD9, 0xD8, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xAB,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBE, 0xE3, 0x00, 0xE2,
+    0xE3, 0xE8, 0x00, 0xE8, 0xE3, 0xE7, 0xE7, 0x00, 0xE8, 0xDC, 0xDD, 0xE7,
+    0x00, 0xBF, 0xEC, 0xD7, 0xDC, 0xD5, 0xE2, 0xDB, 0xD9, 0x00, 0xBD, 0xD5,
+    0xE6, 0xD8, 0x00, 0xD6, 0xD9, 0xDA, 0xE3, 0xE6, 0xD9, 0x00, 0x00, 0x00,
+    0xE6, 0xD9, 0xD7, 0xD9, 0xDD, 0xEA, 0xDD, 0xE2, 0xDB, 0x00, 0xED, 0xE3,
+    0xE9, 0xE6, 0x00, 0xE8, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0xD9,
+    0xD8, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xAB, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00};
 // static u8 rs_wonder_card[0x14E] = {
-//    0xCE, 0x7C, 0x00, 0x00, 0xBA, 0xB4, 0xBE, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xCA, 0xCC, 0xC9, 0xC0, 0xBF, 0xCD, 0xCD, 0xC9, 0xCC, 0x00, 0xC0, 0xBF, 0xC8, 0xC8, 0xBF, 0xC6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCE, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0x00, 0xBD, 0xD9, 0xE6, 0xE8, 0xDD, 0xDA, 0xDD, 0xD7, 0xD5, 0xE8, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD0, 0xDD, 0xE7, 0xDD, 0xE8, 0x00, 0xE8, 0xDC, 0xD9, 0x00, 0xDC, 0xE3, 0xE9, 0xE7, 0xD9, 0x00, 0xE7, 0xE3, 0xE9, 0xE8, 0xDC, 0xD9, 0xD5, 0xE7, 0xE8, 0x00, 0xE3, 0xDA, 0x00, 0xE8, 0xDC, 0xD9, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xBD, 0xBF, 0xC8, 0xCE, 0xBF, 0xCC, 0x00, 0xDD, 0xE2, 0x00, 0xC7, 0xE3, 0xE7, 0xE7, 0xD8, 0xD9, 0xD9, 0xE4, 0x00, 0xBD, 0xDD, 0xE8, 0xED, 0x00, 0xE8, 0xE3, 0x00, 0xE6, 0xD9, 0xD7, 0xDD, 0xD9, 0xEA, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xED, 0xE3, 0xE9, 0xE6, 0x00, 0xE8, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0xD9, 0xD8, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBE, 0xE3, 0x00, 0xE2, 0xE3, 0xE8, 0x00, 0xE8, 0xE3, 0xE7, 0xE7, 0x00, 0xE8, 0xDC, 0xDD, 0xE7, 0x00, 0xBF, 0xEC, 0xD7, 0xDC, 0xD5, 0xE2, 0xDB, 0xD9, 0x00, 0xBD, 0xD5, 0xE6, 0xD8, 0x00, 0xD6, 0xD9, 0xDA, 0xE3, 0xE6, 0xD9, 0x00, 0x00, 0x00, 0xE6, 0xD9, 0xD7, 0xD9, 0xDD, 0xEA, 0xDD, 0xE2, 0xDB, 0x00, 0xED, 0xE3, 0xE9, 0xE6, 0x00, 0xE8, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0xD9, 0xD8, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; // checksum
-static constexpr u8 frlg_wonder_card[0x14E] = {
-    0x67, 0x18, 0x00, 0x00, 0xBA, 0xB4, 0xBE, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xCA, 0xCC, 0xC9, 0xC0, 0xBF, 0xCD, 0xCD, 0xC9, 0xCC, 0x00, 0xC0, 0xBF, 0xC8, 0xC8, 0xBF, 0xC6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCE, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0x00, 0xBD, 0xD9, 0xE6, 0xE8, 0xDD, 0xDA, 0xDD, 0xD7, 0xD5, 0xE8, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD0, 0xDD, 0xE7, 0xDD, 0xE8, 0x00, 0xE8, 0xDC, 0xD9, 0x00, 0xDC, 0xE3, 0xE9, 0xE7, 0xD9, 0x00, 0xE7, 0xE3, 0xE9, 0xE8, 0xDC, 0x00, 0xE3, 0xDA, 0x00, 0xE8, 0xDC, 0xD9, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0x00, 0x00, 0x00, 0x00, 0xBD, 0xBF, 0xC8, 0xCE, 0xBF, 0xCC, 0x00, 0xE3, 0xE2, 0x00, 0xCD, 0xD9, 0xEA, 0xD9, 0xE2, 0x00, 0xC3, 0xE7, 0xE0, 0xD5, 0xE2, 0xD8, 0x00, 0xE8, 0xE3, 0x00, 0xE6, 0xD9, 0xD7, 0xDD, 0xD9, 0xEA, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xED, 0xE3, 0xE9, 0xE6, 0x00, 0xE8, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0xD9, 0xD8, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBE, 0xE3, 0x00, 0xE2, 0xE3, 0xE8, 0x00, 0xE8, 0xE3, 0xE7, 0xE7, 0x00, 0xE8, 0xDC, 0xDD, 0xE7, 0x00, 0xBF, 0xEC, 0xD7, 0xDC, 0xD5, 0xE2, 0xDB, 0xD9, 0x00, 0xBD, 0xD5, 0xE6, 0xD8, 0x00, 0xD6, 0xD9, 0xDA, 0xE3, 0xE6, 0xD9, 0x00, 0x00, 0x00, 0xE6, 0xD9, 0xD7, 0xD9, 0xDD, 0xEA, 0xDD, 0xE2, 0xDB, 0x00, 0xED, 0xE3, 0xE9, 0xE6, 0x00, 0xE8, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0xD9, 0xD8, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; // checksum
+//    0xCE, 0x7C, 0x00, 0x00, 0xBA, 0xB4, 0xBE, 0xB9, 0x00, 0x00, 0x00, 0x00,
+//    0x1C, 0x00, 0x00, 0x00, 0xCA, 0xCC, 0xC9, 0xC0, 0xBF, 0xCD, 0xCD, 0xC9,
+//    0xCC, 0x00, 0xC0, 0xBF, 0xC8, 0xC8, 0xBF, 0xC6, 0x00, 0x00, 0x00, 0x00,
+//    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCE, 0xE6, 0xD5, 0xE2,
+//    0xE7, 0xDA, 0xD9, 0xE6, 0x00, 0xBD, 0xD9, 0xE6, 0xE8, 0xDD, 0xDA, 0xDD,
+//    0xD7, 0xD5, 0xE8, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD0, 0xDD,
+//    0xE7, 0xDD, 0xE8, 0x00, 0xE8, 0xDC, 0xD9, 0x00, 0xDC, 0xE3, 0xE9, 0xE7,
+//    0xD9, 0x00, 0xE7, 0xE3, 0xE9, 0xE8, 0xDC, 0xD9, 0xD5, 0xE7, 0xE8, 0x00,
+//    0xE3, 0xDA, 0x00, 0xE8, 0xDC, 0xD9, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7,
+//    0xC9, 0xC8, 0xBD, 0xBF, 0xC8, 0xCE, 0xBF, 0xCC, 0x00, 0xDD, 0xE2, 0x00,
+//    0xC7, 0xE3, 0xE7, 0xE7, 0xD8, 0xD9, 0xD9, 0xE4, 0x00, 0xBD, 0xDD, 0xE8,
+//    0xED, 0x00, 0xE8, 0xE3, 0x00, 0xE6, 0xD9, 0xD7, 0xDD, 0xD9, 0xEA, 0xD9,
+//    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xED, 0xE3, 0xE9, 0xE6, 0x00, 0xE8,
+//    0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0xD9, 0xD8, 0x00, 0xCA, 0xC9,
+//    0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+//    0x00, 0x00, 0xBE, 0xE3, 0x00, 0xE2, 0xE3, 0xE8, 0x00, 0xE8, 0xE3, 0xE7,
+//    0xE7, 0x00, 0xE8, 0xDC, 0xDD, 0xE7, 0x00, 0xBF, 0xEC, 0xD7, 0xDC, 0xD5,
+//    0xE2, 0xDB, 0xD9, 0x00, 0xBD, 0xD5, 0xE6, 0xD8, 0x00, 0xD6, 0xD9, 0xDA,
+//    0xE3, 0xE6, 0xD9, 0x00, 0x00, 0x00, 0xE6, 0xD9, 0xD7, 0xD9, 0xDD, 0xEA,
+//    0xDD, 0xE2, 0xDB, 0x00, 0xED, 0xE3, 0xE9, 0xE6, 0x00, 0xE8, 0xE6, 0xD5,
+//    0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0xD9, 0xD8, 0x00, 0xCA, 0xC9, 0xC5, 0x1B,
+//    0xC7, 0xC9, 0xC8, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; // checksum
+static constexpr u8 frlg_wonder_card[0x14E] = {0x67, 0x18, 0x00, 0x00, 0xBA,
+    0xB4, 0xBE, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xCA,
+    0xCC, 0xC9, 0xC0, 0xBF, 0xCD, 0xCD, 0xC9, 0xCC, 0x00, 0xC0, 0xBF, 0xC8,
+    0xC8, 0xBF, 0xC6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xCE, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6, 0x00,
+    0xBD, 0xD9, 0xE6, 0xE8, 0xDD, 0xDA, 0xDD, 0xD7, 0xD5, 0xE8, 0xD9, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xD0, 0xDD, 0xE7, 0xDD, 0xE8, 0x00, 0xE8,
+    0xDC, 0xD9, 0x00, 0xDC, 0xE3, 0xE9, 0xE7, 0xD9, 0x00, 0xE7, 0xE3, 0xE9,
+    0xE8, 0xDC, 0x00, 0xE3, 0xDA, 0x00, 0xE8, 0xDC, 0xD9, 0x00, 0xCA, 0xC9,
+    0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0x00, 0x00, 0x00, 0x00, 0xBD, 0xBF, 0xC8,
+    0xCE, 0xBF, 0xCC, 0x00, 0xE3, 0xE2, 0x00, 0xCD, 0xD9, 0xEA, 0xD9, 0xE2,
+    0x00, 0xC3, 0xE7, 0xE0, 0xD5, 0xE2, 0xD8, 0x00, 0xE8, 0xE3, 0x00, 0xE6,
+    0xD9, 0xD7, 0xDD, 0xD9, 0xEA, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xED, 0xE3, 0xE9, 0xE6, 0x00, 0xE8, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA,
+    0xD9, 0xE6, 0xD9, 0xD8, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8,
+    0xAB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBE, 0xE3, 0x00,
+    0xE2, 0xE3, 0xE8, 0x00, 0xE8, 0xE3, 0xE7, 0xE7, 0x00, 0xE8, 0xDC, 0xDD,
+    0xE7, 0x00, 0xBF, 0xEC, 0xD7, 0xDC, 0xD5, 0xE2, 0xDB, 0xD9, 0x00, 0xBD,
+    0xD5, 0xE6, 0xD8, 0x00, 0xD6, 0xD9, 0xDA, 0xE3, 0xE6, 0xD9, 0x00, 0x00,
+    0x00, 0xE6, 0xD9, 0xD7, 0xD9, 0xDD, 0xEA, 0xDD, 0xE2, 0xDB, 0x00, 0xED,
+    0xE3, 0xE9, 0xE6, 0x00, 0xE8, 0xE6, 0xD5, 0xE2, 0xE7, 0xDA, 0xD9, 0xE6,
+    0xD9, 0xD8, 0x00, 0xCA, 0xC9, 0xC5, 0x1B, 0xC7, 0xC9, 0xC8, 0xAB, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00}; // checksum
 
 /// function to calculate a 32-bit checksum of a script buffer.
 static u32 calc_checksum32(const u8 *buffer, u32 size)
@@ -161,7 +311,8 @@ static u32 calc_checksum32(const u8 *buffer, u32 size)
 }
 
 /// function to calculate a 16-bit CRC of a script buffer.
-static u16 calc_crc16(const u8 *buffer, u32 size) // Implementation taken from PokeEmerald Decomp
+static u16 calc_crc16(
+    const u8 *buffer, u32 size) // Implementation taken from PokeEmerald Decomp
 {
     u32 i, j;
     u16 crc = 0x1121;
@@ -183,71 +334,79 @@ static u16 calc_crc16(const u8 *buffer, u32 size) // Implementation taken from P
 /** Converts the lang code to the PCCS Language enum */
 static Language convertLangCodeIntoLanguage(int32_t langCode)
 {
-    switch(langCode)
+    switch (langCode)
     {
-        case LANG_JPN:
-            return JAPANESE;
-        case LANG_ENG:
-            return ENGLISH;
-        case LANG_FRE:
-            return FRENCH;
-        case LANG_ITA:
-            return ITALIAN;
-        case LANG_GER:
-            return GERMAN;
-        case LANG_SPA:
-            return SPANISH;
-        default:
-            return ENGLISH;
+    case LANG_JPN:
+        return JAPANESE;
+    case LANG_ENG:
+        return ENGLISH;
+    case LANG_FRE:
+        return FRENCH;
+    case LANG_ITA:
+        return ITALIAN;
+    case LANG_GER:
+        return GERMAN;
+    case LANG_SPA:
+        return SPANISH;
+    default:
+        return ENGLISH;
     }
 }
 
 static void pickRSEFRLGChunks(Language lang, const u8 **&chunkList, u32 &size)
 {
     size = 1;
-    switch(lang)
+    switch (lang)
     {
-        case JAPANESE:
-            chunkList = RSEFRLG_japanese_chunk_list;
-            break;
-        case FRENCH:
-            chunkList = RSEFRLG_french_chunk_list;
-            break;
-        case ITALIAN:
-            chunkList = RSEFRLG_italian_chunk_list;
-            break;
-        case GERMAN:
-            chunkList = RSEFRLG_german_chunk_list;
-            break;
-        case SPANISH:
-            chunkList = RSEFRLG_spanish_chunk_list;
-            break;
-        default:
-            chunkList = RSEFRLG_english_chunk_list;
-            break;
+    case JAPANESE:
+        chunkList = RSEFRLG_japanese_chunk_list;
+        break;
+    case FRENCH:
+        chunkList = RSEFRLG_french_chunk_list;
+        break;
+    case ITALIAN:
+        chunkList = RSEFRLG_italian_chunk_list;
+        break;
+    case GERMAN:
+        chunkList = RSEFRLG_german_chunk_list;
+        break;
+    case SPANISH:
+        chunkList = RSEFRLG_spanish_chunk_list;
+        break;
+    default:
+        chunkList = RSEFRLG_english_chunk_list;
+        break;
     }
 }
 
 /**
- * @brief This one loads the specified textEntry index into a newly malloc'ed outBuffer.
- * It removes the colored text from the text entry if necessary and stores the actual buffer depth into outBufferDepth
+ * @brief This one loads the specified textEntry index into a newly malloc'ed
+ * outBuffer. It removes the colored text from the text entry if necessary and
+ * stores the actual buffer depth into outBufferDepth
  *
- * WARNING: the caller  becomes owner of the outBuffer pointer. Make sure to free() it!
+ * WARNING: the caller  becomes owner of the outBuffer pointer. Make sure to
+ * free() it!
  */
-static void loadProcessedTextEntry(const u16 *charset, FileContainerReader &textReader, u16 entryIndex, u8 *&outBuffer, u32 &outBufferDepth)
+static void loadProcessedTextEntry(const u16 *charset,
+    FileContainerReader &textReader, u16 entryIndex, u8 *&outBuffer,
+    u32 &outBufferDepth)
 {
-    const u8 *curText = textReader.getPointerToFileInDecompressionBuffer(entryIndex);
+    const u8 *curText =
+        textReader.getPointerToFileInDecompressionBuffer(entryIndex);
     u8 *curBuffer;
 
-    outBuffer = (u8*)malloc(textReader.getFileSize(entryIndex));
+    outBuffer = (u8 *)malloc(textReader.getFileSize(entryIndex));
     curBuffer = outBuffer;
 
-    // Process the text entry and copy it into a temporary buffer, removing any colored text if necessary.
-    while((*curText) != 0xFF)
+    // Process the text entry and copy it into a temporary buffer, removing any
+    // colored text if necessary.
+    while ((*curText) != 0xFF)
     {
-        if(curr_GBA_rom.is_hoenn())
+        if (curr_GBA_rom.is_hoenn())
         {
-            if(*curText == 0xFC && (get_char_from_charset(charset, (u16)(*(curText + 1))) == 0x01)) // Removes colored text
+            if (*curText == 0xFC &&
+                (get_char_from_charset(charset, (u16)(*(curText + 1))) ==
+                    0x01)) // Removes colored text
             {
                 curText += 2;
                 continue;
@@ -265,17 +424,22 @@ static void loadProcessedTextEntry(const u16 *charset, FileContainerReader &text
 }
 
 /**
- * @brief This function injects a text entry generated by text_helper into the provided buffer.
- * NOTE: bufferPos should point to the exact location at which the text entry should be injected.
- * NOTE: this code originated from text_var::insert_text() and has been adapted for use in this context.
+ * @brief This function injects a text entry generated by text_helper into the
+ * provided buffer. NOTE: bufferPos should point to the exact location at which
+ * the text entry should be injected. NOTE: this code originated from
+ * text_var::insert_text() and has been adapted for use in this context.
  *
- * @param charset a charset buffer to use hen injecting the text entry. It's used to detect colored text and remove it if necessary.
- * @param bufferPos an offset into the buffer where the text entry should be injected.
+ * @param charset a charset buffer to use hen injecting the text entry. It's
+ * used to detect colored text and remove it if necessary.
+ * @param bufferPos an offset into the buffer where the text entry should be
+ * injected.
  * @param textReader a FileContainerReader instance used to read the text entry.
  * @param entryIndex the index of the text entry to inject.
  * @return u32 the number of bytes injected into the buffer.
  */
-static u32 __attribute__((noinline)) injectTextEntryIntoBuffer(const u16 *charset, u8 *buffer, u32 bufferSize, u32 bufferPos, FileContainerReader &textReader, u16 entryIndex, bool isFirstTime)
+static u32 __attribute__((noinline)) injectTextEntryIntoBuffer(
+    const u16 *charset, u8 *buffer, u32 bufferSize, u32 bufferPos,
+    FileContainerReader &textReader, u16 entryIndex, bool isFirstTime)
 {
     u8 *curBuffer = buffer + bufferPos;
     u8 *tempBuffer;
@@ -284,14 +448,17 @@ static u32 __attribute__((noinline)) injectTextEntryIntoBuffer(const u16 *charse
     u16 otherEntryIndex;
     u32 otherBufferDepth;
 
-    // if this is a first_time related text, determine which entry to inject first.
+    // if this is a first_time related text, determine which entry to inject
+    // first.
     selectedEntryIndex = entryIndex;
     otherEntryIndex = UINT16_MAX;
-    for(u32 i = 0; i < sizeof(firstTimeTextEntryPairs) / sizeof(firstTimeTextEntryPairs[0]); ++i)
+    for (u32 i = 0; i < sizeof(firstTimeTextEntryPairs) /
+                            sizeof(firstTimeTextEntryPairs[0]);
+        ++i)
     {
-        if(entryIndex == firstTimeTextEntryPairs[i].first)
+        if (entryIndex == firstTimeTextEntryPairs[i].first)
         {
-            if(isFirstTime)
+            if (isFirstTime)
             {
                 otherEntryIndex = firstTimeTextEntryPairs[i].second;
             }
@@ -303,22 +470,27 @@ static u32 __attribute__((noinline)) injectTextEntryIntoBuffer(const u16 *charse
         }
     }
 
-    loadProcessedTextEntry(charset, textReader, selectedEntryIndex, tempBuffer, bufferDepth);
+    loadProcessedTextEntry(
+        charset, textReader, selectedEntryIndex, tempBuffer, bufferDepth);
     // Move the existing buffer content to make room for the new text entry
-    memmove(curBuffer + bufferDepth, curBuffer, bufferSize - bufferPos - bufferDepth);
+    memmove(curBuffer + bufferDepth, curBuffer,
+        bufferSize - bufferPos - bufferDepth);
     // now copy the processed text into the buffer at the current position
     memcpy(curBuffer, tempBuffer, bufferDepth);
     free(tempBuffer);
 
-    // mystery_gift_builder in gba-payload-generator reserves space for the largest entry of the first_time/second_time pair.
-    // this is done to make sure the pointer references within the payload remain the same, no matter which one we inject.
-    // however, we need to take this into account, so we inject the next entry at the right offset as well, taking that reservation
-    // of space into account.
-    if(otherEntryIndex != UINT16_MAX)
+    // mystery_gift_builder in gba-payload-generator reserves space for the
+    // largest entry of the first_time/second_time pair. this is done to make
+    // sure the pointer references within the payload remain the same, no matter
+    // which one we inject. however, we need to take this into account, so we
+    // inject the next entry at the right offset as well, taking that
+    // reservation of space into account.
+    if (otherEntryIndex != UINT16_MAX)
     {
-        loadProcessedTextEntry(charset, textReader, otherEntryIndex, tempBuffer, otherBufferDepth);
+        loadProcessedTextEntry(
+            charset, textReader, otherEntryIndex, tempBuffer, otherBufferDepth);
         free(tempBuffer);
-        if(bufferDepth < otherBufferDepth)
+        if (bufferDepth < otherBufferDepth)
         {
             bufferDepth = otherBufferDepth;
         }
@@ -328,18 +500,22 @@ static u32 __attribute__((noinline)) injectTextEntryIntoBuffer(const u16 *charse
 }
 
 /**
- * @brief This function re-injects the RSEFRLG text table entries into the section30 and script payload buffers.
- * In gba-payload-generator, we are stripping those texts after payload generation to improve compression and while keeping the pointers/offsets
- * inside the payload intact.
+ * @brief This function re-injects the RSEFRLG text table entries into the
+ * section30 and script payload buffers. In gba-payload-generator, we are
+ * stripping those texts after payload generation to improve compression and
+ * while keeping the pointers/offsets inside the payload intact.
  *
- * But in order to use the payload, we actually need to reinsert those at runtime.
+ * But in order to use the payload, we actually need to reinsert those at
+ * runtime.
  */
-static void __attribute__((noinline)) reinjectMysteryGiftPayloadTexts(u8 *section30Buffer, u8 *mgScriptBuffer, bool isFirstTime)
+static void __attribute__((noinline)) reinjectMysteryGiftPayloadTexts(
+    u8 *section30Buffer, u8 *mgScriptBuffer, bool isFirstTime)
 {
     u8 decompressionBuffer[4096];
     u16 gen3Charset[256];
     u32 bytesInjected;
-    // the reason for using std::array for these is simply to be able to use initializer lists below.
+    // the reason for using std::array for these is simply to be able to use
+    // initializer lists below.
     std::array<u8, 8> section30TextSequence;
     std::array<u8, 4> scriptTextSequence;
     u8 textGreetEntryIndex;
@@ -351,67 +527,89 @@ static void __attribute__((noinline)) reinjectMysteryGiftPayloadTexts(u8 *sectio
     Language lang = convertLangCodeIntoLanguage(curr_GBA_rom.language);
 
     pickRSEFRLGChunks(lang, chunklist, chunkListSize);
-    FileContainerReader textReader(chunklist, chunkListSize, sizeof(decompressionBuffer));
+    FileContainerReader textReader(
+        chunklist, chunkListSize, sizeof(decompressionBuffer));
     textReader.init(decompressionBuffer, sizeof(decompressionBuffer));
 
+    // make the section30Buffer and mgScriptBuffer pointers point to the exact
+    // insertion position within them. the section30 text offset (0x97E) remains
+    // consistent across languages and games in the payload. the script text
+    // offset shifts depending on the game version. (observed based on logs from
+    // gba-payload-generator)
 
-    // make the section30Buffer and mgScriptBuffer pointers point to the exact insertion position within them.
-    // the section30 text offset (0x97E) remains consistent across languages and games in the payload.
-    // the script text offset shifts depending on the game version. (observed based on logs from gba-payload-generator)
-
-    // Also construct text entry sequences, because we need to maintain the same order of injection
-    // as during the payload generation with gba-payload-generator
+    // Also construct text entry sequences, because we need to maintain the same
+    // order of injection as during the payload generation with
+    // gba-payload-generator
     section30Offset = 0x97E;
 
-    switch(curr_GBA_rom.gamecode)
+    switch (curr_GBA_rom.gamecode)
     {
     case RUBY_ID:
     case SAPPHIRE_ID:
         mgScriptOffset = 0x268;
         textGreetEntryIndex = RSEFRLG_dia_textGreet_rse;
         iAmEntryIndex = RSEFRLG_dia_textIAm_first_rs;
-        section30TextSequence = { RSEFRLG_dia_textThank_rs, RSEFRLG_dia_textPCFull_rs, RSEFRLG_dia_textWeHere_rs, RSEFRLG_dia_textPCConvo_rs, RSEFRLG_dia_textPCThanks_rs, RSEFRLG_dia_textLookerFull_rs, RSEFRLG_dia_textMoveBox_rs, RSEFRLG_dia_textRecieved_rs };
+        section30TextSequence = {RSEFRLG_dia_textThank_rs,
+            RSEFRLG_dia_textPCFull_rs, RSEFRLG_dia_textWeHere_rs,
+            RSEFRLG_dia_textPCConvo_rs, RSEFRLG_dia_textPCThanks_rs,
+            RSEFRLG_dia_textLookerFull_rs, RSEFRLG_dia_textMoveBox_rs,
+            RSEFRLG_dia_textRecieved_rs};
         break;
     case FIRERED_ID:
     case LEAFGREEN_ID:
         mgScriptOffset = 0x278;
         textGreetEntryIndex = RSEFRLG_dia_textGreet_frlg;
         iAmEntryIndex = RSEFRLG_dia_textIAm_first_frlge;
-        section30TextSequence = { RSEFRLG_dia_textThank_frlge, RSEFRLG_dia_textPCFull_frlge, RSEFRLG_dia_textWeHere_frlg, RSEFRLG_dia_textPCConvo_frlge, RSEFRLG_dia_textPCThanks_frlge, RSEFRLG_dia_textLookerFull_frlge, RSEFRLG_dia_textMoveBox_frlg, RSEFRLG_dia_textRecieved_frlge };
+        section30TextSequence = {RSEFRLG_dia_textThank_frlge,
+            RSEFRLG_dia_textPCFull_frlge, RSEFRLG_dia_textWeHere_frlg,
+            RSEFRLG_dia_textPCConvo_frlge, RSEFRLG_dia_textPCThanks_frlge,
+            RSEFRLG_dia_textLookerFull_frlge, RSEFRLG_dia_textMoveBox_frlg,
+            RSEFRLG_dia_textRecieved_frlge};
         break;
     default:
         mgScriptOffset = 0x298;
         textGreetEntryIndex = RSEFRLG_dia_textGreet_rse;
         iAmEntryIndex = RSEFRLG_dia_textIAm_first_frlge;
-        section30TextSequence = { RSEFRLG_dia_textThank_frlge, RSEFRLG_dia_textPCFull_frlge, RSEFRLG_dia_textWeHere_e, RSEFRLG_dia_textPCConvo_frlge, RSEFRLG_dia_textPCThanks_frlge, RSEFRLG_dia_textLookerFull_frlge, RSEFRLG_dia_textMoveBox_e, RSEFRLG_dia_textRecieved_frlge };
+        section30TextSequence = {RSEFRLG_dia_textThank_frlge,
+            RSEFRLG_dia_textPCFull_frlge, RSEFRLG_dia_textWeHere_e,
+            RSEFRLG_dia_textPCConvo_frlge, RSEFRLG_dia_textPCThanks_frlge,
+            RSEFRLG_dia_textLookerFull_frlge, RSEFRLG_dia_textMoveBox_e,
+            RSEFRLG_dia_textRecieved_frlge};
         break;
     }
 
-    scriptTextSequence = {textGreetEntryIndex, RSEFRLG_dia_textYouMustBe_first, iAmEntryIndex };
+    scriptTextSequence = {
+        textGreetEntryIndex, RSEFRLG_dia_textYouMustBe_first, iAmEntryIndex};
 
     load_localized_charset(gen3Charset, 3, lang);
 
-    for(unsigned i=0; i < 8; ++i)
+    for (unsigned i = 0; i < 8; ++i)
     {
-        bytesInjected = injectTextEntryIntoBuffer(gen3Charset, section30Buffer, 0x1000, section30Offset, textReader, section30TextSequence[i], isFirstTime);
+        bytesInjected = injectTextEntryIntoBuffer(gen3Charset, section30Buffer,
+            0x1000, section30Offset, textReader, section30TextSequence[i],
+            isFirstTime);
         section30Offset += bytesInjected;
     }
 
-    for(unsigned i=0; i < 3; ++i)
+    for (unsigned i = 0; i < 3; ++i)
     {
-        bytesInjected = injectTextEntryIntoBuffer(gen3Charset, mgScriptBuffer, MG_SCRIPT_SIZE, mgScriptOffset, textReader, scriptTextSequence[i], isFirstTime);
+        bytesInjected = injectTextEntryIntoBuffer(gen3Charset, mgScriptBuffer,
+            MG_SCRIPT_SIZE, mgScriptOffset, textReader, scriptTextSequence[i],
+            isFirstTime);
         mgScriptOffset += bytesInjected;
     }
 }
 
 /**
- * @brief This function injects the PokeBox pokémons into section30 at offset 0x0, which is what the payload expects.
- * It assumes that all the pokemons in the box are already converted. (should be done by script_array.cpp)
+ * @brief This function injects the PokeBox pokémons into section30 at offset
+ * 0x0, which is what the payload expects. It assumes that all the pokemons in
+ * the box are already converted. (should be done by script_array.cpp)
  *
  * @param box pointer to the PokeBox instance containing the Pokémon to inject.
  * @param section30Buffer The buffer representing section 30 of the save file.
  */
-static void __attribute__((noinline)) injectBoxIntoSection30(PokeBox* box, u8* section30Buffer)
+static void __attribute__((noinline)) injectBoxIntoSection30(
+    PokeBox *box, u8 *section30Buffer)
 {
     u8 dex_nums[MAX_PKMN_IN_BOX] = {};
     u8 *curSection30 = section30Buffer;
@@ -434,65 +632,67 @@ static void __attribute__((noinline)) injectBoxIntoSection30(PokeBox* box, u8* s
     tonccpy(curSection30, dex_nums, MAX_PKMN_IN_BOX);
 }
 
-static void pickPatchFiles(u32 &gamePatchFile, u32 &languagePatchFile, u32 &specificPatchFile)
+static void pickPatchFiles(
+    u32 &gamePatchFile, u32 &languagePatchFile, u32 &specificPatchFile)
 {
     u32 simplifiedGameCode;
     u32 simplifiedLanguageCode;
 
-    switch(curr_GBA_rom.gamecode)
+    switch (curr_GBA_rom.gamecode)
     {
-        case RUBY_ID:
-            gamePatchFile = (u32)Script_patchesFiles::SCRIPT_RUBY_ENGLISH_1_0;
-            simplifiedGameCode = MAP_RUBY;
-            break;
-        case SAPPHIRE_ID:
-            gamePatchFile = (u32)Script_patchesFiles::SCRIPT_RUBY_ENGLISH_1_0;
-            simplifiedGameCode = MAP_SAPPHIRE;
-            break;
-        case FIRERED_ID:
-            gamePatchFile = (u32)Script_patchesFiles::SCRIPT_FIRERED_ENGLISH_1_0;
-            simplifiedGameCode = MAP_FIRERED;
-            break;
-        case LEAFGREEN_ID:
-            gamePatchFile = (u32)Script_patchesFiles::SCRIPT_FIRERED_ENGLISH_1_0;
-            simplifiedGameCode = MAP_LEAFGREEN;
-            break;
-        case EMERALD_ID:
-        default:
-            gamePatchFile = (u32)Script_patchesFiles::SCRIPT_EMERALD_ENGLISH_1_0;
-            simplifiedGameCode = MAP_EMERALD;
-            break;
+    case RUBY_ID:
+        gamePatchFile = (u32)Script_patchesFiles::SCRIPT_RUBY_ENGLISH_1_0;
+        simplifiedGameCode = MAP_RUBY;
+        break;
+    case SAPPHIRE_ID:
+        gamePatchFile = (u32)Script_patchesFiles::SCRIPT_RUBY_ENGLISH_1_0;
+        simplifiedGameCode = MAP_SAPPHIRE;
+        break;
+    case FIRERED_ID:
+        gamePatchFile = (u32)Script_patchesFiles::SCRIPT_FIRERED_ENGLISH_1_0;
+        simplifiedGameCode = MAP_FIRERED;
+        break;
+    case LEAFGREEN_ID:
+        gamePatchFile = (u32)Script_patchesFiles::SCRIPT_FIRERED_ENGLISH_1_0;
+        simplifiedGameCode = MAP_LEAFGREEN;
+        break;
+    case EMERALD_ID:
+    default:
+        gamePatchFile = (u32)Script_patchesFiles::SCRIPT_EMERALD_ENGLISH_1_0;
+        simplifiedGameCode = MAP_EMERALD;
+        break;
     }
 
-    switch(curr_GBA_rom.language)
+    switch (curr_GBA_rom.language)
     {
-        case LANG_JPN:
-            simplifiedLanguageCode = MAP_JAPANESE;
-            break;
-        case LANG_ENG:
-            simplifiedLanguageCode = MAP_ENGLISH;
-            break;
-        case LANG_FRE:
-            simplifiedLanguageCode = MAP_FRENCH;
-            break;
-        case LANG_GER:
-            simplifiedLanguageCode = MAP_GERMAN;
-            break;
-        case LANG_ITA:
-            simplifiedLanguageCode = MAP_ITALIAN;
-            break;
-        case LANG_SPA:
-            simplifiedLanguageCode = MAP_SPANISH;
-            break;
-        default:
-            simplifiedLanguageCode = MAP_ENGLISH;
-            break;
+    case LANG_JPN:
+        simplifiedLanguageCode = MAP_JAPANESE;
+        break;
+    case LANG_ENG:
+        simplifiedLanguageCode = MAP_ENGLISH;
+        break;
+    case LANG_FRE:
+        simplifiedLanguageCode = MAP_FRENCH;
+        break;
+    case LANG_GER:
+        simplifiedLanguageCode = MAP_GERMAN;
+        break;
+    case LANG_ITA:
+        simplifiedLanguageCode = MAP_ITALIAN;
+        break;
+    case LANG_SPA:
+        simplifiedLanguageCode = MAP_SPANISH;
+        break;
+    default:
+        simplifiedLanguageCode = MAP_ENGLISH;
+        break;
     }
 
-    const u8 mapKey = PACK_PATCH_KEY(simplifiedGameCode, simplifiedLanguageCode, (u8)curr_GBA_rom.version);
-    for(u32 i=0; i < sizeof(patchFileTable) / sizeof(patchFileTable[0]); ++i)
+    const u8 mapKey = PACK_PATCH_KEY(
+        simplifiedGameCode, simplifiedLanguageCode, (u8)curr_GBA_rom.version);
+    for (u32 i = 0; i < sizeof(patchFileTable) / sizeof(patchFileTable[0]); ++i)
     {
-        if(patchFileTable[i].key == mapKey)
+        if (patchFileTable[i].key == mapKey)
         {
             languagePatchFile = patchFileTable[i].languagePatchIndex;
             specificPatchFile = patchFileTable[i].specificPatchIndex;
@@ -502,33 +702,41 @@ static void pickPatchFiles(u32 &gamePatchFile, u32 &languagePatchFile, u32 &spec
 }
 
 /**
- * @brief This helper function will apply the BPS patch with index patchFileIndex stored in reader
- * to the srcBuffer data and store the result in dstBuffer. srcBuffer remains untouched.
+ * @brief This helper function will apply the BPS patch with index
+ * patchFileIndex stored in reader to the srcBuffer data and store the result in
+ * dstBuffer. srcBuffer remains untouched.
  */
-static void __attribute__((noinline)) applyBPSPatchToBuffer(FileContainerReader &reader, u8* dstBuffer, u8 *srcBuffer, u32 patchFileIndex)
+static void __attribute__((noinline)) applyBPSPatchToBuffer(
+    FileContainerReader &reader, u8 *dstBuffer, u8 *srcBuffer,
+    u32 patchFileIndex)
 {
-    // Note: you may think it's peculiar that we're malloc'ing patchBuffer below.
-    // But here's the dilemma: the files in the file container may span multiple chunks.
-    // (mostly the last file in each chunk)
-    // Therefore using getPointerToFileInDecompressionBuffer() would be unsafe.
-    // We could've used the @noSpanChunks directive in the .containerdef file to overcome that.
-    // However, then we're hit by an additional problem: We've constructed patchFileTable above using the script_patches
-    // indexes, relying on those to be consistent/representative for both the section30 and script patch filecontainers.
-    // but section30 is much larger than script. Therefore the patches don't have the same filesizes either.
-    // This would result in @noSpanChunks injecting a different number of dummy files in each filecontainer,
-    // which would break the index consistency.
+    // Note: you may think it's peculiar that we're malloc'ing patchBuffer
+    // below. But here's the dilemma: the files in the file container may span
+    // multiple chunks. (mostly the last file in each chunk) Therefore using
+    // getPointerToFileInDecompressionBuffer() would be unsafe. We could've used
+    // the @noSpanChunks directive in the .containerdef file to overcome that.
+    // However, then we're hit by an additional problem: We've constructed
+    // patchFileTable above using the script_patches indexes, relying on those
+    // to be consistent/representative for both the section30 and script patch
+    // filecontainers. but section30 is much larger than script. Therefore the
+    // patches don't have the same filesizes either. This would result in
+    // @noSpanChunks injecting a different number of dummy files in each
+    // filecontainer, which would break the index consistency.
     //
-    // You might argue that we might as well use a statically allocated buffer for the patch.
-    // However, our IWRAM consumption is already quite high here. And malloc() will just use unused space at the end of EWRAM.
+    // You might argue that we might as well use a statically allocated buffer
+    // for the patch. However, our IWRAM consumption is already quite high here.
+    // And malloc() will just use unused space at the end of EWRAM.
     // (=where our multiboot rom resides)
     const u32 patchFileSize = reader.getFileSize(patchFileIndex);
-    u8 *patchBuffer = (u8*)malloc(patchFileSize);
+    u8 *patchBuffer = (u8 *)malloc(patchFileSize);
     reader.readFile(patchFileIndex, patchBuffer);
     bps_patch(srcBuffer, dstBuffer, patchBuffer, patchFileSize);
     free(patchBuffer);
 }
 
-static void __attribute__((noinline)) patchBuffer(FileContainerReader &reader, u8 *buffer, u32 bufferSize, u32 gamePatchFileIndex, u32 languagePatchFileIndex, u32 specificPatchFileIndex)
+static void __attribute__((noinline)) patchBuffer(FileContainerReader &reader,
+    u8 *buffer, u32 bufferSize, u32 gamePatchFileIndex,
+    u32 languagePatchFileIndex, u32 specificPatchFileIndex)
 {
     u8 tempBuffer[4096];
     memset(tempBuffer, 0, bufferSize);
@@ -537,59 +745,82 @@ static void __attribute__((noinline)) patchBuffer(FileContainerReader &reader, u
 
     // We shouldn't attempt to apply the same base payload patch twice.
     // that's what the magic SKIP_SPECIFIC_PAYLOAD_PATCH_INDEX value is for.
-    if(languagePatchFileIndex != SKIP_PATCH_INDEX)
+    if (languagePatchFileIndex != SKIP_PATCH_INDEX)
     {
-        applyBPSPatchToBuffer(reader, buffer, tempBuffer, languagePatchFileIndex);
+        applyBPSPatchToBuffer(
+            reader, buffer, tempBuffer, languagePatchFileIndex);
     }
     else
     {
         memcpy(buffer, tempBuffer, bufferSize);
     }
 
-    if(specificPatchFileIndex != SKIP_PATCH_INDEX)
+    if (specificPatchFileIndex != SKIP_PATCH_INDEX)
     {
-        // now turn the english <gametype> payload into the specific language payload.
-        // the result will be stored in tempBuffer
-        applyBPSPatchToBuffer(reader, tempBuffer, buffer, specificPatchFileIndex);
+        // now turn the english <gametype> payload into the specific language
+        // payload. the result will be stored in tempBuffer
+        applyBPSPatchToBuffer(
+            reader, tempBuffer, buffer, specificPatchFileIndex);
         memcpy(buffer, tempBuffer, bufferSize);
     }
 }
 
 /**
- * @brief This function reconstructs the pregenerated payload for section30 and the script buffer.
- * The way it works is this:
- * - We have stored the english ruby 1.0 payload (section30 + scriptbuffer) in compressed form.
- * - We have created BPS patches to convert this payload from english ruby to english <gametype> for 3 variants (ruby, emerald and fire red)
- * - There's another BPS patch to convert the english <gameType> variant to the language specific variant (for 3 game types: ruby, emerald and fire red)
- * - Finally, there's another BPS patch to convert the language specific base payload to the final payload (for example: from french ruby 1.0 to french sapphire 1.1)
- * 
- * This is all done to conserve space as much as possible and benefit most from compression. 
- * 
- * So, in order to reconstruct the payload for a specific game and language, we need to:
+ * @brief This function reconstructs the pregenerated payload for section30 and
+ * the script buffer. The way it works is this:
+ * - We have stored the english ruby 1.0 payload (section30 + scriptbuffer) in
+ * compressed form.
+ * - We have created BPS patches to convert this payload from english ruby to
+ * english <gametype> for 3 variants (ruby, emerald and fire red)
+ * - There's another BPS patch to convert the english <gameType> variant to the
+ * language specific variant (for 3 game types: ruby, emerald and fire red)
+ * - Finally, there's another BPS patch to convert the language specific base
+ * payload to the final payload (for example: from french ruby 1.0 to french
+ * sapphire 1.1)
+ *
+ * This is all done to conserve space as much as possible and benefit most from
+ * compression.
+ *
+ * So, in order to reconstruct the payload for a specific game and language, we
+ * need to:
  * 1. Decompress the english ruby payload into section30Buffer and scriptBuffer.
- * 2. Determine the 3 patch sets required (transform to right gametype, transform to right language, transform to final version) for both scriptBuffer and section30Buffer.
+ * 2. Determine the 3 patch sets required (transform to right gametype,
+ * transform to right language, transform to final version) for both
+ * scriptBuffer and section30Buffer.
  * 3. uncompress these patches from the filecontainer.
  * 4. Apply these patches.
- * 
- * This function attempts to do it in a way that requires the least amount of IWRAM possible.
- * One way we do that is by reusing the same decompression buffer for both file containers.
- * 
- * WARNING: This function will require more than 6KB of additional IWRAM for decompression buffer and temp buffer!
- * NOTE: __attribute__((noinline)) is used to ensure this function gets its own stack frame and therefore the local
- * buffers don't leak into the caller's stack frame. This is important because IWRAM consumption is a big concern in PTGB.
+ *
+ * This function attempts to do it in a way that requires the least amount of
+ * IWRAM possible. One way we do that is by reusing the same decompression
+ * buffer for both file containers.
+ *
+ * WARNING: This function will require more than 6KB of additional IWRAM for
+ * decompression buffer and temp buffer! NOTE: __attribute__((noinline)) is used
+ * to ensure this function gets its own stack frame and therefore the local
+ * buffers don't leak into the caller's stack frame. This is important because
+ * IWRAM consumption is a big concern in PTGB.
  */
-static void __attribute__((noinline)) reconstructPregeneratedPayloads(u8* section30Buffer, u8* scriptBuffer)
+static void __attribute__((noinline)) reconstructPregeneratedPayloads(
+    u8 *section30Buffer, u8 *scriptBuffer)
 {
-    const u32 patchContainerChunkSize = 4096; // defined by @chunkSize directive in the .containerdef files
+    const u32 patchContainerChunkSize =
+        4096; // defined by @chunkSize directive in the .containerdef files
     u8 decompressionBuffer[patchContainerChunkSize];
     u32 gamePatchFile;
     u32 languagePatchFile;
     u32 specificPatchFile = (u8)Script_patchesFiles::SCRIPT_RUBY_ENGLISH_1_0;
 
-    FileContainerReader section30PatchesReader(section30_patches_chunk_list, sizeof(section30_patches_chunk_list) / sizeof(section30_patches_chunk_list[0]), BPS_PATCH_FILECONTAINER_CHUNK_SIZE);
-    FileContainerReader scriptPatchesReader(script_patches_chunk_list, sizeof(script_patches_chunk_list) / sizeof(script_patches_chunk_list[0]), BPS_PATCH_FILECONTAINER_CHUNK_SIZE);
+    FileContainerReader section30PatchesReader(section30_patches_chunk_list,
+        sizeof(section30_patches_chunk_list) /
+            sizeof(section30_patches_chunk_list[0]),
+        BPS_PATCH_FILECONTAINER_CHUNK_SIZE);
+    FileContainerReader scriptPatchesReader(script_patches_chunk_list,
+        sizeof(script_patches_chunk_list) /
+            sizeof(script_patches_chunk_list[0]),
+        BPS_PATCH_FILECONTAINER_CHUNK_SIZE);
 
-    // first determine the patch indexes needed to convert the base payloads to the specific game.
+    // first determine the patch indexes needed to convert the base payloads to
+    // the specific game.
     pickPatchFiles(gamePatchFile, languagePatchFile, specificPatchFile);
 
     // assume we found the entry.
@@ -600,24 +831,26 @@ static void __attribute__((noinline)) reconstructPregeneratedPayloads(u8* sectio
 
     // patch section30
     section30PatchesReader.init(decompressionBuffer, patchContainerChunkSize);
-    patchBuffer(section30PatchesReader, section30Buffer, 0x1000, gamePatchFile, languagePatchFile, specificPatchFile);
+    patchBuffer(section30PatchesReader, section30Buffer, 0x1000, gamePatchFile,
+        languagePatchFile, specificPatchFile);
 
     // patch script
     scriptPatchesReader.init(decompressionBuffer, patchContainerChunkSize);
-    patchBuffer(scriptPatchesReader, scriptBuffer, MG_SCRIPT_SIZE, gamePatchFile, languagePatchFile, specificPatchFile);
+    patchBuffer(scriptPatchesReader, scriptBuffer, MG_SCRIPT_SIZE,
+        gamePatchFile, languagePatchFile, specificPatchFile);
 }
 
-
-bool inject_mystery(PokeBox* box, bool isFirstTime)
+bool inject_mystery(PokeBox *box, bool isFirstTime)
 {
     u32 checksum;
     u8 script_buffer[MG_SCRIPT_SIZE];
 
     reconstructPregeneratedPayloads(global_memory_buffer, script_buffer);
-    reinjectMysteryGiftPayloadTexts(global_memory_buffer, script_buffer, isFirstTime);
+    reinjectMysteryGiftPayloadTexts(
+        global_memory_buffer, script_buffer, isFirstTime);
 
-    // One thing our pregeneration process obviously leaves out is the pokemon data.
-    // so let's add that in now.
+    // One thing our pregeneration process obviously leaves out is the pokemon
+    // data. so let's add that in now.
     injectBoxIntoSection30(box, global_memory_buffer);
 
     if (curr_GBA_rom.is_ruby_sapphire())
@@ -630,15 +863,16 @@ bool inject_mystery(PokeBox* box, bool isFirstTime)
     }
 
     // Add in Pokemon and Dex data
-    // In the steps after this, we will be recycling the global_memory_buffer to read and write data to other sections of the save.
-    // So we really MUST write the generated data now, before we lose it.
+    // In the steps after this, we will be recycling the global_memory_buffer to
+    // read and write data to other sections of the save. So we really MUST
+    // write the generated data now, before we lose it.
 
     update_memory_buffer_checksum(global_memory_buffer, false);
     erase_sector(0x1E000);
     copy_ram_to_save(&global_memory_buffer[0], 0x1E000, 0x1000);
 
-    // section_30 data has been stored, so now we can safely re-use the global_memory_buffer for other sections.
-    // Let's move on to the next step.
+    // section_30 data has been stored, so now we can safely re-use the
+    // global_memory_buffer for other sections. Let's move on to the next step.
 
     // Add in Wonder Card
     copy_save_to_ram(memory_section_array[4], &global_memory_buffer[0], 0x1000);
@@ -650,11 +884,13 @@ bool inject_mystery(PokeBox* box, bool isFirstTime)
         break;
     case FIRERED_ID:
     case LEAFGREEN_ID:
-        memcpy(global_memory_buffer + curr_GBA_rom.offset_wondercard, frlg_wonder_card, 0x14E);
+        memcpy(global_memory_buffer + curr_GBA_rom.offset_wondercard,
+            frlg_wonder_card, 0x14E);
         break;
     case EMERALD_ID:
     default:
-        memcpy(global_memory_buffer + curr_GBA_rom.offset_wondercard, em_wonder_card, 0x14E);
+        memcpy(global_memory_buffer + curr_GBA_rom.offset_wondercard,
+            em_wonder_card, 0x14E);
         break;
     }
 
@@ -665,31 +901,45 @@ bool inject_mystery(PokeBox* box, bool isFirstTime)
     global_memory_buffer[curr_GBA_rom.offset_script + 3] = checksum >> 24;
 
     // Add in Mystery Script data
-    memcpy(global_memory_buffer + curr_GBA_rom.offset_script + 4, script_buffer, MG_SCRIPT_SIZE);
+    memcpy(global_memory_buffer + curr_GBA_rom.offset_script + 4, script_buffer,
+        MG_SCRIPT_SIZE);
 
     update_memory_buffer_checksum(global_memory_buffer, false);
     erase_sector(memory_section_array[4]);
     copy_ram_to_save(&global_memory_buffer[0], memory_section_array[4], 0x1000);
 
     // Set flags
-    int memory_section = 1 + ((curr_GBA_rom.offset_flags + (curr_GBA_rom.unused_flag_start / 8)) / 0xF80); // This sets the correct memory section, since flags stretch between section 1 and 2.
-    copy_save_to_ram(memory_section_array[memory_section], &global_memory_buffer[0], 0x1000);
-    global_memory_buffer[(curr_GBA_rom.offset_flags + (curr_GBA_rom.all_collected_flag / 8)) % 0xF80] &= ~(1 << (curr_GBA_rom.all_collected_flag % 8)); // Set "collected all" flag to 0
+    int memory_section =
+        1 +
+        ((curr_GBA_rom.offset_flags + (curr_GBA_rom.unused_flag_start / 8)) /
+            0xF80); // This sets the correct memory section, since flags stretch
+                    // between section 1 and 2.
+    copy_save_to_ram(
+        memory_section_array[memory_section], &global_memory_buffer[0], 0x1000);
+    global_memory_buffer[(curr_GBA_rom.offset_flags +
+                             (curr_GBA_rom.all_collected_flag / 8)) %
+                         0xF80] &= ~(1 << (curr_GBA_rom.all_collected_flag %
+                                           8)); // Set "collected all" flag to 0
 
     for (int i = 0; i < box->getNumInBox(); i++)
     {
         int curr_flag;
         curr_flag = curr_GBA_rom.pkmn_collected_flag_start + i;
-        global_memory_buffer[(curr_GBA_rom.offset_flags + (curr_flag / 8)) % 0xF80] &= ~(1 << (curr_flag % 8)); // Reset the flag
+        global_memory_buffer[(curr_GBA_rom.offset_flags + (curr_flag / 8)) %
+                             0xF80] &=
+            ~(1 << (curr_flag % 8)); // Reset the flag
         if (box->getGen3Pokemon(i)->isValid)
         {
-            global_memory_buffer[(curr_GBA_rom.offset_flags + (curr_flag / 8)) % 0xF80] |= (1 << (curr_flag % 8)); // Set flag accordingly
+            global_memory_buffer[(curr_GBA_rom.offset_flags + (curr_flag / 8)) %
+                                 0xF80] |=
+                (1 << (curr_flag % 8)); // Set flag accordingly
         }
     }
 
     update_memory_buffer_checksum(global_memory_buffer, false);
     erase_sector(memory_section_array[memory_section]);
-    copy_ram_to_save(&global_memory_buffer[0], memory_section_array[memory_section], 0x1000);
+    copy_ram_to_save(
+        &global_memory_buffer[0], memory_section_array[memory_section], 0x1000);
 
     // Save custom save data
     write_custom_save_data();
diff --git a/source/pokedex.cpp b/source/pokedex.cpp
index bc0739d..569e3cc 100644
--- a/source/pokedex.cpp
+++ b/source/pokedex.cpp
@@ -1,18 +1,18 @@
-#include <tonc.h>
 #include <cmath>
+#include <tonc.h>
 
-#include "pokedex.h"
-#include "dex_handler.h"
-#include "sprite_data.h"
-#include "pokemon_data.h"
-#include "global_frame_controller.h"
-#include "ptgb_save_data_manager.h"
-#include "button_handler.h"
-#include "translated_text.h"
-#include "text_engine.h"
 #include "FileContainerReader.h"
-#include "text_tables.h"
 #include "TYPES_lz10_bin.h"
+#include "button_handler.h"
+#include "dex_handler.h"
+#include "global_frame_controller.h"
+#include "pokedex.h"
+#include "pokemon_data.h"
+#include "ptgb_save_data_manager.h"
+#include "sprite_data.h"
+#include "text_engine.h"
+#include "text_tables.h"
+#include "translated_text.h"
 
 Dex dex_array[DEX_MAX];
 int dex_shift = 0;
@@ -30,7 +30,8 @@ bool mew_caught;
 bool celebi_caught;
 bool missingno_caught = false;
 
-static void load_general_table_text_entries(u8 *decompression_buffer, u32 decompression_buffer_size, u8 *kanto_buffer, u8 *johto_buffer)
+static void load_general_table_text_entries(u8 *decompression_buffer,
+    u32 decompression_buffer_size, u8 *kanto_buffer, u8 *johto_buffer)
 {
     const u8 **chunkList;
     u32 numChunks;
@@ -47,7 +48,8 @@ void pokedex_init()
 {
     for (int i = 0; i < DEX_MAX; i++)
     {
-        // dex_array[i] = Dex(dex_sprites[DEX_SPRITE_LEFT][i], dex_sprites[DEX_SPRITE_MID][i], dex_sprites[DEX_SPRITE_RIGHT][i]);
+        // dex_array[i] = Dex(dex_sprites[DEX_SPRITE_LEFT][i],
+        // dex_sprites[DEX_SPRITE_MID][i], dex_sprites[DEX_SPRITE_RIGHT][i]);
         // dex_array[i].set_location(dex_x_cord, (i * (8 * 3)) + 8);
     }
     // kanto_count = Button(button_blank_left, button_blank_right, 64);
@@ -87,38 +89,44 @@ void pokedex_init()
 #include "gen_3_charsets_lz10_bin.h"
 #include "libstd_replacements.h"
 
-// attribute noinline is used to make sure it doesn't get inlined and permanently use IWRAM for the decompression_buffer
+// attribute noinline is used to make sure it doesn't get inlined and
+// permanently use IWRAM for the decompression_buffer
 int __attribute__((noinline)) pokedex_loop()
 {
     u8 TYPES[POKEMON_ARRAY_SIZE][2];
     u8 kanto_name[12];
     u8 johto_name[12];
     u8 decompression_buffer[2048];
-    //u16 charset[512];
+    // u16 charset[512];
     u8 name_buffer[16];
     const u8 **namesChunkList;
     u32 namesNumChunks;
     u32 namesChunkSize;
 
-    LZ77UnCompWram(TYPES_lz10_bin, (u8*)TYPES);
-    //LZ77UnCompWram(gen_3_charsets_lz10_bin, (u8*)charset);
+    LZ77UnCompWram(TYPES_lz10_bin, (u8 *)TYPES);
+    // LZ77UnCompWram(gen_3_charsets_lz10_bin, (u8*)charset);
 
-    load_general_table_text_entries(decompression_buffer, sizeof(decompression_buffer), kanto_name, johto_name);
+    load_general_table_text_entries(decompression_buffer,
+        sizeof(decompression_buffer), kanto_name, johto_name);
 
-    get_text_table_chunks(PKMN_NAMES_INDEX, &namesChunkList, &namesNumChunks, &namesChunkSize);
-    FileContainerReader PKMN_NAMES(namesChunkList, namesNumChunks, namesChunkSize);
+    get_text_table_chunks(
+        PKMN_NAMES_INDEX, &namesChunkList, &namesNumChunks, &namesChunkSize);
+    FileContainerReader PKMN_NAMES(
+        namesChunkList, namesNumChunks, namesChunkSize);
     PKMN_NAMES.init(decompression_buffer, sizeof(decompression_buffer));
 
     pokedex_init();
     pokedex_show();
     bool update = true;
 
-    const byte undiscovered_text[] = {0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xFF};
-    byte temp_string[4] = {}; // Should never be longer than 4 characters (including endline)
-                              // TODO: For some reason there is screen tearing here. Probably not noticable on console,
-                              // but it should be removed at some point
+    const byte undiscovered_text[] = {
+        0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xFF};
+    byte temp_string[4] =
+        {}; // Should never be longer than 4 characters (including endline)
+            // TODO: For some reason there is screen tearing here. Probably not
+            // noticable on console, but it should be removed at some point
 
-	tte_set_ink(INK_DARK_GREY);
+    tte_set_ink(INK_DARK_GREY);
     tte_set_pos(8, 146);
     ptgb_write_simple(kanto_name, true);
     convert_int_to_ptgb_str(kanto_dex_num, temp_string, 3);
@@ -256,19 +264,28 @@ int __attribute__((noinline)) pokedex_loop()
                 }
 
                 tte_set_pos(dex_x_cord + (3 * 8), (i * 8 * 2) + 28);
-                convert_int_to_ptgb_str(dex_shift + i + 1 + mythic_skip, temp_string, 3);
+                convert_int_to_ptgb_str(
+                    dex_shift + i + 1 + mythic_skip, temp_string, 3);
                 ptgb_write_simple(temp_string, true);
 
                 tte_set_pos(dex_x_cord + (7 * 8), (i * 8 * 2) + 28);
-                PKMN_NAMES.readFile(dex_shift + i + 1 + mythic_skip, name_buffer);
-                ptgb_write_simple(is_caught(dex_shift + i + 1 + mythic_skip) ? name_buffer : undiscovered_text, true);
-
+                PKMN_NAMES.readFile(
+                    dex_shift + i + 1 + mythic_skip, name_buffer);
+                ptgb_write_simple(is_caught(dex_shift + i + 1 + mythic_skip)
+                                      ? name_buffer
+                                      : undiscovered_text,
+                    true);
             }
-            //global_next_frame(); // This is a bit silly, but it works. Makes the types one frame off from the text, but that's 'fine'
-            // Eventually it could be optimized to move the labels around, but this honestly makes the most sense. Less code but one frame different
+            // global_next_frame(); // This is a bit silly, but it works. Makes
+            // the types one frame off from the text, but that's 'fine'
+            //  Eventually it could be optimized to move the labels around, but
+            //  this honestly makes the most sense. Less code but one frame
+            //  different
             for (int i = 0; i < DEX_MAX; i++)
             {
-                load_type_sprites((const u8*)TYPES, dex_shift + i + 1 + mythic_skip, i, is_caught(dex_shift + i + 1 + mythic_skip));
+                load_type_sprites((const u8 *)TYPES,
+                    dex_shift + i + 1 + mythic_skip, i,
+                    is_caught(dex_shift + i + 1 + mythic_skip));
             }
             update = false;
         }
diff --git a/source/ptgb_save_data_manager.cpp b/source/ptgb_save_data_manager.cpp
index 8d73dbf..181a3f5 100644
--- a/source/ptgb_save_data_manager.cpp
+++ b/source/ptgb_save_data_manager.cpp
@@ -1,11 +1,11 @@
-#include <tonc.h>
 #include "ptgb_save_data_manager.h"
-#include "flash_mem.h"
-#include "dbg/debug_mode.h"
 #include "button_menu.h"
-#include "pokemon_data.h"
+#include "dbg/debug_mode.h"
+#include "flash_mem.h"
 #include "libraries/Pokemon-Gen3-to-Gen-X/include/save.h"
+#include "pokemon_data.h"
 #include "script_array.h"
+#include <tonc.h>
 
 byte save_data_array[SAVE_DATA_SIZE];
 
@@ -27,7 +27,9 @@ void write_custom_save_data()
 
 bool is_caught(int dex_num)
 {
-    return (((save_data_array[CAUGHT_DATA + (dex_num / 8)]) >> dex_num % 8) & 1) || g_debug_options.force_all_caught;
+    return (((save_data_array[CAUGHT_DATA + (dex_num / 8)]) >> dex_num % 8) &
+               1) ||
+           g_debug_options.force_all_caught;
 }
 
 void set_caught(int dex_num)
@@ -36,28 +38,17 @@ void set_caught(int dex_num)
     {
         newPkmn |= true;
     }
-    save_data_array[CAUGHT_DATA + (dex_num / 8)] = save_data_array[CAUGHT_DATA + (dex_num / 8)] | (1 << (dex_num % 8));
+    save_data_array[CAUGHT_DATA + (dex_num / 8)] =
+        save_data_array[CAUGHT_DATA + (dex_num / 8)] | (1 << (dex_num % 8));
 }
 
-int get_def_lang_num()
-{
-    return save_data_array[DEFAULT_LANGUAGE];
-}
+int get_def_lang_num() { return save_data_array[DEFAULT_LANGUAGE]; }
 
-void set_def_lang(int nLang)
-{
-    save_data_array[DEFAULT_LANGUAGE] = nLang;
-}
+void set_def_lang(int nLang) { save_data_array[DEFAULT_LANGUAGE] = nLang; }
 
-void set_tutorial_flag(bool value)
-{
-    save_data_array[TUTORIAL_FLAG] = value;
-}
+void set_tutorial_flag(bool value) { save_data_array[TUTORIAL_FLAG] = value; }
 
-bool get_tutorial_flag()
-{
-    return save_data_array[TUTORIAL_FLAG];
-}
+bool get_tutorial_flag() { return save_data_array[TUTORIAL_FLAG]; }
 
 void initialize_save_data()
 {
@@ -86,7 +77,8 @@ bool check_can_save()
     byte data_buffer[8] = {};
     byte test_buffer[8] = {0xC7, 0xCF, 0xCA, 0xCA, 0xBF, 0xCE, 0xA4, 0xBE};
 
-    // Copy the current bytes and save them to the data buffer, and replace them with the test_buffer
+    // Copy the current bytes and save them to the data buffer, and replace them
+    // with the test_buffer
     copy_save_to_ram(HALL_OF_FAME + 0x1000, &global_memory_buffer[0], 0x1000);
     for (int i = 0; i < 8; i++)
     {
@@ -96,7 +88,8 @@ bool check_can_save()
     erase_sector(HALL_OF_FAME + 0x1000);
     copy_ram_to_save(&global_memory_buffer[0], HALL_OF_FAME + 0x1000, 0x1000);
 
-    // Overwrite the data in the global memory buffer to make sure that it isn't still there when testing
+    // Overwrite the data in the global memory buffer to make sure that it isn't
+    // still there when testing
     for (int i = 0; i < 8; i++)
     {
         global_memory_buffer[HOF_SECTION + i] = 0;
@@ -111,7 +104,8 @@ bool check_can_save()
             // Did not save correctly, return false
             return false;
         }
-        // Set the byte in the memory buffer back in preperation for saving it back again
+        // Set the byte in the memory buffer back in preperation for saving it
+        // back again
         global_memory_buffer[HOF_SECTION + i] = data_buffer[i];
     }
 
diff --git a/source/random.cpp b/source/random.cpp
index 2c6c98c..a3bb96d 100644
--- a/source/random.cpp
+++ b/source/random.cpp
@@ -1,21 +1,16 @@
-#include <tonc.h>
 #include "random.h"
+#include <tonc.h>
 
 unsigned int u32_rand;
 
-void rand_set_seed(unsigned int init_seed)
-{
-    u32_rand = init_seed + 1;
-}
+void rand_set_seed(unsigned int init_seed) { u32_rand = init_seed + 1; }
 
-unsigned int rand_get_seed()
-{
-    return u32_rand;
-}
+unsigned int rand_get_seed() { return u32_rand; }
 
 void rand_next_frame()
 {
-    u32_rand = (0x41C64E6D * u32_rand) + 0x6073; // This is the randomization method used in Gen 3
+    u32_rand = (0x41C64E6D * u32_rand) +
+               0x6073; // This is the randomization method used in Gen 3
 }
 
 u32 get_rand_u32()
@@ -30,25 +25,20 @@ u16 get_rand_u16()
     return (u32_rand >> 16);
 }
 
-u32 get_rev_rand_u32(u32 input)
-{
-    return (input - 24691) * 4005161829;
-}
+u32 get_rev_rand_u32(u32 input) { return (input - 24691) * 4005161829; }
 
-u16 get_rev_rand_u16(u32 input)
-{
-    return (get_rev_rand_u32(input) >> 16);
-}
+u16 get_rev_rand_u16(u32 input) { return (get_rev_rand_u32(input) >> 16); }
 
 // Force ARM mode. In Thumb mode this imports __aeabi_lmul.
-__attribute__((target("arm"), noinline))
-static unsigned multiply_high(unsigned x, unsigned y)
+__attribute__((target("arm"), noinline)) static unsigned multiply_high(
+    unsigned x, unsigned y)
 {
-    return ((unsigned long long)x * y) >> 32;    // umull
+    return ((unsigned long long)x * y) >> 32; // umull
 }
 
 unsigned get_rand_range(unsigned inc_min, unsigned exc_max)
 {
-    // fixed point: get_rand_u32() / (float)0x100000000 * (exc_max - inc_min) + inc_min
+    // fixed point: get_rand_u32() / (float)0x100000000 * (exc_max - inc_min) +
+    // inc_min
     return multiply_high(get_rand_u32(), exc_max - inc_min) + inc_min;
 }
\ No newline at end of file
diff --git a/source/rom_data.cpp b/source/rom_data.cpp
index ddfeeb6..c72fc59 100644
--- a/source/rom_data.cpp
+++ b/source/rom_data.cpp
@@ -1,16 +1,16 @@
 #include "rom_data.h"
 #include "dbg/debug_mode.h"
-#include "pokemon_data.h"
-#include "text_engine.h"
-#include "ptgb_save_data_manager.h"
 #include "gba_rom_values/gba_rom_values.h"
-#include "libraries/nanoprintf/nanoprintf.h"
 #include "gba_rom_values_eng_lz10_bin.h"
 #include "gba_rom_values_fre_lz10_bin.h"
 #include "gba_rom_values_ger_lz10_bin.h"
 #include "gba_rom_values_ita_lz10_bin.h"
 #include "gba_rom_values_jpn_lz10_bin.h"
 #include "gba_rom_values_spa_lz10_bin.h"
+#include "libraries/nanoprintf/nanoprintf.h"
+#include "pokemon_data.h"
+#include "ptgb_save_data_manager.h"
+#include "text_engine.h"
 
 extern rom_data curr_GBA_rom;
 
@@ -69,7 +69,8 @@ bool rom_data::load_rom(bool debug)
     }*/
 
     // byte 2-4 of the compressed data store the decompressed size
-    rom_list_size = compressed_rom_list[1] | (compressed_rom_list[2] << 8) | (compressed_rom_list[3] << 16);
+    rom_list_size = compressed_rom_list[1] | (compressed_rom_list[2] << 8) |
+                    (compressed_rom_list[3] << 16);
     LZ77UnCompWram(compressed_rom_list, rom_list_buffer);
 
     cur = rom_list_buffer;
@@ -78,7 +79,8 @@ bool rom_data::load_rom(bool debug)
     {
         const ROM_DATA *rom_values = reinterpret_cast<const ROM_DATA *>(cur);
         if (rom_values->is_valid && rom_values->gamecode == gamecode &&
-            rom_values->version == version && (rom_values->entrypoint == entrypoint || debug))
+            rom_values->version == version &&
+            (rom_values->entrypoint == entrypoint || debug))
         {
             fill_values(rom_values);
             rom_loaded = true;
@@ -103,11 +105,20 @@ void rom_data::fill_values(const ROM_DATA *rom_values)
     offset_wondercard = rom_values->offset_wondercard;
     offset_script = rom_values->offset_script;
 
-    e4_flag = rom_values->e4_flag;                                 // The flag that is set when you become champion. Often listed as "GAME_CLEAR"
-    mg_flag = rom_values->mg_flag;                                 // The flag that is set when you enable Mystery Gift. Known as "EXDATA_ENABLE" in RS
-    unused_flag_start = rom_values->unused_flag_start;             // The start of the unused flags and must have 31 open flags in a row
-    all_collected_flag = rom_values->unused_flag_start;            // The flag for if everything has been collected
-    pkmn_collected_flag_start = rom_values->unused_flag_start + 1; // The beginning of the flags for each of the Pokemon
+    e4_flag = rom_values->e4_flag; // The flag that is set when you become
+                                   // champion. Often listed as "GAME_CLEAR"
+    mg_flag =
+        rom_values->mg_flag; // The flag that is set when you enable Mystery
+                             // Gift. Known as "EXDATA_ENABLE" in RS
+    unused_flag_start =
+        rom_values->unused_flag_start; // The start of the unused flags and must
+                                       // have 31 open flags in a row
+    all_collected_flag =
+        rom_values->unused_flag_start; // The flag for if everything has been
+                                       // collected
+    pkmn_collected_flag_start =
+        rom_values->unused_flag_start +
+        1; // The beginning of the flags for each of the Pokemon
 
     map_bank = rom_values->map_bank;
     map_id = rom_values->map_id;
@@ -120,7 +131,8 @@ void rom_data::fill_values(const ROM_DATA *rom_values)
 
 bool rom_data::is_hoenn()
 {
-    return (gamecode == RUBY_ID || gamecode == SAPPHIRE_ID || gamecode == EMERALD_ID);
+    return (gamecode == RUBY_ID || gamecode == SAPPHIRE_ID ||
+            gamecode == EMERALD_ID);
 }
 
 bool rom_data::is_ruby_sapphire()
@@ -154,7 +166,8 @@ void rom_data::print_rom_info()
         break;
     }
 
-    npf_snprintf(buffer, sizeof(buffer), "%c-%d-%c", gameTypeChar, version, language);
+    npf_snprintf(
+        buffer, sizeof(buffer), "%c-%d-%c", gameTypeChar, version, language);
 
     ptgb_write_simple(reinterpret_cast<const byte *>(buffer), true);
 }
@@ -162,9 +175,10 @@ void rom_data::print_rom_info()
 bool rom_data::verify_rom()
 {
     // This should really be replaced with a "cart pulled" interrupt
-    return !rom_loaded ||
-           g_debug_options.ignore_game_pak ||
-           ((gamecode == ((*(vu8 *)(0x80000AC)) << 0x10 | (*(vu8 *)(0x80000AD)) << 0x08 | (*(vu8 *)(0x80000AE)) << 0x00)) &&
-            (language == (*(vu8 *)(0x80000AF))) &&
-            (version == (*(vu8 *)(0x80000BC)))); 
+    return !rom_loaded || g_debug_options.ignore_game_pak ||
+           ((gamecode ==
+                ((*(vu8 *)(0x80000AC)) << 0x10 | (*(vu8 *)(0x80000AD)) << 0x08 |
+                    (*(vu8 *)(0x80000AE)) << 0x00)) &&
+               (language == (*(vu8 *)(0x80000AF))) &&
+               (version == (*(vu8 *)(0x80000BC))));
 }
\ No newline at end of file
diff --git a/source/script_array.cpp b/source/script_array.cpp
index 74bb12e..b08aacd 100644
--- a/source/script_array.cpp
+++ b/source/script_array.cpp
@@ -2,19 +2,19 @@
 #include "background_engine.h"
 #include "box_menu.h"
 #include "button_menu.h"
+#include "dbg/debug_mode.h"
 #include "flash_mem.h"
 #include "gb_rom_values/gb_rom_values.h"
 #include "global_frame_controller.h"
 #include "link_handler.h"
 #include "mystery_gift_injector.h"
-#include "ptgb_save_data_manager.h"
 #include "pokemon_data.h"
+#include "ptgb_save_data_manager.h"
 #include "select_menu.h"
 #include "sprite_data.h"
 #include "text_engine.h"
 #include "text_tables.h"
 #include "translated_text.h"
-#include "dbg/debug_mode.h"
 #include <tonc.h>
 
 int last_error;
@@ -110,8 +110,7 @@ Box_Menu box_viewer;
 // values So if adding a new dia, command or condition, make sure to add it in
 // the right position/index. defining it this way does not generate an expensive
 // function. It's all stored as read-only data in EWRAM.
-const script_obj_params transfer_script_params[SCRIPT_SIZE] = {
-    // PTGB_DIA_OPEN
+const script_obj_params transfer_script_params[SCRIPT_SIZE] = {// PTGB_DIA_OPEN
     {.text_entry_index = PTGB_DIA_OPEN, .next_if_true = CMD_SET_TUTOR_TRUE},
     // PTGB_DIA_E4
     {.text_entry_index = PTGB_DIA_E4, .next_if_true = CMD_END_SCRIPT},
@@ -546,7 +545,7 @@ bool run_conditional(int index)
         return get_tutorial_flag() && !g_debug_options.force_tutorial;
 
     case COND_NEW_POKEMON:
-        //return box.getHasNewPkmn();    
+        // return box.getHasNewPkmn();
         return newPkmn;
 
     case COND_IS_HOENN_RS:
@@ -694,15 +693,18 @@ bool run_conditional(int index)
 
             obj_unhide(gb_flag, 0);
             obj_set_pos(gb_flag, 1.5 * 8, 14 * 8);
-        
-            globalLinkCable.LinkCommand_ReadMemorySection(globalLinkCable.pccsROMptr->wCurrentBoxNum, &globalLinkCable.boxNum, 1);
+
+            globalLinkCable.LinkCommand_ReadMemorySection(
+                globalLinkCable.pccsROMptr->wCurrentBoxNum,
+                &globalLinkCable.boxNum, 1);
 
             byte boxDataArray[globalLinkCable.pccsROMptr->box_data_size];
-            globalLinkCable.LinkCommand_ReadMemorySection(globalLinkCable.pccsROMptr->wBoxDataStart,
-            boxDataArray, globalLinkCable.pccsROMptr->box_data_size);
+            globalLinkCable.LinkCommand_ReadMemorySection(
+                globalLinkCable.pccsROMptr->wBoxDataStart, boxDataArray,
+                globalLinkCable.pccsROMptr->box_data_size);
 
-            box.loadData(globalLinkCable.gen, globalLinkCable.lang,
-            boxDataArray);
+            box.loadData(
+                globalLinkCable.gen, globalLinkCable.lang, boxDataArray);
         }
         reload_textbox_background();
         load_flex_background(FBG_Fennel, 2);
@@ -794,13 +796,15 @@ bool run_conditional(int index)
         }
         boxRemovalPayload[arrayIndex] = 0xFF;
         arrayIndex++;
-        globalLinkCable.LinkCommand_TransferPokemon(globalLinkCable.boxNum, boxRemovalPayload, arrayIndex);
+        globalLinkCable.LinkCommand_TransferPokemon(
+            globalLinkCable.boxNum, boxRemovalPayload, arrayIndex);
     }
         return true;
 
     case CMD_BOX_MENU:
         hide_textbox();
-        ret = (box_viewer.box_main(&box, globalLinkCable.vers) == CONFIRM_BUTTON);
+        ret =
+            (box_viewer.box_main(&box, globalLinkCable.vers) == CONFIRM_BUTTON);
         show_textbox();
         return ret;
 
diff --git a/source/script_obj.cpp b/source/script_obj.cpp
index 3f3f01f..6ecaa85 100644
--- a/source/script_obj.cpp
+++ b/source/script_obj.cpp
@@ -1,40 +1,23 @@
 #include "script_obj.h"
 
-script_obj::script_obj()
-    : params_({0})
-{
-};
+script_obj::script_obj() : params_({0}) {};
 
-script_obj::script_obj(const script_obj_params &params)
-    : params_(params)
-{
-}
+script_obj::script_obj(const script_obj_params &params) : params_(params) {}
 
 bool script_obj::has_text() const
 {
-    // So the thing is: when conditional_index is set, its value will always be higher than 0
-    // because the way these integer defines have been set up.
-    // So that means that if conditional_index IS 0, then we must have a text entry index defined instead!
-    // We can't base this check on the text_entry_index itself since unfortunately its value being zero can be legit.
+    // So the thing is: when conditional_index is set, its value will always be
+    // higher than 0 because the way these integer defines have been set up. So
+    // that means that if conditional_index IS 0, then we must have a text entry
+    // index defined instead! We can't base this check on the text_entry_index
+    // itself since unfortunately its value being zero can be legit.
     return (params_.conditional_index == 0);
 }
 
-u8 script_obj::get_text_entry_index() const
-{
-    return params_.text_entry_index;
-}
+u8 script_obj::get_text_entry_index() const { return params_.text_entry_index; }
 
-u16 script_obj::get_true_index() const
-{
-    return params_.next_if_true;
-}
+u16 script_obj::get_true_index() const { return params_.next_if_true; }
 
-u16 script_obj::get_false_index() const
-{
-    return params_.next_if_false;
-}
+u16 script_obj::get_false_index() const { return params_.next_if_false; }
 
-u16 script_obj::get_cond_id() const
-{
-    return params_.conditional_index;
-}
\ No newline at end of file
+u16 script_obj::get_cond_id() const { return params_.conditional_index; }
\ No newline at end of file
diff --git a/source/select_menu.cpp b/source/select_menu.cpp
index 15f6435..940cd8e 100644
--- a/source/select_menu.cpp
+++ b/source/select_menu.cpp
@@ -1,31 +1,30 @@
 #include "select_menu.h"
+#include "global_frame_controller.h"
 #include "sprite_data.h"
 #include "translated_text.h"
-#include "global_frame_controller.h"
 
 #define TEXT_HEIGHT 10
 #define TEXT_WIDTH 8
 #define TILE_HEIGHT 8
 #define TILE_WIDTH 8
 
-Select_Menu::Select_Menu(bool enable_cancel, u8 nMenu_type, unsigned nStartTileX, unsigned nStartTileY)
-    : vertical_menu_cursor_handler(TEXT_WIDTH, 3)
-    , menu_widget_(vertical_menu_settings{
-        .x = static_cast<unsigned>(nStartTileX * TILE_WIDTH),
-        .y = static_cast<unsigned>(nStartTileY * TILE_HEIGHT),
-        .width = 10 * TEXT_WIDTH,
-        .height = TILE_HEIGHT * 2, // to account for the margins
-        .margin_top = TILE_HEIGHT,
-        .margin_bottom = TILE_HEIGHT,
-        .initial_focus_index = 0,
-        .item_height = TEXT_HEIGHT,
-        .text_table_index = GENERAL_INDEX,
-        .allow_cancel = enable_cancel,
-        .should_delete_item_widgets_on_destruct = true,
-        .should_hide_state_changed_handler_on_not_focused = false
-    })
-    , menu_type(nMenu_type)
-    , lang(0)
+Select_Menu::Select_Menu(bool enable_cancel, u8 nMenu_type,
+    unsigned nStartTileX, unsigned nStartTileY)
+    : vertical_menu_cursor_handler(TEXT_WIDTH, 3),
+      menu_widget_(vertical_menu_settings{
+          .x = static_cast<unsigned>(nStartTileX * TILE_WIDTH),
+          .y = static_cast<unsigned>(nStartTileY * TILE_HEIGHT),
+          .width = 10 * TEXT_WIDTH,
+          .height = TILE_HEIGHT * 2, // to account for the margins
+          .margin_top = TILE_HEIGHT,
+          .margin_bottom = TILE_HEIGHT,
+          .initial_focus_index = 0,
+          .item_height = TEXT_HEIGHT,
+          .text_table_index = GENERAL_INDEX,
+          .allow_cancel = enable_cancel,
+          .should_delete_item_widgets_on_destruct = true,
+          .should_hide_state_changed_handler_on_not_focused = false}),
+      menu_type(nMenu_type), lang(0)
 {
     menu_widget_.set_state_changed_handler(this);
     menu_widget_.set_run_cycle_handler(this);
@@ -34,14 +33,11 @@ Select_Menu::Select_Menu(bool enable_cancel, u8 nMenu_type, unsigned nStartTileX
 void Select_Menu::add_option(const u8 option, u8 return_value)
 {
     const simple_item_widget_data item_data = {
-        .text = {
-            .text_table_index = option,
+        .text = {.text_table_index = option,
             .margin_left = 2 * TILE_WIDTH,
-            .margin_top = 0
-        },
+            .margin_top = 0},
         .value = return_value,
-        .on_execute_callback = nullptr
-    };
+        .on_execute_callback = nullptr};
     menu_widget_.add_item_widget(new simple_item_renderer(item_data));
 
     vertical_menu_settings settings = menu_widget_.get_settings();
@@ -62,27 +58,25 @@ int Select_Menu::select_menu_main()
 {
     unsigned choice_index;
     unsigned item_value;
-    simple_item_renderer* widget = nullptr;
+    simple_item_renderer *widget = nullptr;
 
     menu_widget_.show();
     choice_index = menu_widget_.run();
 
-    if(choice_index != UINT32_MAX)
+    if (choice_index != UINT32_MAX)
     {
-        widget = static_cast<simple_item_renderer*>(menu_widget_.get_item_widget_at(choice_index));
+        widget = static_cast<simple_item_renderer *>(
+            menu_widget_.get_item_widget_at(choice_index));
     }
     item_value = (widget) ? widget->get_data().value : UINT8_MAX;
 
     menu_widget_.hide();
 
-    //global_next_frame();
+    // global_next_frame();
     return item_value;
 }
 
-void Select_Menu::set_lang(u8 nLang)
-{
-    lang = nLang;
-}
+void Select_Menu::set_lang(u8 nLang) { lang = nLang; }
 
 void Select_Menu::on_hide()
 {
@@ -93,12 +87,14 @@ void Select_Menu::on_hide()
     obj_hide(gb_flag);
 }
 
-void Select_Menu::on_selection_changed(unsigned new_index, unsigned x, unsigned y)
+void Select_Menu::on_selection_changed(
+    unsigned new_index, unsigned x, unsigned y)
 {
     // call the base implementation to move the cursor
     vertical_menu_cursor_handler::on_selection_changed(new_index, x, y);
 
-    simple_item_renderer* widget = static_cast<simple_item_renderer*>(menu_widget_.get_item_widget_at(new_index));
+    simple_item_renderer *widget = static_cast<simple_item_renderer *>(
+        menu_widget_.get_item_widget_at(new_index));
     const unsigned item_value = (widget) ? widget->get_data().value : UINT8_MAX;
 
     if (item_value == UINT8_MAX)
@@ -119,19 +115,16 @@ void Select_Menu::on_selection_changed(unsigned new_index, unsigned x, unsigned
         switch (menu_type)
         {
         case CART_MENU:
-            //load_select_sprites(item_value, lang);
+            // load_select_sprites(item_value, lang);
             obj_unhide(cart_shell, 0);
             obj_unhide(cart_label, 0);
             break;
         case LANG_MENU:
-            //load_select_sprites(0, item_value);
+            // load_select_sprites(0, item_value);
             obj_unhide(gb_flag, 0);
             break;
         }
     }
 }
 
-void Select_Menu::on_run_cycle()
-{
-    update_y_offset();
-}
\ No newline at end of file
+void Select_Menu::on_run_cycle() { update_y_offset(); }
\ No newline at end of file
diff --git a/source/sound.c b/source/sound.c
index 7d416ee..8bf7b31 100644
--- a/source/sound.c
+++ b/source/sound.c
@@ -1,14 +1,14 @@
-#include <maxmod.h>
 #include "sound.h"
 #include "soundbank_bin.h"
+#include <maxmod.h>
 
 #if ENABLE_SOUND
 static void sound_irq_handler(void)
 {
-    #ifdef INCLUDE_SOUND
+#ifdef INCLUDE_SOUND
     mmVBlank();
     mmFrame();
-    #endif
+#endif
 }
 #endif
 
diff --git a/source/sprite_data.cpp b/source/sprite_data.cpp
index 7802e03..66d7fbe 100644
--- a/source/sprite_data.cpp
+++ b/source/sprite_data.cpp
@@ -1,10 +1,10 @@
-#include <tonc.h>
-#include <cstring>
 #include "sprite_data.h"
+#include "background_engine.h"
 #include "dbg/debug_mode.h"
 #include "gba_rom_values/base_gba_rom_struct.h"
 #include "global_frame_controller.h"
-#include "background_engine.h"
+#include <cstring>
+#include <tonc.h>
 
 #define SPRITE_CHAR_BLOCK 4
 
@@ -23,10 +23,12 @@ void load_background()
     // Load palette
     tonccpy(pal_bg_mem, backgroundPal, backgroundPalLen);
     // Load tiles into CBB 0
-    LZ77UnCompVram(backgroundTiles, &tile_mem[TILESET_PTGB][TILESET_OFFSET_BACKDROP]);
+    LZ77UnCompVram(
+        backgroundTiles, &tile_mem[TILESET_PTGB][TILESET_OFFSET_BACKDROP]);
     // Load map into SBB 0
     LZ77UnCompVram(backgroundMap, &se_mem[TILEMAP_BACKDROP][0]);
-    BG_BACKDROP = BG_CBB(TILESET_PTGB) | BG_SBB(TILEMAP_BACKDROP) | BG_4BPP | BG_REG_32x32 | BG_PRIO(3);
+    BG_BACKDROP = BG_CBB(TILESET_PTGB) | BG_SBB(TILEMAP_BACKDROP) | BG_4BPP |
+                  BG_REG_32x32 | BG_PRIO(3);
 }
 
 void set_background_pal(int curr_rom_id, bool dark, bool fade)
@@ -96,10 +98,16 @@ void set_background_pal(int curr_rom_id, bool dark, bool fade)
                     old_pal[b] = (curr_pal_bg[i] >> (b * 5)) & 0b11111;
                     new_pal[b] = (new_pal_bg[i] >> (b * 5)) & 0b11111;
                 }
-                pal_bg_mem[i] = RGB15(
-                    ((((NUM_CYCLES - n) * INV_NUM_CYCLES) * old_pal[0]) + ((n * INV_NUM_CYCLES) * new_pal[0])) >> 16,
-                    ((((NUM_CYCLES - n) * INV_NUM_CYCLES) * old_pal[1]) + ((n * INV_NUM_CYCLES) * new_pal[1])) >> 16,
-                    ((((NUM_CYCLES - n) * INV_NUM_CYCLES) * old_pal[2]) + ((n * INV_NUM_CYCLES) * new_pal[2])) >> 16);
+                pal_bg_mem[i] =
+                    RGB15(((((NUM_CYCLES - n) * INV_NUM_CYCLES) * old_pal[0]) +
+                              ((n * INV_NUM_CYCLES) * new_pal[0])) >>
+                              16,
+                        ((((NUM_CYCLES - n) * INV_NUM_CYCLES) * old_pal[1]) +
+                            ((n * INV_NUM_CYCLES) * new_pal[1])) >>
+                            16,
+                        ((((NUM_CYCLES - n) * INV_NUM_CYCLES) * old_pal[2]) +
+                            ((n * INV_NUM_CYCLES) * new_pal[2])) >>
+                            16);
             }
             VBlankIntrWait();
         }
@@ -116,20 +124,21 @@ void set_background_pal(int curr_rom_id, bool dark, bool fade)
     pal_bg_bank[15][14] = pal_bg_mem[3];
 }
 
-#include "openingBG.h"
-#include "fennelBG.h"
 #include "dexBG.h"
+#include "fennelBG.h"
 #include "menu_bars.h"
+#include "openingBG.h"
 
+#include "boxBG_Blue.h"
+#include "boxBG_Crystal.h"
+#include "boxBG_Gold.h"
 #include "boxBG_Green.h"
 #include "boxBG_Red.h"
-#include "boxBG_Blue.h"
-#include "boxBG_Yellow.h"
-#include "boxBG_Gold.h"
 #include "boxBG_Silver.h"
-#include "boxBG_Crystal.h"
+#include "boxBG_Yellow.h"
 
-struct flex_background {
+struct flex_background
+{
     const unsigned short *palette;
     u16 palette_len;
     u16 voffset;
@@ -138,88 +147,100 @@ struct flex_background {
 };
 
 static const flex_background FLEX_BACKGROUNDS[] = {
-    [FBG_Opening] = {
-        openingBGPal,
-        openingBGPalLen,
-        96,
-        openingBGTiles,
-        openingBGMap,
-    },
-    [FBG_Fennel] = {
-        fennelBGPal,
-        fennelBGPalLen,
-        FENNEL_SHIFT,
-        fennelBGTiles,
-        fennelBGMap,
-    },
-    [FBG_Dex] = {
-        dexBGPal,
-        dexBGPalLen,
-        0,
-        dexBGTiles,
-        dexBGMap,
-    },
-    [FBG_Main_Menu] = {
-        pal_bg_mem,
-        backgroundPalLen,
-        0,
-        menu_barsTiles,
-        menu_barsMap,
-    },
-    [FBG_Box_Green] = {
-        boxBG_GreenPal,
-        boxBG_GreenPalLen,
-        0,
-        boxBG_GreenTiles,
-        boxBG_GreenMap,
-    },
-    [FBG_Box_Red] = {
-        boxBG_RedPal,
-        boxBG_RedPalLen,
-        0,
-        boxBG_RedTiles,
-        boxBG_RedMap,
-    },
-    [FBG_Box_Blue] = {
-        boxBG_BluePal,
-        boxBG_BluePalLen,
-        0,
-        boxBG_BlueTiles,
-        boxBG_BlueMap,
-    },
-    [FBG_Box_Yellow] = {
-        boxBG_YellowPal,
-        boxBG_YellowPalLen,
-        0,
-        boxBG_YellowTiles,
-        boxBG_YellowMap,
-    },
-    [FBG_Box_Gold] = {
-        boxBG_GoldPal,
-        boxBG_GoldPalLen,
-        0,
-        boxBG_GoldTiles,
-        boxBG_GoldMap,
-    },
-    [FBG_Box_Silver] = {
-        boxBG_SilverPal,
-        boxBG_SilverPalLen,
-        0,
-        boxBG_SilverTiles,
-        boxBG_SilverMap,
-    },
-    [FBG_Box_Crystal] = {
-        boxBG_CrystalPal,
-        boxBG_CrystalPalLen,
-        0,
-        boxBG_CrystalTiles,
-        boxBG_CrystalMap,
-    },
+    [FBG_Opening] =
+        {
+            openingBGPal,
+            openingBGPalLen,
+            96,
+            openingBGTiles,
+            openingBGMap,
+        },
+    [FBG_Fennel] =
+        {
+            fennelBGPal,
+            fennelBGPalLen,
+            FENNEL_SHIFT,
+            fennelBGTiles,
+            fennelBGMap,
+        },
+    [FBG_Dex] =
+        {
+            dexBGPal,
+            dexBGPalLen,
+            0,
+            dexBGTiles,
+            dexBGMap,
+        },
+    [FBG_Main_Menu] =
+        {
+            pal_bg_mem,
+            backgroundPalLen,
+            0,
+            menu_barsTiles,
+            menu_barsMap,
+        },
+    [FBG_Box_Green] =
+        {
+            boxBG_GreenPal,
+            boxBG_GreenPalLen,
+            0,
+            boxBG_GreenTiles,
+            boxBG_GreenMap,
+        },
+    [FBG_Box_Red] =
+        {
+            boxBG_RedPal,
+            boxBG_RedPalLen,
+            0,
+            boxBG_RedTiles,
+            boxBG_RedMap,
+        },
+    [FBG_Box_Blue] =
+        {
+            boxBG_BluePal,
+            boxBG_BluePalLen,
+            0,
+            boxBG_BlueTiles,
+            boxBG_BlueMap,
+        },
+    [FBG_Box_Yellow] =
+        {
+            boxBG_YellowPal,
+            boxBG_YellowPalLen,
+            0,
+            boxBG_YellowTiles,
+            boxBG_YellowMap,
+        },
+    [FBG_Box_Gold] =
+        {
+            boxBG_GoldPal,
+            boxBG_GoldPalLen,
+            0,
+            boxBG_GoldTiles,
+            boxBG_GoldMap,
+        },
+    [FBG_Box_Silver] =
+        {
+            boxBG_SilverPal,
+            boxBG_SilverPalLen,
+            0,
+            boxBG_SilverTiles,
+            boxBG_SilverMap,
+        },
+    [FBG_Box_Crystal] =
+        {
+            boxBG_CrystalPal,
+            boxBG_CrystalPalLen,
+            0,
+            boxBG_CrystalTiles,
+            boxBG_CrystalMap,
+        },
 };
 
 void load_flex_background(FlexBackground background_id, int layer)
 {
-    if (curr_flex_background != background_id) // Only load the background if it isn't already loaded
+    if (curr_flex_background !=
+        background_id) // Only load the background if it isn't already loaded
     {
         // This prevents screen tearing on this frame
         // global_next_frame();
@@ -227,13 +248,17 @@ void load_flex_background(FlexBackground background_id, int layer)
         const flex_background *flex = &FLEX_BACKGROUNDS[background_id];
 #ifdef DEBUG
         // Check to make sure we aren't overflowing tile memory
-        if ((flex->tileset[0] >> 8) > (6 * 1024)) {
-            for (;;) {}
+        if ((flex->tileset[0] >> 8) > (6 * 1024))
+        {
+            for (;;)
+            {
+            }
         }
 #endif
         tonccpy(pal_bg_mem + 32, flex->palette, flex->palette_len);
         // Load tiles
-        LZ77UnCompVram(flex->tileset, &tile_mem[TILESET_PTGB][TILESET_OFFSET_FLEXBG]);
+        LZ77UnCompVram(
+            flex->tileset, &tile_mem[TILESET_PTGB][TILESET_OFFSET_FLEXBG]);
         // Give it a frame to uncompress the data
         global_next_frame();
         // Load map into the tilemap
@@ -242,7 +267,8 @@ void load_flex_background(FlexBackground background_id, int layer)
         REG_BG1VOFS = flex->voffset;
     }
 
-    BG_FLEX = BG_CBB(TILESET_PTGB) | BG_SBB(TILEMAP_FLEXBG) | BG_4BPP | BG_REG_32x32 | BG_PRIO(layer);
+    BG_FLEX = BG_CBB(TILESET_PTGB) | BG_SBB(TILEMAP_FLEXBG) | BG_4BPP |
+              BG_REG_32x32 | BG_PRIO(layer);
     curr_flex_background = background_id;
 }
 #include "textBoxBG.h"
@@ -251,12 +277,14 @@ void load_textbox_background()
     // Load palette
     tonccpy(pal_bg_mem + 16, textBoxBGPal, textBoxBGPalLen);
     // Load tiles into CBB 0
-    LZ77UnCompVram(textBoxBGTiles, &tile_mem[TILESET_PTGB][TILESET_OFFSET_TEXTBOX]);
+    LZ77UnCompVram(
+        textBoxBGTiles, &tile_mem[TILESET_PTGB][TILESET_OFFSET_TEXTBOX]);
     // Load map into SBB 0
     reload_textbox_background();
 
     REG_BG2VOFS = 96;
-    BG_TEXTBOX = BG_CBB(TILESET_PTGB) | BG_SBB(TILEMAP_TEXTBOX) | BG_4BPP | BG_REG_32x32 | BG_PRIO(3);
+    BG_TEXTBOX = BG_CBB(TILESET_PTGB) | BG_SBB(TILEMAP_TEXTBOX) | BG_4BPP |
+                 BG_REG_32x32 | BG_PRIO(3);
 }
 
 void reload_textbox_background()
@@ -298,23 +326,30 @@ void reload_textbox_background()
 
 #define MENU_WIDTH 11 - 1 // Currently static
 
-static const u16 TILE_SE_U_ARR[4] = {TILE_SE_0, TILE_SE_2, TILE_SE_4U, TILE_SE_6U};
+static const u16 TILE_SE_U_ARR[4] = {
+    TILE_SE_0, TILE_SE_2, TILE_SE_4U, TILE_SE_6U};
 static const u16 TILE_S_U_ARR[4] = {TILE_S_0, TILE_S_2, TILE_S_4U, TILE_S_6U};
-static const u16 TILE_SW_U_ARR[4] = {TILE_SW_0, TILE_SW_2, TILE_SW_4U, TILE_SW_6U};
-static const u16 TILE_SE_L_ARR[4] = {TILE_CLEAR, TILE_CLEAR, TILE_SE_4L, TILE_SE_6L};
-static const u16 TILE_S_L_ARR[4] = {TILE_CLEAR, TILE_CLEAR, TILE_S_4L, TILE_S_6L};
-static const u16 TILE_SW_L_ARR[4] = {TILE_CLEAR, TILE_CLEAR, TILE_SW_4L, TILE_SW_6L};
+static const u16 TILE_SW_U_ARR[4] = {
+    TILE_SW_0, TILE_SW_2, TILE_SW_4U, TILE_SW_6U};
+static const u16 TILE_SE_L_ARR[4] = {
+    TILE_CLEAR, TILE_CLEAR, TILE_SE_4L, TILE_SE_6L};
+static const u16 TILE_S_L_ARR[4] = {
+    TILE_CLEAR, TILE_CLEAR, TILE_S_4L, TILE_S_6L};
+static const u16 TILE_SW_L_ARR[4] = {
+    TILE_CLEAR, TILE_CLEAR, TILE_SW_4L, TILE_SW_6L};
 
 void add_menu_box(int options, int startTileX, int startTileY)
 {
     add_menu_box(startTileX, startTileY, (MENU_WIDTH) * 8, (options * 10) + 16);
 }
 
-// TODO: clean this mess. manual masking used for now but there is a buffer overflow in how the bottom
-// row is calculated.
-void add_menu_box(int startTileX, int startTileY, int full_width, int full_height)
+// TODO: clean this mess. manual masking used for now but there is a buffer
+// overflow in how the bottom row is calculated.
+void add_menu_box(
+    int startTileX, int startTileY, int full_width, int full_height)
 {
-    // We can't check the current offset very easily, so we'll just assume it's in the text box position.
+    // We can't check the current offset very easily, so we'll just assume it's
+    // in the text box position.
     startTileY += 12;
 
     int start = (32 * startTileY) + startTileX;
@@ -325,23 +360,30 @@ void add_menu_box(int startTileX, int startTileY, int full_width, int full_heigh
     // Corners
     se_mem[TILEMAP_TEXTBOX][start] = TILE_NW;
     se_mem[TILEMAP_TEXTBOX][start + full_width] = TILE_NE;
-    se_mem[TILEMAP_TEXTBOX][(start + (32 * (tiles))) & 0x3ff] = TILE_SW_U_ARR[vert_rem / 2];
-    se_mem[TILEMAP_TEXTBOX][(start + (32 * (tiles + 1))) & 0x3ff] = TILE_SW_L_ARR[vert_rem / 2];
-    se_mem[TILEMAP_TEXTBOX][(start + (32 * (tiles)) + full_width) & 0x3ff] = TILE_SE_U_ARR[vert_rem / 2];
-    se_mem[TILEMAP_TEXTBOX][(start + (32 * (tiles + 1)) + full_width) & 0x3ff] = TILE_SE_L_ARR[vert_rem / 2];
+    se_mem[TILEMAP_TEXTBOX][(start + (32 * (tiles))) & 0x3ff] =
+        TILE_SW_U_ARR[vert_rem / 2];
+    se_mem[TILEMAP_TEXTBOX][(start + (32 * (tiles + 1))) & 0x3ff] =
+        TILE_SW_L_ARR[vert_rem / 2];
+    se_mem[TILEMAP_TEXTBOX][(start + (32 * (tiles)) + full_width) & 0x3ff] =
+        TILE_SE_U_ARR[vert_rem / 2];
+    se_mem[TILEMAP_TEXTBOX][(start + (32 * (tiles + 1)) + full_width) & 0x3ff] =
+        TILE_SE_L_ARR[vert_rem / 2];
 
     // Top and bottom edge
     for (int i = 1; i < full_width; i++)
     {
         se_mem[TILEMAP_TEXTBOX][start + i] = TILE_N;
-        se_mem[TILEMAP_TEXTBOX][(start + ((32 * (tiles))) + i) & 0x3ff] = TILE_S_U_ARR[vert_rem / 2];
-        se_mem[TILEMAP_TEXTBOX][(start + ((32 * (tiles + 1))) + i) & 0x3ff] = TILE_S_L_ARR[vert_rem / 2];
+        se_mem[TILEMAP_TEXTBOX][(start + ((32 * (tiles))) + i) & 0x3ff] =
+            TILE_S_U_ARR[vert_rem / 2];
+        se_mem[TILEMAP_TEXTBOX][(start + ((32 * (tiles + 1))) + i) & 0x3ff] =
+            TILE_S_L_ARR[vert_rem / 2];
     }
 
     // Sides
     for (int i = 1; i < tiles; i++)
     {
-        se_mem[TILEMAP_TEXTBOX][(start + (32 * i) + full_width) & 0x3ff] = TILE_E;
+        se_mem[TILEMAP_TEXTBOX][(start + (32 * i) + full_width) & 0x3ff] =
+            TILE_E;
         se_mem[TILEMAP_TEXTBOX][(start + (32 * i)) & 0x3ff] = TILE_W;
     }
 
@@ -358,7 +400,8 @@ void add_menu_box(int startTileX, int startTileY, int full_width, int full_heigh
 void erase_textbox_tiles()
 {
 
-    // We can't check the current offset very easily, so we'll just assume it's in the text box position.
+    // We can't check the current offset very easily, so we'll just assume it's
+    // in the text box position.
     int startTileY = 12;
 
     int start = (32 * startTileY);
@@ -393,7 +436,6 @@ OBJ_ATTR *cart_label = &obj_buffer[num_sprites++];
 OBJ_ATTR *gb_flag = &obj_buffer[num_sprites++];
 OBJ_ATTR *gba_flag = &obj_buffer[num_sprites++];
 
-
 OBJ_ATTR *type_sprites[14] = {
     &obj_buffer[num_sprites++],
     &obj_buffer[num_sprites++],
@@ -469,13 +511,11 @@ OBJ_ATTR *grabbed_front_sprite = &obj_buffer[num_sprites++];
 
 u32 global_tile_id_end = 0;
 
-inline void BitUnPack(const void *src, void *dst, uint16_t len, uint8_t from, uint8_t to)
+inline void BitUnPack(
+    const void *src, void *dst, uint16_t len, uint8_t from, uint8_t to)
 {
     BUP bupInfo = {
-        .src_len = len,
-        .src_bpp = from,
-        .dst_bpp = to,
-        .dst_ofs = 0};
+        .src_len = len, .src_bpp = from, .dst_bpp = to, .dst_ofs = 0};
     BitUnPack(src, dst, &bupInfo);
 }
 
@@ -485,39 +525,58 @@ void load_eternal_sprites()
     tonccpy(pal_obj_mem + (BTN_LIT_PAL * 16), button_yesPal, button_yesPalLen);
     tonccpy(pal_obj_mem + (LOGO_PAL * 16), ptgb_logo_lPal, ptgb_logo_lPalLen);
     tonccpy(pal_obj_mem + (TYPES_PAL1 * 16), typesPal, typesPalLen);
-    tonccpy(pal_obj_mem + (LINK_CABLE_PAL * 16), link_frame1Pal, link_frame1PalLen);
+    tonccpy(
+        pal_obj_mem + (LINK_CABLE_PAL * 16), link_frame1Pal, link_frame1PalLen);
 
     u32 curr_tile_id = 0;
-    load_sprite_compressed(ptgb_logo_l, ptgb_logo_lTiles, curr_tile_id, LOGO_PAL, ATTR0_SQUARE, ATTR1_SIZE_64x64, 1);
-    load_sprite_compressed(ptgb_logo_r, ptgb_logo_rTiles, curr_tile_id, LOGO_PAL, ATTR0_SQUARE, ATTR1_SIZE_64x64, 1);
-    load_sprite_compressed(button_yes, button_yesTiles, curr_tile_id, BTN_PAL, ATTR0_WIDE, ATTR1_SIZE_64x32, 1);
-    load_sprite_compressed(button_no, button_noTiles, curr_tile_id, BTN_PAL, ATTR0_WIDE, ATTR1_SIZE_64x32, 1);
-    load_sprite_compressed(cart_label, Label_GreenTiles, curr_tile_id, GB_CART_PAL, ATTR0_SQUARE, ATTR1_SIZE_32x32, 1);
+    load_sprite_compressed(ptgb_logo_l, ptgb_logo_lTiles, curr_tile_id,
+        LOGO_PAL, ATTR0_SQUARE, ATTR1_SIZE_64x64, 1);
+    load_sprite_compressed(ptgb_logo_r, ptgb_logo_rTiles, curr_tile_id,
+        LOGO_PAL, ATTR0_SQUARE, ATTR1_SIZE_64x64, 1);
+    load_sprite_compressed(button_yes, button_yesTiles, curr_tile_id, BTN_PAL,
+        ATTR0_WIDE, ATTR1_SIZE_64x32, 1);
+    load_sprite_compressed(button_no, button_noTiles, curr_tile_id, BTN_PAL,
+        ATTR0_WIDE, ATTR1_SIZE_64x32, 1);
+    load_sprite_compressed(cart_label, Label_GreenTiles, curr_tile_id,
+        GB_CART_PAL, ATTR0_SQUARE, ATTR1_SIZE_32x32, 1);
 
     /**
      * @brief Okay, the next lines to load the arrows are a bit confusing.
      * Be aware that tempTileBuf is NOT a u8 array, but a u32 array!
-     * The incoming arrows image is 1bpp, but we convert it into 4bpp in tempTileBuf. So every pixel is a nibble.
+     * The incoming arrows image is 1bpp, but we convert it into 4bpp in
+     * tempTileBuf. So every pixel is a nibble.
      *
-     * Still, every index of tempTileBuf is a full 32 bit integer, yet the third argument of load_sprite is a size_in_bytes.
-     * This is why those indexes look off. But they are correct.
+     * Still, every index of tempTileBuf is a full 32 bit integer, yet the third
+     * argument of load_sprite is a size_in_bytes. This is why those indexes
+     * look off. But they are correct.
      */
     unsigned int tempTileBuf[48];
     BitUnPack(arrowsTiles, tempTileBuf, arrowsTilesLen, 1, 4);
-    load_sprite(point_arrow, &tempTileBuf[32], 32, curr_tile_id, BTN_PAL, ATTR0_SQUARE, ATTR1_SIZE_8x8, 1);
-    load_sprite(toggle_arrow_right, &tempTileBuf[40], 32, curr_tile_id, BTN_PAL, ATTR0_SQUARE, ATTR1_SIZE_8x8, 1);
-    load_sprite(toggle_arrow_left, &tempTileBuf[40], 32, curr_tile_id, BTN_PAL, ATTR0_SQUARE, ATTR1_SIZE_8x8 | ATTR1_HFLIP, 1);
-    load_sprite(down_arrow, &tempTileBuf[0], 64, curr_tile_id, BTN_PAL, ATTR0_WIDE, ATTR1_SIZE_16x8, 1);
-    load_sprite(up_arrow, &tempTileBuf[16], 64, curr_tile_id, BTN_PAL, ATTR0_WIDE, ATTR1_SIZE_16x8, 1);
+    load_sprite(point_arrow, &tempTileBuf[32], 32, curr_tile_id, BTN_PAL,
+        ATTR0_SQUARE, ATTR1_SIZE_8x8, 1);
+    load_sprite(toggle_arrow_right, &tempTileBuf[40], 32, curr_tile_id, BTN_PAL,
+        ATTR0_SQUARE, ATTR1_SIZE_8x8, 1);
+    load_sprite(toggle_arrow_left, &tempTileBuf[40], 32, curr_tile_id, BTN_PAL,
+        ATTR0_SQUARE, ATTR1_SIZE_8x8 | ATTR1_HFLIP, 1);
+    load_sprite(down_arrow, &tempTileBuf[0], 64, curr_tile_id, BTN_PAL,
+        ATTR0_WIDE, ATTR1_SIZE_16x8, 1);
+    load_sprite(up_arrow, &tempTileBuf[16], 64, curr_tile_id, BTN_PAL,
+        ATTR0_WIDE, ATTR1_SIZE_16x8, 1);
 
-    load_sprite_compressed(link_frame1, link_frame1Tiles, curr_tile_id, LINK_CABLE_PAL, ATTR0_SQUARE, ATTR1_SIZE_32x32, 1);
-    load_sprite_compressed(link_frame2, link_frame2Tiles, curr_tile_id, LINK_CABLE_PAL, ATTR0_WIDE, ATTR1_SIZE_8x32, 1);
-    load_sprite_compressed(link_frame3, link_frame3Tiles, curr_tile_id, LINK_CABLE_PAL, ATTR0_WIDE, ATTR1_SIZE_16x32, 1);
+    load_sprite_compressed(link_frame1, link_frame1Tiles, curr_tile_id,
+        LINK_CABLE_PAL, ATTR0_SQUARE, ATTR1_SIZE_32x32, 1);
+    load_sprite_compressed(link_frame2, link_frame2Tiles, curr_tile_id,
+        LINK_CABLE_PAL, ATTR0_WIDE, ATTR1_SIZE_8x32, 1);
+    load_sprite_compressed(link_frame3, link_frame3Tiles, curr_tile_id,
+        LINK_CABLE_PAL, ATTR0_WIDE, ATTR1_SIZE_16x32, 1);
 
     BitUnPack(link_blobsTiles, tempTileBuf, link_blobsTilesLen, 1, 4);
-    load_sprite(link_blob1, &tempTileBuf[0], 32, curr_tile_id, LINK_CABLE_PAL, ATTR0_SQUARE, ATTR1_SIZE_8x8, 1);
-    load_sprite(link_blob2, &tempTileBuf[8], 32, curr_tile_id, LINK_CABLE_PAL, ATTR0_SQUARE, ATTR1_SIZE_8x8, 1);
-    load_sprite(link_blob3, &tempTileBuf[16], 32, curr_tile_id, LINK_CABLE_PAL, ATTR0_SQUARE, ATTR1_SIZE_8x8, 1);
+    load_sprite(link_blob1, &tempTileBuf[0], 32, curr_tile_id, LINK_CABLE_PAL,
+        ATTR0_SQUARE, ATTR1_SIZE_8x8, 1);
+    load_sprite(link_blob2, &tempTileBuf[8], 32, curr_tile_id, LINK_CABLE_PAL,
+        ATTR0_SQUARE, ATTR1_SIZE_8x8, 1);
+    load_sprite(link_blob3, &tempTileBuf[16], 32, curr_tile_id, LINK_CABLE_PAL,
+        ATTR0_SQUARE, ATTR1_SIZE_8x8, 1);
     global_tile_id_end = curr_tile_id;
 
     obj_set_pos(down_arrow, 14 * 8, 17 * 8);
@@ -528,7 +587,8 @@ void load_temp_box_sprites(PokeBox *box)
 {
     u32 curr_tile_id = global_tile_id_end;
 
-    if (!(g_debug_options.ignore_game_pak || g_debug_options.ignore_game_pak_sprites))
+    if (!(g_debug_options.ignore_game_pak ||
+            g_debug_options.ignore_game_pak_sprites))
     {
         for (int i = 0; i < 30; i++)
         {
@@ -545,10 +605,20 @@ void load_temp_box_sprites(PokeBox *box)
                     dex_num = 0;
                 }
 
-                u32 sprite_location = (*(u32 *)(curr_GBA_rom.loc_gMonIconTable + (dex_num * 4)));
-                int pal_num = *(byte *)(curr_GBA_rom.loc_gMonIconPaletteIndices + dex_num);
-                load_sprite(party_sprites[i], (const unsigned int *)sprite_location, 512, curr_tile_id, MENU_PAL_RED + pal_num, ATTR0_SQUARE, ATTR1_SIZE_32x32, 1);
-                obj_set_pos(party_sprites[i], ((BOXMENU_SPRITE_WIDTH + BOXMENU_HSPACE) * (i % BOXMENU_HNUM)) + (BOXMENU_LEFT + BOXMENU_SPRITE_HOFFSET), ((BOXMENU_SPRITE_HEIGHT + BOXMENU_VSPACE) * (i / BOXMENU_HNUM)) + (BOXMENU_TOP + BOXMENU_SPRITE_VOFFSET));
+                u32 sprite_location =
+                    (*(u32 *)(curr_GBA_rom.loc_gMonIconTable + (dex_num * 4)));
+                int pal_num = *(
+                    byte *)(curr_GBA_rom.loc_gMonIconPaletteIndices + dex_num);
+                load_sprite(party_sprites[i],
+                    (const unsigned int *)sprite_location, 512, curr_tile_id,
+                    MENU_PAL_RED + pal_num, ATTR0_SQUARE, ATTR1_SIZE_32x32, 1);
+                obj_set_pos(party_sprites[i],
+                    ((BOXMENU_SPRITE_WIDTH + BOXMENU_HSPACE) *
+                        (i % BOXMENU_HNUM)) +
+                        (BOXMENU_LEFT + BOXMENU_SPRITE_HOFFSET),
+                    ((BOXMENU_SPRITE_HEIGHT + BOXMENU_VSPACE) *
+                        (i / BOXMENU_HNUM)) +
+                        (BOXMENU_TOP + BOXMENU_SPRITE_VOFFSET));
                 obj_unhide(party_sprites[i], 0);
             }
             else
@@ -559,21 +629,33 @@ void load_temp_box_sprites(PokeBox *box)
         // Load the menu sprite palettes. Should this be done somewhere else?
         for (int i = 0; i < 3; i++)
         {
-            tonccpy((pal_obj_mem + ((MENU_PAL_RED + i) * 16)), (const unsigned short *)(curr_GBA_rom.loc_gMonIconPalettes + (i * 32)), 32);
+            tonccpy((pal_obj_mem + ((MENU_PAL_RED + i) * 16)),
+                (const unsigned short *)(curr_GBA_rom.loc_gMonIconPalettes +
+                                         (i * 32)),
+                32);
         }
 
-        load_sprite_compressed(grabbed_front_sprite, (const unsigned int *)*(u32 *)(curr_GBA_rom.loc_gMonFrontPicTable + (0 * 8)), curr_tile_id, PULLED_SPRITE_PAL, ATTR0_SQUARE, ATTR1_SIZE_64x64, 1);
+        load_sprite_compressed(grabbed_front_sprite,
+            (const unsigned int *)*(
+                u32 *)(curr_GBA_rom.loc_gMonFrontPicTable + (0 * 8)),
+            curr_tile_id, PULLED_SPRITE_PAL, ATTR0_SQUARE, ATTR1_SIZE_64x64, 1);
         obj_set_pos(grabbed_front_sprite, 8, 16);
     }
 
-    load_sprite_compressed(box_select, box_selectTiles, curr_tile_id, BTN_PAL, ATTR0_SQUARE, ATTR1_SIZE_32x32, 0);
-    load_sprite_compressed(button_cancel_left, button_cancel_leftTiles, curr_tile_id, BTN_PAL, ATTR0_WIDE, ATTR1_SIZE_64x32, 1);
-    load_sprite_compressed(button_cancel_right, button_edgeTiles, curr_tile_id, BTN_PAL, ATTR0_TALL, ATTR1_SIZE_8x32, 1);
-    load_sprite_compressed(button_confirm_left, button_confirm_leftTiles, curr_tile_id, BTN_PAL, ATTR0_WIDE, ATTR1_SIZE_64x32, 1);
-    load_sprite_compressed(button_confirm_right, button_edgeTiles, curr_tile_id, BTN_PAL, ATTR0_TALL, ATTR1_SIZE_8x32, 1);
+    load_sprite_compressed(box_select, box_selectTiles, curr_tile_id, BTN_PAL,
+        ATTR0_SQUARE, ATTR1_SIZE_32x32, 0);
+    load_sprite_compressed(button_cancel_left, button_cancel_leftTiles,
+        curr_tile_id, BTN_PAL, ATTR0_WIDE, ATTR1_SIZE_64x32, 1);
+    load_sprite_compressed(button_cancel_right, button_edgeTiles, curr_tile_id,
+        BTN_PAL, ATTR0_TALL, ATTR1_SIZE_8x32, 1);
+    load_sprite_compressed(button_confirm_left, button_confirm_leftTiles,
+        curr_tile_id, BTN_PAL, ATTR0_WIDE, ATTR1_SIZE_64x32, 1);
+    load_sprite_compressed(button_confirm_right, button_edgeTiles, curr_tile_id,
+        BTN_PAL, ATTR0_TALL, ATTR1_SIZE_8x32, 1);
 }
 
-void load_type_sprites(const u8 *pkmn_type_table, int pkmn_index, int dex_offset, bool is_caught)
+void load_type_sprites(
+    const u8 *pkmn_type_table, int pkmn_index, int dex_offset, bool is_caught)
 {
     if (is_caught)
     {
@@ -581,11 +663,19 @@ void load_type_sprites(const u8 *pkmn_type_table, int pkmn_index, int dex_offset
         u16 type1 = pkmn_type_table[pkmn_index * 2];
         u16 type2 = pkmn_type_table[pkmn_index * 2 + 1];
 
-        load_sprite(type_sprites[(dex_offset * 2) + 0], &typesTiles[(type1 * 32)], 128, curr_tile_id, (type1 < 13 ? TYPES_PAL1 : TYPES_PAL2), ATTR0_WIDE, ATTR1_SIZE_32x8, 1);
-        load_sprite(type_sprites[(dex_offset * 2) + 1], &typesTiles[(type2 * 32)], 128, curr_tile_id, (type2 < 13 ? TYPES_PAL1 : TYPES_PAL2), ATTR0_WIDE, ATTR1_SIZE_32x8, 1);
+        load_sprite(type_sprites[(dex_offset * 2) + 0],
+            &typesTiles[(type1 * 32)], 128, curr_tile_id,
+            (type1 < 13 ? TYPES_PAL1 : TYPES_PAL2), ATTR0_WIDE, ATTR1_SIZE_32x8,
+            1);
+        load_sprite(type_sprites[(dex_offset * 2) + 1],
+            &typesTiles[(type2 * 32)], 128, curr_tile_id,
+            (type2 < 13 ? TYPES_PAL1 : TYPES_PAL2), ATTR0_WIDE, ATTR1_SIZE_32x8,
+            1);
 
-        obj_set_pos(type_sprites[(dex_offset * 2) + 0], 19 * 8, (8 * 2 * dex_offset) + (8 * 4));
-        obj_set_pos(type_sprites[(dex_offset * 2) + 1], 23 * 8, (8 * 2 * dex_offset) + (8 * 4));
+        obj_set_pos(type_sprites[(dex_offset * 2) + 0], 19 * 8,
+            (8 * 2 * dex_offset) + (8 * 4));
+        obj_set_pos(type_sprites[(dex_offset * 2) + 1], 23 * 8,
+            (8 * 2 * dex_offset) + (8 * 4));
 
         obj_unhide(type_sprites[(dex_offset * 2) + 0], 0);
         if (type1 != type2)
@@ -600,22 +690,25 @@ void load_type_sprites(const u8 *pkmn_type_table, int pkmn_index, int dex_offset
     }
 }
 
-void load_sprite(OBJ_ATTR *sprite, const unsigned int objTiles[], int objTilesLen,
-                 u32 &tile_id, u32 pal_bank, int attr0, int attr1, u32 priority)
+void load_sprite(OBJ_ATTR *sprite, const unsigned int objTiles[],
+    int objTilesLen, u32 &tile_id, u32 pal_bank, int attr0, int attr1,
+    u32 priority)
 {
     tonccpy(&tile_mem[SPRITE_CHAR_BLOCK][tile_id], objTiles, objTilesLen);
-    obj_set_attr(sprite, attr0, attr1, ATTR2_PALBANK(pal_bank) | tile_id | ATTR2_PRIO(priority));
+    obj_set_attr(sprite, attr0, attr1,
+        ATTR2_PALBANK(pal_bank) | tile_id | ATTR2_PRIO(priority));
     tile_id += objTilesLen / 32;
     obj_hide(sprite);
 };
 
 void load_sprite_compressed(OBJ_ATTR *sprite, const unsigned int objTiles[],
-                            u32 &tile_id, u32 pal_bank, int attr0, int attr1, u32 priority)
+    u32 &tile_id, u32 pal_bank, int attr0, int attr1, u32 priority)
 {
     // bits 8-31 of the header are the length
     int objTilesLen = objTiles[0] >> 8;
     LZ77UnCompVram(objTiles, &tile_mem[SPRITE_CHAR_BLOCK][tile_id]);
-    obj_set_attr(sprite, attr0, attr1, ATTR2_PALBANK(pal_bank) | tile_id | ATTR2_PRIO(priority));
+    obj_set_attr(sprite, attr0, attr1,
+        ATTR2_PALBANK(pal_bank) | tile_id | ATTR2_PRIO(priority));
     tile_id += objTilesLen / 32;
     obj_hide(sprite);
 };
@@ -623,16 +716,29 @@ void load_sprite_compressed(OBJ_ATTR *sprite, const unsigned int objTiles[],
 void load_select_sprites(GameBoyROM currROM)
 {
     u32 curr_tile_id = global_tile_id_end;
-    //                                    Alpha         Shadow          Main Color       Grey             Black         Mid
-    const unsigned short jpn_gb_pal[6] = {RGB15(0, 0, 0), RGB15(10, 9, 10), RGB15(17, 17, 17), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(14, 13, 14)};
-    const unsigned short eng_red_pal[6] = {RGB15(0, 0, 0), RGB15(16, 1, 0), RGB15(27, 6, 5), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(23, 3, 2)};
-    const unsigned short eng_blue_pal[6] = {RGB15(0, 0, 0), RGB15(0, 4, 16), RGB15(5, 10, 24), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(1, 6, 20)};
-    const unsigned short eng_yellow_pal[6] = {RGB15(0, 0, 0), RGB15(18, 12, 0), RGB15(27, 21, 5), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(22, 16, 1)};
-    const unsigned short eng_gold_pal[6] = {RGB15(0, 0, 0), RGB15(13, 10, 2), RGB15(22, 18, 8), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(17, 14, 4)};
-    const unsigned short eng_silver_pal[6] = {RGB15(0, 0, 0), RGB15(11, 12, 14), RGB15(20, 22, 23), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(15, 16, 19)};
-    const unsigned short crystal_pal[6] = {RGB15(0, 0, 0), RGB15(9, 13, 17), RGB15(16, 21, 25), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(12, 17, 22)};
-    const unsigned short jpn_gold_pal[6] = {RGB15(0, 0, 0), RGB15(0, 0, 0), RGB15(5, 7, 12), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(3, 4, 8)};
-    const unsigned short jpn_silver_pal[6] = {RGB15(0, 0, 0), RGB15(5, 4, 5), RGB15(11, 10, 10), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(8, 7, 7)};
+    //                                    Alpha         Shadow          Main
+    //                                    Color       Grey             Black Mid
+    const unsigned short jpn_gb_pal[6] = {RGB15(0, 0, 0), RGB15(10, 9, 10),
+        RGB15(17, 17, 17), RGB15(22, 22, 22), RGB15(0, 0, 0),
+        RGB15(14, 13, 14)};
+    const unsigned short eng_red_pal[6] = {RGB15(0, 0, 0), RGB15(16, 1, 0),
+        RGB15(27, 6, 5), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(23, 3, 2)};
+    const unsigned short eng_blue_pal[6] = {RGB15(0, 0, 0), RGB15(0, 4, 16),
+        RGB15(5, 10, 24), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(1, 6, 20)};
+    const unsigned short eng_yellow_pal[6] = {RGB15(0, 0, 0), RGB15(18, 12, 0),
+        RGB15(27, 21, 5), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(22, 16, 1)};
+    const unsigned short eng_gold_pal[6] = {RGB15(0, 0, 0), RGB15(13, 10, 2),
+        RGB15(22, 18, 8), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(17, 14, 4)};
+    const unsigned short eng_silver_pal[6] = {RGB15(0, 0, 0), RGB15(11, 12, 14),
+        RGB15(20, 22, 23), RGB15(22, 22, 22), RGB15(0, 0, 0),
+        RGB15(15, 16, 19)};
+    const unsigned short crystal_pal[6] = {RGB15(0, 0, 0), RGB15(9, 13, 17),
+        RGB15(16, 21, 25), RGB15(22, 22, 22), RGB15(0, 0, 0),
+        RGB15(12, 17, 22)};
+    const unsigned short jpn_gold_pal[6] = {RGB15(0, 0, 0), RGB15(0, 0, 0),
+        RGB15(5, 7, 12), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(3, 4, 8)};
+    const unsigned short jpn_silver_pal[6] = {RGB15(0, 0, 0), RGB15(5, 4, 5),
+        RGB15(11, 10, 10), RGB15(22, 22, 22), RGB15(0, 0, 0), RGB15(8, 7, 7)};
 
     const unsigned int *label_tiles = 0;
     const unsigned short *label_palette = 0;
@@ -782,8 +888,10 @@ void load_select_sprites(GameBoyROM currROM)
 
     tonccpy(pal_obj_mem + (GB_CART_PAL * 16), cart_palette, 12);
     tonccpy(pal_obj_mem + (GB_CART_PAL * 16) + 6, label_palette + 6, 20);
-    load_sprite_compressed(cart_shell, cart_tiles, curr_tile_id, GB_CART_PAL, ATTR0_SQUARE, ATTR1_SIZE_64x64, 1);
-    load_sprite_compressed(cart_label, label_tiles, curr_tile_id, GB_CART_PAL, ATTR0_SQUARE, ATTR1_SIZE_32x32, 1);
+    load_sprite_compressed(cart_shell, cart_tiles, curr_tile_id, GB_CART_PAL,
+        ATTR0_SQUARE, ATTR1_SIZE_64x64, 1);
+    load_sprite_compressed(cart_label, label_tiles, curr_tile_id, GB_CART_PAL,
+        ATTR0_SQUARE, ATTR1_SIZE_32x32, 1);
 
     const unsigned int *gb_flag_tiles = 0;
     const unsigned short *gb_flag_palette = 0;
@@ -871,9 +979,12 @@ void load_select_sprites(GameBoyROM currROM)
         break;
     }
 
-    load_sprite_compressed(gb_flag, gb_flag_tiles, curr_tile_id, GB_FLAG_PAL, ATTR0_WIDE, ATTR1_SIZE_32x64, 1);
-    load_sprite_compressed(gba_flag, gb_flag_tiles, curr_tile_id, GBA_FLAG_PAL, ATTR0_WIDE, ATTR1_SIZE_32x64, 1);
-    tonccpy(pal_obj_mem + (GB_FLAG_PAL * 16), gb_flag_palette, 16); // Grit is being stupid.
+    load_sprite_compressed(gb_flag, gb_flag_tiles, curr_tile_id, GB_FLAG_PAL,
+        ATTR0_WIDE, ATTR1_SIZE_32x64, 1);
+    load_sprite_compressed(gba_flag, gb_flag_tiles, curr_tile_id, GBA_FLAG_PAL,
+        ATTR0_WIDE, ATTR1_SIZE_32x64, 1);
+    tonccpy(pal_obj_mem + (GB_FLAG_PAL * 16), gb_flag_palette,
+        16); // Grit is being stupid.
 
     const unsigned int *gba_cart_tiles = 0;
     const unsigned short *gba_cart_palette = 0;
@@ -902,7 +1013,8 @@ void load_select_sprites(GameBoyROM currROM)
         break;
     }
 
-    load_sprite_compressed(gba_cart, gba_cart_tiles, curr_tile_id, GBA_CART_PAL, ATTR0_WIDE, ATTR1_SIZE_32x64, 1);
+    load_sprite_compressed(gba_cart, gba_cart_tiles, curr_tile_id, GBA_CART_PAL,
+        ATTR0_WIDE, ATTR1_SIZE_32x64, 1);
     tonccpy(pal_obj_mem + (GBA_CART_PAL * 16), gba_cart_palette, 32);
 
     const unsigned int *gba_flag_tiles = 0;
@@ -945,10 +1057,12 @@ void load_select_sprites(GameBoyROM currROM)
         break;
     }
 
-    load_sprite_compressed(gba_flag, gba_flag_tiles, curr_tile_id, GBA_FLAG_PAL, ATTR0_WIDE, ATTR1_SIZE_32x64, 1);
-    load_sprite_compressed(gba_flag, gba_flag_tiles, curr_tile_id, GBA_FLAG_PAL, ATTR0_WIDE, ATTR1_SIZE_32x64, 1);
-    tonccpy(pal_obj_mem + (GBA_FLAG_PAL * 16), gba_flag_palette, 16); // Grit is being stupid.
-
+    load_sprite_compressed(gba_flag, gba_flag_tiles, curr_tile_id, GBA_FLAG_PAL,
+        ATTR0_WIDE, ATTR1_SIZE_32x64, 1);
+    load_sprite_compressed(gba_flag, gba_flag_tiles, curr_tile_id, GBA_FLAG_PAL,
+        ATTR0_WIDE, ATTR1_SIZE_32x64, 1);
+    tonccpy(pal_obj_mem + (GBA_FLAG_PAL * 16), gba_flag_palette,
+        16); // Grit is being stupid.
 }
 // tile ID, VH Flip, Palette Bank
 #define FEN_BLI_L00 ((TILESET_OFFSET_FLEXBG + 34) | (0b00 << 0xA) | (2 << 0xC))
@@ -977,20 +1091,29 @@ void fennel_blink(int frame)
     switch (frame)
     {
     case 0:
-        se_mem[TILEMAP_FLEXBG][12 + (5 * 32)] = missingno ? FEN_SPE_00 | FEN_BLI_L20 : FEN_BLI_L20;
-        se_mem[TILEMAP_FLEXBG][13 + (5 * 32)] = missingno ? FEN_SPE_01 | FEN_BLI_L21 : FEN_BLI_L21;
-        se_mem[TILEMAP_FLEXBG][15 + (5 * 32)] = missingno ? FEN_SPE_10 | FEN_BLI_R2 : FEN_BLI_R2;
+        se_mem[TILEMAP_FLEXBG][12 + (5 * 32)] =
+            missingno ? FEN_SPE_00 | FEN_BLI_L20 : FEN_BLI_L20;
+        se_mem[TILEMAP_FLEXBG][13 + (5 * 32)] =
+            missingno ? FEN_SPE_01 | FEN_BLI_L21 : FEN_BLI_L21;
+        se_mem[TILEMAP_FLEXBG][15 + (5 * 32)] =
+            missingno ? FEN_SPE_10 | FEN_BLI_R2 : FEN_BLI_R2;
         break;
     case 1:
     case 3:
-        se_mem[TILEMAP_FLEXBG][12 + (5 * 32)] = missingno ? FEN_SPE_11 | FEN_BLI_L10 : FEN_BLI_L10;
-        se_mem[TILEMAP_FLEXBG][13 + (5 * 32)] = missingno ? FEN_SPE_20 | FEN_BLI_L11 : FEN_BLI_L11;
-        se_mem[TILEMAP_FLEXBG][15 + (5 * 32)] = missingno ? FEN_SPE_21 | FEN_BLI_R1 : FEN_BLI_R1;
+        se_mem[TILEMAP_FLEXBG][12 + (5 * 32)] =
+            missingno ? FEN_SPE_11 | FEN_BLI_L10 : FEN_BLI_L10;
+        se_mem[TILEMAP_FLEXBG][13 + (5 * 32)] =
+            missingno ? FEN_SPE_20 | FEN_BLI_L11 : FEN_BLI_L11;
+        se_mem[TILEMAP_FLEXBG][15 + (5 * 32)] =
+            missingno ? FEN_SPE_21 | FEN_BLI_R1 : FEN_BLI_R1;
         break;
     case 2:
-        se_mem[TILEMAP_FLEXBG][12 + (5 * 32)] = missingno ? FEN_SPE_30 | FEN_BLI_L00 : FEN_BLI_L00;
-        se_mem[TILEMAP_FLEXBG][13 + (5 * 32)] = missingno ? FEN_SPE_31 | FEN_BLI_L01 : FEN_BLI_L01;
-        se_mem[TILEMAP_FLEXBG][15 + (5 * 32)] = missingno ? FEN_SPE_00 | FEN_BLI_R0 : FEN_BLI_R0;
+        se_mem[TILEMAP_FLEXBG][12 + (5 * 32)] =
+            missingno ? FEN_SPE_30 | FEN_BLI_L00 : FEN_BLI_L00;
+        se_mem[TILEMAP_FLEXBG][13 + (5 * 32)] =
+            missingno ? FEN_SPE_31 | FEN_BLI_L01 : FEN_BLI_L01;
+        se_mem[TILEMAP_FLEXBG][15 + (5 * 32)] =
+            missingno ? FEN_SPE_00 | FEN_BLI_R0 : FEN_BLI_R0;
         break;
     }
 }
@@ -1001,29 +1124,34 @@ void fennel_speak(int frame)
     switch (frame)
     {
     case 0:
-        se_mem[TILEMAP_FLEXBG][14 + (6 * 32)] = missingno ? FEN_SPE_00 | FEN_BLI_L20 : FEN_SPE_00;
-        se_mem[TILEMAP_FLEXBG][14 + (7 * 32)] = missingno ? FEN_SPE_01 | FEN_BLI_L21 : FEN_SPE_01;
+        se_mem[TILEMAP_FLEXBG][14 + (6 * 32)] =
+            missingno ? FEN_SPE_00 | FEN_BLI_L20 : FEN_SPE_00;
+        se_mem[TILEMAP_FLEXBG][14 + (7 * 32)] =
+            missingno ? FEN_SPE_01 | FEN_BLI_L21 : FEN_SPE_01;
         break;
     case 1:
-        se_mem[TILEMAP_FLEXBG][14 + (6 * 32)] = missingno ? FEN_SPE_10 | FEN_BLI_R2 : FEN_SPE_10;
-        se_mem[TILEMAP_FLEXBG][14 + (7 * 32)] = missingno ? FEN_SPE_11 | FEN_BLI_L10 : FEN_SPE_11;
+        se_mem[TILEMAP_FLEXBG][14 + (6 * 32)] =
+            missingno ? FEN_SPE_10 | FEN_BLI_R2 : FEN_SPE_10;
+        se_mem[TILEMAP_FLEXBG][14 + (7 * 32)] =
+            missingno ? FEN_SPE_11 | FEN_BLI_L10 : FEN_SPE_11;
         break;
     case 2:
     case 4:
-        se_mem[TILEMAP_FLEXBG][14 + (6 * 32)] = missingno ? FEN_SPE_01 | FEN_BLI_L21 : FEN_SPE_20;
-        se_mem[TILEMAP_FLEXBG][14 + (7 * 32)] = missingno ? FEN_SPE_01 | FEN_BLI_L21 : FEN_SPE_21;
+        se_mem[TILEMAP_FLEXBG][14 + (6 * 32)] =
+            missingno ? FEN_SPE_01 | FEN_BLI_L21 : FEN_SPE_20;
+        se_mem[TILEMAP_FLEXBG][14 + (7 * 32)] =
+            missingno ? FEN_SPE_01 | FEN_BLI_L21 : FEN_SPE_21;
         break;
     case 3:
-        se_mem[TILEMAP_FLEXBG][14 + (6 * 32)] = missingno ? FEN_SPE_30 | FEN_BLI_L00 : FEN_SPE_30;
-        se_mem[TILEMAP_FLEXBG][14 + (7 * 32)] = missingno ? FEN_SPE_31 | FEN_BLI_L01 : FEN_SPE_31;
+        se_mem[TILEMAP_FLEXBG][14 + (6 * 32)] =
+            missingno ? FEN_SPE_30 | FEN_BLI_L00 : FEN_SPE_30;
+        se_mem[TILEMAP_FLEXBG][14 + (7 * 32)] =
+            missingno ? FEN_SPE_31 | FEN_BLI_L01 : FEN_SPE_31;
         break;
     }
 }
 
-int get_curr_flex_background()
-{
-    return curr_flex_background;
-}
+int get_curr_flex_background() { return curr_flex_background; }
 
 void update_y_offset()
 {
@@ -1053,13 +1181,16 @@ void update_y_offset()
 
 void update_front_box_sprite(Pokemon *curr_pkmn, bool make_greyscale)
 {
-    if (g_debug_options.ignore_game_pak || g_debug_options.ignore_game_pak_sprites)
+    if (g_debug_options.ignore_game_pak ||
+        g_debug_options.ignore_game_pak_sprites)
     {
         return; // We don't want to look into garbage data, get out of here.
     }
 
-    // in load_temp_sprites(), we reserve 30 box sprite icons after global_tile_id_end. Each of them occupy 16 tiles.
-    // the grabbed_front_sprite comes right after it. And we load the pokémon front sprite directly into its tiles.
+    // in load_temp_sprites(), we reserve 30 box sprite icons after
+    // global_tile_id_end. Each of them occupy 16 tiles. the
+    // grabbed_front_sprite comes right after it. And we load the pokémon front
+    // sprite directly into its tiles.
     u32 curr_tile_id = global_tile_id_end + (30 * 16);
 
     int dex_num = curr_pkmn->getSpeciesIndexNumber();
@@ -1079,11 +1210,17 @@ void update_front_box_sprite(Pokemon *curr_pkmn, bool make_greyscale)
         dex_num = 277;
     }
 
-    u32 sprite_location = *(u32 *)(curr_GBA_rom.loc_gMonFrontPicTable + (dex_num * 8));
-    u32 palette_location = *(u32 *)((curr_pkmn->getIsShiny() ? curr_GBA_rom.loc_gMonShinyPaletteTable : curr_GBA_rom.loc_gMonPaletteTable) + (curr_pkmn->getSpeciesIndexNumber() * 8));
+    u32 sprite_location =
+        *(u32 *)(curr_GBA_rom.loc_gMonFrontPicTable + (dex_num * 8));
+    u32 palette_location = *(
+        u32 *)((curr_pkmn->getIsShiny() ? curr_GBA_rom.loc_gMonShinyPaletteTable
+                                        : curr_GBA_rom.loc_gMonPaletteTable) +
+               (curr_pkmn->getSpeciesIndexNumber() * 8));
     unsigned short buffer[16];
 
-    LZ77UnCompWram((const unsigned short *)palette_location, buffer); // This is a little silly, but it's being weird with bytes vs shorts when we copy it directly
+    LZ77UnCompWram((const unsigned short *)palette_location,
+        buffer); // This is a little silly, but it's being weird with bytes vs
+                 // shorts when we copy it directly
 
     if (make_greyscale)
     {
@@ -1092,7 +1229,9 @@ void update_front_box_sprite(Pokemon *curr_pkmn, bool make_greyscale)
             unsigned red = (buffer[i] >> 0) & 0b11111;
             unsigned green = (buffer[i] >> 5) & 0b11111;
             unsigned blue = (buffer[i] >> 10) & 0b11111;
-            unsigned grey = ((QF(0.299f) * red) + (QF(0.587f) * green) + (QF(0.114f) * blue)) >> 16;
+            unsigned grey = ((QF(0.299f) * red) + (QF(0.587f) * green) +
+                                (QF(0.114f) * blue)) >>
+                            16;
 
             // buffer[i] = RGB15_SAFE(red, ((int)green >> 1), 0);
             buffer[i] = RGB15_SAFE(grey, (grey >> 1), 0);
@@ -1100,12 +1239,14 @@ void update_front_box_sprite(Pokemon *curr_pkmn, bool make_greyscale)
     }
 
     tonccpy((pal_obj_mem + (PULLED_SPRITE_PAL * 16)), buffer, 32);
-    LZ77UnCompVram((const unsigned int *)sprite_location, &tile_mem[SPRITE_CHAR_BLOCK][curr_tile_id]);
+    LZ77UnCompVram((const unsigned int *)sprite_location,
+        &tile_mem[SPRITE_CHAR_BLOCK][curr_tile_id]);
 }
 
 void update_menu_sprite(PokeBox *box, int index, int frame)
 {
-    if (g_debug_options.ignore_game_pak || g_debug_options.ignore_game_pak_sprites)
+    if (g_debug_options.ignore_game_pak ||
+        g_debug_options.ignore_game_pak_sprites)
     {
         return; // We don't want to look into garbage data, get out of here.
     }
@@ -1131,6 +1272,9 @@ void update_menu_sprite(PokeBox *box, int index, int frame)
         dex_num = 277;
     }
 
-    u32 sprite_location = (*(u32 *)(curr_GBA_rom.loc_gMonIconTable + (dex_num * 4))) + (frame == 0 ? 0 : 512);
-    tonccpy(&tile_mem[SPRITE_CHAR_BLOCK][curr_tile_id], (const unsigned int *)sprite_location, 512);
+    u32 sprite_location =
+        (*(u32 *)(curr_GBA_rom.loc_gMonIconTable + (dex_num * 4))) +
+        (frame == 0 ? 0 : 512);
+    tonccpy(&tile_mem[SPRITE_CHAR_BLOCK][curr_tile_id],
+        (const unsigned int *)sprite_location, 512);
 }
\ No newline at end of file
diff --git a/source/text_engine.cpp b/source/text_engine.cpp
index eb4d119..ce519e5 100644
--- a/source/text_engine.cpp
+++ b/source/text_engine.cpp
@@ -1,17 +1,17 @@
-#include <tonc.h>
 #include <cstring>
+#include <tonc.h>
 
-#include "text_engine.h"
+#include "FileContainerReader.h"
+#include "background_engine.h"
+#include "button_menu.h"
+#include "dbg/debug_mode.h"
+#include "fonts.h"
 #include "global_frame_controller.h"
 #include "pkmn_font.h"
-#include "script_array.h"
-#include "dbg/debug_mode.h"
-#include "button_menu.h"
-#include "sprite_data.h"
-#include "fonts.h"
-#include "background_engine.h"
 #include "pokemon_data.h"
-#include "FileContainerReader.h"
+#include "script_array.h"
+#include "sprite_data.h"
+#include "text_engine.h"
 #include "text_tables.h"
 
 script_obj curr_line;
@@ -20,14 +20,18 @@ uint line_char_index;
 const byte *curr_text;
 bool text_exit;
 
-// This function was separated from text_loop to reduce the scope of the text_decompression_buffer.
-// if we didn't do this, the decompression_buffer would be kept on the stack (=IWRAM) for the entire duration of the
-// text_loop() call. This is particularly bad because the whole mystery_gift_builder sequence is being triggered from within
-// text_loop(). And there we need all the IWRAM we can muster.
-// Doing it this way does mean that we need to completely restart decompression whenever we switch from dialog entry.
-// but given that it requires user input to do so, I believe it's worth it and not time-critical.
-// attribute noinline was used to make sure the compiler doesn't inline this code back into text_loop()
-static __attribute__((noinline)) const u8 *read_dialogue_text_entry(u32 index, u32 text_section, u8 *output_buffer)
+// This function was separated from text_loop to reduce the scope of the
+// text_decompression_buffer. if we didn't do this, the decompression_buffer
+// would be kept on the stack (=IWRAM) for the entire duration of the
+// text_loop() call. This is particularly bad because the whole
+// mystery_gift_builder sequence is being triggered from within text_loop(). And
+// there we need all the IWRAM we can muster. Doing it this way does mean that
+// we need to completely restart decompression whenever we switch from dialog
+// entry. but given that it requires user input to do so, I believe it's worth
+// it and not time-critical. attribute noinline was used to make sure the
+// compiler doesn't inline this code back into text_loop()
+static __attribute__((noinline)) const u8 *read_dialogue_text_entry(
+    u32 index, u32 text_section, u8 *output_buffer)
 {
     u8 text_decompression_buffer[4096];
     const u8 **chunkList;
@@ -37,14 +41,16 @@ static __attribute__((noinline)) const u8 *read_dialogue_text_entry(u32 index, u
     get_text_table_chunks(text_section, &chunkList, &numChunks, &chunkSize);
     FileContainerReader dialogueTable(chunkList, numChunks, chunkSize);
 
-    dialogueTable.init(text_decompression_buffer, sizeof(text_decompression_buffer));
+    dialogueTable.init(
+        text_decompression_buffer, sizeof(text_decompression_buffer));
     dialogueTable.readFile(index, output_buffer);
 
     return output_buffer;
 }
 
-// This will have to be changed to be dynamic to support nicknamed Pokemon that are in a different language than the current build.
-// Maybe combine Japanese and Latin into one larger font?
+// This will have to be changed to be dynamic to support nicknamed Pokemon that
+// are in a different language than the current build. Maybe combine Japanese
+// and Latin into one larger font?
 
 #if PTGB_BUILD_LANGUAGE == 1
 #define BUILD_FONT &japanese_normalFont
@@ -55,19 +61,21 @@ static __attribute__((noinline)) const u8 *read_dialogue_text_entry(u32 index, u
 void init_text_engine()
 {
     // Load the TTE
-    // tte_init_se(3, BG_CBB(TEXT_CBB) | BG_SBB(TEXT_SBB) | BG_PRIO(0), 0, CLR_WHITE, 14, &japanese_smallFont, NULL);
+    // tte_init_se(3, BG_CBB(TEXT_CBB) | BG_SBB(TEXT_SBB) | BG_PRIO(0), 0,
+    // CLR_WHITE, 14, &japanese_smallFont, NULL);
 
-    tte_init_chr4c(3,                                           // BG 3
-                   BG_CBB(TILESET_TEXT) | BG_SBB(TILEMAP_TEXT), // Charblock 0; screenblock 10
-                   0xF000,                                      // Screen-entry offset
-                   bytes2word(                                  // Color attributes:
-                       13,                                      // Text color
-                       15,                                      // Shadow color
-                       0,                                       // Paper
-                       0),                                      // Special
-                   CLR_WHITE,                                   // White text
-                   BUILD_FONT,                                  // Custom font
-                   NULL                                         // Use default chr4 renderer
+    tte_init_chr4c(3, // BG 3
+        BG_CBB(TILESET_TEXT) |
+            BG_SBB(TILEMAP_TEXT), // Charblock 0; screenblock 10
+        0xF000,                   // Screen-entry offset
+        bytes2word(               // Color attributes:
+            13,                   // Text color
+            15,                   // Shadow color
+            0,                    // Paper
+            0),                   // Special
+        CLR_WHITE,                // White text
+        BUILD_FONT,               // Custom font
+        NULL                      // Use default chr4 renderer
     );
     tte_init_con();
 
@@ -83,8 +91,9 @@ void init_text_engine()
 
 int text_loop(int script)
 {
-    // we have restricted the dialog entries to 1024 bytes in the text_helper main.py
-    // so we shouldn't run into problems when we only use 1 KB to contain a text entry.
+    // we have restricted the dialog entries to 1024 bytes in the text_helper
+    // main.py so we shouldn't run into problems when we only use 1 KB to
+    // contain a text entry.
     u8 diag_entry_text_buffer[1024];
     switch (script)
     {
@@ -101,17 +110,21 @@ int text_loop(int script)
         break;
     }
 
-    curr_text = (curr_line.has_text()) ? read_dialogue_text_entry(curr_line.get_text_entry_index(), PTGB_INDEX, diag_entry_text_buffer) : NULL;
+    curr_text = (curr_line.has_text())
+                    ? read_dialogue_text_entry(curr_line.get_text_entry_index(),
+                          PTGB_INDEX, diag_entry_text_buffer)
+                    : NULL;
 
     // tte_set_margins(LEFT, TOP, RIGHT, BOTTOM);
     if (script != SCRIPT_DEBUG)
     {
         while (true) // This loops through all the connected script objects
         {
-            if (curr_text != NULL && curr_text[char_index] != 0xFF && curr_text[char_index] != 0xFB)
+            if (curr_text != NULL && curr_text[char_index] != 0xFF &&
+                curr_text[char_index] != 0xFB)
             {
-                ptgb_write_textbox(curr_text, false, true,
-                                   PTGB_INDEX, curr_line.get_text_entry_index(), false);
+                ptgb_write_textbox(curr_text, false, true, PTGB_INDEX,
+                    curr_line.get_text_entry_index(), false);
             }
 
             // wait_for_user_to_continue();
@@ -127,7 +140,11 @@ int text_loop(int script)
                 break;
             }
 
-            curr_text = (curr_line.has_text()) ? read_dialogue_text_entry(curr_line.get_text_entry_index(), PTGB_INDEX, diag_entry_text_buffer) : NULL;
+            curr_text =
+                (curr_line.has_text())
+                    ? read_dialogue_text_entry(curr_line.get_text_entry_index(),
+                          PTGB_INDEX, diag_entry_text_buffer)
+                    : NULL;
             char_index = 0;
 
             if (text_exit)
@@ -157,32 +174,41 @@ int text_loop(int script)
             {
                 if (key_hit(KEY_LEFT))
                 {
-                    text_key = (text_key + (text_section_lengths[text_section] - 1)) % text_section_lengths[text_section];
+                    text_key =
+                        (text_key + (text_section_lengths[text_section] - 1)) %
+                        text_section_lengths[text_section];
                     update_text = true;
                 }
                 else if (key_hit(KEY_RIGHT))
                 {
-                    text_key = (text_key + 1) % text_section_lengths[text_section];
+                    text_key =
+                        (text_key + 1) % text_section_lengths[text_section];
                     update_text = true;
                 }
                 else if (key_hit(KEY_UP))
                 {
-                    if (text_section == 0) {
+                    if (text_section == 0)
+                    {
                         text_section = NUM_TEXT_SECTIONS - 1;
                     }
-                    else {
-                        text_section = ((text_section + (NUM_TEXT_SECTIONS - 1)) % NUM_TEXT_SECTIONS);
+                    else
+                    {
+                        text_section =
+                            ((text_section + (NUM_TEXT_SECTIONS - 1)) %
+                                NUM_TEXT_SECTIONS);
                     }
                     update_text = true;
                 }
                 else if (key_hit(KEY_DOWN))
                 {
-                    text_section = (text_section + (NUM_TEXT_SECTIONS - 1)) % NUM_TEXT_SECTIONS;
+                    text_section = (text_section + (NUM_TEXT_SECTIONS - 1)) %
+                                   NUM_TEXT_SECTIONS;
                     update_text = true;
                 }
                 else if (key_hit(KEY_START) || key_hit(KEY_SELECT))
                 {
-                    instant_text = key_hit(KEY_START); // instant with start, not with select
+                    instant_text = key_hit(
+                        KEY_START); // instant with start, not with select
                     exit = true;
                     tte_erase_line();
                 }
@@ -199,9 +225,11 @@ int text_loop(int script)
                     tte_set_pos(0, 0);
                     tte_erase_rect(0, 0, 240, 160);
                     ptgb_write_debug(debug_charset, "(", true);
-                    ptgb_write_debug(debug_charset, ptgb::to_string(text_section), true);
+                    ptgb_write_debug(
+                        debug_charset, ptgb::to_string(text_section), true);
                     ptgb_write_debug(debug_charset, ", ", true);
-                    ptgb_write_debug(debug_charset, ptgb::to_string(text_key), true);
+                    ptgb_write_debug(
+                        debug_charset, ptgb::to_string(text_key), true);
                     ptgb_write_debug(debug_charset, ")", true);
                     update_text = false;
                 }
@@ -209,13 +237,15 @@ int text_loop(int script)
             }
 
             line_char_index = 0;
-            curr_text = read_dialogue_text_entry(text_key, text_section, diag_entry_text_buffer);
+            curr_text = read_dialogue_text_entry(
+                text_key, text_section, diag_entry_text_buffer);
             char_index = 0;
 
-            if (curr_text != NULL && curr_text[char_index] != 0xFF && curr_text[char_index] != 0xFB)
+            if (curr_text != NULL && curr_text[char_index] != 0xFF &&
+                curr_text[char_index] != 0xFB)
             {
-                ptgb_write_textbox(curr_text, instant_text, true,
-                                   text_section, text_key, true);
+                ptgb_write_textbox(curr_text, instant_text, true, text_section,
+                    text_key, true);
             }
 
             update_text = true;
@@ -257,7 +287,7 @@ void set_text_exit()
 
 // Implement a version that creates the textbox as well
 int ptgb_write_textbox(const byte *text, bool instant, bool waitForUser,
-                       int text_section, int text_key, bool eraseMainBox)
+    int text_section, int text_key, bool eraseMainBox)
 {
     tte_erase_rect(0, 0, H_MAX, V_MAX);
     erase_textbox_tiles();
@@ -267,10 +297,12 @@ int ptgb_write_textbox(const byte *text, bool instant, bool waitForUser,
     {
         load_flex_background(FBG_Fennel, 2);
     }
-    int out = ptgb_write(text, instant, 9999, text_box_type_tables[text_section][text_key]); // This is kinda silly but it'll work.
+    int out = ptgb_write(text, instant, 9999,
+        text_box_type_tables[text_section]
+                            [text_key]); // This is kinda silly but it'll work.
     if (waitForUser)
     {
-        
+
         int right = H_MAX - 5;
         int bottom = V_MAX - 5;
         wait_for_user_to_continue(right, bottom);
@@ -287,7 +319,8 @@ int ptgb_write_textbox(const byte *text, bool instant, bool waitForUser,
 // Implement a version that just writes the whole string
 int ptgb_write_simple(const byte *text, bool instant)
 {
-    return ptgb_write(text, instant, 9999, -1); // This is kinda silly but it'll work.
+    return ptgb_write(
+        text, instant, 9999, -1); // This is kinda silly but it'll work.
 }
 
 // Re-implementing TTE's "tte_write" to use the gen 3 character encoding chart
@@ -322,7 +355,8 @@ int ptgb_write(const byte *text, bool instant, int length, int box_type)
 
     while ((ch = *str) != 0xFF && num < length)
     {
-        if (get_frame_count() % 2 == 0 || key_held(KEY_B) || key_held(KEY_A) || instant)
+        if (get_frame_count() % 2 == 0 || key_held(KEY_B) || key_held(KEY_A) ||
+            instant)
         {
             str++;
             switch (ch)
@@ -417,12 +451,13 @@ int ptgb_write_debug(const u16 *charset, const char *text, bool instant)
         else
         {
             u16 utf16_char;
-            // we need to use this conversion function in order to convert char values >= 0x80
-            // correctly to UTF-16 (which is used by the charset)
+            // we need to use this conversion function in order to convert char
+            // values >= 0x80 correctly to UTF-16 (which is used by the charset)
             convert_utf8_to_utf16_char((const u8 *)(text + i), utf16_char);
-            // WARNING: the conversion of the text characters from u8 to u16 done here, is incorrect
-            // for every character value >= 0x80. The character set uses UTF-16 to represent characters.
-            // But the input text is in UTF-8.
+            // WARNING: the conversion of the text characters from u8 to u16
+            // done here, is incorrect for every character value >= 0x80. The
+            // character set uses UTF-16 to represent characters. But the input
+            // text is in UTF-8.
             temp_holding[i] = get_char_from_charset(charset, utf16_char);
         }
     }
@@ -444,10 +479,10 @@ void wait_for_user_to_continue(int right, int bottom)
         }
     }
 
-    //obj_set_pos(scroll_indicator_red, right-16, bottom-11);
-    //obj_set_pos(scroll_indicator_gray, right-16, bottom-10);
-    //obj_unhide(scroll_indicator_red, 0);
-    
+    // obj_set_pos(scroll_indicator_red, right-16, bottom-11);
+    // obj_set_pos(scroll_indicator_gray, right-16, bottom-10);
+    // obj_unhide(scroll_indicator_red, 0);
+
     VBlankIntrWait();
     while (!(key_hit(KEY_A) || key_hit(KEY_B)))
     {
@@ -464,46 +499,55 @@ void wait_for_user_to_continue(int right, int bottom)
         */
         VBlankIntrWait();
     }
-    //obj_hide(scroll_indicator_red);
-    //obj_hide(scroll_indicator_gray);
+    // obj_hide(scroll_indicator_red);
+    // obj_hide(scroll_indicator_gray);
 }
 
-void scroll_text(bool instant, TTC *tc, bool scrollUp, int left, int top, int right, int bottom)
+void scroll_text(bool instant, TTC *tc, bool scrollUp, int left, int top,
+    int right, int bottom)
 {
     int direction = scrollUp ? 1 : -1;
 
     for (int i = 1; i <= tc->font->charH; i++)
     {
         REG_BG3VOFS = i * direction;
-        tte_erase_rect(left, top - tc->font->charH, right, top + (i * direction));
-        if (!instant) // This is somewhat of a silly way to do this - can be optimized
+        tte_erase_rect(
+            left, top - tc->font->charH, right, top + (i * direction));
+        if (!instant) // This is somewhat of a silly way to do this - can be
+                      // optimized
         {
             VBlankIntrWait();
         }
     }
     REG_BG3VOFS = 0;
-    
-    // The map starts at tile 0 in the top left, increases by 1 as you go down, and then loops back at the top.
+
+    // The map starts at tile 0 in the top left, increases by 1 as you go down,
+    // and then loops back at the top.
     if (scrollUp)
     {
         for (int i = 0; i < 30; i++)
         {
-            tonccpy(&tile_mem[TILESET_TEXT][0 + (i * 20)], &tile_mem[TILESET_TEXT][2 + (i * 20)], 20 * 32);
+            tonccpy(&tile_mem[TILESET_TEXT][0 + (i * 20)],
+                &tile_mem[TILESET_TEXT][2 + (i * 20)], 20 * 32);
         }
     }
     else
     {
         for (int i = 29; i >= 0; i--)
         {
-            // Due to the order of tonccpy, we need to store the data in a temporary buffer
+            // Due to the order of tonccpy, we need to store the data in a
+            // temporary buffer
             byte buffer[20 * 32];
             tonccpy(&buffer, &tile_mem[TILESET_TEXT][0 + (i * 20)], 20 * 32);
             tonccpy(&tile_mem[TILESET_TEXT][2 + (i * 20)], &buffer, 20 * 32);
         }
     }
     // Remove text that went outside of the box and set the position
-    tte_erase_rect(left, scrollUp ? (top - tc->font->charH) : bottom, right, scrollUp ? top : (bottom + tc->font->charH));
+    tte_erase_rect(left, scrollUp ? (top - tc->font->charH) : bottom, right,
+        scrollUp ? top : (bottom + tc->font->charH));
 
-    tc->cursorY = (scrollUp ? bottom - tc->font->charH : top); // The newline will trigger after this and move it down a line
+    tc->cursorY = (scrollUp ? bottom - tc->font->charH
+                            : top); // The newline will trigger after this and
+                                    // move it down a line
     tc->cursorX = left;
 }
\ No newline at end of file
diff --git a/source/text_tables.cpp b/source/text_tables.cpp
index a9ccfee..c7084fc 100644
--- a/source/text_tables.cpp
+++ b/source/text_tables.cpp
@@ -1,12 +1,14 @@
 #include "text_tables.h"
-#include "translated_text.h"
 #include "compression_chunks.h"
+#include "translated_text.h"
 
-void get_text_table_chunks(u32 tableIndex, const u8 ***chunkList, u32 *numChunks, u32 *chunkSize)
+void get_text_table_chunks(
+    u32 tableIndex, const u8 ***chunkList, u32 *numChunks, u32 *chunkSize)
 {
-    // every table except for RSEFRLG is 2048 bytes per chunk, so we can set that by default and only change it for RSEFRLG
+    // every table except for RSEFRLG is 2048 bytes per chunk, so we can set
+    // that by default and only change it for RSEFRLG
     *chunkSize = 2048;
-    switch(tableIndex)
+    switch (tableIndex)
     {
     case PTGB_INDEX:
         *chunkList = PTGB_chunk_list;
@@ -26,11 +28,13 @@ void get_text_table_chunks(u32 tableIndex, const u8 ***chunkList, u32 *numChunks
         break;
     case PKMN_NAMES_INDEX:
         *chunkList = PKMN_NAMES_chunk_list;
-        *numChunks = sizeof(PKMN_NAMES_chunk_list) / sizeof(PKMN_NAMES_chunk_list[0]);
+        *numChunks =
+            sizeof(PKMN_NAMES_chunk_list) / sizeof(PKMN_NAMES_chunk_list[0]);
         break;
     case TUTORIAL_INDEX:
         *chunkList = TUTORIAL_chunk_list;
-        *numChunks = sizeof(TUTORIAL_chunk_list) / sizeof(TUTORIAL_chunk_list[0]);
+        *numChunks =
+            sizeof(TUTORIAL_chunk_list) / sizeof(TUTORIAL_chunk_list[0]);
         break;
     default:
         *chunkList = NULL;
diff --git a/source/vertical_menu.cpp b/source/vertical_menu.cpp
index 345c309..3752c30 100644
--- a/source/vertical_menu.cpp
+++ b/source/vertical_menu.cpp
@@ -1,31 +1,29 @@
 #include "vertical_menu.h"
-#include "sprite_data.h"
 #include "global_frame_controller.h"
+#include "sprite_data.h"
 #include "text_engine.h"
-#include "translated_text.h"
 #include "text_tables.h"
+#include "translated_text.h"
 
 #define TILE_HEIGHT 8
 #define TILE_WIDTH 8
 
-i_item_widget::~i_item_widget()
-{
-}
+i_item_widget::~i_item_widget() {}
 
 i_vertical_menu_state_changed_handler::~i_vertical_menu_state_changed_handler()
 {
 }
 
-i_run_cycle_handler::~i_run_cycle_handler()
-{
-}
+i_run_cycle_handler::~i_run_cycle_handler() {}
 
-static unsigned get_num_visible_items(unsigned vertical_menu_height, unsigned margin_top, unsigned margin_bottom, unsigned item_height)
+static unsigned get_num_visible_items(unsigned vertical_menu_height,
+    unsigned margin_top, unsigned margin_bottom, unsigned item_height)
 {
     return ((vertical_menu_height - margin_top - margin_bottom) / item_height);
 }
 
-static unsigned get_viewport_end_index(unsigned viewport_start_index, unsigned num_visible_items, unsigned total_items)
+static unsigned get_viewport_end_index(unsigned viewport_start_index,
+    unsigned num_visible_items, unsigned total_items)
 {
     unsigned end_index = viewport_start_index + num_visible_items;
     // bounds check to make sure we don't go past the total number of items
@@ -35,18 +33,18 @@ static unsigned get_viewport_end_index(unsigned viewport_start_index, unsigned n
 }
 
 vertical_menu::vertical_menu(const vertical_menu_settings &settings)
-    : settings_(settings), state_changed_handler_(nullptr), run_cycle_handler_(nullptr), focused_index_(settings.initial_focus_index), viewport_start_index_(0), items_(), is_focused_(true)
+    : settings_(settings), state_changed_handler_(nullptr),
+      run_cycle_handler_(nullptr), focused_index_(settings.initial_focus_index),
+      viewport_start_index_(0), items_(), is_focused_(true)
 {
 }
 
-vertical_menu::~vertical_menu()
-{
-    clear_item_widgets();
-}
+vertical_menu::~vertical_menu() { clear_item_widgets(); }
 
 void vertical_menu::show()
 {
-    add_menu_box(settings_.x / TILE_WIDTH, settings_.y / TILE_HEIGHT, settings_.width, settings_.height);
+    add_menu_box(settings_.x / TILE_WIDTH, settings_.y / TILE_HEIGHT,
+        settings_.width, settings_.height);
 
     update_viewport();
 
@@ -57,7 +55,9 @@ void vertical_menu::show()
 
     // initial selection change notification
     const unsigned render_index = focused_index_ - viewport_start_index_;
-    handle_selection_change(focused_index_, settings_.x, settings_.y + settings_.margin_top + (render_index * settings_.item_height));
+    handle_selection_change(focused_index_, settings_.x,
+        settings_.y + settings_.margin_top +
+            (render_index * settings_.item_height));
 }
 
 i_item_widget *vertical_menu::get_item_widget_at(unsigned index) const
@@ -91,7 +91,8 @@ void vertical_menu::set_settings(const vertical_menu_settings &settings)
     settings_ = settings;
 }
 
-void vertical_menu::add_item_widgets(i_item_widget **item_widgets, unsigned num_widgets)
+void vertical_menu::add_item_widgets(
+    i_item_widget **item_widgets, unsigned num_widgets)
 {
     items_.reserve(items_.size() + num_widgets);
     for (unsigned i = 0; i < num_widgets; ++i)
@@ -122,7 +123,8 @@ void vertical_menu::clear_item_widgets()
 void vertical_menu::set_focused(bool is_focused)
 {
     is_focused_ = is_focused;
-    if (state_changed_handler_ && settings_.should_hide_state_changed_handler_on_not_focused)
+    if (state_changed_handler_ &&
+        settings_.should_hide_state_changed_handler_on_not_focused)
     {
         if (is_focused_)
         {
@@ -154,9 +156,11 @@ MenuInputHandleState vertical_menu::handle_input()
     {
         // the child widget is requesting that we update the viewport.
         //  so we do that here and then degrade the result to HANDLED,
-        // since we've already done the viewport update that the child widget requested.
+        // since we've already done the viewport update that the child widget
+        // requested.
         update_viewport();
-        result = MenuInputHandleState::HANDLED; // degrade to HANDLED after updating the viewport
+        result = MenuInputHandleState::HANDLED; // degrade to HANDLED after
+                                                // updating the viewport
     }
     if (result != MenuInputHandleState::NOT_HANDLED)
     {
@@ -164,7 +168,8 @@ MenuInputHandleState vertical_menu::handle_input()
     }
 
     // if the user presses B, and the current settings allow it,
-    // we will return the CANCELLED state, which the caller can use to know that they should exit the menu.
+    // we will return the CANCELLED state, which the caller can use to know that
+    // they should exit the menu.
     if (settings_.allow_cancel && key_hit(KEY_B))
     {
         return MenuInputHandleState::CANCELLED;
@@ -172,8 +177,11 @@ MenuInputHandleState vertical_menu::handle_input()
 
     if (key_hit(KEY_DOWN))
     {
-        const unsigned num_visible_items = get_num_visible_items(settings_.height, settings_.margin_top, settings_.margin_bottom, settings_.item_height);
-        const unsigned current_viewport_end_index = get_viewport_end_index(viewport_start_index_, num_visible_items, items_.size());
+        const unsigned num_visible_items =
+            get_num_visible_items(settings_.height, settings_.margin_top,
+                settings_.margin_bottom, settings_.item_height);
+        const unsigned current_viewport_end_index = get_viewport_end_index(
+            viewport_start_index_, num_visible_items, items_.size());
         ++focused_index_;
         if (focused_index_ == current_viewport_end_index)
         {
@@ -193,10 +201,13 @@ MenuInputHandleState vertical_menu::handle_input()
     {
         if (focused_index_ == 0)
         {
-            // currently the first item was selected, so do wrap around to the end.
-            const unsigned num_visible_items = get_num_visible_items(settings_.height, settings_.margin_top, settings_.margin_bottom, settings_.item_height);
+            // currently the first item was selected, so do wrap around to the
+            // end.
+            const unsigned num_visible_items =
+                get_num_visible_items(settings_.height, settings_.margin_top,
+                    settings_.margin_bottom, settings_.item_height);
             const unsigned max_index = items_.size() - 1;
-            
+
             viewport_start_index_ = (max_index - num_visible_items) + 1;
             focused_index_ = max_index;
             viewport_changed = true;
@@ -208,7 +219,8 @@ MenuInputHandleState vertical_menu::handle_input()
         did_navigate = true;
     }
 
-    // if we did navigate, we need to update the viewport and state changed handler.
+    // if we did navigate, we need to update the viewport and state changed
+    // handler.
     if (did_navigate)
     {
         const unsigned render_index = focused_index_ - viewport_start_index_;
@@ -216,7 +228,9 @@ MenuInputHandleState vertical_menu::handle_input()
         {
             update_viewport();
         }
-        handle_selection_change(focused_index_, settings_.x, settings_.y + settings_.margin_top + (render_index * settings_.item_height));
+        handle_selection_change(focused_index_, settings_.x,
+            settings_.y + settings_.margin_top +
+                (render_index * settings_.item_height));
         return MenuInputHandleState::HANDLED;
     }
 
@@ -230,8 +244,10 @@ void vertical_menu::update_viewport()
     u32 textTableNumChunks;
     u32 textTableChunkSize;
 
-    get_text_table_chunks(settings_.text_table_index, &textTableChunkList, &textTableNumChunks, &textTableChunkSize);
-    FileContainerReader text_table(textTableChunkList, textTableNumChunks, textTableChunkSize);
+    get_text_table_chunks(settings_.text_table_index, &textTableChunkList,
+        &textTableNumChunks, &textTableChunkSize);
+    FileContainerReader text_table(
+        textTableChunkList, textTableNumChunks, textTableChunkSize);
 
     clear_viewport();
 
@@ -240,21 +256,26 @@ void vertical_menu::update_viewport()
         text_table.init(decompression_buffer, sizeof(decompression_buffer));
     }
 
-    const unsigned num_visible_items = get_num_visible_items(settings_.height, settings_.margin_top, settings_.margin_bottom, settings_.item_height);
-    const unsigned viewport_end_index = get_viewport_end_index(viewport_start_index_, num_visible_items, items_.size());
+    const unsigned num_visible_items = get_num_visible_items(settings_.height,
+        settings_.margin_top, settings_.margin_bottom, settings_.item_height);
+    const unsigned viewport_end_index = get_viewport_end_index(
+        viewport_start_index_, num_visible_items, items_.size());
     unsigned cur_y = settings_.y + settings_.margin_top;
 
     for (unsigned i = viewport_start_index_; i < viewport_end_index; ++i)
     {
-        items_[i]->render_item(text_table, settings_.x, cur_y, (i == focused_index_));
+        items_[i]->render_item(
+            text_table, settings_.x, cur_y, (i == focused_index_));
         cur_y += settings_.item_height;
     }
 }
 
 void vertical_menu::clear_viewport()
 {
-    // tte_erase_rect expects (left, top, right, bottom), not (x, y, width, height)
-    tte_erase_rect(settings_.x, settings_.y, settings_.x + settings_.width, settings_.y + settings_.height);
+    // tte_erase_rect expects (left, top, right, bottom), not (x, y, width,
+    // height)
+    tte_erase_rect(settings_.x, settings_.y, settings_.x + settings_.width,
+        settings_.y + settings_.height);
 }
 
 unsigned vertical_menu::run()
@@ -291,7 +312,8 @@ unsigned vertical_menu::run()
     return UINT32_MAX;
 }
 
-void vertical_menu::set_state_changed_handler(i_vertical_menu_state_changed_handler *handler)
+void vertical_menu::set_state_changed_handler(
+    i_vertical_menu_state_changed_handler *handler)
 {
     state_changed_handler_ = handler;
 }
@@ -301,7 +323,8 @@ void vertical_menu::set_run_cycle_handler(i_run_cycle_handler *handler)
     run_cycle_handler_ = handler;
 }
 
-void vertical_menu::handle_selection_change(unsigned new_index, unsigned x, unsigned y)
+void vertical_menu::handle_selection_change(
+    unsigned new_index, unsigned x, unsigned y)
 {
     if (state_changed_handler_)
     {
@@ -314,16 +337,15 @@ simple_item_renderer::simple_item_renderer(const simple_item_widget_data &data)
 {
 }
 
-simple_item_renderer::~simple_item_renderer()
-{
-}
+simple_item_renderer::~simple_item_renderer() {}
 
 const simple_item_widget_data &simple_item_renderer::get_data() const
 {
     return data_;
 }
 
-void simple_item_renderer::render_item(FileContainerReader &text_table, unsigned x, unsigned y, bool is_focused)
+void simple_item_renderer::render_item(
+    FileContainerReader &text_table, unsigned x, unsigned y, bool is_focused)
 {
     // text_helper/main.py restricts each line to 1024 bytes.
     u8 lineBuffer[1024];
diff --git a/source/vertical_menu_cursor_handler.cpp b/source/vertical_menu_cursor_handler.cpp
index 39383d1..8ace884 100644
--- a/source/vertical_menu_cursor_handler.cpp
+++ b/source/vertical_menu_cursor_handler.cpp
@@ -1,27 +1,20 @@
 #include "vertical_menu_cursor_handler.h"
 #include "sprite_data.h"
 
-vertical_menu_cursor_handler::vertical_menu_cursor_handler(s16 cursor_offset_x, s16 cursor_offset_y)
-    : cursor_offset_x_(cursor_offset_x)
-    , cursor_offset_y_(cursor_offset_y)
+vertical_menu_cursor_handler::vertical_menu_cursor_handler(
+    s16 cursor_offset_x, s16 cursor_offset_y)
+    : cursor_offset_x_(cursor_offset_x), cursor_offset_y_(cursor_offset_y)
 {
 }
 
-vertical_menu_cursor_handler::~vertical_menu_cursor_handler()
-{
-}
+vertical_menu_cursor_handler::~vertical_menu_cursor_handler() {}
 
-void vertical_menu_cursor_handler::on_show()
-{
-    obj_unhide(point_arrow, 0);
-}
+void vertical_menu_cursor_handler::on_show() { obj_unhide(point_arrow, 0); }
 
-void vertical_menu_cursor_handler::on_hide()
-{
-    obj_hide(point_arrow);
-}
+void vertical_menu_cursor_handler::on_hide() { obj_hide(point_arrow); }
 
-void vertical_menu_cursor_handler::on_selection_changed(unsigned new_index, unsigned x, unsigned y)
+void vertical_menu_cursor_handler::on_selection_changed(
+    unsigned new_index, unsigned x, unsigned y)
 {
     // set the cursor pos accordingly
     const int cursor_x = static_cast<int>(x) + cursor_offset_x_;