diff --git a/dependencies/symbol-processor/src b/dependencies/symbol-processor/src
index 842f05a..67c4ada 160000
--- a/dependencies/symbol-processor/src
+++ b/dependencies/symbol-processor/src
@@ -1 +1 @@
-Subproject commit 842f05a288de6be14fa92f97755d2e18acb00873
+Subproject commit 67c4adaa772445f919f37131d7605bd374c67845
diff --git a/libreborn/include/libreborn/patch.h b/libreborn/include/libreborn/patch.h
index 38b6d82..63e617c 100644
--- a/libreborn/include/libreborn/patch.h
+++ b/libreborn/include/libreborn/patch.h
@@ -11,24 +11,53 @@ extern "C" {
 void reborn_init_patch();
 
 void _overwrite_call(const char *file, int line, void *start, void *target);
-#define overwrite_call(start, target) _overwrite_call(__FILE__, __LINE__, start, target);
+#define overwrite_call(start, target) _overwrite_call(__FILE__, __LINE__, start, target)
+
+#define _setup_fancy_overwrite(start, name, target) \
+    if (!_is_new_method_##name()) { \
+        ERR("Method Is Not \"New\""); \
+    } \
+    static name##_t _original_for_##target = start; \
+    static name##_t _helper_for_##target = _overwrite_helper_for_##name(target, _original_for_##target)
+
+#define _update_references(from, to) \
+    { \
+        void *old_reference = (void *) from; \
+        for (int i = 0; _all_method_symbols[i] != nullptr; i++) { \
+            if (_all_method_symbols[i] == old_reference) { \
+                _all_method_symbols[i] = (void *) to; \
+            } \
+        } \
+    }
 
 void _overwrite_calls(const char *file, int line, void *start, void *target);
-#define overwrite_calls(start, target) _overwrite_calls(__FILE__, __LINE__, start, target);
+#define overwrite_calls_manual(start, target) _overwrite_calls(__FILE__, __LINE__, start, target)
+#define overwrite_calls(start, target) \
+    { \
+        _setup_fancy_overwrite(start, start, target); \
+        overwrite_calls_manual((void *) start, (void *) _helper_for_##target); \
+        _update_references(start, _helper_for_##target); \
+    }
+
+#define overwrite_virtual_calls(start, target) \
+    { \
+        _setup_fancy_overwrite(*start##_vtable_addr, start, target); \
+        overwrite_calls_manual((void *) *start##_vtable_addr, (void *) _helper_for_##target); \
+    }
 
 void _overwrite_calls_within(const char *file, int line, void *from, void *to, void *start, void *target);
-#define overwrite_calls_within(from, to, start, target) _overwrite_calls_within(__FILE__, __LINE__, from, to, start, target);
+#define overwrite_calls_within(from, to, start, target) _overwrite_calls_within(__FILE__, __LINE__, from, to, start, target)
 
 void *extract_from_bl_instruction(unsigned char *from);
 
 void _overwrite(const char *file, int line, void *start, void *target);
-#define overwrite(start, target) _overwrite(__FILE__, __LINE__, start, target);
+#define overwrite(start, target) _overwrite(__FILE__, __LINE__, (void *) start, (void *) target)
 
 void _patch(const char *file, int line, void *start, unsigned char patch[4]);
-#define patch(start, patch) _patch(__FILE__, __LINE__, start, patch);
+#define patch(start, patch) _patch(__FILE__, __LINE__, start, patch)
 
 void _patch_address(const char *file, int line, void *start, void *target);
-#define patch_address(start, target) _patch_address(__FILE__, __LINE__, start, target);
+#define patch_address(start, target) _patch_address(__FILE__, __LINE__, (void *) start, (void *) target)
 
 #endif
 
diff --git a/mods/include/mods/misc/misc.h b/mods/include/mods/misc/misc.h
index af2ecc5..e9d6587 100644
--- a/mods/include/mods/misc/misc.h
+++ b/mods/include/mods/misc/misc.h
@@ -22,9 +22,4 @@ void misc_run_on_language_setup(misc_update_function_void_t function); // obj ==
 typedef bool (*misc_update_function_key_press_t)(Minecraft *minecrtaft, int key);
 void misc_run_on_game_key_press(misc_update_function_key_press_t function); // In-Game Key Presses Only
 
-void Level_saveLevelData_injection(Level *level);
-
-// Use this instead of directly calling Gui::addMessage(), it has proper logging!
-void misc_add_message(Gui *gui, const char *text);
-
 extern bool is_in_chat;
diff --git a/mods/src/atlas/atlas.cpp b/mods/src/atlas/atlas.cpp
index a110fc5..a169a8f 100644
--- a/mods/src/atlas/atlas.cpp
+++ b/mods/src/atlas/atlas.cpp
@@ -7,7 +7,7 @@
 #include <mods/init/init.h>
 
 // Fix Grass And Leaves Inventory Rendering When The gui_blocks Atlas Is Disabled
-static void ItemRenderer_renderGuiItemCorrect_injection(Font *font, Textures *textures, ItemInstance *item_instance, int32_t param_1, int32_t param_2) {
+static void ItemRenderer_renderGuiItemCorrect_injection(ItemRenderer_renderGuiItemCorrect_t original, Font *font, Textures *textures, ItemInstance *item_instance, int32_t param_1, int32_t param_2) {
     int32_t leaves_id = Tile_leaves->id;
     int32_t grass_id = Tile_grass->id;
     // Replace Rendered Item With Carried Variant
@@ -28,7 +28,7 @@ static void ItemRenderer_renderGuiItemCorrect_injection(Font *font, Textures *te
     glDisable(GL_DEPTH_TEST);
 
     // Call Original Method
-    ItemRenderer_renderGuiItemCorrect(font, textures, use_carried ? &carried_item_instance : item_instance, param_1, param_2);
+    original(font, textures, use_carried ? &carried_item_instance : item_instance, param_1, param_2);
 
     // Revert GL State Changes
     if (depth_test_was_enabled) {
@@ -40,7 +40,7 @@ static void ItemRenderer_renderGuiItemCorrect_injection(Font *font, Textures *te
 static int item_color_fix_mode = 0;
 #define POTENTIAL_FURNACE_ITEM_TRANSPARENCY 0x33
 #define INVALID_FURNACE_ITEM_MULTIPLIER 0.25f
-static void Tesselator_color_injection(Tesselator *tesselator, int32_t r, int32_t g, int32_t b, int32_t a) {
+static void Tesselator_color_injection(Tesselator_color_t original, Tesselator *tesselator, int32_t r, int32_t g, int32_t b, int32_t a) {
     // Fix Furnace UI
     if (item_color_fix_mode != 0) {
         // Force Translucent
@@ -55,16 +55,16 @@ static void Tesselator_color_injection(Tesselator *tesselator, int32_t r, int32_
     }
 
     // Call Original Method
-    Tesselator_color(tesselator, r, g, b, a);
+    original(tesselator, r, g, b, a);
 }
-static void Tesselator_begin_injection(Tesselator *tesselator, int32_t mode) {
+static void Tesselator_begin_injection(Tesselator_begin_t original, Tesselator *tesselator, int32_t mode) {
     // Call Original Method
-    Tesselator_begin(tesselator, mode);
+    original(tesselator, mode);
 
     // Fix Furnace UI
     if (item_color_fix_mode != 0) {
         // Implict Translucent
-        Tesselator_color_injection(tesselator, 0xff, 0xff, 0xff, 0xff);
+        Tesselator_color(tesselator, 0xff, 0xff, 0xff, 0xff);
     }
 }
 static void InventoryPane_renderBatch_Tesselator_color_injection(Tesselator *tesselator, int32_t r, int32_t g, int32_t b) {
@@ -74,9 +74,9 @@ static void InventoryPane_renderBatch_Tesselator_color_injection(Tesselator *tes
     // Enable Item Color Fix
     item_color_fix_mode = 2;
 }
-static void ItemRenderer_renderGuiItem_two_injection(Font *font, Textures *textures, ItemInstance *item_instance, float param_1, float param_2, float param_3, float param_4, bool param_5) {
+static void ItemRenderer_renderGuiItem_two_injection(ItemRenderer_renderGuiItem_two_t original, Font *font, Textures *textures, ItemInstance *item_instance, float param_1, float param_2, float param_3, float param_4, bool param_5) {
     // Call Original Method
-    ItemRenderer_renderGuiItem_two(font, textures, item_instance, param_1, param_2, param_3, param_4, param_5);
+    original(font, textures, item_instance, param_1, param_2, param_3, param_4, param_5);
 
     // Disable Item Color Fix
     item_color_fix_mode = 0;
@@ -92,17 +92,17 @@ static void FurnaceScreen_render_ItemRenderer_renderGuiItem_one_injection(Font *
 // Init
 void init_atlas() {
     // Add Better nullptr-Check (And More UI Fixes When The gui_blocks Atlas Is Disabled)
-    overwrite_calls((void *) ItemRenderer_renderGuiItem_two, (void *) ItemRenderer_renderGuiItem_two_injection);
+    overwrite_calls(ItemRenderer_renderGuiItem_two, ItemRenderer_renderGuiItem_two_injection);
 
     // Disable The gui_blocks Atlas Which Contains Pre-Rendered Textures For Blocks In The Inventory
     if (feature_has("Disable \"gui_blocks\" Atlas", server_disabled)) {
         unsigned char disable_gui_blocks_atlas_patch[4] = {0x00, 0xf0, 0x20, 0xe3}; // "nop"
         patch((void *) 0x63c2c, disable_gui_blocks_atlas_patch);
         // Fix Grass And Leaves Inventory Rendering When The gui_blocks Atlas Is Disabled
-        overwrite_calls((void *) ItemRenderer_renderGuiItemCorrect, (void *) ItemRenderer_renderGuiItemCorrect_injection);
+        overwrite_calls(ItemRenderer_renderGuiItemCorrect, ItemRenderer_renderGuiItemCorrect_injection);
         // Fix Furnace UI
-        overwrite_calls((void *) Tesselator_begin, (void *) Tesselator_begin_injection);
-        overwrite_calls((void *) Tesselator_color, (void *) Tesselator_color_injection);
+        overwrite_calls(Tesselator_begin, Tesselator_begin_injection);
+        overwrite_calls(Tesselator_color, Tesselator_color_injection);
         overwrite_call((void *) 0x32324, (void *) FurnaceScreen_render_ItemRenderer_renderGuiItem_one_injection);
         overwrite_call((void *) 0x1e21c, (void *) InventoryPane_renderBatch_Tesselator_color_injection);
     }
diff --git a/mods/src/benchmark/benchmark.cpp b/mods/src/benchmark/benchmark.cpp
index 3c708c4..aae2bab 100644
--- a/mods/src/benchmark/benchmark.cpp
+++ b/mods/src/benchmark/benchmark.cpp
@@ -64,7 +64,7 @@ static void Minecraft_tick_injection(__attribute__((unused)) Minecraft *minecraf
 
 // Get Time
 static long long int get_time() {
-    struct timespec ts;
+    timespec ts = {};
     clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
     long long int a = (long long int) ts.tv_nsec;
     long long int b = ((long long int) ts.tv_sec) * NANOSECONDS_IN_SECOND;
diff --git a/mods/src/bucket/bucket.cpp b/mods/src/bucket/bucket.cpp
index bea4614..41d1843 100644
--- a/mods/src/bucket/bucket.cpp
+++ b/mods/src/bucket/bucket.cpp
@@ -136,7 +136,7 @@ static int BucketItem_getUseDuration(__attribute__((unused)) FoodItem *item, Ite
 
 static ItemInstance BucketItem_useTimeDepleted(FoodItem *item, ItemInstance *item_instance, Level *level, Player *player) {
     if (item_instance->auxiliary == 1) {
-        *item_instance = FoodItem_useTimeDepleted_non_virtual(item, item_instance, level, player);
+        *item_instance = (*FoodItem_useTimeDepleted_vtable_addr)(item, item_instance, level, player);
         // Set it to a empty bucket
         item_instance->auxiliary = 0;
         item_instance->count = 1;
@@ -212,25 +212,25 @@ static void Item_initItems_injection(__attribute__((unused)) void *null) {
 }
 
 // Change Max Stack Size Based On Auxiliary
-static int32_t ItemInstance_getMaxStackSize_injection(ItemInstance *item_instance) {
+static int32_t ItemInstance_getMaxStackSize_injection(ItemInstance_getMaxStackSize_t original, ItemInstance *item_instance) {
     if (item_instance->id == bucket->id && item_instance->auxiliary == 0) {
         // Custom Value
         return 16;
     } else {
         // Call Original Method
-        return ItemInstance_getMaxStackSize(item_instance);
+        return original(item_instance);
     }
 }
 
 // Milking
-bool Cow_interact_injection(Cow *self, Player *player) {
+bool Cow_interact_injection(Cow_interact_t original, Cow *self, Player *player) {
     ItemInstance *item = Inventory_getSelected(player->inventory);
     if (item && item->id == bucket->id && item->auxiliary == 0) {
         // Fill with milk
         fill_bucket(item, player, 1);
         return true;
     }
-    return Cow_interact_non_virtual(self, player);
+    return original(self, player);
 }
 
 // Creative Inventory
@@ -277,7 +277,7 @@ static bool is_calm_liquid(int32_t id) {
         return false;
     }
 }
-static void Minecraft_handleMouseDown_injection(Minecraft *minecraft, int param_1, bool can_destroy) {
+static void Minecraft_handleMouseDown_injection(Minecraft_handleMouseDown_t original, Minecraft *minecraft, int param_1, bool can_destroy) {
     // Check
     Level *level = minecraft->level;
     if (level != nullptr) {
@@ -291,7 +291,7 @@ static void Minecraft_handleMouseDown_injection(Minecraft *minecraft, int param_
     }
 
     // Call Original Method
-    Minecraft_handleMouseDown(minecraft, param_1, can_destroy);
+    original(minecraft, param_1, can_destroy);
 }
 
 // Custom Crafting Recipes
@@ -319,12 +319,12 @@ static void Recipes_injection(Recipes *recipes) {
 }
 
 // Custom Furnace Fuel
-static int32_t FurnaceTileEntity_getBurnDuration_injection(ItemInstance *item_instance) {
+static int32_t FurnaceTileEntity_getBurnDuration_injection(FurnaceTileEntity_getBurnDuration_t original, ItemInstance *item_instance) {
     if (item_instance->count > 0 && item_instance->id == bucket->id && item_instance->auxiliary == Tile_lava->id) {
         return 20000;
     } else {
         // Call Original Method
-        return FurnaceTileEntity_getBurnDuration(item_instance);
+        return original(item_instance);
     }
 }
 static void FurnaceTileEntity_tick_ItemInstance_setNull_injection(ItemInstance *item_instance) {
@@ -353,20 +353,20 @@ void init_bucket() {
         // Add Items
         misc_run_on_items_setup(Item_initItems_injection);
         // Change Max Stack Size Based On Auxiliary
-        overwrite_calls((void *) ItemInstance_getMaxStackSize, (void *) ItemInstance_getMaxStackSize_injection);
+        overwrite_calls(ItemInstance_getMaxStackSize, ItemInstance_getMaxStackSize_injection);
         // Enable milking
-        patch_address((void *) Cow_interact_vtable_addr, (void *) Cow_interact_injection);
+        overwrite_virtual_calls(Cow_interact, Cow_interact_injection);
         // Creative Inventory
         misc_run_on_creative_inventory_setup(Inventory_setupDefault_FillingContainer_addItem_call_injection);
         // Make Liquids Selectable
         overwrite_call((void *) 0x7f5b0, (void *) Mob_pick_Level_clip_injection);
         misc_run_on_tick(handle_tick);
         // Prevent Breaking Liquid
-        overwrite_calls((void *) Minecraft_handleMouseDown, (void *) Minecraft_handleMouseDown_injection);
+        overwrite_calls(Minecraft_handleMouseDown, Minecraft_handleMouseDown_injection);
         // Custom Crafting Recipes
         misc_run_on_recipes_setup(Recipes_injection);
         // Custom Furnace Fuel
-        overwrite_calls((void *) FurnaceTileEntity_getBurnDuration, (void *) FurnaceTileEntity_getBurnDuration_injection);
+        overwrite_calls(FurnaceTileEntity_getBurnDuration, FurnaceTileEntity_getBurnDuration_injection);
         overwrite_call((void *) 0xd351c, (void *) FurnaceTileEntity_tick_ItemInstance_setNull_injection);
         // Language for milk
         misc_run_on_language_setup(Language_injection);
diff --git a/mods/src/camera/camera.cpp b/mods/src/camera/camera.cpp
index af89237..59c3265 100644
--- a/mods/src/camera/camera.cpp
+++ b/mods/src/camera/camera.cpp
@@ -7,16 +7,16 @@
 #include <mods/init/init.h>
 
 // Take Screenshot Using TripodCamera
-static void AppPlatform_linux_saveScreenshot_injection(__attribute__((unused)) AppPlatform *app_platform, __attribute__((unused)) std::string const& path, __attribute__((unused)) int32_t width, __attribute__((unused)) int32_t height) {
+static void AppPlatform_saveScreenshot_injection(__attribute__((unused)) AppPlatform_saveScreenshot_t original, __attribute__((unused)) AppPlatform *app_platform, __attribute__((unused)) std::string *path, __attribute__((unused)) int32_t width, __attribute__((unused)) int32_t height) {
 #ifndef MCPI_HEADLESS_MODE
     screenshot_take(home_get());
 #endif
 }
 
 // Enable TripodCameraRenderer
-static EntityRenderDispatcher *EntityRenderDispatcher_injection(EntityRenderDispatcher *dispatcher) {
+static EntityRenderDispatcher *EntityRenderDispatcher_injection(EntityRenderDispatcher_constructor_t original, EntityRenderDispatcher *dispatcher) {
     // Call Original Method
-    EntityRenderDispatcher_constructor(dispatcher);
+    original(dispatcher);
 
     // Register TripodCameraRenderer
     TripodCameraRenderer *renderer = alloc_TripodCameraRenderer();
@@ -36,12 +36,12 @@ static void TripodCamera_tick_Level_addParticle_call_injection(Level *level, std
 // Init
 void init_camera() {
     // Implement AppPlatform_linux::saveScreenshot So Cameras Work
-    patch_address(AppPlatform_linux_saveScreenshot_vtable_addr, (void *) AppPlatform_linux_saveScreenshot_injection);
+    overwrite_virtual_calls(AppPlatform_saveScreenshot, AppPlatform_saveScreenshot_injection);
 
     // Fix Camera Rendering
     if (feature_has("Fix Camera Rendering", server_disabled)) {
         // Enable TripodCameraRenderer
-        overwrite_calls((void *) EntityRenderDispatcher_constructor, (void *) EntityRenderDispatcher_injection);
+        overwrite_calls(EntityRenderDispatcher_constructor, EntityRenderDispatcher_injection);
         // Display Smoke From TripodCamera Higher
         overwrite_call((void *) 0x87dc4, (void *) TripodCamera_tick_Level_addParticle_call_injection);
     }
diff --git a/mods/src/chat/chat.cpp b/mods/src/chat/chat.cpp
index fd499b5..66d6266 100644
--- a/mods/src/chat/chat.cpp
+++ b/mods/src/chat/chat.cpp
@@ -21,7 +21,7 @@
 
 // Send API Command
 std::string chat_send_api_command(Minecraft *minecraft, std::string str) {
-    struct ConnectedClient client;
+    ConnectedClient client;
     client.sock = -1;
     client.str = "";
     client.time = 0;
@@ -116,7 +116,7 @@ void init_chat() {
         // Manually Send (And Loopback) ChatPacket
         overwrite_call((void *) 0x6b518, (void *) CommandServer_parse_CommandServer_dispatchPacket_injection);
         // Re-Broadcast ChatPacket
-        patch_address(ServerSideNetworkHandler_handle_ChatPacket_vtable_addr, (void *) ServerSideNetworkHandler_handle_ChatPacket_injection);
+        patch_address(ServerSideNetworkHandler_handle_ChatPacket_vtable_addr, ServerSideNetworkHandler_handle_ChatPacket_injection);
 #ifndef MCPI_HEADLESS_MODE
         // Send Messages On Input Tick
         input_run_on_tick(send_queued_messages);
diff --git a/mods/src/chat/ui.cpp b/mods/src/chat/ui.cpp
index 66b9b1e..1c151bc 100644
--- a/mods/src/chat/ui.cpp
+++ b/mods/src/chat/ui.cpp
@@ -69,8 +69,9 @@ CUSTOM_VTABLE(chat_screen, Screen) {
         original_render(super, x, y, param_1);
     };
     // Positioning
+    static Screen_setupPositions_t original_setupPositions = vtable->setupPositions;
     vtable->setupPositions = [](Screen *super) {
-        Screen_setupPositions_non_virtual(super);
+        original_setupPositions(super);
         ChatScreen *self = (ChatScreen *) super;
         self->send->height = 24;
         self->send->width = 40;
@@ -118,6 +119,7 @@ CUSTOM_VTABLE(chat_screen, Screen) {
         original_keyPressed(super, key);
     };
     // Button Click
+    static Screen_buttonClicked_t original_buttonClicked = vtable->buttonClicked;
     vtable->buttonClicked = [](Screen *super, Button *button) {
         ChatScreen *self = (ChatScreen *) super;
         if (button == self->send) {
@@ -126,7 +128,7 @@ CUSTOM_VTABLE(chat_screen, Screen) {
             super->vtable->keyPressed(super, 0x0d);
         } else {
             // Call Original Method
-            Screen_buttonClicked_non_virtual(super, button);
+            original_buttonClicked(super, button);
         }
     };
 }
diff --git a/mods/src/death/death.cpp b/mods/src/death/death.cpp
index 241ed9a..c4efb61 100644
--- a/mods/src/death/death.cpp
+++ b/mods/src/death/death.cpp
@@ -65,19 +65,19 @@ std::string get_death_message(Player *player, Entity *cause, bool was_shot = fal
 }
 
 static bool is_hurt = false;
-static bool Mob_hurt_injection(Mob *mob, Entity *source, int dmg) {
-    // Call Original Method
+static bool Mob_hurt_injection(Mob_hurt_t original, Mob *mob, Entity *source, int dmg) {
     is_hurt = true;
-    bool ret = Mob_hurt_non_virtual(mob, source, dmg);
+    bool ret = original(mob, source, dmg);
     is_hurt = false;
     return ret;
 }
 
 // Death Message Logic
-#define Player_death_injections(type) \
-    static void type##Player_die_injection(type##Player *player, Entity *cause) { \
+#define Player_die_injections(type) \
+    static type##_die_t original_##type##_die; \
+    static void type##_die_injection(type *player, Entity *cause) { \
         /* Call Original Method */ \
-        type##Player_die_non_virtual(player, cause); \
+        original_##type##_die(player, cause); \
         \
         /* Get Variable */ \
         RakNetInstance *rak_net_instance = player->minecraft->rak_net_instance; \
@@ -90,14 +90,14 @@ static bool Mob_hurt_injection(Mob *mob, Entity *source, int dmg) {
             ServerSideNetworkHandler *server_side_network_handler = (ServerSideNetworkHandler *) player->minecraft->network_handler; \
             ServerSideNetworkHandler_displayGameMessage(server_side_network_handler, &message); \
         } \
-    } \
-    \
-    static void type##Player_actuallyHurt_injection(type##Player *player, int32_t damage) { \
+    }
+#define Player_actuallyHurt_injections(type) \
+    static void type##_actuallyHurt_injection(type *player, int32_t damage) { \
         /* Store Old Health */ \
         int32_t old_health = player->health; \
         \
         /* Call Original Method */ \
-        type##Player_actuallyHurt_non_virtual(player, damage); \
+        (*Mob_actuallyHurt_vtable_addr)((Mob *) player, damage); \
         if (is_hurt == true) return; \
         \
         /* Store New Health */ \
@@ -119,18 +119,21 @@ static bool Mob_hurt_injection(Mob *mob, Entity *source, int dmg) {
         } \
     }
 
-Player_death_injections(Local);
-Player_death_injections(Server);
+Player_die_injections(LocalPlayer)
+Player_die_injections(ServerPlayer)
+
+Player_actuallyHurt_injections(LocalPlayer)
+Player_actuallyHurt_injections(ServerPlayer)
 
 // Init
 void init_death() {
     // Death Messages
     if (feature_has("Implement Death Messages", server_auto)) {
-        patch_address(ServerPlayer_die_vtable_addr, (void *) ServerPlayer_die_injection);
-        patch_address(LocalPlayer_die_vtable_addr, (void *) LocalPlayer_die_injection);
-        patch_address(ServerPlayer_actuallyHurt_vtable_addr, (void *) ServerPlayer_actuallyHurt_injection);
-        patch_address(LocalPlayer_actuallyHurt_vtable_addr, (void *) LocalPlayer_actuallyHurt_injection);
-        overwrite_calls((void *) Mob_hurt_non_virtual, (void *) Mob_hurt_injection);
+        patch_address(ServerPlayer_die_vtable_addr, ServerPlayer_die_injection);
+        patch_address(LocalPlayer_die_vtable_addr, LocalPlayer_die_injection);
+        patch_address(LocalPlayer_actuallyHurt_vtable_addr, LocalPlayer_actuallyHurt_injection);
+        patch_address(ServerPlayer_actuallyHurt_vtable_addr, ServerPlayer_actuallyHurt_injection);
+        overwrite_virtual_calls(Mob_hurt, Mob_hurt_injection);
     }
 
     // Fix TNT
diff --git a/mods/src/fps/fps.cpp b/mods/src/fps/fps.cpp
index 3e2ec78..6bdc683 100644
--- a/mods/src/fps/fps.cpp
+++ b/mods/src/fps/fps.cpp
@@ -9,7 +9,7 @@
 // Track FPS
 #define NANOSECONDS_IN_SECOND 1000000000ll
 static long long int get_time() {
-    struct timespec ts;
+    timespec ts = {};
     clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
     long long int a = (long long int) ts.tv_nsec;
     long long int b = ((long long int) ts.tv_sec) * NANOSECONDS_IN_SECOND;
diff --git a/mods/src/game-mode/game-mode.cpp b/mods/src/game-mode/game-mode.cpp
index fafb4de..3fd2087 100644
--- a/mods/src/game-mode/game-mode.cpp
+++ b/mods/src/game-mode/game-mode.cpp
@@ -28,21 +28,21 @@ static void set_is_survival(bool new_is_survival) {
 }
 
 // Handle Gamemode Switching
-static void Minecraft_setIsCreativeMode_injection(Minecraft *self, int32_t new_game_mode) {
+static void Minecraft_setIsCreativeMode_injection(Minecraft_setIsCreativeMode_t original, Minecraft *self, int32_t new_game_mode) {
     set_is_survival(!new_game_mode);
 
     // Call Original Method
-    Minecraft_setIsCreativeMode(self, new_game_mode);
+    original(self, new_game_mode);
 }
 
 // Disable CreatorMode-Specific API Features (Polling Block Hits) In SurvivalMode, This Is Preferable To Crashing
-static unsigned char *Minecraft_getCreator_injection(Minecraft *minecraft) {
+static unsigned char *Minecraft_getCreator_injection(Minecraft_getCreator_t original, Minecraft *minecraft) {
     if (is_survival) {
         // SurvivalMode, Return nullptr
         return nullptr;
     } else {
         // CreatorMode, Call Original Method
-        return Minecraft_getCreator(minecraft);
+        return original(minecraft);
     }
 }
 
@@ -51,7 +51,7 @@ void init_game_mode() {
     // Dynamic Game Mode Switching
     if (feature_has("Implement Game-Mode Switching", server_enabled)) {
         set_is_survival(true);
-        overwrite_calls((void *) Minecraft_setIsCreativeMode, (void *) Minecraft_setIsCreativeMode_injection);
+        overwrite_calls(Minecraft_setIsCreativeMode, Minecraft_setIsCreativeMode_injection);
 
         // Replace CreatorLevel With ServerLevel (This Fixes Beds And Mob Spawning)
         overwrite_call((void *) 0x16f84, (void *) ServerLevel_constructor);
@@ -61,7 +61,7 @@ void init_game_mode() {
         patch_address((void *) 0x17004, (void *) level_size);
 
         // Disable CreatorMode-Specific API Features (Polling Block Hits) In SurvivalMode, This Is Preferable To Crashing
-        overwrite_calls((void *) Minecraft_getCreator, (void *) Minecraft_getCreator_injection);
+        overwrite_calls(Minecraft_getCreator, Minecraft_getCreator_injection);
     }
 
     // Create World Dialog
diff --git a/mods/src/game-mode/ui.cpp b/mods/src/game-mode/ui.cpp
index 9dd5932..ad5154d 100644
--- a/mods/src/game-mode/ui.cpp
+++ b/mods/src/game-mode/ui.cpp
@@ -92,8 +92,9 @@ CUSTOM_VTABLE(create_world_screen, Screen) {
         Screen_drawString(super, super->font, &description, self->game_mode->x, self->game_mode->y + self->game_mode->height + description_padding, 0xa0a0a0);
     };
     // Positioning
+    static Screen_setupPositions_t original_setupPositions = vtable->setupPositions;
     vtable->setupPositions = [](Screen *super) {
-        Screen_setupPositions_non_virtual(super);
+        original_setupPositions(super);
         CreateWorldScreen *self = (CreateWorldScreen *) super;
         // Height/Width
         int width = 120;
@@ -234,7 +235,7 @@ static void create_world(Minecraft *minecraft, std::string name, bool is_creativ
 
 // Redirect Create World Button
 #define create_SelectWorldScreen_tick_injection(prefix) \
-    static void prefix##SelectWorldScreen_tick_injection(prefix##SelectWorldScreen *screen) { \
+    static void prefix##SelectWorldScreen_tick_injection(prefix##SelectWorldScreen_tick_t original, prefix##SelectWorldScreen *screen) { \
         if (screen->should_create_world) { \
             /* Open Screen */ \
             Minecraft_setScreen(screen->minecraft, create_create_world_screen()); \
@@ -242,7 +243,7 @@ static void create_world(Minecraft *minecraft, std::string name, bool is_creativ
             screen->should_create_world = false; \
         } else { \
             /* Call Original Method */ \
-            prefix##SelectWorldScreen_tick_non_virtual(screen); \
+            original(screen); \
         } \
     }
 create_SelectWorldScreen_tick_injection()
@@ -251,8 +252,8 @@ create_SelectWorldScreen_tick_injection(Touch_)
 // Init
 void _init_game_mode_ui() {
     // Hijack Create World Button
-    patch_address(SelectWorldScreen_tick_vtable_addr, (void *) SelectWorldScreen_tick_injection);
-    patch_address(Touch_SelectWorldScreen_tick_vtable_addr, (void *) Touch_SelectWorldScreen_tick_injection);
+    overwrite_virtual_calls(SelectWorldScreen_tick, SelectWorldScreen_tick_injection);
+    overwrite_virtual_calls(Touch_SelectWorldScreen_tick, Touch_SelectWorldScreen_tick_injection);
 }
 
 #else
diff --git a/mods/src/input/attack.cpp b/mods/src/input/attack.cpp
index 52dcdde..c421e9e 100644
--- a/mods/src/input/attack.cpp
+++ b/mods/src/input/attack.cpp
@@ -14,9 +14,9 @@ void input_set_is_left_click(int val) {
 }
 
 // Add Attacking To MouseBuildInput
-static int32_t MouseBuildInput_tickBuild_injection(MouseBuildInput *mouse_build_input, Player *local_player, uint32_t *build_action_intention_return) {
+static int32_t MouseBuildInput_tickBuild_injection(MouseBuildInput_tickBuild_t original, MouseBuildInput *mouse_build_input, Player *local_player, uint32_t *build_action_intention_return) {
     // Call Original Method
-    int32_t ret = MouseBuildInput_tickBuild_non_virtual(mouse_build_input, local_player, build_action_intention_return);
+    int32_t ret = original(mouse_build_input, local_player, build_action_intention_return);
 
     // Use Attack/Place BuildActionIntention If No Other Valid BuildActionIntention Was Selected And This Was Not A Repeated Left Click
     if (ret != 0 && is_left_click == 1 && *build_action_intention_return == 0xa) {
@@ -36,7 +36,7 @@ static int32_t MouseBuildInput_tickBuild_injection(MouseBuildInput *mouse_build_
 }
 
 // Fix Holding Attack
-static bool last_player_attack_successful = 0;
+static bool last_player_attack_successful = false;
 static bool Player_attack_Entity_hurt_injection(Entity *entity, Entity *attacker, int32_t damage) {
     // Call Original Method
     last_player_attack_successful = entity->vtable->hurt(entity, attacker, damage);
@@ -56,7 +56,7 @@ static ItemInstance *Player_attack_Inventory_getSelected_injection(Inventory *in
 void _init_attack() {
     // Allow Attacking Mobs
     if (feature_has("Fix Attacking", server_disabled)) {
-        patch_address(MouseBuildInput_tickBuild_vtable_addr, (void *) MouseBuildInput_tickBuild_injection);
+        overwrite_virtual_calls(MouseBuildInput_tickBuild, MouseBuildInput_tickBuild_injection);
 
         // Fix Holding Attack
         overwrite_call((void *) 0x8fc1c, (void *) Player_attack_Entity_hurt_injection);
diff --git a/mods/src/input/input.cpp b/mods/src/input/input.cpp
index 49c2c64..09a18d2 100644
--- a/mods/src/input/input.cpp
+++ b/mods/src/input/input.cpp
@@ -19,9 +19,9 @@ void input_run_on_tick(input_tick_function_t function) {
 }
 
 // Handle Input Fixes
-static void Minecraft_tickInput_injection(Minecraft *minecraft) {
+static void Minecraft_tickInput_injection(Minecraft_tickInput_t original, Minecraft *minecraft) {
     // Call Original Method
-    Minecraft_tickInput(minecraft);
+    original(minecraft);
 
     // Run Input Tick Functions
     for (input_tick_function_t function : get_input_tick_functions()) {
@@ -44,7 +44,7 @@ void init_input() {
     _init_bow();
 
     // Loop
-    overwrite_calls((void *) Minecraft_tickInput, (void *) Minecraft_tickInput_injection);
+    overwrite_calls(Minecraft_tickInput, Minecraft_tickInput_injection);
 
     // Allow Attacking Mobs
     _init_attack();
diff --git a/mods/src/input/misc.cpp b/mods/src/input/misc.cpp
index a437707..a97c712 100644
--- a/mods/src/input/misc.cpp
+++ b/mods/src/input/misc.cpp
@@ -40,11 +40,11 @@ static bool OptionsScreen_handleBackEvent_injection(OptionsScreen *screen, bool
         Minecraft *minecraft = screen->minecraft;
         Minecraft_setScreen(minecraft, nullptr);
     }
-    return 1;
+    return true;
 }
 
 // Fix "Sleeping Beauty" Bug
-static int32_t InBedScreen_handleBackEvent_injection(InBedScreen *screen, bool do_nothing) {
+static bool InBedScreen_handleBackEvent_injection(InBedScreen *screen, bool do_nothing) {
     if (!do_nothing) {
         // Close Screen
         Minecraft *minecraft = screen->minecraft;
@@ -55,7 +55,7 @@ static int32_t InBedScreen_handleBackEvent_injection(InBedScreen *screen, bool d
             player->vtable->stopSleepInBed(player, 1, 1, 1);
         }
     }
-    return 1;
+    return true;
 }
 
 // Set Mouse Grab State
@@ -91,10 +91,10 @@ static bool Gui_tickItemDrop_Minecraft_isCreativeMode_call_injection(Minecraft *
 }
 
 // Block UI Interaction When Mouse Is Locked
-static void Gui_handleClick_injection(Gui *gui, int32_t param_2, int32_t param_3, int32_t param_4) {
+static void Gui_handleClick_injection(Gui_handleClick_t original, Gui *gui, int32_t param_2, int32_t param_3, int32_t param_4) {
     if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF) {
         // Call Original Method
-        Gui_handleClick(gui, param_2, param_3, param_4);
+        original(gui, param_2, param_3, param_4);
     }
 }
 
@@ -103,11 +103,11 @@ void _init_misc() {
     enable_misc = feature_has("Miscellaneous Input Fixes", server_disabled);
     if (enable_misc) {
         // Fix OptionsScreen Ignoring The Back Button
-        patch_address(OptionsScreen_handleBackEvent_vtable_addr, (void *) OptionsScreen_handleBackEvent_injection);
+        patch_address(OptionsScreen_handleBackEvent_vtable_addr, OptionsScreen_handleBackEvent_injection);
         // Fix "Sleeping Beauty" Bug
-        patch_address(InBedScreen_handleBackEvent_vtable_addr, (void *) InBedScreen_handleBackEvent_injection);
+        patch_address(InBedScreen_handleBackEvent_vtable_addr, InBedScreen_handleBackEvent_injection);
         // Disable Opening Inventory Using The Cursor When Cursor Is Hidden
-        overwrite_calls((void *) Gui_handleClick, (void *) Gui_handleClick_injection);
+        overwrite_calls(Gui_handleClick, Gui_handleClick_injection);
     }
     // Disable Item Dropping Using The Cursor When Cursor Is Hidden
     overwrite_call((void *) 0x27800, (void *) Gui_tickItemDrop_Minecraft_isCreativeMode_call_injection);
diff --git a/mods/src/input/toggle.cpp b/mods/src/input/toggle.cpp
index e106f0d..5fff22d 100644
--- a/mods/src/input/toggle.cpp
+++ b/mods/src/input/toggle.cpp
@@ -12,13 +12,13 @@ static bool _handle_toggle_options(Minecraft *minecraft, int key) {
     if (key == 0x70) {
         // Toggle Hide GUI
         options->hide_gui = options->hide_gui ^ 1;
-        return 1;
+        return true;
     } else if (key == 0x74) {
         // Toggle Third Person
         options->third_person = (options->third_person + 1) % 3;
-        return 1;
+        return true;
     } else {
-        return 0;
+        return false;
     }
 }
 static void _fix_third_person(Minecraft *minecraft) {
@@ -49,7 +49,7 @@ static void revert_rotation(Entity *entity) {
 }
 static int is_front_facing = 0;
 static LocalPlayer *stored_player = nullptr;
-static void GameRenderer_setupCamera_injection(GameRenderer *game_renderer, float param_1, int param_2) {
+static void GameRenderer_setupCamera_injection(GameRenderer_setupCamera_t original, GameRenderer *game_renderer, float param_1, int param_2) {
     // Get Objects
     Minecraft *minecraft = game_renderer->minecraft;
     stored_player = minecraft->player;
@@ -64,21 +64,21 @@ static void GameRenderer_setupCamera_injection(GameRenderer *game_renderer, floa
     }
 
     // Call Original Method
-    GameRenderer_setupCamera(game_renderer, param_1, param_2);
+    original(game_renderer, param_1, param_2);
 
     // Revert
     if (is_front_facing) {
         revert_rotation((Entity *) stored_player);
     }
 }
-static void ParticleEngine_render_injection(ParticleEngine *particle_engine, Entity *entity, float param_2) {
+static void ParticleEngine_render_injection(ParticleEngine_render_t original, ParticleEngine *particle_engine, Entity *entity, float param_2) {
     // Invert Rotation
     if (is_front_facing && (Entity *) stored_player == entity) {
         invert_rotation((Entity *) stored_player);
     }
 
     // Call Original Method
-    ParticleEngine_render(particle_engine, entity, param_2);
+    original(particle_engine, entity, param_2);
 
     // Revert
     if (is_front_facing && (Entity *) stored_player == entity) {
@@ -93,7 +93,7 @@ void _init_toggle() {
         misc_run_on_update(_fix_third_person);
 
         // Font-Facing View
-        overwrite_calls((void *) GameRenderer_setupCamera, (void *) GameRenderer_setupCamera_injection);
-        overwrite_calls((void *) ParticleEngine_render, (void *) ParticleEngine_render_injection);
+        overwrite_calls(GameRenderer_setupCamera, GameRenderer_setupCamera_injection);
+        overwrite_calls(ParticleEngine_render, ParticleEngine_render_injection);
     }
 }
diff --git a/mods/src/misc/api.cpp b/mods/src/misc/api.cpp
index 0d3b4de..5ea182f 100644
--- a/mods/src/misc/api.cpp
+++ b/mods/src/misc/api.cpp
@@ -1,3 +1,4 @@
+#include <utility>
 #include <vector>
 
 #include <libreborn/libreborn.h>
@@ -26,9 +27,9 @@
 // Run Functions On Update
 SETUP_CALLBACK(update, Minecraft);
 // Handle Custom Update Behavior
-static void Minecraft_update_injection(Minecraft *minecraft) {
+static void Minecraft_update_injection(Minecraft_update_t original, Minecraft *minecraft) {
     // Call Original Method
-    Minecraft_update_non_virtual(minecraft);
+    original(minecraft);
 
     // Run Functions
     handle_misc_update(minecraft);
@@ -37,9 +38,9 @@ static void Minecraft_update_injection(Minecraft *minecraft) {
 // Run Functions On Tick
 SETUP_CALLBACK(tick, Minecraft);
 // Handle Custom Tick Behavior
-static void Minecraft_tick_injection(Minecraft *minecraft, int32_t param_1, int32_t param_2) {
+static void Minecraft_tick_injection(Minecraft_tick_t original, Minecraft *minecraft, int32_t param_1, int32_t param_2) {
     // Call Original Method
-    Minecraft_tick(minecraft, param_1, param_2);
+    original(minecraft, param_1, param_2);
 
     // Run Functions
     handle_misc_tick(minecraft);
@@ -48,9 +49,9 @@ static void Minecraft_tick_injection(Minecraft *minecraft, int32_t param_1, int3
 // Run Functions On Recipes Setup
 SETUP_CALLBACK(recipes_setup, Recipes);
 // Handle Custom Recipes Setup Behavior
-static Recipes *Recipes_injection(Recipes *recipes) {
+static Recipes *Recipes_injection(Recipes_constructor_t original, Recipes *recipes) {
     // Call Original Method
-    Recipes_constructor(recipes);
+    original(recipes);
 
     // Run Functions
     handle_misc_recipes_setup(recipes);
@@ -62,9 +63,9 @@ static Recipes *Recipes_injection(Recipes *recipes) {
 // Run Functions On Furnace Recipes Setup
 SETUP_CALLBACK(furnace_recipes_setup, FurnaceRecipes);
 // Handle Custom Furnace Recipes Setup Behavior
-static FurnaceRecipes *FurnaceRecipes_injection(FurnaceRecipes *recipes) {
+static FurnaceRecipes *FurnaceRecipes_injection(FurnaceRecipes_constructor_t original, FurnaceRecipes *recipes) {
     // Call Original Method
-    FurnaceRecipes_constructor(recipes);
+    original(recipes);
 
     // Run Functions
     handle_misc_furnace_recipes_setup(recipes);
@@ -87,20 +88,20 @@ static void Inventory_setupDefault_FillingContainer_addItem_call_injection(Filli
 // Run Functions On Tiles Setup
 SETUP_CALLBACK(tiles_setup, void);
 // Handle Custom Tiles Setup Behavior
-static void Tile_initTiles_injection() {
+static void Tile_initTiles_injection(Tile_initTiles_t original) {
     // Run Functions
     handle_misc_tiles_setup(nullptr);
 
     // Call Original Method
-    Tile_initTiles();
+    original();
 }
 
 // Run Functions On Items Setup
 SETUP_CALLBACK(items_setup, void);
 // Handle Custom Items Setup Behavior
-static void Item_initItems_injection() {
+static void Item_initItems_injection(Item_initItems_t original) {
     // Call Original Method
-    Item_initItems();
+    original();
 
     // Run Functions
     handle_misc_items_setup(nullptr);
@@ -109,9 +110,9 @@ static void Item_initItems_injection() {
 // Run Functions On Language Setup
 SETUP_CALLBACK(language_setup, void);
 // Handle Custom Items Setup Behavior
-static void I18n_loadLanguage_injection(AppPlatform *app, std::string language_name) {
+static void I18n_loadLanguage_injection(I18n_loadLanguage_t original, AppPlatform *app, std::string language_name) {
     // Call Original Method
-    I18n_loadLanguage(app, language_name);
+    original(app, std::move(language_name));
 
     // Run Functions
     handle_misc_language_setup(nullptr);
@@ -128,32 +129,32 @@ static bool handle_misc_game_key_press(Minecraft *minecraft, int key) {
     return false;
 }
 // Handle Key Presses
-static void Gui_handleKeyPressed_injection(Gui *self, int key) {
+static void Gui_handleKeyPressed_injection(Gui_handleKeyPressed_t original, Gui *self, int key) {
     // Run Functions
     if (handle_misc_game_key_press(self->minecraft, key)) {
         return;
     }
 
     // Call Original Method
-    Gui_handleKeyPressed(self, key);
+    original(self, key);
 }
 
 // Init
 void _init_misc_api() {
     // Handle Custom Update Behavior
-    overwrite_calls((void *) Minecraft_update_non_virtual, (void *) Minecraft_update_injection);
+    overwrite_virtual_calls(Minecraft_update, Minecraft_update_injection);
     // Handle Custom Tick Behavior
-    overwrite_calls((void *) Minecraft_tick, (void *) Minecraft_tick_injection);
+    overwrite_calls(Minecraft_tick, Minecraft_tick_injection);
     // Handle Custom Recipe Setup Behavior
-    overwrite_calls((void *) Recipes_constructor, (void *) Recipes_injection);
-    overwrite_calls((void *) FurnaceRecipes_constructor, (void *) FurnaceRecipes_injection);
+    overwrite_calls(Recipes_constructor, Recipes_injection);
+    overwrite_calls(FurnaceRecipes_constructor, FurnaceRecipes_injection);
     // Handle Custom Creative Inventory Setup Behavior
     overwrite_call((void *) 0x8e0fc, (void *) Inventory_setupDefault_FillingContainer_addItem_call_injection);
     // Handle Custom Item/Tile Init Behavior
-    overwrite_calls((void *) Tile_initTiles, (void *) Tile_initTiles_injection);
-    overwrite_calls((void *) Item_initItems, (void *) Item_initItems_injection);
+    overwrite_calls(Tile_initTiles, Tile_initTiles_injection);
+    overwrite_calls(Item_initItems, Item_initItems_injection);
     // Handle Custom Language Entries
-    overwrite_calls((void *) I18n_loadLanguage, (void *) I18n_loadLanguage_injection);
+    overwrite_calls(I18n_loadLanguage, I18n_loadLanguage_injection);
     // Handle Key Presses
-    overwrite_calls((void *) Gui_handleKeyPressed, (void *) Gui_handleKeyPressed_injection);
+    overwrite_calls(Gui_handleKeyPressed, Gui_handleKeyPressed_injection);
 }
diff --git a/mods/src/misc/logging.cpp b/mods/src/misc/logging.cpp
index baf6336..a516b59 100644
--- a/mods/src/misc/logging.cpp
+++ b/mods/src/misc/logging.cpp
@@ -8,7 +8,7 @@
 
 // Print Chat To Log
 static bool Gui_addMessage_recursing = false;
-static void Gui_addMessage_injection(Gui *gui, std::string *text) {
+static void Gui_addMessage_injection(Gui_addMessage_t original, Gui *gui, std::string *text) {
     // Sanitize Message
     char *new_message = strdup(text->c_str());
     ALLOC_CHECK(new_message);
@@ -26,22 +26,18 @@ static void Gui_addMessage_injection(Gui *gui, std::string *text) {
         free(safe_message);
 
         // Call Original Method
-        Gui_addMessage(gui, &cpp_str);
+        original(gui, &cpp_str);
 
         // End Recursing
         Gui_addMessage_recursing = false;
     } else {
         // Call Original Method
-        Gui_addMessage(gui, &cpp_str);
+        original(gui, &cpp_str);
     }
 
     // Free
     free(new_message);
 }
-void misc_add_message(Gui *gui, const char *text) {
-    std::string str = text;
-    Gui_addMessage_injection(gui, &str);
-}
 
 // Print Progress Reports
 static int last_progress = -1;
@@ -79,24 +75,24 @@ static void Minecraft_update_injection(Minecraft *minecraft) {
 }
 
 // Log When Game Is Saved
-void Level_saveLevelData_injection(Level *level) {
+static void Level_saveLevelData_injection(Level_saveLevelData_t original, Level *level) {
     // Print Log Message
     DEBUG("Saving Game");
 
     // Call Original Method
-    Level_saveLevelData(level);
+    original(level);
 }
 
 // Init
 void _init_misc_logging() {
     // Print Chat To Log
-    overwrite_calls((void *) Gui_addMessage, (void *) Gui_addMessage_injection);
+    overwrite_calls(Gui_addMessage, Gui_addMessage_injection);
 
     // Print Progress Reports
     misc_run_on_update(Minecraft_update_injection);
 
     // Print Log On Game Save
-    overwrite_calls((void *) Level_saveLevelData, (void *) Level_saveLevelData_injection);
+    overwrite_calls(Level_saveLevelData, Level_saveLevelData_injection);
 
     // Disable stdout Buffering
     setvbuf(stdout, nullptr, _IONBF, 0);
diff --git a/mods/src/misc/misc.cpp b/mods/src/misc/misc.cpp
index eac3dce..5d06d6d 100644
--- a/mods/src/misc/misc.cpp
+++ b/mods/src/misc/misc.cpp
@@ -26,7 +26,7 @@
 
 // Heart food overlay
 static int heal_amount = 0, heal_amount_drawing = 0;
-void Gui_renderHearts_injection(Gui *gui) {
+static void Gui_renderHearts_injection(Gui_renderHearts_t original, Gui *gui) {
     // Get heal_amount
     heal_amount = heal_amount_drawing = 0;
 
@@ -43,13 +43,13 @@ void Gui_renderHearts_injection(Gui *gui) {
     }
 
     // Call original
-    Gui_renderHearts(gui);
+    original(gui);
 }
 
 #define PINK_HEART_FULL 70
 #define PINK_HEART_HALF 79
-Gui_blit_t Gui_blit_renderHearts_original = nullptr;
-void Gui_renderHearts_GuiComponent_blit_overlay_empty_injection(Gui *gui, int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t w1, int32_t h1, int32_t w2, int32_t h2) {
+static Gui_blit_t Gui_blit_renderHearts_original = nullptr;
+static void Gui_renderHearts_GuiComponent_blit_overlay_empty_injection(Gui *gui, int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t w1, int32_t h1, int32_t w2, int32_t h2) {
     // Call original
     Gui_blit_renderHearts_original(gui, x1, y1, x2, y2, w1, h1, w2, h2);
     // Render the overlay
@@ -64,7 +64,7 @@ void Gui_renderHearts_GuiComponent_blit_overlay_empty_injection(Gui *gui, int32_
     }
 }
 
-void Gui_renderHearts_GuiComponent_blit_overlay_hearts_injection(Gui *gui, int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t w1, int32_t h1, int32_t w2, int32_t h2) {
+static void Gui_renderHearts_GuiComponent_blit_overlay_hearts_injection(Gui *gui, int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t w1, int32_t h1, int32_t w2, int32_t h2) {
     // Offset the overlay
     if (x2 == 52) {
         heal_amount_drawing += 2;
@@ -126,7 +126,7 @@ static void Gui_renderBubbles_GuiComponent_blit_injection(Gui *component, int32_
 static int hide_chat_messages = 0;
 bool is_in_chat = 0;
 static int render_selected_item_text = 0;
-static void Gui_renderChatMessages_injection(Gui *gui, int32_t y_offset, uint32_t max_messages, bool disable_fading, Font *font) {
+static void Gui_renderChatMessages_injection(Gui_renderChatMessages_t original, Gui *gui, int32_t y_offset, uint32_t max_messages, bool disable_fading, Font *font) {
     // Handle Classic HUD
     if (use_classic_hud) {
         Minecraft *minecraft = gui->minecraft;
@@ -137,7 +137,7 @@ static void Gui_renderChatMessages_injection(Gui *gui, int32_t y_offset, uint32_
 
     // Call Original Method
     if (!hide_chat_messages && !is_in_chat) {
-        Gui_renderChatMessages(gui, y_offset, max_messages, disable_fading, font);
+        original(gui, y_offset, max_messages, disable_fading, font);
     }
 
     // Render Selected Item Text
@@ -156,9 +156,9 @@ static void Gui_renderChatMessages_injection(Gui *gui, int32_t y_offset, uint32_
 }
 // Reset Selected Item Text Timer On Slot Select
 static uint32_t reset_selected_item_text_timer = 0;
-static void Gui_tick_injection(Gui *gui) {
+static void Gui_tick_injection(Gui_tick_t original, Gui *gui) {
     // Call Original Method
-    Gui_tick(gui);
+    original(gui);
 
     // Handle Reset
     if (render_selected_item_text) {
@@ -171,9 +171,9 @@ static void Gui_tick_injection(Gui *gui) {
     }
 }
 // Trigger Reset Selected Item Text Timer On Slot Select
-static void Inventory_selectSlot_injection(Inventory *inventory, int32_t slot) {
+static void Inventory_selectSlot_injection(Inventory_selectSlot_t original, Inventory *inventory, int32_t slot) {
     // Call Original Method
-    Inventory_selectSlot(inventory, slot);
+    original(inventory, slot);
 
     // Trigger Reset Selected Item Text Timer
     if (render_selected_item_text) {
@@ -182,7 +182,7 @@ static void Inventory_selectSlot_injection(Inventory *inventory, int32_t slot) {
 }
 
 // Translucent Toolbar
-static void Gui_renderToolBar_injection(Gui *gui, float param_1, int32_t param_2, int32_t param_3) {
+static void Gui_renderToolBar_injection(Gui_renderToolBar_t original, Gui *gui, float param_1, int32_t param_2, int32_t param_3) {
     // Call Original Method
 #ifndef MCPI_HEADLESS_MODE
     int was_blend_enabled = glIsEnabled(GL_BLEND);
@@ -191,7 +191,7 @@ static void Gui_renderToolBar_injection(Gui *gui, float param_1, int32_t param_2
     }
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 #endif
-    Gui_renderToolBar(gui, param_1, param_2, param_3);
+    original(gui, param_1, param_2, param_3);
 #ifndef MCPI_HEADLESS_MODE
     if (!was_blend_enabled) {
         glDisable(GL_BLEND);
@@ -210,20 +210,20 @@ static void Gui_renderToolBar_glColor4f_injection(GLfloat red, GLfloat green, GL
 }
 
 // Fix Screen Rendering When GUI is Hidden
-static void Screen_render_injection(Screen *screen, int32_t param_1, int32_t param_2, float param_3) {
+static void Screen_render_injection(Screen_render_t original, Screen *screen, int32_t param_1, int32_t param_2, float param_3) {
     // Fix
 #ifndef MCPI_HEADLESS_MODE
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 #endif
     // Call Original Method
-    Screen_render_non_virtual(screen, param_1, param_2, param_3);
+    original(screen, param_1, param_2, param_3);
 }
 
 // Sanitize Username
 #define MAX_USERNAME_LENGTH 16
-static void LoginPacket_read_injection(LoginPacket *packet, RakNet_BitStream *bit_stream) {
+static void LoginPacket_read_injection(LoginPacket_read_t original, LoginPacket *packet, RakNet_BitStream *bit_stream) {
     // Call Original Method
-    LoginPacket_read_non_virtual(packet, bit_stream);
+    original(packet, bit_stream);
 
     // Prepare
     RakNet_RakString *rak_string = &packet->username;
@@ -284,9 +284,9 @@ static RakNet_StartupResult RakNetInstance_host_RakNet_RakPeer_Startup_injection
 }
 
 // Fix Bug Where RakNetInstance Starts Pinging Potential Servers Before The "Join Game" Screen Is Opened
-static RakNetInstance *RakNetInstance_injection(RakNetInstance *rak_net_instance) {
+static RakNetInstance *RakNetInstance_injection(RakNetInstance_constructor_t original, RakNetInstance *rak_net_instance) {
     // Call Original Method
-    RakNetInstance *result = RakNetInstance_constructor(rak_net_instance);
+    RakNetInstance *result = original(rak_net_instance);
     // Fix
     rak_net_instance->pinging_for_hosts = 0;
     // Return
@@ -294,17 +294,17 @@ static RakNetInstance *RakNetInstance_injection(RakNetInstance *rak_net_instance
 }
 
 // Close Current Screen On Death To Prevent Bugs
-static void LocalPlayer_die_injection(LocalPlayer *entity, Entity *cause) {
+static void LocalPlayer_die_injection(LocalPlayer_die_t original, LocalPlayer *entity, Entity *cause) {
     // Close Screen
     Minecraft *minecraft = entity->minecraft;
     Minecraft_setScreen(minecraft, nullptr);
 
     // Call Original Method
-    LocalPlayer_die_non_virtual(entity, cause);
+    original(entity, cause);
 }
 
 // Fix Furnace Not Checking Item Auxiliary When Inserting New Item
-static int32_t FurnaceScreen_handleAddItem_injection(FurnaceScreen *furnace_screen, int32_t slot, ItemInstance *item) {
+static int32_t FurnaceScreen_handleAddItem_injection(FurnaceScreen_handleAddItem_t original, FurnaceScreen *furnace_screen, int32_t slot, ItemInstance *item) {
     // Get Existing Item
     FurnaceTileEntity *tile_entity = furnace_screen->tile_entity;
     ItemInstance *existing_item = tile_entity->vtable->getItem(tile_entity, slot);
@@ -328,7 +328,7 @@ static int32_t FurnaceScreen_handleAddItem_injection(FurnaceScreen *furnace_scre
     // Call Original Method
     if (valid) {
         // Valid
-        return FurnaceScreen_handleAddItem(furnace_screen, slot, item);
+        return original(furnace_screen, slot, item);
     } else {
         // Invalid
         return 0;
@@ -340,9 +340,9 @@ static int32_t FurnaceScreen_handleAddItem_injection(FurnaceScreen *furnace_scre
 // The default behavior for Touch GUI is to only render the cursor when the mouse is clicking, this fixes that.
 // This also makes the cursor always render if the mouse is unlocked, instead of just when there is a Screen showing.
 #ifndef MCPI_HEADLESS_MODE
-static void GameRenderer_render_injection(GameRenderer *game_renderer, float param_1) {
+static void GameRenderer_render_injection(GameRenderer_render_t original, GameRenderer *game_renderer, float param_1) {
     // Call Original Method
-    GameRenderer_render(game_renderer, param_1);
+    original(game_renderer, param_1);
 
     // Check If Cursor Should Render
     if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF) {
@@ -383,8 +383,8 @@ static void anGenBuffers_injection(int32_t count, uint32_t *buffers) {
 #endif
 
 // Fix Graphics Bug When Switching To First-Person While Sneaking
-static void HumanoidMobRenderer_render_injection(HumanoidMobRenderer *model_renderer, Entity *entity, float param_2, float param_3, float param_4, float param_5, float param_6) {
-    HumanoidMobRenderer_render_non_virtual(model_renderer, entity, param_2, param_3, param_4, param_5, param_6);
+static void PlayerRenderer_render_injection(PlayerRenderer *model_renderer, Entity *entity, float param_2, float param_3, float param_4, float param_5, float param_6) {
+    (*HumanoidMobRenderer_render_vtable_addr)((HumanoidMobRenderer *) model_renderer, entity, param_2, param_3, param_4, param_5, param_6);
     HumanoidModel *model = model_renderer->model;
     model->is_sneaking = false;
 }
@@ -438,8 +438,8 @@ static int32_t GrassTile_getColor_injection(__attribute__((unused)) Tile *tile,
     int b_avg = b_sum / color_sum;
     return (r_avg << 16) | (g_avg << 8) | b_avg;
 }
-static int32_t TallGrass_getColor_injection(TallGrass *tile, LevelSource *level_source, int32_t x, int32_t y, int32_t z) {
-    int32_t original_color = TallGrass_getColor_non_virtual(tile, level_source, x, y, z);
+static int32_t TallGrass_getColor_injection(TallGrass_getColor_t original, TallGrass *tile, LevelSource *level_source, int32_t x, int32_t y, int32_t z) {
+    int32_t original_color = original(tile, level_source, x, y, z);
     if (original_color == 0x339933) {
         return GrassTile_getColor_injection((Tile *) tile, level_source, x, y, z);
     } else {
@@ -448,9 +448,9 @@ static int32_t TallGrass_getColor_injection(TallGrass *tile, LevelSource *level_
 }
 
 // Generate Caves
-static void RandomLevelSource_buildSurface_injection(RandomLevelSource *random_level_source, int32_t chunk_x, int32_t chunk_y, unsigned char *chunk_data, Biome **biomes) {
+static void RandomLevelSource_buildSurface_injection(RandomLevelSource_buildSurface_t original, RandomLevelSource *random_level_source, int32_t chunk_x, int32_t chunk_y, unsigned char *chunk_data, Biome **biomes) {
     // Call Original Method
-    RandomLevelSource_buildSurface(random_level_source, chunk_x, chunk_y, chunk_data, biomes);
+    original(random_level_source, chunk_x, chunk_y, chunk_data, biomes);
 
     // Get Level
     Level *level = random_level_source->level;
@@ -501,9 +501,9 @@ static int32_t Tile_getRenderShape_injection(Tile *tile) {
         return tile->vtable->getRenderShape(tile);
     }
 }
-static ChestTileEntity *ChestTileEntity_injection(ChestTileEntity *tile_entity) {
+static ChestTileEntity *ChestTileEntity_injection(ChestTileEntity_constructor_t original, ChestTileEntity *tile_entity) {
     // Call Original Method
-    ChestTileEntity_constructor(tile_entity);
+    original(tile_entity);
 
     // Enable Renderer
     tile_entity->renderer_id = 1;
@@ -522,23 +522,23 @@ static void ModelPart_render_injection(ModelPart *model_part, float scale) {
     // Stop
     is_rendering_chest = false;
 }
-static void Tesselator_vertexUV_injection(Tesselator *tesselator, float x, float y, float z, float u, float v) {
+static void Tesselator_vertexUV_injection(Tesselator_vertexUV_t original, Tesselator *tesselator, float x, float y, float z, float u, float v) {
     // Fix Chest Texture
     if (is_rendering_chest) {
         v /= 2;
     }
 
     // Call Original Method
-    Tesselator_vertexUV(tesselator, x, y, z, u, v);
+    original(tesselator, x, y, z, u, v);
 }
 static bool ChestTileEntity_shouldSave_injection(__attribute__((unused)) unsigned char *tile_entity) {
     return true;
 }
 
 // Animated 3D Chest
-static ContainerMenu *ContainerMenu_injection(ContainerMenu *container_menu, Container *container, int32_t param_1) {
+static ContainerMenu *ContainerMenu_injection(ContainerMenu_constructor_t original, ContainerMenu *container_menu, Container *container, int32_t param_1) {
     // Call Original Method
-    ContainerMenu_constructor(container_menu, container, param_1);
+    original(container_menu, container, param_1);
 
     // Play Animation
     ChestTileEntity *tile_entity = (ChestTileEntity *) (((unsigned char *) container) - offsetof(ChestTileEntity, container));
@@ -550,7 +550,7 @@ static ContainerMenu *ContainerMenu_injection(ContainerMenu *container_menu, Con
     // Return
     return container_menu;
 }
-static ContainerMenu *ContainerMenu_destructor_injection(ContainerMenu *container_menu) {
+static ContainerMenu *ContainerMenu_destructor_injection(ContainerMenu_destructor_complete_t original, ContainerMenu *container_menu) {
     // Play Animation
     Container *container = container_menu->container;
     ChestTileEntity *tile_entity = (ChestTileEntity *) (((unsigned char *) container) - offsetof(ChestTileEntity, container));
@@ -560,7 +560,7 @@ static ContainerMenu *ContainerMenu_destructor_injection(ContainerMenu *containe
     }
 
     // Call Original Method
-    return ContainerMenu_destructor_complete_non_virtual(container_menu);
+    return original(container_menu);
 }
 
 #ifndef MCPI_HEADLESS_MODE
@@ -593,9 +593,9 @@ static void glColor4f_injection(__attribute__((unused)) GLfloat red, __attribute
 #endif
 
 // Fix Furnace Visual Bug
-static int FurnaceTileEntity_getLitProgress_injection(FurnaceTileEntity *furnace, int max) {
+static int FurnaceTileEntity_getLitProgress_injection(FurnaceTileEntity_getLitProgress_t original, FurnaceTileEntity *furnace, int max) {
     // Call Original Method
-    int ret = FurnaceTileEntity_getLitProgress(furnace, max);
+    int ret = original(furnace, max);
 
     // Fix Bug
     if (ret > max) {
@@ -608,15 +608,15 @@ static int FurnaceTileEntity_getLitProgress_injection(FurnaceTileEntity *furnace
 
 // Fix used items transferring durability
 static int selected_slot = -1;
-static void Player_startUsingItem_injection(Player *self, ItemInstance *item_instance, int time) {
+static void Player_startUsingItem_injection(Player_startUsingItem_t original, Player *self, ItemInstance *item_instance, int time) {
     selected_slot = self->inventory->selectedSlot;
-    Player_startUsingItem(self, item_instance, time);
+    original(self, item_instance, time);
 }
-static void Player_stopUsingItem_injection(Player *self) {
+static void Player_stopUsingItem_injection(Player_stopUsingItem_t original, Player *self) {
     if (selected_slot != self->inventory->selectedSlot) {
         self->itemBeingUsed.id = 0;
     }
-    Player_stopUsingItem(self);
+    original(self);
 }
 
 // Java Light Ramp
@@ -657,9 +657,9 @@ static AppPlatform_readAssetFile_return_value AppPlatform_readAssetFile_injectio
 }
 
 // Add Missing Buttons To Pause Menu
-static void PauseScreen_init_injection(PauseScreen *screen) {
+static void PauseScreen_init_injection(PauseScreen_init_t original, PauseScreen *screen) {
     // Call Original Method
-    PauseScreen_init_non_virtual(screen);
+    original(screen);
 
     // Check If Server
     Minecraft *minecraft = screen->minecraft;
@@ -778,7 +778,7 @@ void init_misc() {
 
     // Food overlay
     if (feature_has("Food Overlay", server_disabled)) {
-        overwrite_calls((void *) Gui_renderHearts, (void *) Gui_renderHearts_injection);
+        overwrite_calls(Gui_renderHearts, Gui_renderHearts_injection);
         overwrite_call((void *) 0x266f8, (void *) Gui_renderHearts_GuiComponent_blit_overlay_empty_injection);
         overwrite_call((void *) 0x267c8, (void *) Gui_renderHearts_GuiComponent_blit_overlay_hearts_injection);
     }
@@ -786,47 +786,47 @@ void init_misc() {
     // Render Selected Item Text + Hide Chat Messages
     hide_chat_messages = feature_has("Hide Chat Messages", server_disabled);
     render_selected_item_text = feature_has("Render Selected Item Text", server_disabled);
-    overwrite_calls((void *) Gui_renderChatMessages, (void *) Gui_renderChatMessages_injection);
-    overwrite_calls((void *) Gui_tick, (void *) Gui_tick_injection);
-    overwrite_calls((void *) Inventory_selectSlot, (void *) Inventory_selectSlot_injection);
+    overwrite_calls(Gui_renderChatMessages, Gui_renderChatMessages_injection);
+    overwrite_calls(Gui_tick, Gui_tick_injection);
+    overwrite_calls(Inventory_selectSlot, Inventory_selectSlot_injection);
 
     // Translucent Toolbar
     if (feature_has("Translucent Toolbar", server_disabled)) {
-        overwrite_calls((void *) Gui_renderToolBar, (void *) Gui_renderToolBar_injection);
+        overwrite_calls(Gui_renderToolBar, Gui_renderToolBar_injection);
         overwrite_call((void *) 0x26c5c, (void *) Gui_renderToolBar_glColor4f_injection);
     }
 
     // Fix Screen Rendering When GUI is Hidden
-    overwrite_calls((void *) Screen_render_non_virtual, (void *) Screen_render_injection);
+    overwrite_virtual_calls(Screen_render, Screen_render_injection);
 
     // Sanitize Username
-    patch_address(LoginPacket_read_vtable_addr, (void *) LoginPacket_read_injection);
+    overwrite_virtual_calls(LoginPacket_read, LoginPacket_read_injection);
 
     // Fix RakNet::RakString Security Bug
-    overwrite_calls((void *) RakNet_RakString_constructor, (void *) RakNet_RakString_injection);
+    overwrite_calls_manual((void *) RakNet_RakString_constructor, (void *) RakNet_RakString_injection);
 
     // Print Error Message If RakNet Startup Fails
     overwrite_call((void *) 0x73778, (void *) RakNetInstance_host_RakNet_RakPeer_Startup_injection);
 
     // Fix Bug Where RakNetInstance Starts Pinging Potential Servers Before The "Join Game" Screen Is Opened
-    overwrite_calls((void *) RakNetInstance_constructor, (void *) RakNetInstance_injection);
+    overwrite_calls(RakNetInstance_constructor, RakNetInstance_injection);
 
     // Close Current Screen On Death To Prevent Bugs
     if (feature_has("Close Current Screen On Death", server_disabled)) {
-        patch_address(LocalPlayer_die_vtable_addr, (void *) LocalPlayer_die_injection);
+        overwrite_virtual_calls(LocalPlayer_die, LocalPlayer_die_injection);
     }
 
     // Fix Furnace Not Checking Item Auxiliary When Inserting New Item
     if (feature_has("Fix Furnace Not Checking Item Auxiliary", server_disabled)) {
-        overwrite_calls((void *) FurnaceScreen_handleAddItem, (void *) FurnaceScreen_handleAddItem_injection);
+        overwrite_calls(FurnaceScreen_handleAddItem, FurnaceScreen_handleAddItem_injection);
     }
 
 #ifdef MCPI_HEADLESS_MODE
     // Don't Render Game In Headless Mode
-    overwrite_calls((void *) GameRenderer_render, (void *) nop);
-    overwrite_calls((void *) NinecraftApp_initGLStates, (void *) nop);
-    overwrite_calls((void *) Gui_onConfigChanged, (void *) nop);
-    overwrite_calls((void *) LevelRenderer_generateSky, (void *) nop);
+    overwrite(GameRenderer_render, nop);
+    overwrite(NinecraftApp_initGLStates, nop);
+    overwrite(Gui_onConfigChanged, nop);
+    overwrite(LevelRenderer_generateSky, nop);
 #else
     // Improved Cursor Rendering
     if (feature_has("Improved Cursor Rendering", server_disabled)) {
@@ -834,7 +834,7 @@ void init_misc() {
         unsigned char disable_cursor_patch[4] = {0x00, 0xf0, 0x20, 0xe3}; // "nop"
         patch((void *) 0x4a6c0, disable_cursor_patch);
         // Add Custom Cursor Rendering
-        overwrite_calls((void *) GameRenderer_render, (void *) GameRenderer_render_injection);
+        overwrite_calls(GameRenderer_render, GameRenderer_render_injection);
     }
 #endif
 
@@ -850,16 +850,16 @@ void init_misc() {
 
     // Remove Forced GUI Lag
     if (feature_has("Remove Forced GUI Lag (Can Break Joining Servers)", server_enabled)) {
-        overwrite_calls((void *) Common_sleepMs, (void *) nop);
+        overwrite(Common_sleepMs, nop);
     }
 
 #ifndef MCPI_HEADLESS_MODE
     // Properly Generate Buffers
-    overwrite((void *) Common_anGenBuffers, (void *) anGenBuffers_injection);
+    overwrite(Common_anGenBuffers, anGenBuffers_injection);
 #endif
 
     // Fix Graphics Bug When Switching To First-Person While Sneaking
-    patch_address(PlayerRenderer_render_vtable_addr, (void *) HumanoidMobRenderer_render_injection);
+    patch_address(PlayerRenderer_render_vtable_addr, PlayerRenderer_render_injection);
 
     // Disable Speed Bridging
     if (feature_has("Disable Speed Bridging", server_disabled)) {
@@ -875,22 +875,22 @@ void init_misc() {
 
     // Change Grass Color
     if (feature_has("Add Biome Colors To Grass", server_disabled)) {
-        patch_address((void *) GrassTile_getColor_vtable_addr, (void *) GrassTile_getColor_injection);
-        patch_address((void *) TallGrass_getColor_vtable_addr, (void *) TallGrass_getColor_injection);
+        patch_address(GrassTile_getColor_vtable_addr, GrassTile_getColor_injection);
+        overwrite_virtual_calls(TallGrass_getColor, TallGrass_getColor_injection);
     }
 
     // Generate Caves
     if (feature_has("Generate Caves", server_auto)) {
-        overwrite_calls((void *) RandomLevelSource_buildSurface, (void *) RandomLevelSource_buildSurface_injection);
+        overwrite_calls(RandomLevelSource_buildSurface, RandomLevelSource_buildSurface_injection);
     }
 
     // Disable Block Tinting
     if (feature_has("Disable Block Tinting", server_disabled)) {
-        patch_address((void *) GrassTile_getColor_vtable_addr, (void *) Tile_getColor_injection);
-        patch_address((void *) TallGrass_getColor_vtable_addr, (void *) Tile_getColor_injection);
-        patch_address((void *) StemTile_getColor_vtable_addr, (void *) Tile_getColor_injection);
-        patch_address((void *) LeafTile_getColor_vtable_addr, (void *) Tile_getColor_injection);
-        overwrite((void *) LiquidTile_getColor_non_virtual, (void *) Tile_getColor_injection);
+        patch_address(GrassTile_getColor_vtable_addr, Tile_getColor_injection);
+        patch_address(TallGrass_getColor_vtable_addr, Tile_getColor_injection);
+        patch_address(StemTile_getColor_vtable_addr, Tile_getColor_injection);
+        patch_address(LeafTile_getColor_vtable_addr, Tile_getColor_injection);
+        overwrite(*LiquidTile_getColor_vtable_addr, Tile_getColor_injection);
     }
 
     // Custom GUI Scale
@@ -913,19 +913,19 @@ void init_misc() {
     // 3D Chests
     if (feature_has("3D Chest Model", server_disabled)) {
         overwrite_call((void *) 0x5e830, (void *) Tile_getRenderShape_injection);
-        overwrite_calls((void *) ChestTileEntity_constructor, (void *) ChestTileEntity_injection);
+        overwrite_calls(ChestTileEntity_constructor, ChestTileEntity_injection);
         overwrite_call((void *) 0x6655c, (void *) ModelPart_render_injection);
         overwrite_call((void *) 0x66568, (void *) ModelPart_render_injection);
         overwrite_call((void *) 0x66574, (void *) ModelPart_render_injection);
-        overwrite_calls((void *) Tesselator_vertexUV, (void *) Tesselator_vertexUV_injection);
+        overwrite_calls(Tesselator_vertexUV, Tesselator_vertexUV_injection);
         unsigned char chest_model_patch[4] = {0x13, 0x20, 0xa0, 0xe3}; // "mov r2, #0x13"
         patch((void *) 0x66fc8, chest_model_patch);
         unsigned char chest_color_patch[4] = {0x00, 0xf0, 0x20, 0xe3}; // "nop"
         patch((void *) 0x66404, chest_color_patch);
 
         // Animation
-        overwrite_calls((void *) ContainerMenu_constructor, (void *) ContainerMenu_injection);
-        overwrite_calls((void *) ContainerMenu_destructor_complete_non_virtual, (void *) ContainerMenu_destructor_injection);
+        overwrite_calls(ContainerMenu_constructor, ContainerMenu_injection);
+        overwrite_virtual_calls(ContainerMenu_destructor_complete, ContainerMenu_destructor_injection);
     }
     patch_address((void *) 0x115b48, (void *) ChestTileEntity_shouldSave_injection);
 
@@ -940,7 +940,7 @@ void init_misc() {
 #endif
 
     // Fix Furnace Visual Bug
-    overwrite_calls((void *) FurnaceTileEntity_getLitProgress, (void *) FurnaceTileEntity_getLitProgress_injection);
+    overwrite_calls(FurnaceTileEntity_getLitProgress, FurnaceTileEntity_getLitProgress_injection);
 
     // Send the full level, not only changed chunks
     if (feature_has("Send Full Level When Hosting Game", server_enabled)) {
@@ -952,12 +952,12 @@ void init_misc() {
 
     // Java Light Ramp
     if (feature_has("Use Java Beta 1.3 Light Ramp", server_disabled)) {
-        overwrite((void *) Dimension_updateLightRamp_non_virtual, (void *) Dimension_updateLightRamp_injection);
+        overwrite(*Dimension_updateLightRamp_vtable_addr, Dimension_updateLightRamp_injection);
     }
 
     // Fix used items transferring durability
-    overwrite_calls((void *) Player_startUsingItem, (void *) Player_startUsingItem_injection);
-    overwrite_calls((void *) Player_stopUsingItem, (void *) Player_stopUsingItem_injection);
+    overwrite_calls(Player_startUsingItem, Player_startUsingItem_injection);
+    overwrite_calls(Player_stopUsingItem, Player_stopUsingItem_injection);
 
     // Fix invalid ItemInHandRenderer texture cache
     if (feature_has("Disable Buggy Held Item Caching", server_disabled)) {
@@ -971,18 +971,18 @@ void init_misc() {
 
     // Implement AppPlatform::readAssetFile So Translations Work
     if (feature_has("Load Language Files", server_enabled)) {
-        overwrite((void *) *AppPlatform_readAssetFile_vtable_addr, (void *) AppPlatform_readAssetFile_injection);
+        overwrite(*AppPlatform_readAssetFile_vtable_addr, AppPlatform_readAssetFile_injection);
     }
 
     // Fix Pause Menu
     if (feature_has("Fix Pause Menu", server_disabled)) {
         // Add Missing Buttons To Pause Menu
-        patch_address(PauseScreen_init_vtable_addr, (void *) PauseScreen_init_injection);
+        overwrite_virtual_calls(PauseScreen_init, PauseScreen_init_injection);
     }
 
     // Implement Crafting Remainders
     overwrite_call((void *) 0x2e230, (void *) PaneCraftingScreen_craftSelectedItem_PaneCraftingScreen_recheckRecipes_injection);
-    overwrite((void *) Item_getCraftingRemainingItem_non_virtual, (void *) Item_getCraftingRemainingItem_injection);
+    overwrite(*Item_getCraftingRemainingItem_vtable_addr, Item_getCraftingRemainingItem_injection);
 
     // Replace 2011 std::sort With Optimized(TM) Code
     if (feature_has("Optimized Chunk Sorting", server_enabled)) {
@@ -991,7 +991,7 @@ void init_misc() {
 
     // Display Date In Select World Screen
     if (feature_has("Display Date In Select World Screen", server_disabled)) {
-        patch_address(AppPlatform_linux_getDateString_vtable_addr, (void *) AppPlatform_linux_getDateString_injection);
+        patch_address(AppPlatform_linux_getDateString_vtable_addr, AppPlatform_linux_getDateString_injection);
     }
 
     // Init Logging
diff --git a/mods/src/multiplayer/multiplayer.cpp b/mods/src/multiplayer/multiplayer.cpp
index 5fa60b0..6007824 100644
--- a/mods/src/multiplayer/multiplayer.cpp
+++ b/mods/src/multiplayer/multiplayer.cpp
@@ -113,9 +113,9 @@ static void iterate_servers(std::function<void(const char *address, int port)> c
 }
 
 // Ping External Servers
-static void RakNetInstance_pingForHosts_injection(RakNetInstance *rak_net_instance, int32_t base_port) {
+static void RakNetInstance_pingForHosts_injection(RakNetInstance_pingForHosts_t original, RakNetInstance *rak_net_instance, int32_t base_port) {
     // Call Original Method
-    RakNetInstance_pingForHosts_non_virtual(rak_net_instance, base_port);
+    original(rak_net_instance, base_port);
 
     // Get RakNet::RakPeer
     RakNet_RakPeer *rak_peer = rak_net_instance->peer;
@@ -130,6 +130,6 @@ static void RakNetInstance_pingForHosts_injection(RakNetInstance *rak_net_instan
 void init_multiplayer() {
     // Inject Code
     if (feature_has("External Server Support", server_disabled)) {
-        patch_address(RakNetInstance_pingForHosts_vtable_addr, (void *) RakNetInstance_pingForHosts_injection);
+        overwrite_virtual_calls(RakNetInstance_pingForHosts, RakNetInstance_pingForHosts_injection);
     }
 }
diff --git a/mods/src/options/options.cpp b/mods/src/options/options.cpp
index f691279..29367bf 100644
--- a/mods/src/options/options.cpp
+++ b/mods/src/options/options.cpp
@@ -49,10 +49,10 @@ __attribute__((destructor)) static void _free_safe_username() {
 
 static int render_distance;
 // Configure Options
-Options *stored_options = nullptr;
-static void Options_initDefaultValue_injection(Options *options) {
+static Options *stored_options = nullptr;
+static void Options_initDefaultValue_injection(Options_initDefaultValue_t original, Options *options) {
     // Call Original Method
-    Options_initDefaultValue(options);
+    original(options);
 
     // Default Graphics Settings
 #ifndef MCPI_SERVER_MODE
@@ -63,9 +63,9 @@ static void Options_initDefaultValue_injection(Options *options) {
     // Store
     stored_options = options;
 }
-static void Minecraft_init_injection(Minecraft *minecraft) {
+static void Minecraft_init_injection(Minecraft_init_t original, Minecraft *minecraft) {
     // Call Original Method
-    Minecraft_init_non_virtual(minecraft);
+    original(minecraft);
 
     Options *options = &minecraft->options;
     // Enable Crosshair In Touch GUI
@@ -75,12 +75,12 @@ static void Minecraft_init_injection(Minecraft *minecraft) {
 }
 
 // Smooth Lighting
-static void TileRenderer_tesselateBlockInWorld_injection(TileRenderer *tile_renderer, Tile *tile, int32_t x, int32_t y, int32_t z) {
+static bool TileRenderer_tesselateBlockInWorld_injection(TileRenderer_tesselateBlockInWorld_t original, TileRenderer *tile_renderer, Tile *tile, int32_t x, int32_t y, int32_t z) {
     // Set Variable
     Minecraft_useAmbientOcclusion = stored_options->ambient_occlusion;
 
     // Call Original Method
-    TileRenderer_tesselateBlockInWorld(tile_renderer, tile, x, y, z);
+    return original(tile_renderer, tile, x, y, z);
 }
 
 // Fix Initial Option Button Rendering
@@ -166,7 +166,7 @@ static char *get_new_options_txt_path() {
 #endif
 
 // Modify Option Toggles
-static void OptionsPane_unknown_toggle_creating_function_injection(OptionsPane *options_pane, uint32_t group_id, std::string *name_ptr, Options_Option *option) {
+static void OptionsPane_unknown_toggle_creating_function_injection(OptionsPane_unknown_toggle_creating_function_t original, OptionsPane *options_pane, uint32_t group_id, std::string *name_ptr, Options_Option *option) {
     // Modify
     std::string name = *name_ptr;
     std::string new_name = name;
@@ -192,23 +192,23 @@ static void OptionsPane_unknown_toggle_creating_function_injection(OptionsPane *
     }
 
     // Call Original Method
-    OptionsPane_unknown_toggle_creating_function(options_pane, group_id, &new_name, option);
+    original(options_pane, group_id, &new_name, option);
 
     // Add 3D Anaglyph
     if (option == &Options_Option_GRAPHICS) {
         std::string cpp_string = "3D Anaglyph";
-        OptionsPane_unknown_toggle_creating_function(options_pane, group_id, &cpp_string, &Options_Option_ANAGLYPH);
+        original(options_pane, group_id, &cpp_string, &Options_Option_ANAGLYPH);
     }
 
     // Add Peaceful Mode
     if (option == &Options_Option_SERVER_VISIBLE) {
         std::string cpp_string = "Peaceful mode";
-        OptionsPane_unknown_toggle_creating_function(options_pane, group_id, &cpp_string, &Options_Option_DIFFICULTY);
+        original(options_pane, group_id, &cpp_string, &Options_Option_DIFFICULTY);
     }
 }
 
 // Add Missing Options To Options::getBooleanValue
-static bool Options_getBooleanValue_injection(Options *options, Options_Option *option) {
+static bool Options_getBooleanValue_injection(Options_getBooleanValue_t original, Options *options, Options_Option *option) {
     // Check
     if (option == &Options_Option_GRAPHICS) {
         return options->fancy_graphics;
@@ -216,7 +216,7 @@ static bool Options_getBooleanValue_injection(Options *options, Options_Option *
         return options->game_difficulty == 0;
     } else {
         // Call Original Method
-        return Options_getBooleanValue(options, option);
+        return original(options, option);
     }
 }
 
@@ -246,8 +246,8 @@ void init_options() {
     DEBUG("Setting Render Distance: %i", render_distance);
 
     // Set Options
-    overwrite_calls((void *) Options_initDefaultValue, (void *) Options_initDefaultValue_injection);
-    overwrite_calls((void *) Minecraft_init_non_virtual, (void *) Minecraft_init_injection);
+    overwrite_calls(Options_initDefaultValue, Options_initDefaultValue_injection);
+    overwrite_virtual_calls(Minecraft_init, Minecraft_init_injection);
 
     // Change Username
     const char *username = get_username();
@@ -272,7 +272,7 @@ void init_options() {
     }
 
     // Smooth Lighting
-    overwrite_calls((void *) TileRenderer_tesselateBlockInWorld, (void *) TileRenderer_tesselateBlockInWorld_injection);
+    overwrite_calls(TileRenderer_tesselateBlockInWorld, TileRenderer_tesselateBlockInWorld_injection);
 
     // NOP
     unsigned char nop_patch[4] = {0x00, 0xf0, 0x20, 0xe3}; // "nop"
@@ -292,10 +292,10 @@ void init_options() {
         patch((void *) 0x3577c, this_works_slider_patch);
 
         // Modify Option Toggles
-        overwrite_calls((void *) OptionsPane_unknown_toggle_creating_function, (void *) OptionsPane_unknown_toggle_creating_function_injection);
+        overwrite_calls(OptionsPane_unknown_toggle_creating_function, OptionsPane_unknown_toggle_creating_function_injection);
 
         // Add Missing Options To Options::getBooleanValue
-        overwrite_calls((void *) Options_getBooleanValue, (void *) Options_getBooleanValue_injection);
+        overwrite_calls(Options_getBooleanValue, Options_getBooleanValue_injection);
 
         // Fix Difficulty When Toggling
         overwrite_call((void *) 0x1cd00, (void *) OptionButton_toggle_Options_save_injection);
@@ -308,7 +308,7 @@ void init_options() {
     // When Loading, options.txt Should Be Opened In Read Mode
     patch_address((void *) Strings_options_txt_fopen_mode_when_loading_pointer, (void *) "r");
     // Fix OptionsFile::getOptionStrings
-    overwrite_calls((void *) OptionsFile_getOptionStrings, (void *) OptionsFile_getOptionStrings_injection);
+    overwrite(OptionsFile_getOptionStrings, OptionsFile_getOptionStrings_injection);
 
     // Sensitivity Loading/Saving Is Broken, Disable It
     patch((void *) 0x1931c, nop_patch);
diff --git a/mods/src/sign/sign.cpp b/mods/src/sign/sign.cpp
index c667a07..f9c3a98 100644
--- a/mods/src/sign/sign.cpp
+++ b/mods/src/sign/sign.cpp
@@ -10,7 +10,7 @@
 #include <mods/sign/sign.h>
 
 // Handle Backspace
-static int32_t sdl_key_to_minecraft_key_injection(int32_t sdl_key) {
+static int32_t sdl_key_to_minecraft_key_injection(Common_sdl_key_to_minecraft_key_t original, int32_t sdl_key) {
     if (sdl_key == SDLK_BACKSPACE) {
         return 0x8;
     } else if (sdl_key == SDLK_DELETE) {
@@ -25,7 +25,7 @@ static int32_t sdl_key_to_minecraft_key_injection(int32_t sdl_key) {
         return 0x74;
     } else {
         // Call Original Method
-        return Common_sdl_key_to_minecraft_key(sdl_key);
+        return original(sdl_key);
     }
 }
 
@@ -53,5 +53,5 @@ void init_sign() {
     }
 
     // Handle Backspace
-    overwrite_calls((void *) Common_sdl_key_to_minecraft_key, (void *) sdl_key_to_minecraft_key_injection);
+    overwrite_calls(Common_sdl_key_to_minecraft_key, sdl_key_to_minecraft_key_injection);
 }
diff --git a/mods/src/skin/loader.cpp b/mods/src/skin/loader.cpp
index 2d2c6c7..a78c236 100644
--- a/mods/src/skin/loader.cpp
+++ b/mods/src/skin/loader.cpp
@@ -114,9 +114,9 @@ static void *loader_thread(void *user_data) {
 }
 
 // Intercept Texture Creation
-static int32_t Textures_assignTexture_injection(Textures *textures, std::string *name, unsigned char *data) {
+static int32_t Textures_assignTexture_injection(Textures_assignTexture_t original, Textures *textures, std::string *name, unsigned char *data) {
     // Call Original Method
-    int32_t id = Textures_assignTexture(textures, name, data);
+    int32_t id = original(textures, name, data);
 
     // Load Skin
     if (starts_with(name->c_str(), "$")) {
@@ -136,7 +136,7 @@ static int32_t Textures_assignTexture_injection(Textures *textures, std::string
 // Init
 void _init_skin_loader() {
     // Intercept Texture Creation
-    overwrite_calls((void *) Textures_assignTexture, (void *) Textures_assignTexture_injection);
+    overwrite_calls(Textures_assignTexture, Textures_assignTexture_injection);
     // Pending Skins
     misc_run_on_tick(load_pending_skins);
     // Log
diff --git a/mods/src/sound/sound.cpp b/mods/src/sound/sound.cpp
index 6f44ef4..8b6ddbb 100644
--- a/mods/src/sound/sound.cpp
+++ b/mods/src/sound/sound.cpp
@@ -104,9 +104,9 @@ static void SoundEngine_update_injection(SoundEngine *sound_engine, Mob *listene
 
 // Resolve All Sounds On Init
 // SoundEngine::init Is Called After The Audio Engine Has Been Loaded
-static void SoundEngine_init_injection(SoundEngine *sound_engine, Minecraft *minecraft, Options *options) {
+static void SoundEngine_init_injection(SoundEngine_init_t original, SoundEngine *sound_engine, Minecraft *minecraft, Options *options) {
     // Call Original Method
-    SoundEngine_init(sound_engine, minecraft, options);
+    original(sound_engine, minecraft, options);
 
     // Resolve Sounds
     _sound_resolve_all();
@@ -116,9 +116,9 @@ static void SoundEngine_init_injection(SoundEngine *sound_engine, Minecraft *min
 void init_sound() {
     // Implement Sound Engine
     if (feature_has("Implement Sound Engine", server_disabled)) {
-        overwrite((void *) SoundEngine_playUI, (void *) SoundEngine_playUI_injection);
-        overwrite((void *) SoundEngine_play, (void *) SoundEngine_play_injection);
-        overwrite((void *) SoundEngine_update, (void *) SoundEngine_update_injection);
-        overwrite_calls((void *) SoundEngine_init, (void *) SoundEngine_init_injection);
+        overwrite(SoundEngine_playUI, SoundEngine_playUI_injection);
+        overwrite(SoundEngine_play, SoundEngine_play_injection);
+        overwrite(SoundEngine_update, SoundEngine_update_injection);
+        overwrite_calls(SoundEngine_init, SoundEngine_init_injection);
     }
 }
diff --git a/mods/src/text-input-box/TextInputScreen.cpp b/mods/src/text-input-box/TextInputScreen.cpp
index 9fc9e19..499849e 100644
--- a/mods/src/text-input-box/TextInputScreen.cpp
+++ b/mods/src/text-input-box/TextInputScreen.cpp
@@ -4,32 +4,36 @@
 
 // VTable
 void TextInputScreen::setup(Screen_vtable *vtable) {
+    static Screen_keyPressed_t original_keyPressed = vtable->keyPressed;
     vtable->keyPressed = [](Screen *super2, int key) {
-        Screen_keyPressed_non_virtual(super2, key);
+        original_keyPressed(super2, key);
         TextInputScreen *self = (TextInputScreen *) super2;
         for (int i = 0; i < int(self->m_textInputs->size()); i++) {
             TextInputBox *textInput = (*self->m_textInputs)[i];
             textInput->keyPressed(key);
         }
     };
+    static Screen_keyboardNewChar_t original_keyboardNewChar = vtable->keyboardNewChar;
     vtable->keyboardNewChar = [](Screen *super2, char key) {
-        Screen_keyboardNewChar_non_virtual(super2, key);
+        original_keyboardNewChar(super2, key);
         TextInputScreen *self = (TextInputScreen *) super2;
         for (int i = 0; i < int(self->m_textInputs->size()); i++) {
             TextInputBox *textInput = (*self->m_textInputs)[i];
             textInput->charPressed(key);
         }
     };
+    static Screen_mouseClicked_t original_mouseClicked = vtable->mouseClicked;
     vtable->mouseClicked = [](Screen *super2, int x, int y, int param_1) {
-        Screen_mouseClicked_non_virtual(super2, x, y, param_1);
+        original_mouseClicked(super2, x, y, param_1);
         TextInputScreen *self = (TextInputScreen *) super2;
         for (int i = 0; i < int(self->m_textInputs->size()); i++) {
             TextInputBox *textInput = (*self->m_textInputs)[i];
             textInput->onClick(x, y);
         }
     };
+    static Screen_render_t original_render = vtable->render;
     vtable->render = [](Screen *super2, int x, int y, float param_1) {
-        Screen_render_non_virtual(super2, x, y, param_1);
+        original_render(super2, x, y, param_1);
         TextInputScreen *self = (TextInputScreen *) super2;
         for (int i = 0; i < int(self->m_textInputs->size()); i++) {
             TextInputBox *textInput = (*self->m_textInputs)[i];
@@ -37,13 +41,15 @@ void TextInputScreen::setup(Screen_vtable *vtable) {
             textInput->render();
         }
     };
+    static Screen_init_t original_init = vtable->init;
     vtable->init = [](Screen *super2) {
-        Screen_init_non_virtual(super2);
+        original_init(super2);
         TextInputScreen *self = (TextInputScreen *) super2;
         self->m_textInputs = new std::vector<TextInputBox *>;
     };
+    static Screen_removed_t original_removed = vtable->removed;
     vtable->removed = [](Screen *super2) {
-        Screen_removed_non_virtual(super2);
+        original_removed(super2);
         TextInputScreen *self = (TextInputScreen *) super2;
         delete self->m_textInputs;
     };
diff --git a/mods/src/textures/textures.cpp b/mods/src/textures/textures.cpp
index e9b886d..bfe054c 100644
--- a/mods/src/textures/textures.cpp
+++ b/mods/src/textures/textures.cpp
@@ -234,5 +234,5 @@ void init_textures() {
     overwrite_call((void *) 0x53274, (void *) Textures_tick_glTexSubImage2D_injection);
 
     // Load Textures
-    overwrite((void *) AppPlatform_linux_loadTexture_non_virtual, (void *) AppPlatform_linux_loadTexture_injection);
+    overwrite(*AppPlatform_linux_loadTexture_vtable_addr, AppPlatform_linux_loadTexture_injection);
 }
diff --git a/mods/src/title-screen/title-screen.cpp b/mods/src/title-screen/title-screen.cpp
index 6f109f2..7467be9 100644
--- a/mods/src/title-screen/title-screen.cpp
+++ b/mods/src/title-screen/title-screen.cpp
@@ -22,9 +22,9 @@ static void StartMenuScreen_render_Screen_renderBackground_injection(Screen *scr
 }
 
 // Add Buttons Back To Classic Start Screen
-static void StartMenuScreen_init_injection(StartMenuScreen *screen) {
+static void StartMenuScreen_init_injection(StartMenuScreen_init_t original, StartMenuScreen *screen) {
     // Call Original Method
-    StartMenuScreen_init_non_virtual(screen);
+    original(screen);
 
     // Add Button
     std::vector<Button *> *rendered_buttons = &screen->rendered_buttons;
@@ -38,14 +38,14 @@ static void StartMenuScreen_init_injection(StartMenuScreen *screen) {
 }
 
 // Add Functionality To Quit Button
-static void StartMenuScreen_buttonClicked_injection(StartMenuScreen *screen, Button *button) {
+static void StartMenuScreen_buttonClicked_injection(StartMenuScreen_buttonClicked_t original, StartMenuScreen *screen, Button *button) {
     Button *quit_button = &screen->create_button;
     if (button == quit_button) {
         // Quit
         compat_request_exit();
     } else {
         // Call Original Method
-        StartMenuScreen_buttonClicked_non_virtual(screen, button);
+        original(screen, button);
     }
 }
 
@@ -68,7 +68,7 @@ static Screen *last_screen = nullptr;
 static std::string current_splash;
 static void StartMenuScreen_render_Screen_render_injection(Screen *screen, int x, int y, float param_1) {
     // Call Original Method
-    Screen_render_non_virtual(screen, x, y, param_1);
+    (*Screen_render_vtable_addr)(screen, x, y, param_1);
 
     // Load Splashes
     static std::vector<std::string> splashes;
@@ -130,7 +130,7 @@ void init_title_screen() {
     // Improved Classic Title Screen
     if (feature_has("Improved Classic Title Screen", server_disabled)) {
         // Add Options Button Back To Classic Start Screen
-        patch_address(StartMenuScreen_init_vtable_addr, (void *) StartMenuScreen_init_injection);
+        overwrite_virtual_calls(StartMenuScreen_init, StartMenuScreen_init_injection);
 
         // Fix Classic UI Button Size
         unsigned char classic_button_height_patch[4] = {0x18, 0x30, 0xa0, 0xe3}; // "mov r3, #0x18"
@@ -154,7 +154,7 @@ void init_title_screen() {
         patch_address((void *) Strings_classic_create_button_text_pointer, (void *) "Quit");
 
         // Add Functionality To Quit Button
-        patch_address(StartMenuScreen_buttonClicked_vtable_addr, (void *) StartMenuScreen_buttonClicked_injection);
+        overwrite_virtual_calls(StartMenuScreen_buttonClicked, StartMenuScreen_buttonClicked_injection);
     }
 
     // Add Splashes
diff --git a/symbols/src/entity/Entity.def b/symbols/src/entity/Entity.def
index 3405fe0..77e96c5 100644
--- a/symbols/src/entity/Entity.def
+++ b/symbols/src/entity/Entity.def
@@ -1,3 +1,5 @@
+vtable 0x10a548;
+
 virtual-method void remove() = 0x10;
 virtual-method void tick() = 0x34;
 virtual-method float getBrightness(float param_1) = 0x64;
diff --git a/symbols/src/input/IBuildInput.def b/symbols/src/input/IBuildInput.def
index 627f12d..5eaaf43 100644
--- a/symbols/src/input/IBuildInput.def
+++ b/symbols/src/input/IBuildInput.def
@@ -1 +1,3 @@
+vtable 0x102540;
+
 virtual-method int tickBuild(Player *player, uint *build_action_intention_return) = 0xc;
diff --git a/symbols/src/network/NetEventCallback.def b/symbols/src/network/NetEventCallback.def
index c8b7eeb..5610a0f 100644
--- a/symbols/src/network/NetEventCallback.def
+++ b/symbols/src/network/NetEventCallback.def
@@ -1,3 +1,7 @@
+vtable-destructor-offset 0x4; // Why
+vtable 0x1090f0;
+
+virtual-method void levelGenerated(Level *level) = 0x0;
 virtual-method void onDisconnect(RakNet_RakNetGUID *guid) = 0x18;
 virtual-method void handle_SignUpdatePacket(RakNet_RakNetGUID *guid, SignUpdatePacket *packet) = 0xcc;
-virtual-method void handle_ChatPacket(RakNet_RakNetGUID *rak_net_guid, uchar *packet) = 0xc8;
+virtual-method void handle_ChatPacket(RakNet_RakNetGUID *rak_net_guid, ChatPacket *packet) = 0xc8;