diff --git a/Makefile b/Makefile
index 0f95cba..6be9a04 100644
--- a/Makefile
+++ b/Makefile
@@ -3,7 +3,7 @@ all:
 	@strip build/bnusio.dll
 
 setup:
-	@meson setup build --cross cross-mingw-64.txt --wipe
+	@meson setup build --cross cross-mingw-64.txt
 
 dist-no-7z: all
 	@mkdir -p out/
diff --git a/src/bnusio.cpp b/src/bnusio.cpp
index 1f016b2..6d2e26b 100644
--- a/src/bnusio.cpp
+++ b/src/bnusio.cpp
@@ -11,8 +11,8 @@ extern char accessCode1[21];
 extern char accessCode2[21];
 extern char chipId1[33];
 extern char chipId2[33];
-extern bool autoIME;
-extern bool emulateUSIO;
+extern bool autoIme;
+extern bool emulateUsio;
 extern bool emulateCardReader;
 
 typedef i32 (*callbackAttach) (i32, i32, i32 *);
@@ -45,56 +45,74 @@ Keybindings P2_LEFT_RED   = {};
 Keybindings P2_RIGHT_RED  = {};
 Keybindings P2_RIGHT_BLUE = {};
 
+bool testEnabled  = false;
+int coin_count    = 0;
+bool inited       = false;
+HWND windowHandle = nullptr;
+HKL currentLayout;
+
 namespace bnusio {
 #define RETURN_FALSE(returnType, functionName, ...) \
     returnType functionName (__VA_ARGS__) { return 0; }
 
 extern "C" {
-RETURN_FALSE (i64, bnusio_ClearSram);
+RETURN_FALSE (i64, bnusio_Open);
+RETURN_FALSE (i64, bnusio_Close);
 RETURN_FALSE (i64, bnusio_Communication, i32 a1);
-RETURN_FALSE (i64, bnusio_DecService, i32 a1, u16 a2);
-RETURN_FALSE (void *, bnusio_GetBuffer, u16 a1, i64 a2, i16 a3);
-RETURN_FALSE (i64, bnusio_GetCDOut, u8 a1);
-RETURN_FALSE (void *, bnusio_GetCoinError, i32 a1);
-RETURN_FALSE (i64, bnusio_GetCoinLock, u8 a1);
-RETURN_FALSE (u64, bnusio_GetEncoder);
-RETURN_FALSE (void *, bnusio_GetExpansionMode);
-RETURN_FALSE (u8, bnusio_GetGout, u8 a1);
-RETURN_FALSE (i64, bnusio_GetHopOut, u8 a1);
-RETURN_FALSE (char *, bnusio_GetIoBoardName);
-RETURN_FALSE (u16, bnusio_GetRegisterU16, i16 a1);
-RETURN_FALSE (u8, bnusio_GetRegisterU8, u16 a1);
-RETURN_FALSE (void *, bnusio_GetService, i32 a1);
-RETURN_FALSE (void *, bnusio_GetServiceError, i32 a1);
+RETURN_FALSE (u8, bnusio_IsConnected);
+RETURN_FALSE (i32, bnusio_ResetIoBoard);
 RETURN_FALSE (u16, bnusio_GetStatusU16, u16 a1);
 RETURN_FALSE (u8, bnusio_GetStatusU8, u16 a1);
-RETURN_FALSE (u64, bnusio_GetSwIn64);
-RETURN_FALSE (void *, bnusio_GetSystemError);
-RETURN_FALSE (u8, bnusio_IsConnected);
-RETURN_FALSE (u8, bnusio_IsWideUsio);
-RETURN_FALSE (i64, bnusio_Open);
-RETURN_FALSE (i32, bnusio_ResetIoBoard);
-RETURN_FALSE (i64, bnusio_SetBuffer, u16 a1, i32 a2, i16 a3);
-RETURN_FALSE (i64, bnusio_SetCDOut, u8 a1, u8 a2);
-RETURN_FALSE (i64, bnusio_SetCoinLock, u8 a1, u8 a2);
-RETURN_FALSE (i64, bnusio_SetExpansionMode, i16 a1);
-RETURN_FALSE (i64, bnusio_SetGout, u8 a1, u8 a2);
-RETURN_FALSE (i64, bnusio_SetHopOut, u8 a1, u8 a2);
-RETURN_FALSE (i64, bnusio_SetHopperLimit, u16 a1, i16 a2);
-RETURN_FALSE (i64, bnusio_SetHopperRequest, u16 a1, i16 a2);
-RETURN_FALSE (void *, bnusio_SetPLCounter, i16 a1);
+RETURN_FALSE (u16, bnusio_GetRegisterU16, i16 a1);
+RETURN_FALSE (u8, bnusio_GetRegisterU8, u16 a1);
+RETURN_FALSE (void *, bnusio_GetBuffer, u16 a1, i64 a2, i16 a3);
 RETURN_FALSE (i64, bnusio_SetRegisterU16, u16 a1, u16 a2);
 RETURN_FALSE (i64, bnusio_SetRegisterU8, u16 a1, u8 a2);
+RETURN_FALSE (i64, bnusio_SetBuffer, u16 a1, i32 a2, i16 a3);
+RETURN_FALSE (void *, bnusio_GetSystemError);
 RETURN_FALSE (i64, bnusio_SetSystemError, i16 a1);
+RETURN_FALSE (i64, bnusio_ClearSram);
+RETURN_FALSE (void *, bnusio_GetExpansionMode);
+RETURN_FALSE (i64, bnusio_SetExpansionMode, i16 a1);
+RETURN_FALSE (u8, bnusio_IsWideUsio);
+RETURN_FALSE (u64, bnusio_GetSwIn64);
+RETURN_FALSE (u8, bnusio_GetGout, u8 a1);
+RETURN_FALSE (i64, bnusio_SetGout, u8 a1, u8 a2);
+RETURN_FALSE (u64, bnusio_GetEncoder);
+RETURN_FALSE (i64, bnusio_GetCoinLock, u8 a1);
+RETURN_FALSE (i64, bnusio_SetCoinLock, u8 a1, u8 a2);
+RETURN_FALSE (i64, bnusio_GetCDOut, u8 a1);
+RETURN_FALSE (i64, bnusio_SetCDOut, u8 a1, u8 a2);
+RETURN_FALSE (i64, bnusio_GetHopOut, u8 a1);
+RETURN_FALSE (i64, bnusio_SetHopOut, u8 a1, u8 a2);
+RETURN_FALSE (void *, bnusio_SetPLCounter, i16 a1);
+RETURN_FALSE (char *, bnusio_GetIoBoardName);
+RETURN_FALSE (i64, bnusio_SetHopperRequest, u16 a1, i16 a2);
+RETURN_FALSE (i64, bnusio_SetHopperLimit, u16 a1, i16 a2);
 RETURN_FALSE (i64, bnusio_SramRead, i32 a1, u8 a2, i32 a3, u16 a4);
 RETURN_FALSE (i64, bnusio_SramWrite, i32 a1, u8 a2, i32 a3, u16 a4);
-RETURN_FALSE (i64, bnusio_ResetCoin);
+RETURN_FALSE (void *, bnusio_GetCoinError, i32 a1);
+RETURN_FALSE (void *, bnusio_GetService, i32 a1);
+RETURN_FALSE (void *, bnusio_GetServiceError, i32 a1);
 RETURN_FALSE (i64, bnusio_DecCoin, i32 a1, u16 a2);
+RETURN_FALSE (i64, bnusio_DecService, i32 a1, u16 a2);
+RETURN_FALSE (i64, bnusio_ResetCoin);
 size_t
 bnusio_GetFirmwareVersion () {
     return 126;
 }
 
+u32
+bnusio_GetSwIn () {
+    u32 sw = 0;
+    sw |= (u32)testEnabled << 7;
+    sw |= (u32)IsButtonDown (DEBUG_ENTER) << 9;
+    sw |= (u32)IsButtonDown (DEBUG_DOWN) << 12;
+    sw |= (u32)IsButtonDown (DEBUG_UP) << 13;
+    sw |= (u32)IsButtonDown (SERVICE) << 14;
+    return sw;
+}
+
 u16 drumWaitPeriod = 4;
 bool valueStates[] = {false, false, false, false, false, false, false, false};
 
@@ -165,19 +183,225 @@ bnusio_GetAnalogIn (u8 which) {
     }
 }
 
-bool testEnabled  = false;
-int coin_count    = 0;
-bool inited       = false;
-HWND windowHandle = nullptr;
-HKL currentLayout;
+u16 __fastcall bnusio_GetCoin (i32 a1) { return coin_count; }
+}
 
-u16 __fastcall bnusio_GetCoin (i32 a1) {
-    if (a1 != 1) return coin_count;
+FUNCTION_PTR (i64, bnusio_Open_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_Open"));
+FUNCTION_PTR (i64, bnusio_Close_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_Close"));
+FUNCTION_PTR (u64, bnusio_Communication_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_Communication"), i32);
+FUNCTION_PTR (u8, bnusio_IsConnected_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_IsConnected"));
+FUNCTION_PTR (i32, bnusio_ResetIoBoard_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_ResetIoBoard"));
+FUNCTION_PTR (u16, bnusio_GetStatusU16_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetStatusU16"), u16);
+FUNCTION_PTR (u8, bnusio_GetStatusU8_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetStatusU8"), u16);
+FUNCTION_PTR (u16, bnusio_GetRegisterU16_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetRegisterU16"), i16);
+FUNCTION_PTR (u8, bnusio_GetRegisterU8_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetRegisterU8"), i16);
+FUNCTION_PTR (void *, bnusio_GetBuffer_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetBuffer"), u16, i64, i16);
+FUNCTION_PTR (i64, bnusio_SetRegisterU16_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetRegisterU16"), u16, u16);
+FUNCTION_PTR (i64, bnusio_SetRegisterU8_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetRegisterU8"), u16, u8);
+FUNCTION_PTR (i64, bnusio_SetBuffer_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetBuffer"), u16, i32, i16);
+FUNCTION_PTR (void *, bnusio_GetSystemError_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetSystemError"));
+FUNCTION_PTR (i64, bnusio_SetSystemError_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetSystemError"), i16);
+FUNCTION_PTR (size_t, bnusio_GetFirmwareVersion_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetFirmwareVersion"));
+FUNCTION_PTR (i64, bnusio_ClearSram_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_ClearSram"));
+FUNCTION_PTR (void *, bnusio_GetExpansionMode_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetExpansionMode"));
+FUNCTION_PTR (i64, bnusio_SetExpansionMode_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetExpansionMode"), i16);
+FUNCTION_PTR (u8, bnusio_IsWideUsio_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_IsWideUsio"));
+FUNCTION_PTR (u32, bnusio_GetSwIn_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetSwIn"));
+FUNCTION_PTR (u64, bnusio_GetSwIn64_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetSwIn64"));
+FUNCTION_PTR (u16, bnusio_GetAnalogIn_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetAnalogIn"), u8);
+FUNCTION_PTR (u8, bnusio_GetGout_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetGout"), u8);
+FUNCTION_PTR (i64, bnusio_SetGout_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetGout"), u8, u8);
+FUNCTION_PTR (u64, bnusio_GetEncoder_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetEncoder"));
+FUNCTION_PTR (i64, bnusio_GetCoinLock_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetCoinLock"), u8);
+FUNCTION_PTR (i64, bnusio_SetCoinLock_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetCoinLock"), u8, u8);
+FUNCTION_PTR (i64, bnusio_GetCDOut_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetCDOut"), u8);
+FUNCTION_PTR (i64, bnusio_SetCDOut_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetCDOut"), u8, u8);
+FUNCTION_PTR (i64, bnusio_GetHopOut_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetHopOut"), u8);
+FUNCTION_PTR (i64, bnusio_SetHopOut_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetHopOut"), u8, u8);
+FUNCTION_PTR (void *, bnusio_SetPLCounter_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetPLCounter"), i16);
+FUNCTION_PTR (char *, bnusio_GetIoBoardName_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetIoBoardName"));
+FUNCTION_PTR (i64, bnusio_SetHopperRequest_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetHopperRequest"), u16, i16);
+FUNCTION_PTR (i64, bnusio_SetHopperLimit_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetHopperLimit"), u16, i16);
+FUNCTION_PTR (i64, bnusio_SramRead_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SramRead"), i32, u8, i32, u16);
+FUNCTION_PTR (i64, bnusio_SramWrite_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SramWrite"), i32, u8, i32, u16);
+FUNCTION_PTR (u16, bnusio_GetCoin_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetCoin"), i32);
+FUNCTION_PTR (void *, bnusio_GetCoinError_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetCoinError"), i32);
+FUNCTION_PTR (void *, bnusio_GetService_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetService"), i32);
+FUNCTION_PTR (void *, bnusio_GetServiceError_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetServiceError"), i32);
+FUNCTION_PTR (i64, bnusio_DecCoin_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_DecCoin"), i32, u16);
+FUNCTION_PTR (u64, bnusio_DecService_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_DecService"), i32, u16);
+FUNCTION_PTR (i64, bnusio_ResetCoin_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_ResetCoin"));
 
+HOOK (u64, bngrw_Init, PROC_ADDRESS ("bngrw.dll", "BngRwInit")) { return 0; }
+HOOK (void, bngrw_Fin, PROC_ADDRESS ("bngrw.dll", "BngRwFin")) { return; }
+HOOK (u64, bngrw_IsCmdExec, PROC_ADDRESS ("bngrw.dll", "BngRwIsCmdExec")) { return 0xFFFFFFFF; }
+HOOK (i32, bngrw_ReqCancel, PROC_ADDRESS ("bngrw.dll", "BngRwReqCancel")) { return 1; }
+HOOK (i32, bngrw_ReqSendUrl, PROC_ADDRESS ("bngrw.dll", "BngRwReqSendUrlTo")) { return 1; }
+HOOK (u64, bngrw_ReqLed, PROC_ADDRESS ("bngrw.dll", "BngRwReqLed")) { return 1; }
+HOOK (u64, bngrw_ReqBeep, PROC_ADDRESS ("bngrw.dll", "BngRwReqBeep")) { return 1; }
+HOOK (u64, bngrw_ReqAction, PROC_ADDRESS ("bngrw.dll", "BngRwReqAction")) { return 1; }
+HOOK (u64, bngrw_ReqSetLedPower, PROC_ADDRESS ("bngrw.dll", "BngRwReqSetLedPower")) { return 0; }
+HOOK (u64, bngrw_GetRetryCount, PROC_ADDRESS ("bngrw.dll", "BngRwGetTotalRetryCount")) { return 0; }
+HOOK (u64, bngrw_GetFwVersion, PROC_ADDRESS ("bngrw.dll", "BngRwGetFwVersion")) { return 0; }
+HOOK (u64, bngrw_ReqFwVersionUp, PROC_ADDRESS ("bngrw.dll", "BngRwReqFwVersionUp")) { return 1; }
+HOOK (u64, bngrw_ReqFwCleanup, PROC_ADDRESS ("bngrw.dll", "BngRwReqFwCleanup")) { return 1; }
+HOOK (u64, bngrw_ReadMifare, PROC_ADDRESS ("bngrw.dll", "BngRwExReadMifareAllBlock")) { return 0xFFFFFF9C; }
+HOOK (u64, bngrw_GetStationID, PROC_ADDRESS ("bngrw.dll", "BngRwGetStationID")) { return 0; }
+HOOK (i32, bngrw_ReqSendMail, PROC_ADDRESS ("bngrw.dll", "BngRwReqSendMailTo")) { return 1; }
+HOOK (i32, bngrw_ReqLatchID, PROC_ADDRESS ("bngrw.dll", "BngRwReqLatchID")) { return 1; }
+HOOK (u64, bngrw_ReqAiccAuth, PROC_ADDRESS ("bngrw.dll", "BngRwReqAiccAuth")) { return 1; }
+HOOK (u64, bngrw_DevReset, PROC_ADDRESS ("bngrw.dll", "BngRwDevReset")) { return 1; }
+HOOK (u64, bngrw_Attach, PROC_ADDRESS ("bngrw.dll", "BngRwAttach"), i32 a1, char *a2, i32 a3, i32 a4, i32 (*callback) (i32, i32, i32 *), i32 *a6) {
+    // This is way too fucking jank
+    attachCallback = callback;
+    attachData     = a6;
+    return 1;
+}
+HOOK (u64, bngrw_ReqWaitTouch, PROC_ADDRESS ("bngrw.dll", "BngRwReqWaitTouch"), u32 a1, i32 a2, u32 a3, void (*callback) (i32, i32, u8[168], u64),
+      u64 a5) {
+    waitingForTouch = true;
+    touchCallback   = callback;
+    touchData       = a5;
+    for (auto plugin : plugins) {
+        FARPROC touchEvent = GetProcAddress (plugin, "WaitTouch");
+        if (touchEvent) ((waitTouchEvent *)touchEvent) (callback, a5);
+    }
+    return 1;
+}
+
+void
+Init () {
+    SetKeyboardButtons ();
+
+    auto configPath = std::filesystem::current_path () / "config.toml";
+    std::unique_ptr<toml_table_t, void (*) (toml_table_t *)> config_ptr (openConfig (configPath), toml_free);
+    if (config_ptr) {
+        toml_table_t *config = config_ptr.get ();
+        auto drum            = openConfigSection (config, "drum");
+        if (drum) drumWaitPeriod = readConfigInt (drum, "wait_period", drumWaitPeriod);
+        auto controller = openConfigSection (config, "controller");
+        if (controller) {
+            analogInput = readConfigBool (controller, "analog_input", analogInput);
+            if (analogInput) printf ("Using analog input mode. All the keyboard drum inputs have been disabled.\n");
+        }
+    }
+
+    auto keyconfigPath = std::filesystem::current_path () / "keyconfig.toml";
+    std::unique_ptr<toml_table_t, void (*) (toml_table_t *)> keyconfig_ptr (openConfig (keyconfigPath), toml_free);
+    if (keyconfig_ptr) {
+        toml_table_t *keyconfig = keyconfig_ptr.get ();
+        SetConfigValue (keyconfig, "EXIT", &EXIT);
+
+        SetConfigValue (keyconfig, "TEST", &TEST);
+        SetConfigValue (keyconfig, "SERVICE", &SERVICE);
+        SetConfigValue (keyconfig, "DEBUG_UP", &DEBUG_UP);
+        SetConfigValue (keyconfig, "DEBUG_DOWN", &DEBUG_DOWN);
+        SetConfigValue (keyconfig, "DEBUG_ENTER", &DEBUG_ENTER);
+
+        SetConfigValue (keyconfig, "COIN_ADD", &COIN_ADD);
+        SetConfigValue (keyconfig, "CARD_INSERT_1", &CARD_INSERT_1);
+        SetConfigValue (keyconfig, "CARD_INSERT_2", &CARD_INSERT_2);
+        SetConfigValue (keyconfig, "QR_DATA_READ", &QR_DATA_READ);
+        SetConfigValue (keyconfig, "QR_IMAGE_READ", &QR_IMAGE_READ);
+
+        SetConfigValue (keyconfig, "P1_LEFT_BLUE", &P1_LEFT_BLUE);
+        SetConfigValue (keyconfig, "P1_LEFT_RED", &P1_LEFT_RED);
+        SetConfigValue (keyconfig, "P1_RIGHT_RED", &P1_RIGHT_RED);
+        SetConfigValue (keyconfig, "P1_RIGHT_BLUE", &P1_RIGHT_BLUE);
+        SetConfigValue (keyconfig, "P2_LEFT_BLUE", &P2_LEFT_BLUE);
+        SetConfigValue (keyconfig, "P2_LEFT_RED", &P2_LEFT_RED);
+        SetConfigValue (keyconfig, "P2_RIGHT_RED", &P2_RIGHT_RED);
+        SetConfigValue (keyconfig, "P2_RIGHT_BLUE", &P2_RIGHT_BLUE);
+    }
+
+    if (!emulateUsio && !std::filesystem::exists (std::filesystem::current_path () / "bnusio_original.dll")) {
+        emulateUsio = true;
+        std::cerr << "[Init] bnusio_original.dll not found! usio emulation enabled" << std::endl;
+    }
+
+    if (!emulateUsio) {
+        INSTALL_HOOK_DIRECT (bnusio_Open, bnusio_Open_Original);
+        INSTALL_HOOK_DIRECT (bnusio_Close, bnusio_Close_Original);
+        INSTALL_HOOK_DIRECT (bnusio_Communication, bnusio_Communication_Original);
+        INSTALL_HOOK_DIRECT (bnusio_IsConnected, bnusio_IsConnected_Original);
+        INSTALL_HOOK_DIRECT (bnusio_ResetIoBoard, bnusio_ResetIoBoard_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetStatusU16, bnusio_GetStatusU16_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetStatusU8, bnusio_GetStatusU8_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetRegisterU16, bnusio_GetRegisterU16_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetRegisterU8, bnusio_GetRegisterU8_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetBuffer, bnusio_GetBuffer_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SetRegisterU16, bnusio_SetRegisterU16_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SetRegisterU8, bnusio_SetRegisterU8_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SetBuffer, bnusio_SetBuffer_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetSystemError, bnusio_GetSystemError_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SetSystemError, bnusio_SetSystemError_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetFirmwareVersion, bnusio_GetFirmwareVersion_Original);
+        INSTALL_HOOK_DIRECT (bnusio_ClearSram, bnusio_ClearSram_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetExpansionMode, bnusio_GetExpansionMode_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SetExpansionMode, bnusio_SetExpansionMode_Original);
+        INSTALL_HOOK_DIRECT (bnusio_IsWideUsio, bnusio_IsWideUsio_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetSwIn, bnusio_GetSwIn_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetSwIn64, bnusio_GetSwIn64_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetAnalogIn, bnusio_GetAnalogIn_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetGout, bnusio_GetGout_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SetGout, bnusio_SetGout_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetEncoder, bnusio_GetEncoder_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetCoinLock, bnusio_GetCoinLock_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SetCoinLock, bnusio_SetCoinLock_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetCDOut, bnusio_GetCDOut_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SetCDOut, bnusio_SetCDOut_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetHopOut, bnusio_GetHopOut_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SetHopOut, bnusio_SetHopOut_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SetPLCounter, bnusio_SetPLCounter_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetIoBoardName, bnusio_GetIoBoardName_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SetHopperRequest, bnusio_SetHopperRequest_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SetHopperLimit, bnusio_SetHopperLimit_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SramRead, bnusio_SramRead_Original);
+        INSTALL_HOOK_DIRECT (bnusio_SramWrite, bnusio_SramWrite_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetCoin, bnusio_GetCoin_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetCoinError, bnusio_GetCoinError_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetService, bnusio_GetService_Original);
+        INSTALL_HOOK_DIRECT (bnusio_GetServiceError, bnusio_GetServiceError_Original);
+        INSTALL_HOOK_DIRECT (bnusio_DecCoin, bnusio_DecCoin_Original);
+        INSTALL_HOOK_DIRECT (bnusio_DecService, bnusio_DecService_Original);
+        INSTALL_HOOK_DIRECT (bnusio_ResetCoin, bnusio_ResetCoin_Original);
+
+        std::cout << "[Init] USIO emulation disabled" << std::endl;
+    }
+
+    if (emulateCardReader) {
+        INSTALL_HOOK (bngrw_Init)
+        INSTALL_HOOK (bngrw_Fin);
+        INSTALL_HOOK (bngrw_IsCmdExec);
+        INSTALL_HOOK (bngrw_ReqCancel);
+        INSTALL_HOOK (bngrw_ReqWaitTouch);
+        INSTALL_HOOK (bngrw_ReqSendUrl);
+        INSTALL_HOOK (bngrw_ReqLed);
+        INSTALL_HOOK (bngrw_ReqBeep);
+        INSTALL_HOOK (bngrw_ReqAction);
+        INSTALL_HOOK (bngrw_ReqSetLedPower);
+        INSTALL_HOOK (bngrw_GetRetryCount);
+        INSTALL_HOOK (bngrw_GetFwVersion);
+        INSTALL_HOOK (bngrw_ReqFwVersionUp);
+        INSTALL_HOOK (bngrw_ReqFwCleanup);
+        INSTALL_HOOK (bngrw_ReadMifare);
+        INSTALL_HOOK (bngrw_GetStationID);
+        INSTALL_HOOK (bngrw_ReqSendMail);
+        INSTALL_HOOK (bngrw_ReqLatchID);
+        INSTALL_HOOK (bngrw_ReqAiccAuth);
+        INSTALL_HOOK (bngrw_Attach);
+        INSTALL_HOOK (bngrw_DevReset);
+    } else {
+        std::cout << "[Init] Card reader emulation disabled" << std::endl;
+    }
+}
+
+void
+Update () {
     if (!inited) {
         windowHandle = FindWindowA ("nuFoundation.Window", nullptr);
         InitializePoll (windowHandle);
-        if (autoIME) {
+        if (autoIme) {
             currentLayout  = GetKeyboardLayout (0);
             auto engLayout = LoadKeyboardLayout (TEXT ("00000409"), KLF_ACTIVATE);
             ActivateKeyboardLayout (engLayout, KLF_SETFORPROCESS);
@@ -251,246 +475,14 @@ u16 __fastcall bnusio_GetCoin (i32 a1) {
     patches::Qr::Update ();
 
     if (attachCallback) attachCallback (0, 0, attachData);
-    return coin_count;
 }
 
-u32
-bnusio_GetSwIn () {
-    u32 sw = 0;
-    sw |= (u32)testEnabled << 7;
-    sw |= (u32)IsButtonDown (DEBUG_ENTER) << 9;
-    sw |= (u32)IsButtonDown (DEBUG_DOWN) << 12;
-    sw |= (u32)IsButtonDown (DEBUG_UP) << 13;
-    sw |= (u32)IsButtonDown (SERVICE) << 14;
-    return sw;
-}
-
-i64
-bnusio_Close () {
-    if (autoIME) ActivateKeyboardLayout (currentLayout, KLF_SETFORPROCESS);
+void
+Close () {
+    if (autoIme) ActivateKeyboardLayout (currentLayout, KLF_SETFORPROCESS);
     for (auto plugin : plugins) {
         FARPROC exitEvent = GetProcAddress (plugin, "Exit");
         if (exitEvent) ((event *)exitEvent) ();
     }
-    return 0;
-}
-}
-
-FUNCTION_PTR (i64, bnusio_ClearSram_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_ClearSram"));
-FUNCTION_PTR (u64, bnusio_Communication_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_Communication"), i32 a1);
-FUNCTION_PTR (u64, bnusio_DecService_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_DecService"), i32 a1, u16 a2);
-FUNCTION_PTR (void *, bnusio_GetBuffer_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetBuffer"), u16 a1, i64 a2, i16 a3);
-FUNCTION_PTR (i64, bnusio_GetCDOut_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetCDOut"), u8 a1);
-FUNCTION_PTR (void *, bnusio_GetCoinError_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetCoinError"), i32 a1);
-FUNCTION_PTR (i64, bnusio_GetCoinLock_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetCoinLock"), u8 a1);
-FUNCTION_PTR (u64, bnusio_GetEncoder_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetEncoder"));
-FUNCTION_PTR (void *, bnusio_GetExpansionMode_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetExpansionMode"));
-FUNCTION_PTR (u8, bnusio_GetGout_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetGout"), u8 a1);
-FUNCTION_PTR (i64, bnusio_GetHopOut_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetHopOut"), u8 a1);
-FUNCTION_PTR (char *, bnusio_GetIoBoardName_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetIoBoardName"));
-FUNCTION_PTR (u16, bnusio_GetRegisterU16_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetRegisterU16"), i16 a1);
-FUNCTION_PTR (u8, bnusio_GetRegisterU8_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetRegisterU8"), i16 a1);
-FUNCTION_PTR (void *, bnusio_GetService_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetService"), i32 a1);
-FUNCTION_PTR (void *, bnusio_GetServiceError_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetServiceError"), i32 a1);
-FUNCTION_PTR (u16, bnusio_GetStatusU16_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetStatusU16"), u16 a1);
-FUNCTION_PTR (u8, bnusio_GetStatusU8_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetStatusU8"), u16 a1);
-FUNCTION_PTR (u64, bnusio_GetSwIn64_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetSwIn64"));
-FUNCTION_PTR (void *, bnusio_GetSystemError_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetSystemError"));
-FUNCTION_PTR (u8, bnusio_IsConnected_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_IsConnected"));
-FUNCTION_PTR (u8, bnusio_IsWideUsio_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_IsWideUsio"));
-FUNCTION_PTR (i64, bnusio_Open_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_Open"));
-FUNCTION_PTR (i32, bnusio_ResetIoBoard_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_ResetIoBoard"));
-FUNCTION_PTR (i64, bnusio_SetBuffer_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetBuffer"), u16 a1, i32 a2, i16 a3);
-FUNCTION_PTR (i64, bnusio_SetCDOut_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetCDOut"), u8 a1, u8 a2);
-FUNCTION_PTR (i64, bnusio_SetCoinLock_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetCoinLock"), u8 a1, u8 a2);
-FUNCTION_PTR (i64, bnusio_SetExpansionMode_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetExpansionMode"), i16 a1);
-FUNCTION_PTR (i64, bnusio_SetGout_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetGout"), u8 a1, u8 a2);
-FUNCTION_PTR (i64, bnusio_SetHopOut_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetHopOut"), u8 a1, u8 a2);
-FUNCTION_PTR (i64, bnusio_SetHopperLimit_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetHopperLimit"), u16 a1, i16 a2);
-FUNCTION_PTR (i64, bnusio_SetHopperRequest_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetHopperRequest"), u16 a1, i16 a2);
-FUNCTION_PTR (void *, bnusio_SetPLCounter_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetPLCounter"), i16 a1);
-FUNCTION_PTR (i64, bnusio_SetRegisterU16_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetRegisterU16"), u16 a1, u16 a2);
-FUNCTION_PTR (i64, bnusio_SetRegisterU8_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetRegisterU8"), u16 a1, u8 a2);
-FUNCTION_PTR (i64, bnusio_SetSystemError_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SetSystemError"), i16 a1);
-FUNCTION_PTR (i64, bnusio_SramRead_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SramRead"), i32 a1, u8 a2, i32 a3, u16 a4);
-FUNCTION_PTR (i64, bnusio_SramWrite_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_SramWrite"), i32 a1, u8 a2, i32 a3, u16 a4);
-FUNCTION_PTR (i64, bnusio_ResetCoin_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_ResetCoin"));
-FUNCTION_PTR (i64, bnusio_DecCoin_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_DecCoin"), i32 a1, u16 a2);
-FUNCTION_PTR (size_t, bnusio_GetFirmwareVersion_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetFirmwareVersion"));
-FUNCTION_PTR (u16, bnusio_GetAnalogIn_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetAnalogIn"), u8 a1);
-FUNCTION_PTR (u16, bnusio_GetCoin_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetCoin"), i32 a1);
-FUNCTION_PTR (u32, bnusio_GetSwIn_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_GetSwIn"));
-FUNCTION_PTR (i64, bnusio_Close_Original, PROC_ADDRESS ("bnusio_original.dll", "bnusio_Close"));
-HOOK (u16, bnusio_GetCoin_Hook, bnusio_GetCoin, i32 a1) {
-    originalbnusio_GetCoin_Hook (a1);
-    return bnusio_GetCoin_Original (a1);
-}
-HOOK (i64, bnusio_Close_Hook, bnusio_Close) {
-    originalbnusio_Close_Hook ();
-    return bnusio_Close_Original ();
-}
-
-HOOK (u64, bngrw_DevReset, PROC_ADDRESS ("bngrw.dll", "BngRwDevReset")) { return 1; }
-HOOK (u64, bngrw_ReadMifare, PROC_ADDRESS ("bngrw.dll", "BngRwExReadMifareAllBlock")) { return 0xFFFFFF9C; }
-HOOK (void, bngrw_fin, PROC_ADDRESS ("bngrw.dll", "BngRwFin")) { return; }
-HOOK (u64, bngrw_GetFwVersion, PROC_ADDRESS ("bngrw.dll", "BngRwGetFwVersion")) { return 0; }
-HOOK (u64, bngrw_GetStationID, PROC_ADDRESS ("bngrw.dll", "BngRwGetStationID")) { return 0; }
-HOOK (u64, bngrw_GetRetryCount, PROC_ADDRESS ("bngrw.dll", "BngRwGetTotalRetryCount")) { return 0; }
-HOOK (u64, bngrw_IsCmdExec, PROC_ADDRESS ("bngrw.dll", "BngRwIsCmdExec")) { return 0xFFFFFFFF; }
-HOOK (u64, bngrw_ReqAction, PROC_ADDRESS ("bngrw.dll", "BngRwReqAction")) { return 1; }
-HOOK (u64, bngrw_ReqAiccAuth, PROC_ADDRESS ("bngrw.dll", "BngRwReqAiccAuth")) { return 1; }
-HOOK (u64, bngrw_ReqBeep, PROC_ADDRESS ("bngrw.dll", "BngRwReqBeep")) { return 1; }
-HOOK (u64, bngrw_ReqFwCleanup, PROC_ADDRESS ("bngrw.dll", "BngRwReqFwCleanup")) { return 1; }
-HOOK (u64, bngrw_ReqFwVersionUp, PROC_ADDRESS ("bngrw.dll", "BngRwReqFwVersionUp")) { return 1; }
-HOOK (i32, bngrw_ReqLatchID, PROC_ADDRESS ("bngrw.dll", "BngRwReqLatchID")) { return 1; }
-HOOK (u64, bngrw_ReqLed, PROC_ADDRESS ("bngrw.dll", "BngRwReqLed")) { return 1; }
-HOOK (i32, bngrw_ReqSendMail, PROC_ADDRESS ("bngrw.dll", "BngRwReqSendMailTo")) { return 1; }
-HOOK (i32, bngrw_ReqSendUrl, PROC_ADDRESS ("bngrw.dll", "BngRwReqSendUrlTo")) { return 1; }
-HOOK (u64, bngrw_ReqSetLedPower, PROC_ADDRESS ("bngrw.dll", "BngRwReqSetLedPower")) { return 0; }
-HOOK (i32, bngrw_reqCancel, PROC_ADDRESS ("bngrw.dll", "BngRwReqCancel")) { return 1; }
-HOOK (u64, bngrw_Init, PROC_ADDRESS ("bngrw.dll", "BngRwInit")) { return 0; }
-HOOK (u64, bngrw_attach, PROC_ADDRESS ("bngrw.dll", "BngRwAttach"), i32 a1, char *a2, i32 a3, i32 a4, i32 (*callback) (i32, i32, i32 *), i32 *a6) {
-    // This is way too fucking jank
-    attachCallback = callback;
-    attachData     = a6;
-    return 1;
-}
-HOOK (u64, bngrw_reqWaitTouch, PROC_ADDRESS ("bngrw.dll", "BngRwReqWaitTouch"), u32 a1, i32 a2, u32 a3, void (*callback) (i32, i32, u8[168], u64),
-      u64 a5) {
-    waitingForTouch = true;
-    touchCallback   = callback;
-    touchData       = a5;
-    for (auto plugin : plugins) {
-        FARPROC touchEvent = GetProcAddress (plugin, "WaitTouch");
-        if (touchEvent) ((waitTouchEvent *)touchEvent) (callback, a5);
-    }
-    return 1;
-}
-
-void
-Init () {
-    SetKeyboardButtons ();
-
-    auto configPath = std::filesystem::current_path () / "config.toml";
-    std::unique_ptr<toml_table_t, void (*) (toml_table_t *)> config_ptr (openConfig (configPath), toml_free);
-    if (config_ptr) {
-        toml_table_t *config = config_ptr.get ();
-        auto drum            = openConfigSection (config, "drum");
-        if (drum) drumWaitPeriod = readConfigInt (drum, "wait_period", drumWaitPeriod);
-        auto controller = openConfigSection (config, "controller");
-        if (controller) {
-            analogInput = readConfigBool (controller, "analog_input", analogInput);
-            if (analogInput) printf ("Using analog input mode. All the keyboard drum inputs have been disabled.\n");
-        }
-    }
-
-    auto keyconfigPath = std::filesystem::current_path () / "keyconfig.toml";
-    std::unique_ptr<toml_table_t, void (*) (toml_table_t *)> keyconfig_ptr (openConfig (keyconfigPath), toml_free);
-    if (keyconfig_ptr) {
-        toml_table_t *keyconfig = keyconfig_ptr.get ();
-        SetConfigValue (keyconfig, "EXIT", &EXIT);
-
-        SetConfigValue (keyconfig, "TEST", &TEST);
-        SetConfigValue (keyconfig, "SERVICE", &SERVICE);
-        SetConfigValue (keyconfig, "DEBUG_UP", &DEBUG_UP);
-        SetConfigValue (keyconfig, "DEBUG_DOWN", &DEBUG_DOWN);
-        SetConfigValue (keyconfig, "DEBUG_ENTER", &DEBUG_ENTER);
-
-        SetConfigValue (keyconfig, "COIN_ADD", &COIN_ADD);
-        SetConfigValue (keyconfig, "CARD_INSERT_1", &CARD_INSERT_1);
-        SetConfigValue (keyconfig, "CARD_INSERT_2", &CARD_INSERT_2);
-        SetConfigValue (keyconfig, "QR_DATA_READ", &QR_DATA_READ);
-        SetConfigValue (keyconfig, "QR_IMAGE_READ", &QR_IMAGE_READ);
-
-        SetConfigValue (keyconfig, "P1_LEFT_BLUE", &P1_LEFT_BLUE);
-        SetConfigValue (keyconfig, "P1_LEFT_RED", &P1_LEFT_RED);
-        SetConfigValue (keyconfig, "P1_RIGHT_RED", &P1_RIGHT_RED);
-        SetConfigValue (keyconfig, "P1_RIGHT_BLUE", &P1_RIGHT_BLUE);
-        SetConfigValue (keyconfig, "P2_LEFT_BLUE", &P2_LEFT_BLUE);
-        SetConfigValue (keyconfig, "P2_LEFT_RED", &P2_LEFT_RED);
-        SetConfigValue (keyconfig, "P2_RIGHT_RED", &P2_RIGHT_RED);
-        SetConfigValue (keyconfig, "P2_RIGHT_BLUE", &P2_RIGHT_BLUE);
-    }
-
-    if (!emulateUSIO && !std::filesystem::exists (std::filesystem::current_path () / "bnusio_original.dll")) {
-        emulateUSIO = true;
-        std::cerr << "[Init] bnusio_original.dll not found! usio emulation enabled" << std::endl;
-    }
-
-    if (!emulateUSIO) {
-        INSTALL_HOOK_DIRECT (bnusio_ClearSram, bnusio_ClearSram_Original);
-        INSTALL_HOOK_DIRECT (bnusio_Communication, bnusio_Communication_Original);
-        INSTALL_HOOK_DIRECT (bnusio_DecService, bnusio_DecService_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetBuffer, bnusio_GetBuffer_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetCDOut, bnusio_GetCDOut_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetCoinError, bnusio_GetCoinError_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetCoinLock, bnusio_GetCoinLock_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetEncoder, bnusio_GetEncoder_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetExpansionMode, bnusio_GetExpansionMode_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetGout, bnusio_GetGout_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetHopOut, bnusio_GetHopOut_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetIoBoardName, bnusio_GetIoBoardName_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetRegisterU16, bnusio_GetRegisterU16_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetRegisterU8, bnusio_GetRegisterU8_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetService, bnusio_GetService_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetServiceError, bnusio_GetServiceError_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetStatusU16, bnusio_GetStatusU16_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetStatusU8, bnusio_GetStatusU8_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetSwIn64, bnusio_GetSwIn64_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetSystemError, bnusio_GetSystemError_Original);
-        INSTALL_HOOK_DIRECT (bnusio_IsConnected, bnusio_IsConnected_Original);
-        INSTALL_HOOK_DIRECT (bnusio_IsWideUsio, bnusio_IsWideUsio_Original);
-        INSTALL_HOOK_DIRECT (bnusio_Open, bnusio_Open_Original);
-        INSTALL_HOOK_DIRECT (bnusio_ResetIoBoard, bnusio_ResetIoBoard_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SetBuffer, bnusio_SetBuffer_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SetCDOut, bnusio_SetCDOut_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SetCoinLock, bnusio_SetCoinLock_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SetExpansionMode, bnusio_SetExpansionMode_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SetGout, bnusio_SetGout_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SetHopOut, bnusio_SetHopOut_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SetHopperLimit, bnusio_SetHopperLimit_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SetHopperRequest, bnusio_SetHopperRequest_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SetPLCounter, bnusio_SetPLCounter_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SetRegisterU16, bnusio_SetRegisterU16_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SetRegisterU8, bnusio_SetRegisterU8_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SetSystemError, bnusio_SetSystemError_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SramRead, bnusio_SramRead_Original);
-        INSTALL_HOOK_DIRECT (bnusio_SramWrite, bnusio_SramWrite_Original);
-        INSTALL_HOOK_DIRECT (bnusio_ResetCoin, bnusio_ResetCoin_Original);
-        INSTALL_HOOK_DIRECT (bnusio_DecCoin, bnusio_DecCoin_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetFirmwareVersion, bnusio_GetFirmwareVersion_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetAnalogIn, bnusio_GetAnalogIn_Original);
-        INSTALL_HOOK_DIRECT (bnusio_GetSwIn, bnusio_GetSwIn_Original);
-        INSTALL_HOOK (bnusio_GetCoin_Hook);
-        INSTALL_HOOK (bnusio_Close_Hook);
-
-        std::cout << "[Init] USIO emulation disabled" << std::endl;
-    }
-
-    if (emulateCardReader) {
-        INSTALL_HOOK (bngrw_DevReset);
-        INSTALL_HOOK (bngrw_ReadMifare);
-        INSTALL_HOOK (bngrw_fin);
-        INSTALL_HOOK (bngrw_GetFwVersion);
-        INSTALL_HOOK (bngrw_GetStationID);
-        INSTALL_HOOK (bngrw_GetRetryCount);
-        INSTALL_HOOK (bngrw_IsCmdExec);
-        INSTALL_HOOK (bngrw_ReqAction);
-        INSTALL_HOOK (bngrw_ReqAiccAuth);
-        INSTALL_HOOK (bngrw_ReqBeep);
-        INSTALL_HOOK (bngrw_ReqFwCleanup);
-        INSTALL_HOOK (bngrw_ReqFwVersionUp);
-        INSTALL_HOOK (bngrw_ReqLatchID);
-        INSTALL_HOOK (bngrw_ReqLed);
-        INSTALL_HOOK (bngrw_ReqSendMail);
-        INSTALL_HOOK (bngrw_ReqSendUrl);
-        INSTALL_HOOK (bngrw_ReqSetLedPower);
-        INSTALL_HOOK (bngrw_reqCancel);
-        INSTALL_HOOK (bngrw_Init)
-        INSTALL_HOOK (bngrw_attach);
-        INSTALL_HOOK (bngrw_reqWaitTouch);
-    } else {
-        std::cout << "[Init] Card reader emulation disabled" << std::endl;
-    }
 }
 } // namespace bnusio
diff --git a/src/bnusio.h b/src/bnusio.h
index a932243..fa94b6d 100644
--- a/src/bnusio.h
+++ b/src/bnusio.h
@@ -1,3 +1,5 @@
 namespace bnusio {
 void Init ();
+void Update ();
+void Close ();
 } // namespace bnusio
diff --git a/src/dllmain.cpp b/src/dllmain.cpp
index 8b1047a..65a09be 100644
--- a/src/dllmain.cpp
+++ b/src/dllmain.cpp
@@ -22,12 +22,12 @@ char accessCode2[21]     = "00000000000000000002";
 char chipId1[33]         = "00000000000000000000000000000001";
 char chipId2[33]         = "00000000000000000000000000000002";
 bool windowed            = false;
-bool autoIME             = false;
+bool autoIme             = false;
 bool jpLayout            = false;
-bool useLayeredFS        = false;
-bool emulateUSIO         = true;
+bool useLayeredFs        = false;
+bool emulateUsio         = true;
 bool emulateCardReader   = true;
-bool emulateQR           = true;
+bool emulateQr           = true;
 std::string datatableKey = "0000000000000000000000000000000000000000000000000000000000000000";
 std::string fumenKey     = "0000000000000000000000000000000000000000000000000000000000000000";
 
@@ -59,6 +59,11 @@ HOOK (bool, SetWindowPosition, PROC_ADDRESS ("user32.dll", "SetWindowPos"), HWND
     return originalSetWindowPosition (hWnd, hWndInsertAfter, X, Y, cx, cy, uFlags);
 }
 
+HOOK (void, ExitProcessHook, PROC_ADDRESS ("kernel32.dll", "ExitProcess"), u32 uExitCode) {
+    bnusio::Close ();
+    originalExitProcessHook (uExitCode);
+}
+
 HOOK (i32, XinputGetState, PROC_ADDRESS ("xinput9_1_0.dll", "XInputGetState")) { return ERROR_DEVICE_NOT_CONNECTED; }
 HOOK (i32, XinputSetState, PROC_ADDRESS ("xinput9_1_0.dll", "XInputSetState")) { return ERROR_DEVICE_NOT_CONNECTED; }
 HOOK (i32, XinputGetCapabilites, PROC_ADDRESS ("xinput9_1_0.dll", "XInputGetCapabilities")) { return ERROR_DEVICE_NOT_CONNECTED; }
@@ -115,7 +120,7 @@ GetGameVersion () {
 }
 
 void
-createCard () {
+CreateCard () {
     const char hexCharacterTable[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
     char buf[64]                   = {0};
     srand (time (nullptr));
@@ -163,22 +168,22 @@ DllMain (HMODULE module, DWORD reason, LPVOID reserved) {
             if (patches) version = readConfigString (patches, "version", version);
             auto emulation = openConfigSection (config, "emulation");
             if (emulation) {
-                emulateUSIO       = readConfigBool (emulation, "usio", emulateUSIO);
+                emulateUsio       = readConfigBool (emulation, "usio", emulateUsio);
                 emulateCardReader = readConfigBool (emulation, "card_reader", emulateCardReader);
-                emulateQR         = readConfigBool (emulation, "qr", emulateQR);
+                emulateQr         = readConfigBool (emulation, "qr", emulateQr);
             }
             auto graphics = openConfigSection (config, "graphics");
             if (graphics) windowed = readConfigBool (graphics, "windowed", windowed);
             auto keyboard = openConfigSection (config, "keyboard");
             if (keyboard) {
-                autoIME  = readConfigBool (keyboard, "auto_ime", autoIME);
+                autoIme  = readConfigBool (keyboard, "auto_ime", autoIme);
                 jpLayout = readConfigBool (keyboard, "jp_layout", jpLayout);
             }
-            auto layeredFS = openConfigSection (config, "layeredfs");
-            if (layeredFS) {
-                useLayeredFS = readConfigBool (layeredFS, "enabled", useLayeredFS);
-                datatableKey = readConfigString (layeredFS, "datatable_key", datatableKey);
-                fumenKey     = readConfigString (layeredFS, "fumen_key", fumenKey);
+            auto layeredFs = openConfigSection (config, "layeredfs");
+            if (layeredFs) {
+                useLayeredFs = readConfigBool (layeredFs, "enabled", useLayeredFs);
+                datatableKey = readConfigString (layeredFs, "datatable_key", datatableKey);
+                fumenKey     = readConfigString (layeredFs, "fumen_key", fumenKey);
             }
         }
 
@@ -215,7 +220,7 @@ DllMain (HMODULE module, DWORD reason, LPVOID reserved) {
             }
         }
 
-        if (!std::filesystem::exists (".\\card.ini")) createCard ();
+        if (!std::filesystem::exists (".\\card.ini")) CreateCard ();
         GetPrivateProfileStringA ("card", "accessCode1", accessCode1, accessCode1, 21, ".\\card.ini");
         GetPrivateProfileStringA ("card", "chipId1", chipId1, chipId1, 33, ".\\card.ini");
         GetPrivateProfileStringA ("card", "accessCode2", accessCode2, accessCode2, 21, ".\\card.ini");
@@ -226,6 +231,8 @@ DllMain (HMODULE module, DWORD reason, LPVOID reserved) {
         INSTALL_HOOK (CreateWindow);
         INSTALL_HOOK (SetWindowPosition);
 
+        INSTALL_HOOK (ExitProcessHook);
+
         INSTALL_HOOK (XinputGetState);
         INSTALL_HOOK (XinputSetState);
         INSTALL_HOOK (XinputGetCapabilites);
@@ -252,7 +259,7 @@ DllMain (HMODULE module, DWORD reason, LPVOID reserved) {
         patches::Audio::Init ();
         patches::Dxgi::Init ();
         patches::AmAuth::Init ();
-        if (useLayeredFS) patches::LayeredFS::Init ();
+        if (useLayeredFs) patches::LayeredFs::Init ();
     }
     return true;
 }
diff --git a/src/patches/amauth.cpp b/src/patches/amauth.cpp
index f130310..d726c5a 100644
--- a/src/patches/amauth.cpp
+++ b/src/patches/amauth.cpp
@@ -1,4 +1,3 @@
-#include <winsock2.h>
 #include <MinHook.h>
 #include <bits/stdc++.h>
 #include <format>
@@ -9,6 +8,7 @@
 #include <stdlib.h>
 #include <toml.h>
 #include <windows.h>
+#include <winsock2.h>
 #include <ws2tcpip.h>
 
 /*
diff --git a/src/patches/dxgi.cpp b/src/patches/dxgi.cpp
index 66b1eba..e932ed5 100644
--- a/src/patches/dxgi.cpp
+++ b/src/patches/dxgi.cpp
@@ -15,6 +15,7 @@
 #include "d3d12.h"
 #pragma comment(lib, "d3d12.lib")
 
+#include "bnusio.h"
 #include "patches.h"
 #include <intrin.h>
 
@@ -126,6 +127,8 @@ PresentWrap (IDXGISwapChain *pSwapChain, UINT SyncInterval, UINT Flags) {
 
     if (FpsLimiterEnable) patches::FpsLimiter::Update ();
 
+    bnusio::Update ();
+
     return g_oldPresentWrap (pSwapChain, SyncInterval, Flags);
 }
 
diff --git a/src/patches/fpslimiter.cpp b/src/patches/fpslimiter.cpp
index 02b0ffc..1375fb9 100644
--- a/src/patches/fpslimiter.cpp
+++ b/src/patches/fpslimiter.cpp
@@ -62,4 +62,4 @@ Update () {
     PerformanceCount1.QuadPart = PerformanceCount2.QuadPart >> i;
 }
 
-}
\ No newline at end of file
+} // namespace patches::FpsLimiter
diff --git a/src/patches/layeredfs.cpp b/src/patches/layeredfs.cpp
index f8b97db..f2f32f3 100644
--- a/src/patches/layeredfs.cpp
+++ b/src/patches/layeredfs.cpp
@@ -7,7 +7,7 @@ extern std::string fumenKey;
 
 #define CRCPOLY 0x82F63B78
 
-namespace patches::LayeredFS {
+namespace patches::LayeredFs {
 
 uint32_t
 CRC32C (uint32_t crc, const unsigned char *buf, size_t len) {
@@ -274,4 +274,4 @@ Init () {
     // INSTALL_HOOK (CreateFileWHook);
 }
 
-}
\ No newline at end of file
+} // namespace patches::LayeredFs
diff --git a/src/patches/patches.h b/src/patches/patches.h
index fee6ed7..9bf7927 100644
--- a/src/patches/patches.h
+++ b/src/patches/patches.h
@@ -28,7 +28,7 @@ void Update ();
 namespace AmAuth {
 void Init ();
 } // namespace AmAuth
-namespace LayeredFS {
+namespace LayeredFs {
 void Init ();
-} // namespace LayeredFS
+} // namespace LayeredFs
 } // namespace patches
diff --git a/src/patches/qr.cpp b/src/patches/qr.cpp
index c5bf8ac..a7202d9 100644
--- a/src/patches/qr.cpp
+++ b/src/patches/qr.cpp
@@ -19,7 +19,7 @@ extern Keybindings QR_IMAGE_READ;
 extern char accessCode1[21];
 extern char accessCode2[21];
 extern std::vector<HMODULE> plugins;
-extern bool emulateQR;
+extern bool emulateQr;
 
 typedef void event ();
 typedef void initQrEvent (GameVersion gameVersion);
@@ -38,15 +38,15 @@ std::string accessCode;
 std::vector<HMODULE> qrPlugins;
 bool qrPluginRegistered = false;
 
-HOOK_DYNAMIC (char, __fastcall, qrInit, i64) { return 1; }
-HOOK_DYNAMIC (char, __fastcall, qrClose, i64) { return 1; }
-HOOK_DYNAMIC (char, __fastcall, qrRead, i64 a1) {
+HOOK_DYNAMIC (char, __fastcall, QrInit, i64) { return 1; }
+HOOK_DYNAMIC (char, __fastcall, QrClose, i64) { return 1; }
+HOOK_DYNAMIC (char, __fastcall, QrRead, i64 a1) {
     *(DWORD *)(a1 + 40) = 1;
     *(DWORD *)(a1 + 16) = 1;
     *(BYTE *)(a1 + 112) = 0;
     return 1;
 }
-HOOK_DYNAMIC (i64, __fastcall, callQrUnknown, i64) { return 1; }
+HOOK_DYNAMIC (i64, __fastcall, CallQrUnknown, i64) { return 1; }
 HOOK_DYNAMIC (bool, __fastcall, Send1, i64 a1) {
     *(BYTE *)(a1 + 88) = 1;
     *(i64 *)(a1 + 32)  = *(i64 *)(a1 + 24);
@@ -60,7 +60,7 @@ HOOK_DYNAMIC (bool, __fastcall, Send2, i64 a1) {
 }
 HOOK_DYNAMIC (bool, __fastcall, Send3, i64, char) { return true; }
 HOOK_DYNAMIC (bool, __fastcall, Send4, i64, const void *, i64) { return true; }
-HOOK_DYNAMIC (i64, __fastcall, copy_data, i64, void *dest, int length) {
+HOOK_DYNAMIC (i64, __fastcall, CopyData, i64, void *dest, int length) {
     if (gState == State::CopyWait) {
         std::cout << "Copy data, length: " << length << std::endl;
 
@@ -151,7 +151,7 @@ HOOK_DYNAMIC (i64, __fastcall, copy_data, i64, void *dest, int length) {
             ZXing::ImageView image{buffer.get (), width, height, ZXing::ImageFormat::RGB};
             auto result = ReadBarcode (image);
             if (!result.isValid ()) {
-                std::cerr << "Failed to read qr: " << imagePath << " (" << ToString (result.error ()) << ")"
+                std::cerr << "Failed to read QR: " << imagePath << " (" << ToString (result.error ()) << ")"
                           << "\n";
                 gState = State::Ready;
                 return 0;
@@ -196,7 +196,7 @@ HOOK_DYNAMIC (i64, __fastcall, copy_data, i64, void *dest, int length) {
 
 void
 Update () {
-    if (!emulateQR) return;
+    if (!emulateQr) return;
     if (gState == State::Ready) {
         if (IsButtonTapped (CARD_INSERT_1)) {
             if (gameVersion != GameVersion::CHN00) return;
@@ -239,7 +239,7 @@ Update () {
 
 void
 Init () {
-    if (!emulateQR) {
+    if (!emulateQr) {
         std::cout << "[Init] QR emulation disabled" << std::endl;
         return;
     }
@@ -260,51 +260,51 @@ Init () {
     auto amHandle = (u64)GetModuleHandle ("AMFrameWork.dll");
     switch (gameVersion) {
     case GameVersion::JPN00: {
-        INSTALL_HOOK_DYNAMIC (qrInit, (LPVOID)(amHandle + 0x1b3e0));
-        INSTALL_HOOK_DYNAMIC (qrClose, (LPVOID)(amHandle + 0x1b5b0));
-        INSTALL_HOOK_DYNAMIC (qrRead, (LPVOID)(amHandle + 0x1b600));
-        INSTALL_HOOK_DYNAMIC (callQrUnknown, (LPVOID)(amHandle + 0xfd40));
-        INSTALL_HOOK_DYNAMIC (Send1, (LPVOID)(amHandle + 0x1bbb0));
-        INSTALL_HOOK_DYNAMIC (Send2, (LPVOID)(amHandle + 0x1bbf0));
-        INSTALL_HOOK_DYNAMIC (Send3, (LPVOID)(amHandle + 0x1bc60));
+        INSTALL_HOOK_DYNAMIC (QrInit, (LPVOID)(amHandle + 0x1B3E0));
+        INSTALL_HOOK_DYNAMIC (QrClose, (LPVOID)(amHandle + 0x1B5B0));
+        INSTALL_HOOK_DYNAMIC (QrRead, (LPVOID)(amHandle + 0x1B600));
+        INSTALL_HOOK_DYNAMIC (CallQrUnknown, (LPVOID)(amHandle + 0xFD40));
+        INSTALL_HOOK_DYNAMIC (Send1, (LPVOID)(amHandle + 0x1BBB0));
+        INSTALL_HOOK_DYNAMIC (Send2, (LPVOID)(amHandle + 0x1BBF0));
+        INSTALL_HOOK_DYNAMIC (Send3, (LPVOID)(amHandle + 0x1BC60));
         // JPN00 has no Send4
-        INSTALL_HOOK_DYNAMIC (copy_data, (LPVOID)(amHandle + 0x1bc30));
+        INSTALL_HOOK_DYNAMIC (CopyData, (LPVOID)(amHandle + 0x1BC30));
         break;
     }
     case GameVersion::JPN08: {
-        INSTALL_HOOK_DYNAMIC (qrInit, (LPVOID)(amHandle + 0x1BA00));
-        INSTALL_HOOK_DYNAMIC (qrClose, (LPVOID)(amHandle + 0x1BBD0));
-        INSTALL_HOOK_DYNAMIC (qrRead, (LPVOID)(amHandle + 0x1BC20));
-        INSTALL_HOOK_DYNAMIC (callQrUnknown, (LPVOID)(amHandle + 0xFD40));
+        INSTALL_HOOK_DYNAMIC (QrInit, (LPVOID)(amHandle + 0x1BA00));
+        INSTALL_HOOK_DYNAMIC (QrClose, (LPVOID)(amHandle + 0x1BBD0));
+        INSTALL_HOOK_DYNAMIC (QrRead, (LPVOID)(amHandle + 0x1BC20));
+        INSTALL_HOOK_DYNAMIC (CallQrUnknown, (LPVOID)(amHandle + 0xFD40));
         INSTALL_HOOK_DYNAMIC (Send1, (LPVOID)(amHandle + 0x1C220));
         INSTALL_HOOK_DYNAMIC (Send2, (LPVOID)(amHandle + 0x1C260));
         INSTALL_HOOK_DYNAMIC (Send3, (LPVOID)(amHandle + 0x1C2D0));
         // JPN08 has no Send4
-        INSTALL_HOOK_DYNAMIC (copy_data, (LPVOID)(amHandle + 0x1C2A0));
+        INSTALL_HOOK_DYNAMIC (CopyData, (LPVOID)(amHandle + 0x1C2A0));
         break;
     }
     case GameVersion::JPN39: {
-        INSTALL_HOOK_DYNAMIC (qrInit, (LPVOID)(amHandle + 0x1EDC0));
-        INSTALL_HOOK_DYNAMIC (qrClose, (LPVOID)(amHandle + 0x1EF60));
-        INSTALL_HOOK_DYNAMIC (qrRead, (LPVOID)(amHandle + 0x1EFB0));
-        INSTALL_HOOK_DYNAMIC (callQrUnknown, (LPVOID)(amHandle + 0x11A70));
+        INSTALL_HOOK_DYNAMIC (QrInit, (LPVOID)(amHandle + 0x1EDC0));
+        INSTALL_HOOK_DYNAMIC (QrClose, (LPVOID)(amHandle + 0x1EF60));
+        INSTALL_HOOK_DYNAMIC (QrRead, (LPVOID)(amHandle + 0x1EFB0));
+        INSTALL_HOOK_DYNAMIC (CallQrUnknown, (LPVOID)(amHandle + 0x11A70));
         INSTALL_HOOK_DYNAMIC (Send1, (LPVOID)(amHandle + 0x1F5B0));
         INSTALL_HOOK_DYNAMIC (Send2, (LPVOID)(amHandle + 0x1F5F0));
         INSTALL_HOOK_DYNAMIC (Send3, (LPVOID)(amHandle + 0x1F660));
         INSTALL_HOOK_DYNAMIC (Send4, (LPVOID)(amHandle + 0x1F690));
-        INSTALL_HOOK_DYNAMIC (copy_data, (LPVOID)(amHandle + 0x1F630));
+        INSTALL_HOOK_DYNAMIC (CopyData, (LPVOID)(amHandle + 0x1F630));
         break;
     }
     case GameVersion::CHN00: {
-        INSTALL_HOOK_DYNAMIC (qrInit, (LPVOID)(amHandle + 0x161B0));
-        INSTALL_HOOK_DYNAMIC (qrClose, (LPVOID)(amHandle + 0x16350));
-        INSTALL_HOOK_DYNAMIC (qrRead, (LPVOID)(amHandle + 0x163A0));
-        INSTALL_HOOK_DYNAMIC (callQrUnknown, (LPVOID)(amHandle + 0x8F60));
+        INSTALL_HOOK_DYNAMIC (QrInit, (LPVOID)(amHandle + 0x161B0));
+        INSTALL_HOOK_DYNAMIC (QrClose, (LPVOID)(amHandle + 0x16350));
+        INSTALL_HOOK_DYNAMIC (QrRead, (LPVOID)(amHandle + 0x163A0));
+        INSTALL_HOOK_DYNAMIC (CallQrUnknown, (LPVOID)(amHandle + 0x8F60));
         INSTALL_HOOK_DYNAMIC (Send1, (LPVOID)(amHandle + 0x16940));
         INSTALL_HOOK_DYNAMIC (Send2, (LPVOID)(amHandle + 0x16990));
         INSTALL_HOOK_DYNAMIC (Send3, (LPVOID)(amHandle + 0x16A00));
         INSTALL_HOOK_DYNAMIC (Send4, (LPVOID)(amHandle + 0x16A30));
-        INSTALL_HOOK_DYNAMIC (copy_data, (LPVOID)(amHandle + 0x169D0));
+        INSTALL_HOOK_DYNAMIC (CopyData, (LPVOID)(amHandle + 0x169D0));
         break;
     }
     default: {
diff --git a/src/patches/versions/CHN00.cpp b/src/patches/versions/CHN00.cpp
index 7f99fe7..7a51b29 100644
--- a/src/patches/versions/CHN00.cpp
+++ b/src/patches/versions/CHN00.cpp
@@ -209,13 +209,13 @@ Init () {
     INSTALL_HOOK_DYNAMIC (AMFWTerminate, (void *)(amHandle + 0x25A00));
 
     // Move various files to current directory
-    WRITE_MEMORY (amHandle + 0xC652, u8, 0xEB);                          // CreditLogPathA
-    WRITE_MEMORY (amHandle + 0xC819, u8, 0xEB);                          // CreditLogPathB
-    WRITE_MEMORY (amHandle + 0x243BA, u8, 0xEB);                         // ErrorLogPathA
-    WRITE_MEMORY (amHandle + 0x24539, u8, 0xEB);                         // ErrorLogPathB
-    WRITE_MEMORY (amHandle + 0x24901, u8, 0xEB);                         // CommonLogPathA
-    WRITE_MEMORY (amHandle + 0x24A85, u8, 0xEB);                         // CommonLogPathB
-    WRITE_MEMORY (amHandle + 0x24DD1, u8, 0x90, 0x90, 0x90, 0x90, 0x90); // BackupDataPathA
-    WRITE_MEMORY (amHandle + 0x24E47, u8, 0x90, 0x90, 0x90, 0x90, 0x90); // BackupDataPathB
+    WRITE_MEMORY (amHandle + 0xC652, u8, 0xEB);  // CreditLogPathA
+    WRITE_MEMORY (amHandle + 0xC819, u8, 0xEB);  // CreditLogPathB
+    WRITE_MEMORY (amHandle + 0x243BA, u8, 0xEB); // ErrorLogPathA
+    WRITE_MEMORY (amHandle + 0x24539, u8, 0xEB); // ErrorLogPathB
+    WRITE_MEMORY (amHandle + 0x24901, u8, 0xEB); // CommonLogPathA
+    WRITE_MEMORY (amHandle + 0x24A85, u8, 0xEB); // CommonLogPathB
+    WRITE_NOP (amHandle + 0x24DD1, 0x05);        // BackupDataPathA
+    WRITE_NOP (amHandle + 0x24E47, 0x05);        // BackupDataPathB
 }
 } // namespace patches::CHN00
diff --git a/src/patches/versions/JPN08.cpp b/src/patches/versions/JPN08.cpp
index b23316f..36fe451 100644
--- a/src/patches/versions/JPN08.cpp
+++ b/src/patches/versions/JPN08.cpp
@@ -153,7 +153,7 @@ Init () {
         WRITE_MEMORY (ASLR (0x1403067DE), u8, GENERATE_MOV (RDX_MOV, song_data));
         WRITE_MEMORY (ASLR (0x140306712), u8, GENERATE_MOV (RDX_MOV, song_data));
         WRITE_MEMORY (ASLR (0x1403069A2), u8, GENERATE_MOV (RDX_MOV, song_data));
-        WRITE_MEMORY (ASLR (0x1403069AC), u8, 0x90, 0x90, 0x90, 0x90, 0x90);
+        WRITE_NOP (ASLR (0x1403069AC), 0x05);
         // Unknown
         WRITE_MEMORY (ASLR (0x140313755), u8, GENERATE_MOV (RDX_MOV, song_data));
         WRITE_MEMORY (ASLR (0x140313A0B), u8, GENERATE_MOV (RDX_MOV, song_data));
diff --git a/src/patches/versions/JPN39.cpp b/src/patches/versions/JPN39.cpp
index 2229cb3..f303139 100644
--- a/src/patches/versions/JPN39.cpp
+++ b/src/patches/versions/JPN39.cpp
@@ -356,7 +356,7 @@ Init () {
         INSTALL_HOOK_MID (FreezeTimer);
     }
 
-    // patch to use chs font/wordlist instead of cht
+    // Use chs font/wordlist instead of cht
     if (chsPatch) {
         bool fontExistAll = true;
         const char* fontToCheck[] {"cn_30.nutexb", "cn_30.xml", "cn_32.nutexb", "cn_32.xml", "cn_64.nutexb", "cn_64.xml"};
@@ -406,14 +406,14 @@ Init () {
     INSTALL_HOOK_DYNAMIC (AMFWTerminate, (void *)(amHandle + 0x42DE0));
 
     // Move various files to current directory
-    WRITE_MEMORY (amHandle + 0x15252, u8, 0xEB);                         // CreditLogPathA
-    WRITE_MEMORY (amHandle + 0x15419, u8, 0xEB);                         // CreditLogPathB
-    WRITE_MEMORY (amHandle + 0x416DA, u8, 0xEB);                         // ErrorLogPathA
-    WRITE_MEMORY (amHandle + 0x41859, u8, 0xEB);                         // ErrorLogPathB
-    WRITE_MEMORY (amHandle + 0x41C21, u8, 0xEB);                         // CommonLogPathA
-    WRITE_MEMORY (amHandle + 0x41DA5, u8, 0xEB);                         // CommonLogPathB
-    WRITE_MEMORY (amHandle + 0x420F1, u8, 0x90, 0x90, 0x90, 0x90, 0x90); // BackupDataPathA
-    WRITE_MEMORY (amHandle + 0x42167, u8, 0x90, 0x90, 0x90, 0x90, 0x90); // BackupDataPathB
+    WRITE_MEMORY (amHandle + 0x15252, u8, 0xEB); // CreditLogPathA
+    WRITE_MEMORY (amHandle + 0x15419, u8, 0xEB); // CreditLogPathB
+    WRITE_MEMORY (amHandle + 0x416DA, u8, 0xEB); // ErrorLogPathA
+    WRITE_MEMORY (amHandle + 0x41859, u8, 0xEB); // ErrorLogPathB
+    WRITE_MEMORY (amHandle + 0x41C21, u8, 0xEB); // CommonLogPathA
+    WRITE_MEMORY (amHandle + 0x41DA5, u8, 0xEB); // CommonLogPathB
+    WRITE_NOP (amHandle + 0x420F1, 0x05);        // BackupDataPathA
+    WRITE_NOP (amHandle + 0x42167, 0x05);        // BackupDataPathB
 
     // Redirect garmc requests
     auto garmcHandle = (u64)GetModuleHandle ("garmc.dll");