diff --git a/CMakeLists.txt b/CMakeLists.txt
index aa687222a..5c33bb3e9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -132,13 +132,18 @@ option(RTMIDI       "RtMidi"
 option(FLUIDSYNTH   "FluidSynth"                                                 ON)
 option(MUNT         "MUNT"                                                       ON)
 option(VNC          "VNC renderer"                                               OFF)
-option(NEW_DYNAREC  "Use the PCem v15 (\"new\") dynamic recompiler"              OFF)
 option(MINITRACE    "Enable Chrome tracing using the modified minitrace library" OFF)
 option(GDBSTUB      "Enable GDB stub server for debugging"                       OFF)
 option(DEV_BRANCH   "Development branch"                                         OFF)
 option(DISCORD      "Discord Rich Presence support"                              ON)
 option(DEBUGREGS486 "Enable debug register opeartion on 486+ CPUs"               OFF)
 
+if((ARCH STREQUAL "arm64") OR (ARCH STREQUAL "arm"))
+    set(NEW_DYNAREC ON)
+else()
+    option(NEW_DYNAREC "Use the PCem v15 (\"new\") dynamic recompiler" OFF)
+endif()
+
 if(WIN32)
     set(QT ON)
     option(CPPTHREADS "C++11 threads" OFF)
diff --git a/src/86box.c b/src/86box.c
index 1cd0ffec8..6b64cd2ec 100644
--- a/src/86box.c
+++ b/src/86box.c
@@ -1094,8 +1094,8 @@ pc_init_modules(void)
 void
 pc_send_ca(uint16_t sc)
 {
-    if (keyboard_mode == 0x8A) {
-        /* Use R-Alt because PS/55 DOS assigns L-Alt Kanji */
+    if (keyboard_mode >= 0x81) {
+        /* Use R-Alt because PS/55 DOS and OS/2 assign L-Alt Kanji */
         keyboard_input(1, 0x1D);  /*  Ctrl key pressed */
         keyboard_input(1, 0x138); /* R-Alt key pressed */
         keyboard_input(1, sc);
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 3ae7c297e..432467f7b 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -217,7 +217,6 @@ elseif(APPLE AND NOT QT)
     COMPONENT Runtime)
 endif()
 
-
 # Install the PDB file on Windows builds
 if(MSVC)
     # CMake fully supports PDB files on MSVC-compatible compilers
diff --git a/src/codegen_new/codegen_backend_x86-64.c b/src/codegen_new/codegen_backend_x86-64.c
index 3cbca28f8..6242ea40b 100644
--- a/src/codegen_new/codegen_backend_x86-64.c
+++ b/src/codegen_new/codegen_backend_x86-64.c
@@ -315,13 +315,19 @@ codegen_backend_init(void)
 #    endif
     host_x86_CALL(block, (void *) x86gpf);
     codegen_exit_rout = &codeblock[block_current].data[block_pos];
+#ifdef _WIN64
     host_x86_ADD64_REG_IMM(block, REG_RSP, 0x38);
+#else
+    host_x86_ADD64_REG_IMM(block, REG_RSP, 0x48);
+#endif
     host_x86_POP(block, REG_R15);
     host_x86_POP(block, REG_R14);
     host_x86_POP(block, REG_R13);
     host_x86_POP(block, REG_R12);
+#ifdef _WIN64
     host_x86_POP(block, REG_RDI);
     host_x86_POP(block, REG_RSI);
+#endif
     host_x86_POP(block, REG_RBP);
     host_x86_POP(block, REG_RDX);
     host_x86_RET(block);
@@ -346,13 +352,19 @@ codegen_backend_prologue(codeblock_t *block)
     block_pos = BLOCK_START; /*Entry code*/
     host_x86_PUSH(block, REG_RBX);
     host_x86_PUSH(block, REG_RBP);
+#ifdef _WIN64
     host_x86_PUSH(block, REG_RSI);
     host_x86_PUSH(block, REG_RDI);
+#endif
     host_x86_PUSH(block, REG_R12);
     host_x86_PUSH(block, REG_R13);
     host_x86_PUSH(block, REG_R14);
     host_x86_PUSH(block, REG_R15);
+#ifdef _WIN64
     host_x86_SUB64_REG_IMM(block, REG_RSP, 0x38);
+#else
+    host_x86_SUB64_REG_IMM(block, REG_RSP, 0x48);
+#endif
     host_x86_MOV64_REG_IMM(block, REG_RBP, ((uintptr_t) &cpu_state) + 128);
     if (block->flags & CODEBLOCK_HAS_FPU) {
         host_x86_MOV32_REG_ABS(block, REG_EAX, &cpu_state.TOP);
@@ -360,19 +372,25 @@ codegen_backend_prologue(codeblock_t *block)
         host_x86_MOV32_BASE_OFFSET_REG(block, REG_RSP, IREG_TOP_diff_stack_offset, REG_EAX);
     }
     if (block->flags & CODEBLOCK_NO_IMMEDIATES)
-        host_x86_MOV64_REG_IMM(block, REG_R12, (uintptr_t) ram);
+        host_x86_MOV64_REG_IMM(block, REG_R12, ((uintptr_t) ram) + 2147483648ULL);
 }
 
 void
 codegen_backend_epilogue(codeblock_t *block)
 {
+#ifdef _WIN64
     host_x86_ADD64_REG_IMM(block, REG_RSP, 0x38);
+#else
+    host_x86_ADD64_REG_IMM(block, REG_RSP, 0x48);
+#endif
     host_x86_POP(block, REG_R15);
     host_x86_POP(block, REG_R14);
     host_x86_POP(block, REG_R13);
     host_x86_POP(block, REG_R12);
+#ifdef _WIN64
     host_x86_POP(block, REG_RDI);
     host_x86_POP(block, REG_RSI);
+#endif
     host_x86_POP(block, REG_RBP);
     host_x86_POP(block, REG_RDX);
     host_x86_RET(block);
diff --git a/src/codegen_new/codegen_backend_x86-64_defs.h b/src/codegen_new/codegen_backend_x86-64_defs.h
index 12f05f01c..7c58fec31 100644
--- a/src/codegen_new/codegen_backend_x86-64_defs.h
+++ b/src/codegen_new/codegen_backend_x86-64_defs.h
@@ -1,5 +1,5 @@
 /*RBP = cpu_state + 128
-  R12 = ram (if block->flags & CODEBLOCK_NO_IMMEDIATES)*/
+  R12 = ram + 2147483648 (if block->flags & CODEBLOCK_NO_IMMEDIATES)*/
 #define REG_AX               0
 #define REG_CX               1
 #define REG_DX               2
diff --git a/src/codegen_new/codegen_backend_x86-64_ops.c b/src/codegen_new/codegen_backend_x86-64_ops.c
index 236a86ce7..39173505b 100644
--- a/src/codegen_new/codegen_backend_x86-64_ops.c
+++ b/src/codegen_new/codegen_backend_x86-64_ops.c
@@ -505,10 +505,15 @@ host_x86_MOV8_ABS_IMM(codeblock_t *block, void *p, uint32_t imm_data)
 {
     int64_t offset = (uintptr_t) p - (((uintptr_t) &cpu_state) + 128);
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 4);
         codegen_addbyte3(block, 0xc6, 0x45, offset); /*MOVB offset[RBP], imm_data*/
         codegen_addbyte(block, imm_data);
+    } else if (offset < (1ULL << 32)) {
+        codegen_alloc_bytes(block, 7);
+        codegen_addbyte2(block, 0xc6, 0x85); /*MOVB offset[RBP], imm_data*/
+        codegen_addlong(block, offset);
+        codegen_addbyte(block, imm_data);
     } else {
         if ((uintptr_t) p >> 32)
             fatal("host_x86_MOV8_ABS_IMM - out of range %p\n", p);
@@ -523,10 +528,15 @@ host_x86_MOV16_ABS_IMM(codeblock_t *block, void *p, uint16_t imm_data)
 {
     int64_t offset = (uintptr_t) p - (((uintptr_t) &cpu_state) + 128);
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 6);
         codegen_addbyte4(block, 0x66, 0xc7, 0x45, offset); /*MOV offset[RBP], imm_data*/
         codegen_addword(block, imm_data);
+    } else if (offset < (1ULL << 32)) {
+        codegen_alloc_bytes(block, 8);
+        codegen_addbyte3(block, 0x66, 0xc7, 0x85); /*MOV offset[RBP], imm_data*/
+        codegen_addlong(block, offset);
+        codegen_addword(block, imm_data);
     } else {
         if ((uintptr_t) p >> 32)
             fatal("host_x86_MOV32_ABS_IMM - out of range %p\n", p);
@@ -541,10 +551,15 @@ host_x86_MOV32_ABS_IMM(codeblock_t *block, void *p, uint32_t imm_data)
 {
     int64_t offset = (uintptr_t) p - (((uintptr_t) &cpu_state) + 128);
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 7);
         codegen_addbyte3(block, 0xc7, 0x45, offset); /*MOV offset[RBP], imm_data*/
         codegen_addlong(block, imm_data);
+    } else if (offset < (1ULL << 32)) {
+        codegen_alloc_bytes(block, 10);
+        codegen_addbyte2(block, 0xc7, 0x85); /*MOV offset[RBP], imm_data*/
+        codegen_addlong(block, offset);
+        codegen_addlong(block, imm_data);
     } else {
         if ((uintptr_t) p >> 32)
             fatal("host_x86_MOV32_ABS_IMM - out of range %p\n", p);
@@ -563,9 +578,13 @@ host_x86_MOV8_ABS_REG(codeblock_t *block, void *p, int src_reg)
     if (src_reg & 8)
         fatal("host_x86_MOV8_ABS_REG - bad reg\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 3);
         codegen_addbyte3(block, 0x88, 0x45 | ((src_reg & 7) << 3), offset); /*MOVB offset[RBP], src_reg*/
+    } else if (offset < (1ULL << 32)) {
+        codegen_alloc_bytes(block, 6);
+        codegen_addbyte2(block, 0x88, 0x85 | ((src_reg & 7) << 3)); /*MOVB offset[RBP], src_reg*/
+        codegen_addlong(block, offset);
     } else {
         if ((uintptr_t) p >> 32)
             fatal("host_x86_MOV8_ABS_REG - out of range %p\n", p);
@@ -583,7 +602,7 @@ host_x86_MOV16_ABS_REG(codeblock_t *block, void *p, int src_reg)
     if (src_reg & 8)
         fatal("host_x86_MOV16_ABS_REG - bad reg\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 4);
         codegen_addbyte4(block, 0x66, 0x89, 0x45 | ((src_reg & 7) << 3), offset); /*MOV offset[RBP], src_reg*/
     } else if (offset < (1ULL << 32)) {
@@ -603,7 +622,7 @@ host_x86_MOV32_ABS_REG(codeblock_t *block, void *p, int src_reg)
     if (src_reg & 8)
         fatal("host_x86_MOV32_ABS_REG - bad reg\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 3);
         codegen_addbyte3(block, 0x89, 0x45 | ((src_reg & 7) << 3), offset); /*MOV offset[RBP], src_reg*/
     } else if (offset < (1ULL << 32)) {
@@ -627,9 +646,13 @@ host_x86_MOV64_ABS_REG(codeblock_t *block, void *p, int src_reg)
     if (src_reg & 8)
         fatal("host_x86_MOV64_ABS_REG - bad reg\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 4);
         codegen_addbyte4(block, 0x48, 0x89, 0x45 | ((src_reg & 7) << 3), offset); /*MOV offset[RBP], src_reg*/
+    } else if (offset < (1ULL << 32)) {
+        codegen_alloc_bytes(block, 7);
+        codegen_addbyte3(block, 0x48, 0x89, 0x85 | ((src_reg & 7) << 3)); /*MOV offset[RBP], src_reg*/
+        codegen_addlong(block, offset);
     } else {
         if ((uintptr_t) p >> 32)
             fatal("host_x86_MOV64_ABS_REG - out of range %p\n", p);
@@ -683,19 +706,19 @@ void
 host_x86_MOV8_REG_ABS(codeblock_t *block, int dst_reg, void *p)
 {
     int64_t offset     = (uintptr_t) p - (((uintptr_t) &cpu_state) + 128);
-    int64_t ram_offset = (uintptr_t) p - (uintptr_t) ram;
+    int64_t ram_offset = (uintptr_t) p - (((uintptr_t) ram) + 2147483648ULL);
 
     if (dst_reg & 8)
         fatal("host_x86_MOV8_REG_ABS reg & 8\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 3);
         codegen_addbyte3(block, 0x8a, 0x45 | ((dst_reg & 7) << 3), offset); /*MOV dst_reg, offset[RBP]*/
     } else if (offset < (1ULL << 32)) {
         codegen_alloc_bytes(block, 6);
         codegen_addbyte2(block, 0x8a, 0x85 | ((dst_reg & 7) << 3)); /*MOV dst_reg, offset[RBP]*/
         codegen_addlong(block, offset);
-    } else if ((ram_offset < (1ULL << 32)) && (block->flags & CODEBLOCK_NO_IMMEDIATES)) {
+    } else if ((ram_offset >= -2147483648LL) && (ram_offset <= 2147483647LL) && (block->flags & CODEBLOCK_NO_IMMEDIATES)) {
         codegen_alloc_bytes(block, 8);
         codegen_addbyte4(block, 0x41, 0x8a, 0x84 | ((dst_reg & 7) << 3), 0x24); /*MOV dst_reg, ram_offset[R12]*/
         codegen_addlong(block, ram_offset);
@@ -707,19 +730,19 @@ void
 host_x86_MOV16_REG_ABS(codeblock_t *block, int dst_reg, void *p)
 {
     int64_t offset     = (uintptr_t) p - (((uintptr_t) &cpu_state) + 128);
-    int64_t ram_offset = (uintptr_t) p - (uintptr_t) ram;
+    int64_t ram_offset = (uintptr_t) p - (((uintptr_t) ram) + 2147483648ULL);
 
     if (dst_reg & 8)
         fatal("host_x86_MOV16_REG_ABS reg & 8\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 4);
         codegen_addbyte4(block, 0x66, 0x8b, 0x45 | ((dst_reg & 7) << 3), offset); /*MOV dst_reg, offset[RBP]*/
     } else if (offset < (1ULL << 32)) {
         codegen_alloc_bytes(block, 7);
         codegen_addbyte3(block, 0x66, 0x8b, 0x85 | ((dst_reg & 7) << 3)); /*MOV dst_reg, offset[RBP]*/
         codegen_addlong(block, offset);
-    } else if ((ram_offset < (1ULL << 32)) && (block->flags & CODEBLOCK_NO_IMMEDIATES)) {
+    } else if ((ram_offset >= -2147483648LL) && (ram_offset <= 2147483647LL) && (block->flags & CODEBLOCK_NO_IMMEDIATES)) {
         codegen_alloc_bytes(block, 9);
         codegen_addbyte4(block, 0x66, 0x41, 0x8b, 0x84 | ((dst_reg & 7) << 3)); /*MOV dst_reg, ram_offset[R12]*/
         codegen_addbyte(block, 0x24);
@@ -737,19 +760,19 @@ void
 host_x86_MOV32_REG_ABS(codeblock_t *block, int dst_reg, void *p)
 {
     int64_t offset     = (uintptr_t) p - (((uintptr_t) &cpu_state) + 128);
-    int64_t ram_offset = (uintptr_t) p - (uintptr_t) ram;
+    int64_t ram_offset = (uintptr_t) p - (((uintptr_t) ram) + 2147483648ULL);
 
     if (dst_reg & 8)
         fatal("host_x86_MOV32_REG_ABS reg & 8\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 3);
         codegen_addbyte3(block, 0x8b, 0x45 | ((dst_reg & 7) << 3), offset); /*MOV dst_reg, offset[RBP]*/
     } else if (offset < (1ULL << 32)) {
         codegen_alloc_bytes(block, 6);
         codegen_addbyte2(block, 0x8b, 0x85 | ((dst_reg & 7) << 3)); /*MOV dst_reg, offset[RBP]*/
         codegen_addlong(block, offset);
-    } else if ((ram_offset < (1ULL << 32)) && (block->flags & CODEBLOCK_NO_IMMEDIATES)) {
+    } else if ((ram_offset >= -2147483648LL) && (ram_offset <= 2147483647LL) && (block->flags & CODEBLOCK_NO_IMMEDIATES)) {
         codegen_alloc_bytes(block, 8);
         codegen_addbyte4(block, 0x41, 0x8b, 0x84 | ((dst_reg & 7) << 3), 0x24); /*MOV dst_reg, ram_offset[R12]*/
         codegen_addlong(block, ram_offset);
@@ -769,7 +792,7 @@ host_x86_MOV64_REG_ABS(codeblock_t *block, int dst_reg, void *p)
     if (dst_reg & 8)
         fatal("host_x86_MOV64_REG_ABS reg & 8\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 4);
         codegen_addbyte4(block, 0x48, 0x8b, 0x45 | ((dst_reg & 7) << 3), offset); /*MOV dst_reg, offset[RBP]*/
     } else if (offset < (1ULL << 32)) {
@@ -822,14 +845,14 @@ host_x86_MOV16_REG_BASE_OFFSET(codeblock_t *block, int dst_reg, int base_reg, in
     if ((dst_reg & 8) || (base_reg & 8))
         fatal("host_x86_MOV16_REG_BASE_OFFSET reg & 8\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         if (base_reg == REG_RSP) {
             codegen_alloc_bytes(block, 5);
-            codegen_addbyte(block, 0x66);
+            codegen_addbyte(block, 0x66); /* MOV dst_reg, [RSP + offset] */
             codegen_addbyte4(block, 0x8b, 0x40 | base_reg | (dst_reg << 3), 0x24, offset);
         } else {
             codegen_alloc_bytes(block, 4);
-            codegen_addbyte4(block, 0x66, 0x8b, 0x40 | base_reg | (dst_reg << 3), offset);
+            codegen_addbyte4(block, 0x66, 0x8b, 0x40 | base_reg | (dst_reg << 3), offset);  /* MOV dst_reg, [base_reg + offset] */
         }
     } else
         fatal("MOV16_REG_BASE_OFFSET - offset %i\n", offset);
@@ -840,13 +863,13 @@ host_x86_MOV32_REG_BASE_OFFSET(codeblock_t *block, int dst_reg, int base_reg, in
     if ((dst_reg & 8) || (base_reg & 8))
         fatal("host_x86_MOV32_REG_BASE_OFFSET reg & 8\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         if (base_reg == REG_RSP) {
             codegen_alloc_bytes(block, 4);
-            codegen_addbyte4(block, 0x8b, 0x40 | base_reg | (dst_reg << 3), 0x24, offset);
+            codegen_addbyte4(block, 0x8b, 0x40 | base_reg | (dst_reg << 3), 0x24, offset); /* MOV dst_reg, [RSP + offset] */
         } else {
             codegen_alloc_bytes(block, 3);
-            codegen_addbyte3(block, 0x8b, 0x40 | base_reg | (dst_reg << 3), offset);
+            codegen_addbyte3(block, 0x8b, 0x40 | base_reg | (dst_reg << 3), offset);  /* MOV dst_reg, [base_reg + offset] */
         }
     } else
         fatal("MOV32_REG_BASE_OFFSET - offset %i\n", offset);
@@ -857,14 +880,14 @@ host_x86_MOV64_REG_BASE_OFFSET(codeblock_t *block, int dst_reg, int base_reg, in
     if ((dst_reg & 8) || (base_reg & 8))
         fatal("host_x86_MOV64_REG_BASE_OFFSET reg & 8\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         if (base_reg == REG_RSP) {
             codegen_alloc_bytes(block, 5);
-            codegen_addbyte(block, 0x48);
+            codegen_addbyte(block, 0x48); /* MOV dst_reg, [RSP + offset] */
             codegen_addbyte4(block, 0x8b, 0x40 | base_reg | (dst_reg << 3), 0x24, offset);
         } else {
             codegen_alloc_bytes(block, 4);
-            codegen_addbyte4(block, 0x48, 0x8b, 0x40 | base_reg | (dst_reg << 3), offset);
+            codegen_addbyte4(block, 0x48, 0x8b, 0x40 | base_reg | (dst_reg << 3), offset);  /* MOV dst_reg, [base_reg + offset] */
         }
     } else
         fatal("MOV32_REG_BASE_OFFSET - offset %i\n", offset);
@@ -876,13 +899,13 @@ host_x86_MOV32_BASE_OFFSET_REG(codeblock_t *block, int base_reg, int offset, int
     if ((src_reg & 8) || (base_reg & 8))
         fatal("host_x86_MOV32_BASE_OFFSET_REG reg & 8\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         if (base_reg == REG_RSP) {
-            codegen_alloc_bytes(block, 4);
+            codegen_alloc_bytes(block, 4); /* MOV [RSP + offset], src_reg*/
             codegen_addbyte4(block, 0x89, 0x40 | base_reg | (src_reg << 3), 0x24, offset);
         } else {
             codegen_alloc_bytes(block, 3);
-            codegen_addbyte3(block, 0x89, 0x40 | base_reg | (src_reg << 3), offset);
+            codegen_addbyte3(block, 0x89, 0x40 | base_reg | (src_reg << 3), offset);  /* MOV [base_reg + offset], src_reg*/
         }
     } else
         fatal("MOV32_BASE_OFFSET_REG - offset %i\n", offset);
@@ -893,14 +916,14 @@ host_x86_MOV64_BASE_OFFSET_REG(codeblock_t *block, int base_reg, int offset, int
     if ((src_reg & 8) || (base_reg & 8))
         fatal("host_x86_MOV64_BASE_OFFSET_REG reg & 8\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         if (base_reg == REG_RSP) {
             codegen_alloc_bytes(block, 5);
-            codegen_addbyte(block, 0x48);
+            codegen_addbyte(block, 0x48); /* MOV [RSP + offset], src_reg*/
             codegen_addbyte4(block, 0x89, 0x40 | base_reg | (src_reg << 3), 0x24, offset);
         } else {
             codegen_alloc_bytes(block, 4);
-            codegen_addbyte4(block, 0x48, 0x89, 0x40 | base_reg | (src_reg << 3), offset);
+            codegen_addbyte4(block, 0x48, 0x89, 0x40 | base_reg | (src_reg << 3), offset);  /* MOV [base_reg + offset], src_reg*/
         }
     } else
         fatal("MOV64_BASE_OFFSET_REG - offset %i\n", offset);
@@ -912,14 +935,14 @@ host_x86_MOV32_BASE_OFFSET_IMM(codeblock_t *block, int base_reg, int offset, uin
     if (base_reg & 8)
         fatal("host_x86_MOV32_BASE_OFFSET_IMM reg & 8\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         if (base_reg == REG_RSP) {
             codegen_alloc_bytes(block, 8);
-            codegen_addbyte4(block, 0xc7, 0x40 | base_reg, 0x24, offset);
+            codegen_addbyte4(block, 0xc7, 0x40 | base_reg, 0x24, offset); /* MOV [RSP + offset], imm_data */
             codegen_addlong(block, imm_data);
         } else {
             codegen_alloc_bytes(block, 7);
-            codegen_addbyte3(block, 0xc7, 0x40 | base_reg, offset);
+            codegen_addbyte3(block, 0xc7, 0x40 | base_reg, offset);  /* MOV [base_reg + offset], src_reg*/
             codegen_addlong(block, imm_data);
         }
     } else
@@ -1084,16 +1107,16 @@ void
 host_x86_MOVZX_REG_ABS_16_8(codeblock_t *block, int dst_reg, void *p)
 {
     int64_t offset     = (uintptr_t) p - (((uintptr_t) &cpu_state) + 128);
-    int64_t ram_offset = (uintptr_t) p - (uintptr_t) ram;
+    int64_t ram_offset = (uintptr_t) p - (((uintptr_t) ram) + 2147483648ULL);
 
     if (dst_reg & 8)
         fatal("host_x86_MOVZX_REG_ABS_16_8 - bad reg\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 5);
         codegen_addbyte(block, 0x66);
         codegen_addbyte4(block, 0x0f, 0xb6, 0x45 | ((dst_reg & 7) << 3), offset); /*MOVZX dst_reg, offset[RBP]*/
-    } else if ((ram_offset < (1ULL << 32)) && (block->flags & CODEBLOCK_NO_IMMEDIATES)) {
+    } else if ((ram_offset >= -2147483648LL) && (ram_offset <= 2147483647LL) && (block->flags & CODEBLOCK_NO_IMMEDIATES)) {
         codegen_alloc_bytes(block, 10);
         codegen_addbyte2(block, 0x66, 0x41);
         codegen_addbyte4(block, 0x0f, 0xb6, 0x84 | ((dst_reg & 7) << 3), 0x24); /*MOVZX dst_reg, ram_offset[R12]*/
@@ -1111,14 +1134,14 @@ void
 host_x86_MOVZX_REG_ABS_32_8(codeblock_t *block, int dst_reg, void *p)
 {
     int64_t offset     = (uintptr_t) p - (((uintptr_t) &cpu_state) + 128);
-    int64_t ram_offset = (uintptr_t) p - (uintptr_t) ram;
+    int64_t ram_offset = (uintptr_t) p - (((uintptr_t) ram) + 2147483648ULL);
 
 #if 0
     if (dst_reg & 8)
         fatal("host_x86_MOVZX_REG_ABS_32_8 - bad reg\n");
 #endif
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         if (dst_reg & 8) {
             codegen_alloc_bytes(block, 5);
             codegen_addbyte(block, 0x44);
@@ -1127,7 +1150,7 @@ host_x86_MOVZX_REG_ABS_32_8(codeblock_t *block, int dst_reg, void *p)
             codegen_alloc_bytes(block, 4);
             codegen_addbyte4(block, 0x0f, 0xb6, 0x45 | ((dst_reg & 7) << 3), offset); /*MOVZX dst_reg, offset[RBP]*/
         }
-    } else if ((ram_offset < (1ULL << 32)) && (block->flags & CODEBLOCK_NO_IMMEDIATES)) {
+    } else if ((ram_offset >= -2147483648LL) && (ram_offset <= 2147483647LL) && (block->flags & CODEBLOCK_NO_IMMEDIATES)) {
         if (dst_reg & 8)
             fatal("host_x86_MOVZX_REG_ABS_32_8 - bad reg\n");
 
@@ -1150,15 +1173,15 @@ void
 host_x86_MOVZX_REG_ABS_32_16(codeblock_t *block, int dst_reg, void *p)
 {
     int64_t offset     = (uintptr_t) p - (((uintptr_t) &cpu_state) + 128);
-    int64_t ram_offset = (uintptr_t) p - (uintptr_t) ram;
+    int64_t ram_offset = (uintptr_t) p - (((uintptr_t) ram) + 2147483648ULL);
 
     if (dst_reg & 8)
         fatal("host_x86_MOVZX_REG_ABS_32_16 - bad reg\n");
 
-    if (offset >= -128 && offset < 127) {
+    if (offset >= -128 && offset <= 127) {
         codegen_alloc_bytes(block, 4);
         codegen_addbyte4(block, 0x0f, 0xb7, 0x45 | ((dst_reg & 7) << 3), offset); /*MOVZX dst_reg, offset[RBP]*/
-    } else if ((ram_offset < (1ULL << 32)) && (block->flags & CODEBLOCK_NO_IMMEDIATES)) {
+    } else if ((ram_offset >= -2147483648LL) && (ram_offset <= 2147483647LL) && (block->flags & CODEBLOCK_NO_IMMEDIATES)) {
         codegen_alloc_bytes(block, 9);
         codegen_addbyte(block, 0x41);
         codegen_addbyte4(block, 0x0f, 0xb7, 0x84 | ((dst_reg & 7) << 3), 0x24); /*MOVZX dst_reg, ram_offset[R12]*/
diff --git a/src/device.c b/src/device.c
index 8b2ddf35e..434bd3776 100644
--- a/src/device.c
+++ b/src/device.c
@@ -490,7 +490,7 @@ device_get_name(const device_t *dev, int bus, char *name)
     const char *sbus = NULL;
     const char *fbus;
     char       *tname;
-    char        pbus[12] = { 0 };
+    char        pbus[16] = { 0 };
 
     if (dev == NULL)
         return;
diff --git a/src/device/cassette.c b/src/device/cassette.c
index ac79edff2..5cde2fbd0 100644
--- a/src/device/cassette.c
+++ b/src/device/cassette.c
@@ -715,7 +715,7 @@ cassette_init(UNUSED(const device_t *info))
 const device_t cassette_device = {
     .name          = "IBM PC/PCjr Cassette Device",
     .internal_name = "cassette",
-    .flags         = 0,
+    .flags         = DEVICE_CASETTE,
     .local         = 0,
     .init          = cassette_init,
     .close         = cassette_close,
diff --git a/src/device/isartc.c b/src/device/isartc.c
index 63ce0b065..5d6b4aea4 100644
--- a/src/device/isartc.c
+++ b/src/device/isartc.c
@@ -862,7 +862,7 @@ static const device_config_t mm58167_config[] = {
 static const device_t mm58167_device = {
     .name          = "Generic MM58167 RTC",
     .internal_name = "rtc_mm58167",
-    .flags         = DEVICE_ISA,
+    .flags         = DEVICE_ISA | DEVICE_SIDECAR,
     .local         = ISARTC_MM58167,
     .init          = isartc_init,
     .close         = isartc_close,
diff --git a/src/device/keyboard.c b/src/device/keyboard.c
index 2b851f36c..58d5a4724 100644
--- a/src/device/keyboard.c
+++ b/src/device/keyboard.c
@@ -85,34 +85,6 @@ typedef struct {
     const uint8_t brk[4];
 } scconvtbl;
 
-/* Is this a left-over of something planned earlier? */
-#ifdef USE_SCCONV55_82
-static scconvtbl scconv55_82[18 + 1] =
-{
-    // clang-format off
-      {.sc = 0x02 , .mk = {    0x5f,   0 }, .brk = { 0xf0, 0x5f,   0 } }, /* '1' -> 'Clear/ /SysRq' */
-      {.sc = 0x03 , .mk = {    0x48,   0 }, .brk = { 0xf0, 0x48,   0 } }, /* '2' -> '終了 (Exit)' */
-      {.sc = 0x04 , .mk = {    0x38,   0 }, .brk = { 0xf0, 0x38,   0 } }, /* '3' -> 'メッセージ (Message)/ /応答 (Respond)' */
-      {.sc = 0x05 , .mk = {    0x30,   0 }, .brk = { 0xf0, 0x30,   0 } }, /* '4' -> 'サイズ変換 (Change Size)/ /横倍角 (2x Width)' */
-      {.sc = 0x06 , .mk = {    0x20,   0 }, .brk = { 0xf0, 0x20,   0 } }, /* '5' -> '単語登録 (Register Word)/ /再交換 (Re-change)' */
-      {.sc = 0x07 , .mk = {    0x28,   0 }, .brk = { 0xf0, 0x28,   0 } }, /* '6' -> '漢字 (Kanji)/ /番号 (Number)' */
-      {.sc = 0x08 , .mk = {    0x60,   0 }, .brk = { 0xf0, 0x60,   0 } }, /* '7' -> '取消 (Cancel)' */
-      {.sc = 0x09 , .mk = {    0x40,   0 }, .brk = { 0xf0, 0x40,   0 } }, /* '8' -> 'コピー (Copy)/ /移動 (Move)' */
-      {.sc = 0x3d , .mk = {    0x1f,   0 }, .brk = { 0xf0, 0x1f,   0 } }, /* 'F3' -> 'Cr Bnk/領域呼出 (Call Range)/All Cr/登録 (Register)' */
-      {.sc = 0x3e , .mk = {    0x27,   0 }, .brk = { 0xf0, 0x27,   0 } }, /* 'F4' -> '割込み (Interrupt)' */
-      {.sc = 0x3f , .mk = {    0x2f,   0 }, .brk = { 0xf0, 0x2f,   0 } }, /* 'F5' -> 'UF1' */
-      {.sc = 0x40 , .mk = {    0x5e,   0 }, .brk = { 0xf0, 0x5e,   0 } }, /* 'F6' -> 'UF2' */
-      {.sc = 0x41 , .mk = {    0x08,   0 }, .brk = { 0xf0, 0x08,   0 } }, /* 'F7' -> 'UF3' */
-      {.sc = 0x42 , .mk = {    0x10,   0 }, .brk = { 0xf0, 0x10,   0 } }, /* 'F8' -> 'UF4' */
-      {.sc = 0x43 , .mk = {    0x50,   0 }, .brk = { 0xf0, 0x50,   0 } }, /* 'F9' -> 'EOF/Erase/ErInp' */
-      {.sc = 0x44 , .mk = {    0x18,   0 }, .brk = { 0xf0, 0x18,   0 } }, /* 'F10' -> 'Attn/ /CrSel' */
-      {.sc = 0x57 , .mk = {    0x17,   0 }, .brk = { 0xf0, 0x17,   0 } }, /* 'F11' -> 'PA1/ /DvCncl' */
-      {.sc = 0x58 , .mk = {    0x37,   0 }, .brk = { 0xf0, 0x37,   0 } }, /* 'F12' -> 'PA2/ /PA3' */
-      {.sc = 0 , .mk = { 0 }, .brk = { 0 } } /* end */
-    // clang-format on
-};
-#endif
-
 static scconvtbl scconv55_8a[18 + 1] =
 {
     // clang-format off
@@ -360,6 +332,20 @@ keyboard_input(int down, uint16_t scan)
     }
 }
 
+void
+keyboard_all_up(void)
+{
+    for (unsigned short i = 0; i < 0x200; i++) {
+        if (recv_key_ui[i]) {
+            recv_key_ui[i] = 0;
+        }
+        if (recv_key[i]) {
+            recv_key[i] = 0;
+            key_process(i, 0);
+        }
+    }
+}
+
 static uint8_t
 keyboard_do_break(uint16_t scan)
 {
diff --git a/src/device/keyboard_at.c b/src/device/keyboard_at.c
index 5c66029ad..e61b8547a 100644
--- a/src/device/keyboard_at.c
+++ b/src/device/keyboard_at.c
@@ -25,6 +25,7 @@
 #include <86box/device.h>
 #include <86box/keyboard.h>
 #include <86box/mouse.h>
+#include <86box/machine.h>
 
 #define FLAG_PS2       0x08  /* dev is AT or PS/2 */
 #define FLAG_AT        0x00  /* dev is AT or PS/2 */
@@ -1639,22 +1640,1057 @@ static const scancode scancode_set3[512] = {
     5576 keyboards kept 101-key compatible scancode sets because PS/55 had to support western (PS/2) versions of operating systems.
     The default scancode set is 2.
     In Japanese DOS, the keyboard driver confirms its keyboard ID, and sends a command to switch the scancode set to 8Ah.
-    Japanese OS/2 and Windows use the scancode set 82h.
+    Japanese OS/2 and Windows use the scancode set 81h or 82h.
 
-    The OADG standard (1991-) and modern Japanese keyboards use the same keyboard ID and scancode set number as PS/2 keyboards use.
+    The OADG standard (1991-) and modern Japanese keyboards use the same keyboard ID and scancode set ID as PS/2 keyboards use.
     Three extra scancode sets are no longer available. Instead, language input keys are available in scancode set 1 and 2.
     However, their physical key layout is a bit-paired layout.
     Users have to choose the correct keyboard layout on setup, and the driver needs to remap keys.
 
-    Currently, scancode set 81h and 82h are not implemented yet. Also, the key layout is designed to match with the Japanese keyboard.
+    Currently, the key mapping is designed to match with the Japanese layout keyboard.
 
      [Japanese DOS and keyboard scancode set comparison]
     |                           | K3.3 | J4.0 | J5.0 | J4.0/V | J5.0/V | OS/2 J1.3 | DOS 5(US)|
     |---------------------------|:----:|:----:|:----:|:------:|:------:|:---------:|:--------:|
-    | IBM 101-key               |  n/a |  n/a |  n/a |  n/a   |    2   |    n/a    |     2    |
-    | IBM-J 5576-00x (obsolete) |  8Ah |  8Ah |  8Ah |   82h  |   82h  |     82h   |     2    |
-    | OADG (modern Japanese)    |  n/a |  n/a |  n/a |    2   |    2   |      2    |     2    | */
+    | IBM 101 US English        |  n/a |  n/a |  n/a |    2   |    2   |      2    |     2    |
+    | IBM-J 5576-00x (obsolete) |  8Ah |  8Ah |  8Ah |   82h  |   82h  |     81h   |     2    |
+    | OADG (modern Japanese)    |  n/a |  n/a |  n/a |    2   |    2   |      2    |     2    |
+*/
 
+/* Scancode set 81h : Set 01 with language specific keys support used by OS/2 */
+static const scancode scancode_set81[512] = {
+    // clang-format off
+      { .mk = {            0 }, .brk = {                   0 } }, /* 000 */
+      { .mk = {      0x01, 0 }, .brk = {             0x81, 0 } }, /* 001 */
+      { .mk = {      0x02, 0 }, .brk = {             0x82, 0 } }, /* 002 */
+      { .mk = {      0x03, 0 }, .brk = {             0x83, 0 } }, /* 003 */
+      { .mk = {      0x04, 0 }, .brk = {             0x84, 0 } }, /* 004 */
+      { .mk = {      0x05, 0 }, .brk = {             0x85, 0 } }, /* 005 */
+      { .mk = {      0x06, 0 }, .brk = {             0x86, 0 } }, /* 006 */
+      { .mk = {      0x07, 0 }, .brk = {             0x87, 0 } }, /* 007 */
+      { .mk = {      0x08, 0 }, .brk = {             0x88, 0 } }, /* 008 */
+      { .mk = {      0x09, 0 }, .brk = {             0x89, 0 } }, /* 009 */
+      { .mk = {      0x0a, 0 }, .brk = {             0x8a, 0 } }, /* 00a */
+      { .mk = {      0x0b, 0 }, .brk = {             0x8b, 0 } }, /* 00b */
+      { .mk = {      0x0c, 0 }, .brk = {             0x8c, 0 } }, /* 00c */
+      { .mk = {      0x0d, 0 }, .brk = {             0x8d, 0 } }, /* 00d */
+      { .mk = {      0x0e, 0 }, .brk = {             0x8e, 0 } }, /* 00e */
+      { .mk = {      0x0f, 0 }, .brk = {             0x8f, 0 } }, /* 00f */
+      { .mk = {      0x10, 0 }, .brk = {             0x90, 0 } }, /* 010 */
+      { .mk = {      0x11, 0 }, .brk = {             0x91, 0 } }, /* 011 */
+      { .mk = {      0x12, 0 }, .brk = {             0x92, 0 } }, /* 012 */
+      { .mk = {      0x13, 0 }, .brk = {             0x93, 0 } }, /* 013 */
+      { .mk = {      0x14, 0 }, .brk = {             0x94, 0 } }, /* 014 */
+      { .mk = {      0x15, 0 }, .brk = {             0x95, 0 } }, /* 015 */
+      { .mk = {      0x16, 0 }, .brk = {             0x96, 0 } }, /* 016 */
+      { .mk = {      0x17, 0 }, .brk = {             0x97, 0 } }, /* 017 */
+      { .mk = {      0x18, 0 }, .brk = {             0x98, 0 } }, /* 018 */
+      { .mk = {      0x19, 0 }, .brk = {             0x99, 0 } }, /* 019 */
+      { .mk = {      0x1a, 0 }, .brk = {             0x9a, 0 } }, /* 01a */
+      { .mk = {      0x1b, 0 }, .brk = {             0x9b, 0 } }, /* 01b */
+      { .mk = {      0x1c, 0 }, .brk = {             0x9c, 0 } }, /* 01c */
+      { .mk = {      0x1d, 0 }, .brk = {             0x9d, 0 } }, /* 01d */
+      { .mk = {      0x1e, 0 }, .brk = {             0x9e, 0 } }, /* 01e */
+      { .mk = {      0x1f, 0 }, .brk = {             0x9f, 0 } }, /* 01f */
+      { .mk = {      0x20, 0 }, .brk = {             0xa0, 0 } }, /* 020 */
+      { .mk = {      0x21, 0 }, .brk = {             0xa1, 0 } }, /* 021 */
+      { .mk = {      0x22, 0 }, .brk = {             0xa2, 0 } }, /* 022 */
+      { .mk = {      0x23, 0 }, .brk = {             0xa3, 0 } }, /* 023 */
+      { .mk = {      0x24, 0 }, .brk = {             0xa4, 0 } }, /* 024 */
+      { .mk = {      0x25, 0 }, .brk = {             0xa5, 0 } }, /* 025 */
+      { .mk = {      0x26, 0 }, .brk = {             0xa6, 0 } }, /* 026 */
+      { .mk = {      0x27, 0 }, .brk = {             0xa7, 0 } }, /* 027 */
+      { .mk = {      0x28, 0 }, .brk = {             0xa8, 0 } }, /* 028* */
+      { .mk = {      0x77, 0 }, .brk = {             0xf7, 0 } }, /* 029 0x45 Hankaku, Zenkaku */
+      { .mk = {      0x2a, 0 }, .brk = {             0xaa, 0 } }, /* 02a */
+      { .mk = {      0x1b, 0 }, .brk = {             0x9b, 0 } }, /* 02b 0x17 Mu */
+      { .mk = {      0x2c, 0 }, .brk = {             0xac, 0 } }, /* 02c */
+      { .mk = {      0x2d, 0 }, .brk = {             0xad, 0 } }, /* 02d */
+      { .mk = {      0x2e, 0 }, .brk = {             0xae, 0 } }, /* 02e */
+      { .mk = {      0x2f, 0 }, .brk = {             0xaf, 0 } }, /* 02f */
+      { .mk = {      0x30, 0 }, .brk = {             0xb0, 0 } }, /* 030 */
+      { .mk = {      0x31, 0 }, .brk = {             0xb1, 0 } }, /* 031 */
+      { .mk = {      0x32, 0 }, .brk = {             0xb2, 0 } }, /* 032 */
+      { .mk = {      0x33, 0 }, .brk = {             0xb3, 0 } }, /* 033 */
+      { .mk = {      0x34, 0 }, .brk = {             0xb4, 0 } }, /* 034 */
+      { .mk = {      0x35, 0 }, .brk = {             0xb5, 0 } }, /* 035 */
+      { .mk = {      0x36, 0 }, .brk = {             0xb6, 0 } }, /* 036 */
+      { .mk = {      0x37, 0 }, .brk = {             0xb7, 0 } }, /* 037 * (asterisk) */
+      { .mk = {      0x70, 0 }, .brk = {             0xf0, 0 } }, /* 038 0x3A LALT = Kanji */
+      { .mk = {      0x39, 0 }, .brk = {             0xb9, 0 } }, /* 039 */
+      { .mk = {      0x3a, 0 }, .brk = {             0xba, 0 } }, /* 03a */
+      { .mk = {      0x3b, 0 }, .brk = {             0xbb, 0 } }, /* 03b */
+      { .mk = {      0x3c, 0 }, .brk = {             0xbc, 0 } }, /* 03c */
+      { .mk = {      0x3d, 0 }, .brk = {             0xbd, 0 } }, /* 03d */
+      { .mk = {      0x3e, 0 }, .brk = {             0xbe, 0 } }, /* 03e */
+      { .mk = {      0x3f, 0 }, .brk = {             0xbf, 0 } }, /* 03f */
+      { .mk = {      0x40, 0 }, .brk = {             0xc0, 0 } }, /* 040 */
+      { .mk = {      0x41, 0 }, .brk = {             0xc1, 0 } }, /* 041 */
+      { .mk = {      0x42, 0 }, .brk = {             0xc2, 0 } }, /* 042 */
+      { .mk = {      0x43, 0 }, .brk = {             0xc3, 0 } }, /* 043 */
+      { .mk = {      0x44, 0 }, .brk = {             0xc4, 0 } }, /* 044 */
+      { .mk = {      0x45, 0 }, .brk = {             0xc5, 0 } }, /* 045 NUMLOCKCLEAR -> Shift + SCRLOCK :TODO */
+      { .mk = {      0x46, 0 }, .brk = {             0xc6, 0 } }, /* 046 0x75 SCROLLLOCK */
+      { .mk = {      0x47, 0 }, .brk = {             0xc7, 0 } }, /* 047 */
+      { .mk = {      0x48, 0 }, .brk = {             0xc8, 0 } }, /* 048 */
+      { .mk = {      0x49, 0 }, .brk = {             0xc9, 0 } }, /* 049 */
+      { .mk = {      0x4a, 0 }, .brk = {             0xca, 0 } }, /* 04a */
+      { .mk = {      0x4b, 0 }, .brk = {             0xcb, 0 } }, /* 04b */
+      { .mk = {      0x4c, 0 }, .brk = {             0xcc, 0 } }, /* 04c */
+      { .mk = {      0x4d, 0 }, .brk = {             0xcd, 0 } }, /* 04d */
+      { .mk = {      0x4e, 0 }, .brk = {             0xce, 0 } }, /* 04e */
+      { .mk = {      0x4f, 0 }, .brk = {             0xcf, 0 } }, /* 04f */
+      { .mk = {      0x50, 0 }, .brk = {             0xd0, 0 } }, /* 050 */
+      { .mk = {      0x51, 0 }, .brk = {             0xd1, 0 } }, /* 051 */
+      { .mk = {      0x52, 0 }, .brk = {             0xd2, 0 } }, /* 052 */
+      { .mk = {      0x53, 0 }, .brk = {             0xd3, 0 } }, /* 053 */
+      { .mk = {      0x54, 0 }, .brk = {             0xd4, 0 } }, /* 054 */
+      { .mk = {      0x55, 0 }, .brk = {             0xd5, 0 } }, /* 055 */
+      { .mk = {      0x56, 0 }, .brk = {             0xd6, 0 } }, /* 056 */
+      { .mk = {      0x57, 0 }, .brk = {             0xd7, 0 } }, /* 057 F11 */
+      { .mk = {      0x58, 0 }, .brk = {             0xd8, 0 } }, /* 058 F12 */
+      { .mk = {      0x59, 0 }, .brk = {             0xd9, 0 } }, /* 059 */
+      { .mk = {      0x5a, 0 }, .brk = {             0xda, 0 } }, /* 05a */
+      { .mk = {      0x5b, 0 }, .brk = {             0xdb, 0 } }, /* 05b */
+      { .mk = {      0x5c, 0 }, .brk = {             0xdc, 0 } }, /* 05c */
+      { .mk = {      0x5d, 0 }, .brk = {             0xdd, 0 } }, /* 05d */
+      { .mk = {      0x5e, 0 }, .brk = {             0xde, 0 } }, /* 05e */
+      { .mk = {      0x5f, 0 }, .brk = {             0xdf, 0 } }, /* 05f */
+      { .mk = {      0x60, 0 }, .brk = {             0xe0, 0 } }, /* 060 */
+      { .mk = {      0x61, 0 }, .brk = {             0xe1, 0 } }, /* 061 */
+      { .mk = {      0x62, 0 }, .brk = {             0xe2, 0 } }, /* 062 */
+      { .mk = {      0x63, 0 }, .brk = {             0xe3, 0 } }, /* 063 */
+      { .mk = {      0x64, 0 }, .brk = {             0xe4, 0 } }, /* 064 */
+      { .mk = {      0x65, 0 }, .brk = {             0xe5, 0 } }, /* 065 */
+      { .mk = {      0x66, 0 }, .brk = {             0xe6, 0 } }, /* 066 */
+      { .mk = {      0x67, 0 }, .brk = {             0xe7, 0 } }, /* 067 */
+      { .mk = {      0x68, 0 }, .brk = {             0xe8, 0 } }, /* 068 */
+      { .mk = {      0x69, 0 }, .brk = {             0xe9, 0 } }, /* 069 */
+      { .mk = {      0x6a, 0 }, .brk = {             0xea, 0 } }, /* 06a */
+      { .mk = {      0x6b, 0 }, .brk = {             0xeb, 0 } }, /* 06b */
+      { .mk = {      0x6c, 0 }, .brk = {             0xec, 0 } }, /* 06c */
+      { .mk = {      0x6d, 0 }, .brk = {             0xed, 0 } }, /* 06d */
+      { .mk = {      0x6e, 0 }, .brk = {             0xee, 0 } }, /* 06e */
+      { .mk = {      0x6f, 0 }, .brk = {             0xef, 0 } }, /* 06f */
+      { .mk = {0xe0, 0x38, 0 }, .brk = { 0xe0,       0xb8, 0 } }, /* 070 0x36 Kana */
+      { .mk = {      0x71, 0 }, .brk = {             0xf1, 0 } }, /* 071 */
+      { .mk = {      0x72, 0 }, .brk = {             0xf2, 0 } }, /* 072 */
+      { .mk = {      0x73, 0 }, .brk = {             0xf3, 0 } }, /* 073 0x0b Ro, Underline */
+      { .mk = {      0x74, 0 }, .brk = {             0xf4, 0 } }, /* 074 */
+      { .mk = {      0x75, 0 }, .brk = {             0xf5, 0 } }, /* 075 */
+      { .mk = {      0x76, 0 }, .brk = {             0xf6, 0 } }, /* 076 */
+      { .mk = {      0x77, 0 }, .brk = {             0xf7, 0 } }, /* 077 */
+      { .mk = {      0x78, 0 }, .brk = {             0xf8, 0 } }, /* 078 */
+      { .mk = {      0x79, 0 }, .brk = {             0xf9, 0 } }, /* 079 0x35 Henkan */
+      { .mk = {      0x7a, 0 }, .brk = {             0xfa, 0 } }, /* 07a */
+      { .mk = {      0x7b, 0 }, .brk = {             0xfb, 0 } }, /* 07b 0x33 Muhenkan */
+      { .mk = {      0x7c, 0 }, .brk = {             0xfc, 0 } }, /* 07c */
+      { .mk = {      0x2b, 0 }, .brk = {             0xab, 0 } }, /* 07d 0x30 Yen, Vertical line */
+      { .mk = {      0x7e, 0 }, .brk = {             0xfe, 0 } }, /* 07e */
+      { .mk = {      0x7f, 0 }, .brk = {             0xff, 0 } }, /* 07f */
+      { .mk = {      0x80, 0 }, .brk = {                   0 } }, /* 080 */
+      { .mk = {      0x81, 0 }, .brk = {                   0 } }, /* 081 */
+      { .mk = {      0x82, 0 }, .brk = {                   0 } }, /* 082 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 083 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 084 */
+      { .mk = {      0x85, 0 }, .brk = {                   0 } }, /* 085 */
+      { .mk = {      0x86, 0 }, .brk = {                   0 } }, /* 086 */
+      { .mk = {      0x87, 0 }, .brk = {                   0 } }, /* 087 */
+      { .mk = {      0x88, 0 }, .brk = {                   0 } }, /* 088 */
+      { .mk = {      0x89, 0 }, .brk = {                   0 } }, /* 089 */
+      { .mk = {      0x8a, 0 }, .brk = {                   0 } }, /* 08a */
+      { .mk = {      0x8b, 0 }, .brk = {                   0 } }, /* 08b */
+      { .mk = {      0x8c, 0 }, .brk = {                   0 } }, /* 08c */
+      { .mk = {      0x8d, 0 }, .brk = {                   0 } }, /* 08d */
+      { .mk = {      0x8e, 0 }, .brk = {                   0 } }, /* 08e */
+      { .mk = {      0x8f, 0 }, .brk = {                   0 } }, /* 08f */
+      { .mk = {      0x90, 0 }, .brk = {                   0 } }, /* 090 */
+      { .mk = {      0x91, 0 }, .brk = {                   0 } }, /* 091 */
+      { .mk = {      0x92, 0 }, .brk = {                   0 } }, /* 092 */
+      { .mk = {      0x93, 0 }, .brk = {                   0 } }, /* 093 */
+      { .mk = {      0x94, 0 }, .brk = {                   0 } }, /* 094 */
+      { .mk = {      0x95, 0 }, .brk = {                   0 } }, /* 095 */
+      { .mk = {      0x96, 0 }, .brk = {                   0 } }, /* 096 */
+      { .mk = {      0x97, 0 }, .brk = {                   0 } }, /* 097 */
+      { .mk = {      0x98, 0 }, .brk = {                   0 } }, /* 098 */
+      { .mk = {      0x99, 0 }, .brk = {                   0 } }, /* 099 */
+      { .mk = {      0x9a, 0 }, .brk = {                   0 } }, /* 09a */
+      { .mk = {      0x9b, 0 }, .brk = {                   0 } }, /* 09b */
+      { .mk = {      0x9c, 0 }, .brk = {                   0 } }, /* 09c */
+      { .mk = {      0x9d, 0 }, .brk = {                   0 } }, /* 09d */
+      { .mk = {      0x9e, 0 }, .brk = {                   0 } }, /* 09e */
+      { .mk = {      0x9f, 0 }, .brk = {                   0 } }, /* 09f */
+      { .mk = {      0xa0, 0 }, .brk = {                   0 } }, /* 0a0 */
+      { .mk = {      0xa1, 0 }, .brk = {                   0 } }, /* 0a1 */
+      { .mk = {      0xa2, 0 }, .brk = {                   0 } }, /* 0a2 */
+      { .mk = {      0xa3, 0 }, .brk = {                   0 } }, /* 0a3 */
+      { .mk = {      0xa4, 0 }, .brk = {                   0 } }, /* 0a4 */
+      { .mk = {      0xa5, 0 }, .brk = {                   0 } }, /* 0a5 */
+      { .mk = {      0xa6, 0 }, .brk = {                   0 } }, /* 0a6 */
+      { .mk = {      0xa7, 0 }, .brk = {                   0 } }, /* 0a7 */
+      { .mk = {      0xa8, 0 }, .brk = {                   0 } }, /* 0a8 */
+      { .mk = {      0xa9, 0 }, .brk = {                   0 } }, /* 0a9 */
+      { .mk = {      0xaa, 0 }, .brk = {                   0 } }, /* 0aa */
+      { .mk = {      0xab, 0 }, .brk = {                   0 } }, /* 0ab */
+      { .mk = {      0xac, 0 }, .brk = {                   0 } }, /* 0ac */
+      { .mk = {      0xad, 0 }, .brk = {                   0 } }, /* 0ad */
+      { .mk = {      0xae, 0 }, .brk = {                   0 } }, /* 0ae */
+      { .mk = {      0xaf, 0 }, .brk = {                   0 } }, /* 0af */
+      { .mk = {      0xb0, 0 }, .brk = {                   0 } }, /* 0b0 */
+      { .mk = {      0xb1, 0 }, .brk = {                   0 } }, /* 0b1 */
+      { .mk = {      0xb2, 0 }, .brk = {                   0 } }, /* 0b2 */
+      { .mk = {      0xb3, 0 }, .brk = {                   0 } }, /* 0b3 */
+      { .mk = {      0xb4, 0 }, .brk = {                   0 } }, /* 0b4 */
+      { .mk = {      0xb5, 0 }, .brk = {                   0 } }, /* 0b5 */
+      { .mk = {      0xb6, 0 }, .brk = {                   0 } }, /* 0b6 */
+      { .mk = {      0xb7, 0 }, .brk = {                   0 } }, /* 0b7 */
+      { .mk = {      0xb8, 0 }, .brk = {                   0 } }, /* 0b8 */
+      { .mk = {      0xb9, 0 }, .brk = {                   0 } }, /* 0b9 */
+      { .mk = {      0xba, 0 }, .brk = {                   0 } }, /* 0ba */
+      { .mk = {      0xbb, 0 }, .brk = {                   0 } }, /* 0bb */
+      { .mk = {      0xbc, 0 }, .brk = {                   0 } }, /* 0bc */
+      { .mk = {      0xbd, 0 }, .brk = {                   0 } }, /* 0bd */
+      { .mk = {      0xbe, 0 }, .brk = {                   0 } }, /* 0be */
+      { .mk = {      0xbf, 0 }, .brk = {                   0 } }, /* 0bf */
+      { .mk = {      0xc0, 0 }, .brk = {                   0 } }, /* 0c0 */
+      { .mk = {      0xc1, 0 }, .brk = {                   0 } }, /* 0c1 */
+      { .mk = {      0xc2, 0 }, .brk = {                   0 } }, /* 0c2 */
+      { .mk = {      0xc3, 0 }, .brk = {                   0 } }, /* 0c3 */
+      { .mk = {      0xc4, 0 }, .brk = {                   0 } }, /* 0c4 */
+      { .mk = {      0xc5, 0 }, .brk = {                   0 } }, /* 0c5 */
+      { .mk = {      0xc6, 0 }, .brk = {                   0 } }, /* 0c6 */
+      { .mk = {      0xc7, 0 }, .brk = {                   0 } }, /* 0c7 */
+      { .mk = {      0xc8, 0 }, .brk = {                   0 } }, /* 0c8 */
+      { .mk = {      0xc9, 0 }, .brk = {                   0 } }, /* 0c9 */
+      { .mk = {      0xca, 0 }, .brk = {                   0 } }, /* 0ca */
+      { .mk = {      0xcb, 0 }, .brk = {                   0 } }, /* 0cb */
+      { .mk = {      0xcc, 0 }, .brk = {                   0 } }, /* 0cc */
+      { .mk = {      0xcd, 0 }, .brk = {                   0 } }, /* 0cd */
+      { .mk = {      0xce, 0 }, .brk = {                   0 } }, /* 0ce */
+      { .mk = {      0xcf, 0 }, .brk = {                   0 } }, /* 0cf */
+      { .mk = {      0xd0, 0 }, .brk = {                   0 } }, /* 0d0 */
+      { .mk = {      0xd1, 0 }, .brk = {                   0 } }, /* 0d1 */
+      { .mk = {      0xd2, 0 }, .brk = {                   0 } }, /* 0d2 */
+      { .mk = {      0xd3, 0 }, .brk = {                   0 } }, /* 0d3 */
+      { .mk = {      0xd4, 0 }, .brk = {                   0 } }, /* 0d4 */
+      { .mk = {      0xd5, 0 }, .brk = {                   0 } }, /* 0d5 */
+      { .mk = {      0xd6, 0 }, .brk = {                   0 } }, /* 0d6 */
+      { .mk = {      0xd7, 0 }, .brk = {                   0 } }, /* 0d7 */
+      { .mk = {      0xd8, 0 }, .brk = {                   0 } }, /* 0d8 */
+      { .mk = {      0xd9, 0 }, .brk = {                   0 } }, /* 0d9 */
+      { .mk = {      0xda, 0 }, .brk = {                   0 } }, /* 0da */
+      { .mk = {      0xdb, 0 }, .brk = {                   0 } }, /* 0db */
+      { .mk = {      0xdc, 0 }, .brk = {                   0 } }, /* 0dc */
+      { .mk = {      0xdd, 0 }, .brk = {                   0 } }, /* 0dd */
+      { .mk = {      0xde, 0 }, .brk = {                   0 } }, /* 0de */
+      { .mk = {      0xdf, 0 }, .brk = {                   0 } }, /* 0df */
+      { .mk = {      0xe0, 0 }, .brk = {                   0 } }, /* 0e0 */
+      { .mk = {      0xe1, 0 }, .brk = {                   0 } }, /* 0e1 */
+      { .mk = {      0xe2, 0 }, .brk = {                   0 } }, /* 0e2 */
+      { .mk = {      0xe3, 0 }, .brk = {                   0 } }, /* 0e3 */
+      { .mk = {      0xe4, 0 }, .brk = {                   0 } }, /* 0e4 */
+      { .mk = {      0xe5, 0 }, .brk = {                   0 } }, /* 0e5 */
+      { .mk = {      0xe6, 0 }, .brk = {                   0 } }, /* 0e6 */
+      { .mk = {      0xe7, 0 }, .brk = {                   0 } }, /* 0e7 */
+      { .mk = {      0xe8, 0 }, .brk = {                   0 } }, /* 0e8 */
+      { .mk = {      0xe9, 0 }, .brk = {                   0 } }, /* 0e9 */
+      { .mk = {      0xea, 0 }, .brk = {                   0 } }, /* 0ea */
+      { .mk = {      0xeb, 0 }, .brk = {                   0 } }, /* 0eb */
+      { .mk = {      0xec, 0 }, .brk = {                   0 } }, /* 0ec */
+      { .mk = {      0xed, 0 }, .brk = {                   0 } }, /* 0ed */
+      { .mk = {      0xee, 0 }, .brk = {                   0 } }, /* 0ee */
+      { .mk = {      0xef, 0 }, .brk = {                   0 } }, /* 0ef */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 0f0 */
+      { .mk = {      0xf1, 0 }, .brk = {                   0 } }, /* 0f1 */
+      { .mk = {      0xf2, 0 }, .brk = {                   0 } }, /* 0f2 */
+      { .mk = {      0xf3, 0 }, .brk = {                   0 } }, /* 0f3 */
+      { .mk = {      0xf4, 0 }, .brk = {                   0 } }, /* 0f4 */
+      { .mk = {      0xf5, 0 }, .brk = {                   0 } }, /* 0f5 */
+      { .mk = {      0xf6, 0 }, .brk = {                   0 } }, /* 0f6 */
+      { .mk = {      0xf7, 0 }, .brk = {                   0 } }, /* 0f7 */
+      { .mk = {      0xf8, 0 }, .brk = {                   0 } }, /* 0f8 */
+      { .mk = {      0xf9, 0 }, .brk = {                   0 } }, /* 0f9 */
+      { .mk = {      0xfa, 0 }, .brk = {                   0 } }, /* 0fa */
+      { .mk = {      0xfb, 0 }, .brk = {                   0 } }, /* 0fb */
+      { .mk = {      0xfc, 0 }, .brk = {                   0 } }, /* 0fc */
+      { .mk = {      0xfd, 0 }, .brk = {                   0 } }, /* 0fd */
+      { .mk = {      0xfe, 0 }, .brk = {                   0 } }, /* 0fe */
+      { .mk = {      0xff, 0 }, .brk = {                   0 } }, /* 0ff */
+      { .mk = {0xe1, 0x1d, 0 }, .brk = { 0xe1,       0x9d, 0 } }, /* 100 */
+      { .mk = {0xe0, 0x01, 0 }, .brk = { 0xe0,       0x81, 0 } }, /* 101 */
+      { .mk = {0xe0, 0x02, 0 }, .brk = { 0xe0,       0x82, 0 } }, /* 102 */
+      { .mk = {0xe0, 0x03, 0 }, .brk = { 0xe0,       0x83, 0 } }, /* 103 */
+      { .mk = {0xe0, 0x04, 0 }, .brk = { 0xe0,       0x84, 0 } }, /* 104 */
+      { .mk = {0xe0, 0x05, 0 }, .brk = { 0xe0,       0x85, 0 } }, /* 105 */
+      { .mk = {0xe0, 0x06, 0 }, .brk = { 0xe0,       0x86, 0 } }, /* 106 */
+      { .mk = {0xe0, 0x07, 0 }, .brk = { 0xe0,       0x87, 0 } }, /* 107 */
+      { .mk = {0xe0, 0x08, 0 }, .brk = { 0xe0,       0x88, 0 } }, /* 108 */
+      { .mk = {0xe0, 0x09, 0 }, .brk = { 0xe0,       0x89, 0 } }, /* 109 */
+      { .mk = {0xe0, 0x0a, 0 }, .brk = { 0xe0,       0x8a, 0 } }, /* 10a */
+      { .mk = {0xe0, 0x0b, 0 }, .brk = { 0xe0,       0x8b, 0 } }, /* 10b */
+      { .mk = {0xe0, 0x0c, 0 }, .brk = { 0xe0,       0x8c, 0 } }, /* 10c */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 10d */
+      { .mk = {0xe0, 0x0e, 0 }, .brk = { 0xe0,       0x8e, 0 } }, /* 10e */
+      { .mk = {0xe0, 0x0f, 0 }, .brk = { 0xe0,       0x8f, 0 } }, /* 10f */
+      { .mk = {0xe0, 0x10, 0 }, .brk = { 0xe0,       0x90, 0 } }, /* 110 */
+      { .mk = {0xe0, 0x11, 0 }, .brk = { 0xe0,       0x91, 0 } }, /* 112 */
+      { .mk = {0xe0, 0x12, 0 }, .brk = { 0xe0,       0x92, 0 } }, /* 113 */
+      { .mk = {0xe0, 0x13, 0 }, .brk = { 0xe0,       0x93, 0 } }, /* 113 */
+      { .mk = {0xe0, 0x14, 0 }, .brk = { 0xe0,       0x94, 0 } }, /* 114 */
+      { .mk = {0xe0, 0x15, 0 }, .brk = { 0xe0,       0x95, 0 } }, /* 115 */
+      { .mk = {0xe0, 0x16, 0 }, .brk = { 0xe0,       0x96, 0 } }, /* 116 */
+      { .mk = {0xe0, 0x17, 0 }, .brk = { 0xe0,       0x97, 0 } }, /* 117 */
+      { .mk = {0xe0, 0x18, 0 }, .brk = { 0xe0,       0x98, 0 } }, /* 118 */
+      { .mk = {0xe0, 0x19, 0 }, .brk = { 0xe0,       0x99, 0 } }, /* 119 */
+      { .mk = {0xe0, 0x1a, 0 }, .brk = { 0xe0,       0x9a, 0 } }, /* 11a */
+      { .mk = {0xe0, 0x1b, 0 }, .brk = { 0xe0,       0x9b, 0 } }, /* 11b */
+      { .mk = {0xe0, 0x1c, 0 }, .brk = { 0xe0,       0x9c, 0 } }, /* 11c */
+      { .mk = {0xe0, 0x1d, 0 }, .brk = { 0xe0,       0x9d, 0 } }, /* 11d */
+      { .mk = {0xe0, 0x1e, 0 }, .brk = { 0xe0,       0x9e, 0 } }, /* 11e */
+      { .mk = {0xe0, 0x1f, 0 }, .brk = { 0xe0,       0x9f, 0 } }, /* 11f */
+      { .mk = {0xe0, 0x20, 0 }, .brk = { 0xe0,       0xa0, 0 } }, /* 120 */
+      { .mk = {0xe0, 0x21, 0 }, .brk = { 0xe0,       0xa1, 0 } }, /* 121 */
+      { .mk = {0xe0, 0x22, 0 }, .brk = { 0xe0,       0xa2, 0 } }, /* 122 */
+      { .mk = {0xe0, 0x23, 0 }, .brk = { 0xe0,       0xa3, 0 } }, /* 123 */
+      { .mk = {0xe0, 0x24, 0 }, .brk = { 0xe0,       0xa4, 0 } }, /* 124 */
+      { .mk = {0xe0, 0x25, 0 }, .brk = { 0xe0,       0xa5, 0 } }, /* 125 */
+      { .mk = {0xe0, 0x26, 0 }, .brk = { 0xe0,       0xa6, 0 } }, /* 126 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 127 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 128 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 129 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 12a */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 12b */
+      { .mk = {0xe0, 0x2c, 0 }, .brk = { 0xe0,       0xac, 0 } }, /* 12c */
+      { .mk = {0xe0, 0x2d, 0 }, .brk = { 0xe0,       0xad, 0 } }, /* 12d */
+      { .mk = {0xe0, 0x2e, 0 }, .brk = { 0xe0,       0xae, 0 } }, /* 12e */
+      { .mk = {0xe0, 0x2f, 0 }, .brk = { 0xe0,       0xaf, 0 } }, /* 12f */
+      { .mk = {0xe0, 0x30, 0 }, .brk = { 0xe0,       0xb0, 0 } }, /* 130 */
+      { .mk = {0xe0, 0x31, 0 }, .brk = { 0xe0,       0xb1, 0 } }, /* 131 */
+      { .mk = {0xe0, 0x32, 0 }, .brk = { 0xe0,       0xb2, 0 } }, /* 132 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 133 */
+      { .mk = {0xe0, 0x34, 0 }, .brk = { 0xe0,       0xb4, 0 } }, /* 134 */
+      { .mk = {0xe0, 0x35, 0 }, .brk = { 0xe0,       0xb5, 0 } }, /* 135 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 136 */
+      { .mk = {0xe0, 0x37, 0 }, .brk = { 0xe0,       0xb7, 0 } }, /* 137 */
+      { .mk = {      0x38, 0 }, .brk = {             0xb8, 0 } }, /* 138* 0x31 R-Alt */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 139 */
+      { .mk = {0xe0, 0x3a, 0 }, .brk = { 0xe0,       0xba, 0 } }, /* 13a */
+      { .mk = {0xe0, 0x3b, 0 }, .brk = { 0xe0,       0xbb, 0 } }, /* 13b */
+      { .mk = {0xe0, 0x3c, 0 }, .brk = { 0xe0,       0xbc, 0 } }, /* 13c */
+      { .mk = {0xe0, 0x3d, 0 }, .brk = { 0xe0,       0xbd, 0 } }, /* 13d */
+      { .mk = {0xe0, 0x3e, 0 }, .brk = { 0xe0,       0xbe, 0 } }, /* 13e */
+      { .mk = {0xe0, 0x3f, 0 }, .brk = { 0xe0,       0xbf, 0 } }, /* 13f */
+      { .mk = {0xe0, 0x40, 0 }, .brk = { 0xe0,       0xc0, 0 } }, /* 140 */
+      { .mk = {0xe0, 0x41, 0 }, .brk = { 0xe0,       0xc1, 0 } }, /* 141 */
+      { .mk = {0xe0, 0x42, 0 }, .brk = { 0xe0,       0xc2, 0 } }, /* 142 */
+      { .mk = {0xe0, 0x43, 0 }, .brk = { 0xe0,       0xc3, 0 } }, /* 143 */
+      { .mk = {0xe0, 0x44, 0 }, .brk = { 0xe0,       0xc4, 0 } }, /* 144 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 145 */
+      { .mk = {0xe0, 0x46, 0 }, .brk = { 0xe0,       0xc6, 0 } }, /* 146 */
+      { .mk = {0xe0, 0x47, 0 }, .brk = { 0xe0,       0xc7, 0 } }, /* 147 */
+      { .mk = {0xe0, 0x48, 0 }, .brk = { 0xe0,       0xc8, 0 } }, /* 148 */
+      { .mk = {0xe0, 0x49, 0 }, .brk = { 0xe0,       0xc9, 0 } }, /* 149 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 14a */
+      { .mk = {0xe0, 0x4b, 0 }, .brk = { 0xe0,       0xcb, 0 } }, /* 14b */
+      { .mk = {0xe0, 0x4c, 0 }, .brk = { 0xe0,       0xcc, 0 } }, /* 14c */
+      { .mk = {0xe0, 0x4d, 0 }, .brk = { 0xe0,       0xcd, 0 } }, /* 14d */
+      { .mk = {0xe0, 0x4e, 0 }, .brk = { 0xe0,       0xce, 0 } }, /* 14e */
+      { .mk = {0xe0, 0x4f, 0 }, .brk = { 0xe0,       0xcf, 0 } }, /* 14f */
+      { .mk = {0xe0, 0x50, 0 }, .brk = { 0xe0,       0xd0, 0 } }, /* 150 */
+      { .mk = {0xe0, 0x51, 0 }, .brk = { 0xe0,       0xd1, 0 } }, /* 151 */
+      { .mk = {0xe0, 0x52, 0 }, .brk = { 0xe0,       0xd2, 0 } }, /* 152 */
+      { .mk = {0xe0, 0x53, 0 }, .brk = { 0xe0,       0xd3, 0 } }, /* 153 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 154 */
+      { .mk = {0xe0, 0x55, 0 }, .brk = { 0xe0,       0xd5, 0 } }, /* 155 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 156 */
+      { .mk = {0xe0, 0x57, 0 }, .brk = { 0xe0,       0xd7, 0 } }, /* 157 */
+      { .mk = {0xe0, 0x58, 0 }, .brk = { 0xe0,       0xd8, 0 } }, /* 158 */
+      { .mk = {0xe0, 0x59, 0 }, .brk = { 0xe0,       0xd9, 0 } }, /* 159 */
+      { .mk = {0xe0, 0x5a, 0 }, .brk = { 0xe0,       0xaa, 0 } }, /* 15a */
+      { .mk = {      0x7b, 0 }, .brk = {             0xfb, 0 } }, /* 15b 0x33 LGUI->Muhenkan (in emulator only) */
+      { .mk = {      0x79, 0 }, .brk = {             0xf9, 0 } }, /* 15c 0x35 RGUI->Henkan (in emulator only) */
+      { .mk = {0xe0, 0x38, 0 }, .brk = { 0xe0,       0xb8, 0 } }, /* 15d 0x36 APPLICATION->Kana (in emulator only) */
+      { .mk = {0xe0, 0x5e, 0 }, .brk = { 0xe0,       0xee, 0 } }, /* 15e */
+      { .mk = {0xe0, 0x5f, 0 }, .brk = { 0xe0,       0xdf, 0 } }, /* 15f */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 160 */
+      { .mk = {0xe0, 0x61, 0 }, .brk = { 0xe0,       0xe1, 0 } }, /* 161 */
+      { .mk = {0xe0, 0x62, 0 }, .brk = { 0xe0,       0xe2, 0 } }, /* 162 */
+      { .mk = {0xe0, 0x63, 0 }, .brk = { 0xe0,       0xe3, 0 } }, /* 163 */
+      { .mk = {0xe0, 0x64, 0 }, .brk = { 0xe0,       0xe4, 0 } }, /* 164 */
+      { .mk = {0xe0, 0x65, 0 }, .brk = { 0xe0,       0xe5, 0 } }, /* 165 */
+      { .mk = {0xe0, 0x66, 0 }, .brk = { 0xe0,       0xe6, 0 } }, /* 166 */
+      { .mk = {0xe0, 0x67, 0 }, .brk = { 0xe0,       0xe7, 0 } }, /* 167 */
+      { .mk = {0xe0, 0x68, 0 }, .brk = { 0xe0,       0xe8, 0 } }, /* 168 */
+      { .mk = {0xe0, 0x69, 0 }, .brk = { 0xe0,       0xe9, 0 } }, /* 169 */
+      { .mk = {0xe0, 0x6a, 0 }, .brk = { 0xe0,       0xea, 0 } }, /* 16a */
+      { .mk = {0xe0, 0x6b, 0 }, .brk = { 0xe0,       0xeb, 0 } }, /* 16b */
+      { .mk = {0xe0, 0x6c, 0 }, .brk = { 0xe0,       0xec, 0 } }, /* 16c */
+      { .mk = {0xe0, 0x6d, 0 }, .brk = { 0xe0,       0xed, 0 } }, /* 16d */
+      { .mk = {0xe0, 0x6e, 0 }, .brk = { 0xe0,       0xee, 0 } }, /* 16e */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 16f */
+      { .mk = {0xe0, 0x70, 0 }, .brk = { 0xe0,       0xf0, 0 } }, /* 170 */
+      { .mk = {0xe0, 0x71, 0 }, .brk = { 0xe0,       0xf1, 0 } }, /* 171 */
+      { .mk = {0xe0, 0x72, 0 }, .brk = { 0xe0,       0xf2, 0 } }, /* 172 */
+      { .mk = {0xe0, 0x73, 0 }, .brk = { 0xe0,       0xf3, 0 } }, /* 173 */
+      { .mk = {0xe0, 0x74, 0 }, .brk = { 0xe0,       0xf4, 0 } }, /* 174 */
+      { .mk = {0xe0, 0x75, 0 }, .brk = { 0xe0,       0xf5, 0 } }, /* 175 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 176 */
+      { .mk = {0xe0, 0x77, 0 }, .brk = { 0xe0,       0xf7, 0 } }, /* 177 */
+      { .mk = {0xe0, 0x78, 0 }, .brk = { 0xe0,       0xf8, 0 } }, /* 178 */
+      { .mk = {0xe0, 0x79, 0 }, .brk = { 0xe0,       0xf9, 0 } }, /* 179 */
+      { .mk = {0xe0, 0x7a, 0 }, .brk = { 0xe0,       0xfa, 0 } }, /* 17a */
+      { .mk = {0xe0, 0x7b, 0 }, .brk = { 0xe0,       0xfb, 0 } }, /* 17b */
+      { .mk = {0xe0, 0x7c, 0 }, .brk = { 0xe0,       0xfc, 0 } }, /* 17c */
+      { .mk = {0xe0, 0x7d, 0 }, .brk = { 0xe0,       0xfd, 0 } }, /* 17d */
+      { .mk = {0xe0, 0x7e, 0 }, .brk = { 0xe0,       0xfe, 0 } }, /* 17e */
+      { .mk = {0xe0, 0x7f, 0 }, .brk = { 0xe0,       0xff, 0 } }, /* 17f */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 180 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 181 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 182 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 183 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 184 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 185 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 186 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 187 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 188 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 189 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 18a */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 18b */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 18c */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 18d */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 18e */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 18f */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 190 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 191 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 192 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 193 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 194 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 195 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 196 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 197 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 198 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 199 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 19a */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 19b */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 19c */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 19d */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 19e */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 19f */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1a0 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1a1 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1a2 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1a3 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1a4 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1a5 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1a6 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1a7 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1a8 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1a9 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1aa */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1ab */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1ac */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1ad */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1ae */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1af */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1b0 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1b1 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1b2 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1b3 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1b4 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1b5 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1b6 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1b7 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1b8 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1b9 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1ba */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1bb */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1bc */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1bd */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1be */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1bf */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1c0 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1c1 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1c2 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1c3 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1c4 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1c5 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1c6 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1c7 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1c8 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1c9 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1ca */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1cb */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1cv */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1cd */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1ce */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1cf */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1d0 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1d1 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1d2 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1d3 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1d4 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1d5 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1d6 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1d7 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1d8 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1d9 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1da */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1db */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1dc */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1dd */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1de */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1df */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1e0 */
+      { .mk = {0xe0, 0xe1, 0 }, .brk = {                   0 } }, /* 1e1 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1e2 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1e3 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1e4 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1e5 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1e6 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1e7 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1e8 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1e9 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1ea */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1eb */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1ec */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1ed */
+      { .mk = {0xe0, 0xee, 0 }, .brk = {                   0 } }, /* 1ee */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1ef */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1f0 */
+      { .mk = {0xe0, 0xf1, 0 }, .brk = {                   0 } }, /* 1f1 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1f2 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1f3 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1f4 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1f5 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1f6 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1f7 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1f8 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1f9 */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1fa */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1fb */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1fc */
+      { .mk = {            0 }, .brk = {                   0 } }, /* 1fd */
+      { .mk = {0xe0, 0xfe, 0 }, .brk = {                   0 } }, /* 1fe */
+      { .mk = {0xe0, 0xff, 0 }, .brk = {                   0 } }  /* 1ff */
+    // clang-format on
+    };
+/* Scancode set 82h : Set 02 with language specific keys support used by DOS/V */
+static const scancode scancode_set82[512] = {
+  // clang-format off
+    { .mk = {            0 }, .brk = {                   0 } }, /* 000 */
+    { .mk = {      0x76, 0 }, .brk = {       0xF0, 0x76, 0 } }, /* 001 */
+    { .mk = {      0x16, 0 }, .brk = {       0xF0, 0x16, 0 } }, /* 002 */
+    { .mk = {      0x1E, 0 }, .brk = {       0xF0, 0x1E, 0 } }, /* 003 */
+    { .mk = {      0x26, 0 }, .brk = {       0xF0, 0x26, 0 } }, /* 004 */
+    { .mk = {      0x25, 0 }, .brk = {       0xF0, 0x25, 0 } }, /* 005 */
+    { .mk = {      0x2E, 0 }, .brk = {       0xF0, 0x2E, 0 } }, /* 006 */
+    { .mk = {      0x36, 0 }, .brk = {       0xF0, 0x36, 0 } }, /* 007 */
+    { .mk = {      0x3D, 0 }, .brk = {       0xF0, 0x3D, 0 } }, /* 008 */
+    { .mk = {      0x3E, 0 }, .brk = {       0xF0, 0x3E, 0 } }, /* 009 */
+    { .mk = {      0x46, 0 }, .brk = {       0xF0, 0x46, 0 } }, /* 00a */
+    { .mk = {      0x45, 0 }, .brk = {       0xF0, 0x45, 0 } }, /* 00b */
+    { .mk = {      0x4E, 0 }, .brk = {       0xF0, 0x4E, 0 } }, /* 00c */
+    { .mk = {      0x55, 0 }, .brk = {       0xF0, 0x55, 0 } }, /* 00d */
+    { .mk = {      0x66, 0 }, .brk = {       0xF0, 0x66, 0 } }, /* 00e */
+    { .mk = {      0x0D, 0 }, .brk = {       0xF0, 0x0D, 0 } }, /* 00f */
+    { .mk = {      0x15, 0 }, .brk = {       0xF0, 0x15, 0 } }, /* 010 */
+    { .mk = {      0x1D, 0 }, .brk = {       0xF0, 0x1D, 0 } }, /* 011 */
+    { .mk = {      0x24, 0 }, .brk = {       0xF0, 0x24, 0 } }, /* 012 */
+    { .mk = {      0x2D, 0 }, .brk = {       0xF0, 0x2D, 0 } }, /* 013 */
+    { .mk = {      0x2C, 0 }, .brk = {       0xF0, 0x2C, 0 } }, /* 014 */
+    { .mk = {      0x35, 0 }, .brk = {       0xF0, 0x35, 0 } }, /* 015 */
+    { .mk = {      0x3C, 0 }, .brk = {       0xF0, 0x3C, 0 } }, /* 016 */
+    { .mk = {      0x43, 0 }, .brk = {       0xF0, 0x43, 0 } }, /* 017 */
+    { .mk = {      0x44, 0 }, .brk = {       0xF0, 0x44, 0 } }, /* 018 */
+    { .mk = {      0x4D, 0 }, .brk = {       0xF0, 0x4D, 0 } }, /* 019 */
+    { .mk = {      0x54, 0 }, .brk = {       0xF0, 0x54, 0 } }, /* 01a */
+    { .mk = {      0x5B, 0 }, .brk = {       0xF0, 0x5B, 0 } }, /* 01b */
+    { .mk = {      0x5A, 0 }, .brk = {       0xF0, 0x5A, 0 } }, /* 01c */
+    { .mk = {      0x14, 0 }, .brk = {       0xF0, 0x14, 0 } }, /* 01d */
+    { .mk = {      0x1C, 0 }, .brk = {       0xF0, 0x1C, 0 } }, /* 01e */
+    { .mk = {      0x1B, 0 }, .brk = {       0xF0, 0x1B, 0 } }, /* 01f */
+    { .mk = {      0x23, 0 }, .brk = {       0xF0, 0x23, 0 } }, /* 020 */
+    { .mk = {      0x2B, 0 }, .brk = {       0xF0, 0x2B, 0 } }, /* 021 */
+    { .mk = {      0x34, 0 }, .brk = {       0xF0, 0x34, 0 } }, /* 022 */
+    { .mk = {      0x33, 0 }, .brk = {       0xF0, 0x33, 0 } }, /* 023 */
+    { .mk = {      0x3B, 0 }, .brk = {       0xF0, 0x3B, 0 } }, /* 024 */
+    { .mk = {      0x42, 0 }, .brk = {       0xF0, 0x42, 0 } }, /* 025 */
+    { .mk = {      0x4B, 0 }, .brk = {       0xF0, 0x4B, 0 } }, /* 026 */
+    { .mk = {      0x4C, 0 }, .brk = {       0xF0, 0x4C, 0 } }, /* 027 */
+    { .mk = {      0x52, 0 }, .brk = {       0xF0, 0x52, 0 } }, /* 028* */
+    { .mk = {      0x62, 0 }, .brk = {       0xf0, 0x62, 0 } }, /* 029 0x45 Hankaku, Zenkaku */
+    { .mk = {      0x12, 0 }, .brk = {       0xF0, 0x12, 0 } }, /* 02a */
+    { .mk = {      0x5b, 0 }, .brk = {       0xf0, 0x5b, 0 } }, /* 02b 0x17 Mu */
+    { .mk = {      0x1A, 0 }, .brk = {       0xF0, 0x1A, 0 } }, /* 02c */
+    { .mk = {      0x22, 0 }, .brk = {       0xF0, 0x22, 0 } }, /* 02d */
+    { .mk = {      0x21, 0 }, .brk = {       0xF0, 0x21, 0 } }, /* 02e */
+    { .mk = {      0x2A, 0 }, .brk = {       0xF0, 0x2A, 0 } }, /* 02f */
+    { .mk = {      0x32, 0 }, .brk = {       0xF0, 0x32, 0 } }, /* 030 */
+    { .mk = {      0x31, 0 }, .brk = {       0xF0, 0x31, 0 } }, /* 031 */
+    { .mk = {      0x3A, 0 }, .brk = {       0xF0, 0x3A, 0 } }, /* 032 */
+    { .mk = {      0x41, 0 }, .brk = {       0xF0, 0x41, 0 } }, /* 033 */
+    { .mk = {      0x49, 0 }, .brk = {       0xF0, 0x49, 0 } }, /* 034 */
+    { .mk = {      0x4A, 0 }, .brk = {       0xF0, 0x4A, 0 } }, /* 035 */
+    { .mk = {      0x59, 0 }, .brk = {       0xF0, 0x59, 0 } }, /* 036 */
+    { .mk = {      0x7C, 0 }, .brk = {       0xF0, 0x7C, 0 } }, /* 037 */
+    { .mk = {      0x13, 0 }, .brk = {       0xF0, 0x13, 0 } }, /* 038 0x3A LALT = Kanji */
+    { .mk = {      0x29, 0 }, .brk = {       0xF0, 0x29, 0 } }, /* 039 */
+    { .mk = {      0x58, 0 }, .brk = {       0xF0, 0x58, 0 } }, /* 03a */
+    { .mk = {      0x05, 0 }, .brk = {       0xF0, 0x05, 0 } }, /* 03b */
+    { .mk = {      0x06, 0 }, .brk = {       0xF0, 0x06, 0 } }, /* 03c */
+    { .mk = {      0x04, 0 }, .brk = {       0xF0, 0x04, 0 } }, /* 03d */
+    { .mk = {      0x0C, 0 }, .brk = {       0xF0, 0x0C, 0 } }, /* 03e */
+    { .mk = {      0x03, 0 }, .brk = {       0xF0, 0x03, 0 } }, /* 03f */
+    { .mk = {      0x0B, 0 }, .brk = {       0xF0, 0x0B, 0 } }, /* 040 */
+    { .mk = {      0x83, 0 }, .brk = {       0xF0, 0x83, 0 } }, /* 041 */
+    { .mk = {      0x0A, 0 }, .brk = {       0xF0, 0x0A, 0 } }, /* 042 */
+    { .mk = {      0x01, 0 }, .brk = {       0xF0, 0x01, 0 } }, /* 043 */
+    { .mk = {      0x09, 0 }, .brk = {       0xF0, 0x09, 0 } }, /* 044 */
+    { .mk = {      0x77, 0 }, .brk = {       0xF0, 0x77, 0 } }, /* 045 NUMLOCKCLEAR -> Shift + SCRLOCK :TODO */
+    { .mk = {      0x7E, 0 }, .brk = {       0xF0, 0x7E, 0 } }, /* 046 0x75 SCROLLLOCK */
+    { .mk = {      0x6C, 0 }, .brk = {       0xF0, 0x6C, 0 } }, /* 047 */
+    { .mk = {      0x75, 0 }, .brk = {       0xF0, 0x75, 0 } }, /* 048 */
+    { .mk = {      0x7D, 0 }, .brk = {       0xF0, 0x7D, 0 } }, /* 049 */
+    { .mk = {      0x7B, 0 }, .brk = {       0xF0, 0x7B, 0 } }, /* 04a */
+    { .mk = {      0x6B, 0 }, .brk = {       0xF0, 0x6B, 0 } }, /* 04b */
+    { .mk = {      0x73, 0 }, .brk = {       0xF0, 0x73, 0 } }, /* 04c */
+    { .mk = {      0x74, 0 }, .brk = {       0xF0, 0x74, 0 } }, /* 04d */
+    { .mk = {      0x79, 0 }, .brk = {       0xF0, 0x79, 0 } }, /* 04e */
+    { .mk = {      0x69, 0 }, .brk = {       0xF0, 0x69, 0 } }, /* 04f */
+    { .mk = {      0x72, 0 }, .brk = {       0xF0, 0x72, 0 } }, /* 050 */
+    { .mk = {      0x7A, 0 }, .brk = {       0xF0, 0x7A, 0 } }, /* 051 */
+    { .mk = {      0x70, 0 }, .brk = {       0xF0, 0x70, 0 } }, /* 052 */
+    { .mk = {      0x71, 0 }, .brk = {       0xF0, 0x71, 0 } }, /* 053 */
+    { .mk = {      0x84, 0 }, .brk = {       0xF0, 0x84, 0 } }, /* 054 */
+    { .mk = {      0x60, 0 }, .brk = {       0xF0, 0x60, 0 } }, /* 055 */
+    { .mk = {      0x61, 0 }, .brk = {       0xF0, 0x61, 0 } }, /* 056 */
+    { .mk = {      0x78, 0 }, .brk = {       0xF0, 0x78, 0 } }, /* 057 */
+    { .mk = {      0x07, 0 }, .brk = {       0xF0, 0x07, 0 } }, /* 058 */
+    { .mk = {      0x0F, 0 }, .brk = {       0xF0, 0x0F, 0 } }, /* 059 */
+    { .mk = {      0x17, 0 }, .brk = {       0xF0, 0x17, 0 } }, /* 05a */
+    { .mk = {      0x1F, 0 }, .brk = {       0xF0, 0x1F, 0 } }, /* 05b */
+    { .mk = {      0x27, 0 }, .brk = {       0xF0, 0x27, 0 } }, /* 05c */
+    { .mk = {      0x2F, 0 }, .brk = {       0xF0, 0x2F, 0 } }, /* 05d */
+    { .mk = {      0x37, 0 }, .brk = {       0xF0, 0x37, 0 } }, /* 05e */
+    { .mk = {      0x3F, 0 }, .brk = {       0xF0, 0x3F, 0 } }, /* 05f */
+    { .mk = {      0x47, 0 }, .brk = {       0xF0, 0x47, 0 } }, /* 060 */
+    { .mk = {      0x4F, 0 }, .brk = {       0xF0, 0x4F, 0 } }, /* 061 */
+    { .mk = {      0x56, 0 }, .brk = {       0xF0, 0x56, 0 } }, /* 062 */
+    { .mk = {      0x5E, 0 }, .brk = {       0xF0, 0x5E, 0 } }, /* 063 */
+    { .mk = {      0x08, 0 }, .brk = {       0xF0, 0x08, 0 } }, /* 064 */
+    { .mk = {      0x10, 0 }, .brk = {       0xF0, 0x10, 0 } }, /* 065 */
+    { .mk = {      0x18, 0 }, .brk = {       0xF0, 0x18, 0 } }, /* 066 */
+    { .mk = {      0x20, 0 }, .brk = {       0xF0, 0x20, 0 } }, /* 067 */
+    { .mk = {      0x28, 0 }, .brk = {       0xF0, 0x28, 0 } }, /* 068 */
+    { .mk = {      0x30, 0 }, .brk = {       0xF0, 0x30, 0 } }, /* 069 */
+    { .mk = {      0x38, 0 }, .brk = {       0xF0, 0x38, 0 } }, /* 06a */
+    { .mk = {      0x40, 0 }, .brk = {       0xF0, 0x40, 0 } }, /* 06b */
+    { .mk = {      0x48, 0 }, .brk = {       0xF0, 0x48, 0 } }, /* 06c */
+    { .mk = {      0x50, 0 }, .brk = {       0xF0, 0x50, 0 } }, /* 06d */
+    { .mk = {      0x57, 0 }, .brk = {       0xF0, 0x57, 0 } }, /* 06e */
+    { .mk = {      0x6F, 0 }, .brk = {       0xF0, 0x6F, 0 } }, /* 06f */
+    { .mk = {0xe0, 0x11, 0 }, .brk = { 0xe0, 0xf0, 0x11, 0 } }, /* 070 0x36 Kana */
+    { .mk = {      0x19, 0 }, .brk = {       0xF0, 0x19, 0 } }, /* 071 */
+    { .mk = {      0x39, 0 }, .brk = {       0xF0, 0x39, 0 } }, /* 072 */
+    { .mk = {      0x51, 0 }, .brk = {       0xF0, 0x51, 0 } }, /* 073 0x0b Ro, Underline */
+    { .mk = {      0x53, 0 }, .brk = {       0xF0, 0x53, 0 } }, /* 074 */
+    { .mk = {      0x5C, 0 }, .brk = {       0xF0, 0x5C, 0 } }, /* 075 */
+    { .mk = {      0x5F, 0 }, .brk = {       0xF0, 0x5F, 0 } }, /* 076 */
+    { .mk = {      0x62, 0 }, .brk = {       0xF0, 0x62, 0 } }, /* 077 */
+    { .mk = {      0x63, 0 }, .brk = {       0xF0, 0x63, 0 } }, /* 078 */
+    { .mk = {      0x64, 0 }, .brk = {       0xF0, 0x64, 0 } }, /* 079 0x35 Henkan */
+    { .mk = {      0x65, 0 }, .brk = {       0xF0, 0x65, 0 } }, /* 07a */
+    { .mk = {      0x67, 0 }, .brk = {       0xF0, 0x67, 0 } }, /* 07b 0x33 Muhenkan */
+    { .mk = {      0x68, 0 }, .brk = {       0xF0, 0x68, 0 } }, /* 07c */
+    { .mk = {      0x5d, 0 }, .brk = {       0xf0, 0x5d, 0 } }, /* 07d 0x30 Yen, Vertical line */
+    { .mk = {      0x6D, 0 }, .brk = {       0xF0, 0x6D, 0 } }, /* 07e */
+    { .mk = {      0x6E, 0 }, .brk = {       0xF0, 0x6E, 0 } }, /* 07f */
+    { .mk = {      0x80, 0 }, .brk = {       0xf0, 0x80, 0 } }, /* 080 */
+    { .mk = {      0x81, 0 }, .brk = {       0xf0, 0x81, 0 } }, /* 081 */
+    { .mk = {      0x82, 0 }, .brk = {       0xf0, 0x82, 0 } }, /* 082 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 083 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 084 */
+    { .mk = {      0x85, 0 }, .brk = {       0xf0, 0x54, 0 } }, /* 085 */
+    { .mk = {      0x86, 0 }, .brk = {       0xf0, 0x86, 0 } }, /* 086 */
+    { .mk = {      0x87, 0 }, .brk = {       0xf0, 0x87, 0 } }, /* 087 */
+    { .mk = {      0x88, 0 }, .brk = {       0xf0, 0x88, 0 } }, /* 088 */
+    { .mk = {      0x89, 0 }, .brk = {       0xf0, 0x89, 0 } }, /* 089 */
+    { .mk = {      0x8a, 0 }, .brk = {       0xf0, 0x8a, 0 } }, /* 08a */
+    { .mk = {      0x8b, 0 }, .brk = {       0xf0, 0x8b, 0 } }, /* 08b */
+    { .mk = {      0x8c, 0 }, .brk = {       0xf0, 0x8c, 0 } }, /* 08c */
+    { .mk = {      0x8d, 0 }, .brk = {       0xf0, 0x8d, 0 } }, /* 08d */
+    { .mk = {      0x8e, 0 }, .brk = {       0xf0, 0x8e, 0 } }, /* 08e */
+    { .mk = {      0x8f, 0 }, .brk = {       0xf0, 0x8f, 0 } }, /* 08f */
+    { .mk = {      0x90, 0 }, .brk = {       0xf0, 0x90, 0 } }, /* 090 */
+    { .mk = {      0x91, 0 }, .brk = {       0xf0, 0x91, 0 } }, /* 091 */
+    { .mk = {      0x92, 0 }, .brk = {       0xf0, 0x92, 0 } }, /* 092 */
+    { .mk = {      0x93, 0 }, .brk = {       0xf0, 0x93, 0 } }, /* 093 */
+    { .mk = {      0x94, 0 }, .brk = {       0xf0, 0x94, 0 } }, /* 094 */
+    { .mk = {      0x95, 0 }, .brk = {       0xf0, 0x95, 0 } }, /* 095 */
+    { .mk = {      0x96, 0 }, .brk = {       0xf0, 0x96, 0 } }, /* 096 */
+    { .mk = {      0x97, 0 }, .brk = {       0xf0, 0x97, 0 } }, /* 097 */
+    { .mk = {      0x98, 0 }, .brk = {       0xf0, 0x98, 0 } }, /* 098 */
+    { .mk = {      0x99, 0 }, .brk = {       0xf0, 0x99, 0 } }, /* 099 */
+    { .mk = {      0x9a, 0 }, .brk = {       0xf0, 0x9a, 0 } }, /* 09a */
+    { .mk = {      0x9b, 0 }, .brk = {       0xf0, 0x9b, 0 } }, /* 09b */
+    { .mk = {      0x9c, 0 }, .brk = {       0xf0, 0x9c, 0 } }, /* 09c */
+    { .mk = {      0x9d, 0 }, .brk = {       0xf0, 0x9d, 0 } }, /* 09d */
+    { .mk = {      0x9e, 0 }, .brk = {       0xf0, 0x9e, 0 } }, /* 09e */
+    { .mk = {      0x9f, 0 }, .brk = {       0xf0, 0x9f, 0 } }, /* 09f */
+    { .mk = {      0xa0, 0 }, .brk = {       0xf0, 0xa0, 0 } }, /* 0a0 */
+    { .mk = {      0xa1, 0 }, .brk = {       0xf0, 0xa1, 0 } }, /* 0a1 */
+    { .mk = {      0xa2, 0 }, .brk = {       0xf0, 0xa2, 0 } }, /* 0a2 */
+    { .mk = {      0xa3, 0 }, .brk = {       0xf0, 0xa3, 0 } }, /* 0a3 */
+    { .mk = {      0xa4, 0 }, .brk = {       0xf0, 0xa4, 0 } }, /* 0a4 */
+    { .mk = {      0xa5, 0 }, .brk = {       0xf0, 0xa5, 0 } }, /* 0a5 */
+    { .mk = {      0xa6, 0 }, .brk = {       0xf0, 0xa6, 0 } }, /* 0a6 */
+    { .mk = {      0xa7, 0 }, .brk = {       0xf0, 0xa7, 0 } }, /* 0a7 */
+    { .mk = {      0xa8, 0 }, .brk = {       0xf0, 0xa8, 0 } }, /* 0a8 */
+    { .mk = {      0xa9, 0 }, .brk = {       0xf0, 0xa9, 0 } }, /* 0a9 */
+    { .mk = {      0xaa, 0 }, .brk = {       0xf0, 0xaa, 0 } }, /* 0aa */
+    { .mk = {      0xab, 0 }, .brk = {       0xf0, 0xab, 0 } }, /* 0ab */
+    { .mk = {      0xac, 0 }, .brk = {       0xf0, 0xac, 0 } }, /* 0ac */
+    { .mk = {      0xad, 0 }, .brk = {       0xf0, 0xad, 0 } }, /* 0ad */
+    { .mk = {      0xae, 0 }, .brk = {       0xf0, 0xae, 0 } }, /* 0ae */
+    { .mk = {      0xaf, 0 }, .brk = {       0xf0, 0xaf, 0 } }, /* 0af */
+    { .mk = {      0xb0, 0 }, .brk = {       0xf0, 0xb0, 0 } }, /* 0b0 */
+    { .mk = {      0xb1, 0 }, .brk = {       0xf0, 0xb1, 0 } }, /* 0b1 */
+    { .mk = {      0xb2, 0 }, .brk = {       0xf0, 0xb2, 0 } }, /* 0b2 */
+    { .mk = {      0xb3, 0 }, .brk = {       0xf0, 0xb3, 0 } }, /* 0b3 */
+    { .mk = {      0xb4, 0 }, .brk = {       0xf0, 0xb4, 0 } }, /* 0b4 */
+    { .mk = {      0xb5, 0 }, .brk = {       0xf0, 0xb5, 0 } }, /* 0b5 */
+    { .mk = {      0xb6, 0 }, .brk = {       0xf0, 0xb6, 0 } }, /* 0b6 */
+    { .mk = {      0xb7, 0 }, .brk = {       0xf0, 0xb7, 0 } }, /* 0b7 */
+    { .mk = {      0xb8, 0 }, .brk = {       0xf0, 0xb8, 0 } }, /* 0b8 */
+    { .mk = {      0xb9, 0 }, .brk = {       0xf0, 0xb9, 0 } }, /* 0b9 */
+    { .mk = {      0xba, 0 }, .brk = {       0xf0, 0xba, 0 } }, /* 0ba */
+    { .mk = {      0xbb, 0 }, .brk = {       0xf0, 0xbb, 0 } }, /* 0bb */
+    { .mk = {      0xbc, 0 }, .brk = {       0xf0, 0xbc, 0 } }, /* 0bc */
+    { .mk = {      0xbd, 0 }, .brk = {       0xf0, 0xbd, 0 } }, /* 0bd */
+    { .mk = {      0xbe, 0 }, .brk = {       0xf0, 0xbe, 0 } }, /* 0be */
+    { .mk = {      0xbf, 0 }, .brk = {       0xf0, 0xbf, 0 } }, /* 0bf */
+    { .mk = {      0xc0, 0 }, .brk = {       0xf0, 0xc0, 0 } }, /* 0c0 */
+    { .mk = {      0xc1, 0 }, .brk = {       0xf0, 0xc1, 0 } }, /* 0c1 */
+    { .mk = {      0xc2, 0 }, .brk = {       0xf0, 0xc2, 0 } }, /* 0c2 */
+    { .mk = {      0xc3, 0 }, .brk = {       0xf0, 0xc3, 0 } }, /* 0c3 */
+    { .mk = {      0xc4, 0 }, .brk = {       0xf0, 0xc4, 0 } }, /* 0c4 */
+    { .mk = {      0xc5, 0 }, .brk = {       0xf0, 0xc5, 0 } }, /* 0c5 */
+    { .mk = {      0xc6, 0 }, .brk = {       0xf0, 0xc6, 0 } }, /* 0c6 */
+    { .mk = {      0xc7, 0 }, .brk = {       0xf0, 0xc7, 0 } }, /* 0c7 */
+    { .mk = {      0xc8, 0 }, .brk = {       0xf0, 0xc8, 0 } }, /* 0c8 */
+    { .mk = {      0xc9, 0 }, .brk = {       0xf0, 0xc9, 0 } }, /* 0c9 */
+    { .mk = {      0xca, 0 }, .brk = {       0xf0, 0xca, 0 } }, /* 0ca */
+    { .mk = {      0xcb, 0 }, .brk = {       0xf0, 0xcb, 0 } }, /* 0cb */
+    { .mk = {      0xcc, 0 }, .brk = {       0xf0, 0xcc, 0 } }, /* 0cc */
+    { .mk = {      0xcd, 0 }, .brk = {       0xf0, 0xcd, 0 } }, /* 0cd */
+    { .mk = {      0xce, 0 }, .brk = {       0xf0, 0xce, 0 } }, /* 0ce */
+    { .mk = {      0xcf, 0 }, .brk = {       0xf0, 0xcf, 0 } }, /* 0cf */
+    { .mk = {      0xd0, 0 }, .brk = {       0xf0, 0xd0, 0 } }, /* 0d0 */
+    { .mk = {      0xd1, 0 }, .brk = {       0xf0, 0xd0, 0 } }, /* 0d1 */
+    { .mk = {      0xd2, 0 }, .brk = {       0xf0, 0xd2, 0 } }, /* 0d2 */
+    { .mk = {      0xd3, 0 }, .brk = {       0xf0, 0xd3, 0 } }, /* 0d3 */
+    { .mk = {      0xd4, 0 }, .brk = {       0xf0, 0xd4, 0 } }, /* 0d4 */
+    { .mk = {      0xd5, 0 }, .brk = {       0xf0, 0xd5, 0 } }, /* 0d5 */
+    { .mk = {      0xd6, 0 }, .brk = {       0xf0, 0xd6, 0 } }, /* 0d6 */
+    { .mk = {      0xd7, 0 }, .brk = {       0xf0, 0xd7, 0 } }, /* 0d7 */
+    { .mk = {      0xd8, 0 }, .brk = {       0xf0, 0xd8, 0 } }, /* 0d8 */
+    { .mk = {      0xd9, 0 }, .brk = {       0xf0, 0xd9, 0 } }, /* 0d9 */
+    { .mk = {      0xda, 0 }, .brk = {       0xf0, 0xda, 0 } }, /* 0da */
+    { .mk = {      0xdb, 0 }, .brk = {       0xf0, 0xdb, 0 } }, /* 0db */
+    { .mk = {      0xdc, 0 }, .brk = {       0xf0, 0xdc, 0 } }, /* 0dc */
+    { .mk = {      0xdd, 0 }, .brk = {       0xf0, 0xdd, 0 } }, /* 0dd */
+    { .mk = {      0xde, 0 }, .brk = {       0xf0, 0xde, 0 } }, /* 0de */
+    { .mk = {      0xdf, 0 }, .brk = {       0xf0, 0xdf, 0 } }, /* 0df */
+    { .mk = {      0xe0, 0 }, .brk = {       0xf0, 0xe0, 0 } }, /* 0e0 */
+    { .mk = {      0xe1, 0 }, .brk = {       0xf0, 0xe1, 0 } }, /* 0e1 */
+    { .mk = {      0xe2, 0 }, .brk = {       0xf0, 0xe2, 0 } }, /* 0e2 */
+    { .mk = {      0xe3, 0 }, .brk = {       0xf0, 0xe3, 0 } }, /* 0e3 */
+    { .mk = {      0xe4, 0 }, .brk = {       0xf0, 0xe4, 0 } }, /* 0e4 */
+    { .mk = {      0xe5, 0 }, .brk = {       0xf0, 0xe5, 0 } }, /* 0e5 */
+    { .mk = {      0xe6, 0 }, .brk = {       0xf0, 0xe6, 0 } }, /* 0e6 */
+    { .mk = {      0xe7, 0 }, .brk = {       0xf0, 0xe7, 0 } }, /* 0e7 */
+    { .mk = {      0xe8, 0 }, .brk = {       0xf0, 0xe8, 0 } }, /* 0e8 */
+    { .mk = {      0xe9, 0 }, .brk = {       0xf0, 0xe9, 0 } }, /* 0e9 */
+    { .mk = {      0xea, 0 }, .brk = {       0xf0, 0xea, 0 } }, /* 0ea */
+    { .mk = {      0xeb, 0 }, .brk = {       0xf0, 0xeb, 0 } }, /* 0eb */
+    { .mk = {      0xec, 0 }, .brk = {       0xf0, 0xec, 0 } }, /* 0ec */
+    { .mk = {      0xed, 0 }, .brk = {       0xf0, 0xed, 0 } }, /* 0ed */
+    { .mk = {      0xee, 0 }, .brk = {       0xf0, 0xee, 0 } }, /* 0ee */
+    { .mk = {      0xef, 0 }, .brk = {       0xf0, 0xef, 0 } }, /* 0ef */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 0f0 */
+    { .mk = {      0xf1, 0 }, .brk = {       0xf0, 0xf1, 0 } }, /* 0f1 */
+    { .mk = {      0xf2, 0 }, .brk = {       0xf0, 0xf2, 0 } }, /* 0f2 */
+    { .mk = {      0xf3, 0 }, .brk = {       0xf0, 0xf3, 0 } }, /* 0f3 */
+    { .mk = {      0xf4, 0 }, .brk = {       0xf0, 0xf4, 0 } }, /* 0f4 */
+    { .mk = {      0xf5, 0 }, .brk = {       0xf0, 0xf5, 0 } }, /* 0f5 */
+    { .mk = {      0xf6, 0 }, .brk = {       0xf0, 0xf6, 0 } }, /* 0f6 */
+    { .mk = {      0xf7, 0 }, .brk = {       0xf0, 0xf7, 0 } }, /* 0f7 */
+    { .mk = {      0xf8, 0 }, .brk = {       0xf0, 0xf8, 0 } }, /* 0f8 */
+    { .mk = {      0xf9, 0 }, .brk = {       0xf0, 0xf9, 0 } }, /* 0f9 */
+    { .mk = {      0xfa, 0 }, .brk = {       0xf0, 0xfa, 0 } }, /* 0fa */
+    { .mk = {      0xfb, 0 }, .brk = {       0xf0, 0xfb, 0 } }, /* 0fb */
+    { .mk = {      0xfc, 0 }, .brk = {       0xf0, 0xfc, 0 } }, /* 0fc */
+    { .mk = {      0xfd, 0 }, .brk = {       0xf0, 0xfd, 0 } }, /* 0fd */
+    { .mk = {      0xfe, 0 }, .brk = {       0xf0, 0xfe, 0 } }, /* 0fe */
+    { .mk = {      0xff, 0 }, .brk = {       0xf0, 0xff, 0 } }, /* 0ff */
+    { .mk = {0xe1, 0x14, 0 }, .brk = { 0xe1, 0xf0, 0x14, 0 } }, /* 100 */
+    { .mk = {0xe0, 0x76, 0 }, .brk = { 0xe0, 0xF0, 0x76, 0 } }, /* 101 */
+    { .mk = {0xe0, 0x16, 0 }, .brk = { 0xe0, 0xF0, 0x16, 0 } }, /* 102 */
+    { .mk = {0xe0, 0x1E, 0 }, .brk = { 0xe0, 0xF0, 0x1E, 0 } }, /* 103 */
+    { .mk = {0xe0, 0x26, 0 }, .brk = { 0xe0, 0xF0, 0x26, 0 } }, /* 104 */
+    { .mk = {0xe0, 0x25, 0 }, .brk = { 0xe0, 0xF0, 0x25, 0 } }, /* 105 */
+    { .mk = {0xe0, 0x2E, 0 }, .brk = { 0xe0, 0xF0, 0x2E, 0 } }, /* 106 */
+    { .mk = {0xe0, 0x36, 0 }, .brk = { 0xe0, 0xF0, 0x36, 0 } }, /* 107 */
+    { .mk = {0xe0, 0x3D, 0 }, .brk = { 0xe0, 0xF0, 0x3D, 0 } }, /* 108 */
+    { .mk = {0xe0, 0x3E, 0 }, .brk = { 0xe0, 0xF0, 0x3E, 0 } }, /* 109 */
+    { .mk = {0xe0, 0x46, 0 }, .brk = { 0xe0, 0xF0, 0x46, 0 } }, /* 10a */
+    { .mk = {0xe0, 0x45, 0 }, .brk = { 0xe0, 0xF0, 0x45, 0 } }, /* 10b */
+    { .mk = {0xe0, 0x4E, 0 }, .brk = { 0xe0, 0xF0, 0x4E, 0 } }, /* 10c */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 10d */
+    { .mk = {0xe0, 0x66, 0 }, .brk = { 0xe0, 0xF0, 0x66, 0 } }, /* 10e */
+    { .mk = {0xe0, 0x0D, 0 }, .brk = { 0xe0, 0xF0, 0x0D, 0 } }, /* 10f */
+    { .mk = {0xe0, 0x15, 0 }, .brk = { 0xe0, 0xF0, 0x15, 0 } }, /* 110 */
+    { .mk = {0xe0, 0x1D, 0 }, .brk = { 0xe0, 0xF0, 0x1D, 0 } }, /* 112 */
+    { .mk = {0xe0, 0x24, 0 }, .brk = { 0xe0, 0xF0, 0x24, 0 } }, /* 113 */
+    { .mk = {0xe0, 0x2D, 0 }, .brk = { 0xe0, 0xF0, 0x2D, 0 } }, /* 113 */
+    { .mk = {0xe0, 0x2C, 0 }, .brk = { 0xe0, 0xF0, 0x2C, 0 } }, /* 114 */
+    { .mk = {0xe0, 0x35, 0 }, .brk = { 0xe0, 0xF0, 0x35, 0 } }, /* 115 */
+    { .mk = {0xe0, 0x3C, 0 }, .brk = { 0xe0, 0xF0, 0x3C, 0 } }, /* 116 */
+    { .mk = {0xe0, 0x43, 0 }, .brk = { 0xe0, 0xF0, 0x43, 0 } }, /* 117 */
+    { .mk = {0xe0, 0x44, 0 }, .brk = { 0xe0, 0xF0, 0x44, 0 } }, /* 118 */
+    { .mk = {0xe0, 0x4D, 0 }, .brk = { 0xe0, 0xF0, 0x4D, 0 } }, /* 119 */
+    { .mk = {0xe0, 0x54, 0 }, .brk = { 0xe0, 0xF0, 0x54, 0 } }, /* 11a */
+    { .mk = {0xe0, 0x5B, 0 }, .brk = { 0xe0, 0xF0, 0x5B, 0 } }, /* 11b */
+    { .mk = {0xe0, 0x5A, 0 }, .brk = { 0xe0, 0xF0, 0x5A, 0 } }, /* 11c */
+    { .mk = {0xe0, 0x14, 0 }, .brk = { 0xe0, 0xF0, 0x14, 0 } }, /* 11d */
+    { .mk = {0xe0, 0x1C, 0 }, .brk = { 0xe0, 0xF0, 0x1C, 0 } }, /* 11e */
+    { .mk = {0xe0, 0x1B, 0 }, .brk = { 0xe0, 0xF0, 0x1B, 0 } }, /* 11f */
+    { .mk = {0xe0, 0x23, 0 }, .brk = { 0xe0, 0xF0, 0x23, 0 } }, /* 120 */
+    { .mk = {0xe0, 0x2B, 0 }, .brk = { 0xe0, 0xF0, 0x2B, 0 } }, /* 121 */
+    { .mk = {0xe0, 0x34, 0 }, .brk = { 0xe0, 0xF0, 0x34, 0 } }, /* 122 */
+    { .mk = {0xe0, 0x33, 0 }, .brk = { 0xe0, 0xF0, 0x33, 0 } }, /* 123 */
+    { .mk = {0xe0, 0x3B, 0 }, .brk = { 0xe0, 0xF0, 0x3B, 0 } }, /* 124 */
+    { .mk = {0xe0, 0x42, 0 }, .brk = { 0xe0, 0xF0, 0x42, 0 } }, /* 125 */
+    { .mk = {0xe0, 0x4B, 0 }, .brk = { 0xe0, 0xF0, 0x4B, 0 } }, /* 126 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 127 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 128 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 129 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 12a */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 12b */
+    { .mk = {0xe0, 0x1A, 0 }, .brk = { 0xe0, 0xF0, 0x1A, 0 } }, /* 12c */
+    { .mk = {0xe0, 0x22, 0 }, .brk = { 0xe0, 0xF0, 0x22, 0 } }, /* 12d */
+    { .mk = {0xe0, 0x21, 0 }, .brk = { 0xe0, 0xF0, 0x21, 0 } }, /* 12e */
+    { .mk = {0xe0, 0x2A, 0 }, .brk = { 0xe0, 0xF0, 0x2A, 0 } }, /* 12f */
+    { .mk = {0xe0, 0x32, 0 }, .brk = { 0xe0, 0xF0, 0x32, 0 } }, /* 130 */
+    { .mk = {0xe0, 0x31, 0 }, .brk = { 0xe0, 0xF0, 0x31, 0 } }, /* 131 */
+    { .mk = {0xe0, 0x3A, 0 }, .brk = { 0xe0, 0xF0, 0x3A, 0 } }, /* 132 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 133 */
+    { .mk = {0xe0, 0x49, 0 }, .brk = { 0xe0, 0xF0, 0x49, 0 } }, /* 134 */
+    { .mk = {0xe0, 0x4A, 0 }, .brk = { 0xe0, 0xF0, 0x4A, 0 } }, /* 135 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 136 */
+    { .mk = {0xe0, 0x7C, 0 }, .brk = { 0xe0, 0xF0, 0x7C, 0 } }, /* 137 */
+    { .mk = {0xe0, 0x11, 0 }, .brk = { 0xe0, 0xF0, 0x11, 0 } }, /* 138* 0x31 R-Alt */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 139 */
+    { .mk = {0xe0, 0x58, 0 }, .brk = { 0xe0, 0xF0, 0x58, 0 } }, /* 13a */
+    { .mk = {0xe0, 0x05, 0 }, .brk = { 0xe0, 0xF0, 0x05, 0 } }, /* 13b */
+    { .mk = {0xe0, 0x06, 0 }, .brk = { 0xe0, 0xF0, 0x06, 0 } }, /* 13c */
+    { .mk = {0xe0, 0x04, 0 }, .brk = { 0xe0, 0xF0, 0x04, 0 } }, /* 13d */
+    { .mk = {0xe0, 0x0C, 0 }, .brk = { 0xe0, 0xF0, 0x0C, 0 } }, /* 13e */
+    { .mk = {0xe0, 0x03, 0 }, .brk = { 0xe0, 0xF0, 0x03, 0 } }, /* 13f */
+    { .mk = {0xe0, 0x0B, 0 }, .brk = { 0xe0, 0xF0, 0x0B, 0 } }, /* 140 */
+    { .mk = {0xe0, 0x02, 0 }, .brk = { 0xe0, 0xF0, 0x02, 0 } }, /* 141 */
+    { .mk = {0xe0, 0x0A, 0 }, .brk = { 0xe0, 0xF0, 0x0A, 0 } }, /* 142 */
+    { .mk = {0xe0, 0x01, 0 }, .brk = { 0xe0, 0xF0, 0x01, 0 } }, /* 143 */
+    { .mk = {0xe0, 0x09, 0 }, .brk = { 0xe0, 0xF0, 0x09, 0 } }, /* 144 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 145 */
+    { .mk = {0xe0, 0x7E, 0 }, .brk = { 0xe0, 0xF0, 0x7E, 0 } }, /* 146 */
+    { .mk = {0xe0, 0x6C, 0 }, .brk = { 0xe0, 0xF0, 0x6C, 0 } }, /* 147 */
+    { .mk = {0xe0, 0x75, 0 }, .brk = { 0xe0, 0xF0, 0x75, 0 } }, /* 148 */
+    { .mk = {0xe0, 0x7D, 0 }, .brk = { 0xe0, 0xF0, 0x7D, 0 } }, /* 149 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 14a */
+    { .mk = {0xe0, 0x6B, 0 }, .brk = { 0xe0, 0xF0, 0x6B, 0 } }, /* 14b */
+    { .mk = {0xe0, 0x73, 0 }, .brk = { 0xe0, 0xF0, 0x73, 0 } }, /* 14c */
+    { .mk = {0xe0, 0x74, 0 }, .brk = { 0xe0, 0xF0, 0x74, 0 } }, /* 14d */
+    { .mk = {0xe0, 0x79, 0 }, .brk = { 0xe0, 0xF0, 0x79, 0 } }, /* 14e */
+    { .mk = {0xe0, 0x69, 0 }, .brk = { 0xe0, 0xF0, 0x69, 0 } }, /* 14f */
+    { .mk = {0xe0, 0x72, 0 }, .brk = { 0xe0, 0xF0, 0x72, 0 } }, /* 150 */
+    { .mk = {0xe0, 0x7A, 0 }, .brk = { 0xe0, 0xF0, 0x7A, 0 } }, /* 151 */
+    { .mk = {0xe0, 0x70, 0 }, .brk = { 0xe0, 0xF0, 0x70, 0 } }, /* 152 */
+    { .mk = {0xe0, 0x71, 0 }, .brk = { 0xe0, 0xF0, 0x71, 0 } }, /* 153 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 154 */
+    { .mk = {0xe0, 0x60, 0 }, .brk = { 0xe0, 0xF0, 0x60, 0 } }, /* 155 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 156 */
+    { .mk = {0xe0, 0x78, 0 }, .brk = { 0xe0, 0xF0, 0x78, 0 } }, /* 157 */
+    { .mk = {0xe0, 0x07, 0 }, .brk = { 0xe0, 0xF0, 0x07, 0 } }, /* 158 */
+    { .mk = {0xe0, 0x0F, 0 }, .brk = { 0xe0, 0xF0, 0x0F, 0 } }, /* 159 */
+    { .mk = {0xe0, 0x17, 0 }, .brk = { 0xe0, 0xF0, 0x17, 0 } }, /* 15a */
+    { .mk = {      0x67, 0 }, .brk = {       0xf0, 0x67, 0 } }, /* 15b 0x33 LGUI->Muhenkan (in emulator only) */
+    { .mk = {      0x64, 0 }, .brk = {       0xf0, 0x64, 0 } }, /* 15c 0x35 RGUI->Henkan (in emulator only) */
+    { .mk = {0xe0, 0x11, 0 }, .brk = { 0xe0, 0xf0, 0x11, 0 } }, /* 15d 0x36 APPLICATION->Kana (in emulator only) */
+    { .mk = {0xe0, 0x37, 0 }, .brk = { 0xe0, 0xF0, 0x37, 0 } }, /* 15e */
+    { .mk = {0xe0, 0x3F, 0 }, .brk = { 0xe0, 0xF0, 0x3F, 0 } }, /* 15f */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 160 */
+    { .mk = {0xe0, 0x4F, 0 }, .brk = { 0xe0, 0xF0, 0x4F, 0 } }, /* 161 */
+    { .mk = {0xe0, 0x56, 0 }, .brk = { 0xe0, 0xF0, 0x56, 0 } }, /* 162 */
+    { .mk = {0xe0, 0x5E, 0 }, .brk = { 0xe0, 0xF0, 0x5E, 0 } }, /* 163 */
+    { .mk = {0xe0, 0x08, 0 }, .brk = { 0xe0, 0xF0, 0x08, 0 } }, /* 164 */
+    { .mk = {0xe0, 0x10, 0 }, .brk = { 0xe0, 0xF0, 0x10, 0 } }, /* 165 */
+    { .mk = {0xe0, 0x18, 0 }, .brk = { 0xe0, 0xF0, 0x18, 0 } }, /* 166 */
+    { .mk = {0xe0, 0x20, 0 }, .brk = { 0xe0, 0xF0, 0x20, 0 } }, /* 167 */
+    { .mk = {0xe0, 0x28, 0 }, .brk = { 0xe0, 0xF0, 0x28, 0 } }, /* 168 */
+    { .mk = {0xe0, 0x30, 0 }, .brk = { 0xe0, 0xF0, 0x30, 0 } }, /* 169 */
+    { .mk = {0xe0, 0x38, 0 }, .brk = { 0xe0, 0xF0, 0x38, 0 } }, /* 16a */
+    { .mk = {0xe0, 0x40, 0 }, .brk = { 0xe0, 0xF0, 0x40, 0 } }, /* 16b */
+    { .mk = {0xe0, 0x48, 0 }, .brk = { 0xe0, 0xF0, 0x48, 0 } }, /* 16c */
+    { .mk = {0xe0, 0x50, 0 }, .brk = { 0xe0, 0xF0, 0x50, 0 } }, /* 16d */
+    { .mk = {0xe0, 0x57, 0 }, .brk = { 0xe0, 0xF0, 0x57, 0 } }, /* 16e */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 16f */
+    { .mk = {0xe0, 0x13, 0 }, .brk = { 0xe0, 0xF0, 0x13, 0 } }, /* 170 */
+    { .mk = {0xe0, 0x19, 0 }, .brk = { 0xe0, 0xF0, 0x19, 0 } }, /* 171 */
+    { .mk = {0xe0, 0x39, 0 }, .brk = { 0xe0, 0xF0, 0x39, 0 } }, /* 172 */
+    { .mk = {0xe0, 0x51, 0 }, .brk = { 0xe0, 0xF0, 0x51, 0 } }, /* 173 */
+    { .mk = {0xe0, 0x53, 0 }, .brk = { 0xe0, 0xF0, 0x53, 0 } }, /* 174 */
+    { .mk = {0xe0, 0x5C, 0 }, .brk = { 0xe0, 0xF0, 0x5C, 0 } }, /* 175 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 176 */
+    { .mk = {0xe0, 0x62, 0 }, .brk = { 0xe0, 0xF0, 0x62, 0 } }, /* 177 */
+    { .mk = {0xe0, 0x63, 0 }, .brk = { 0xe0, 0xF0, 0x63, 0 } }, /* 178 */
+    { .mk = {0xe0, 0x64, 0 }, .brk = { 0xe0, 0xF0, 0x64, 0 } }, /* 179 */
+    { .mk = {0xe0, 0x65, 0 }, .brk = { 0xe0, 0xF0, 0x65, 0 } }, /* 17a */
+    { .mk = {0xe0, 0x67, 0 }, .brk = { 0xe0, 0xF0, 0x67, 0 } }, /* 17b */
+    { .mk = {0xe0, 0x68, 0 }, .brk = { 0xe0, 0xF0, 0x68, 0 } }, /* 17c */
+    { .mk = {0xe0, 0x6A, 0 }, .brk = { 0xe0, 0xF0, 0x6A, 0 } }, /* 17d */
+    { .mk = {0xe0, 0x6D, 0 }, .brk = { 0xe0, 0xF0, 0x6D, 0 } }, /* 17e */
+    { .mk = {0xe0, 0x6E, 0 }, .brk = { 0xe0, 0xF0, 0x6E, 0 } }, /* 17f */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 180 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 181 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 182 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 183 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 184 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 185 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 186 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 187 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 188 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 189 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 18a */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 18b */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 18c */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 18d */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 18e */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 18f */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 190 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 191 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 192 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 193 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 194 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 195 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 196 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 197 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 198 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 199 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 19a */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 19b */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 19c */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 19d */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 19e */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 19f */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1a0 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1a1 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1a2 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1a3 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1a4 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1a5 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1a6 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1a7 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1a8 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1a9 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1aa */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1ab */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1ac */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1ad */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1ae */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1af */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1b0 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1b1 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1b2 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1b3 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1b4 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1b5 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1b6 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1b7 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1b8 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1b9 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1ba */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1bb */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1bc */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1bd */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1be */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1bf */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1c0 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1c1 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1c2 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1c3 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1c4 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1c5 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1c6 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1c7 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1c8 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1c9 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1ca */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1cb */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1cv */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1cd */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1ce */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1cf */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1d0 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1d1 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1d2 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1d3 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1d4 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1d5 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1d6 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1d7 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1d8 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1d9 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1da */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1db */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1dc */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1dd */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1de */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1df */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1e0 */
+    { .mk = {0xe0, 0xe1, 0 }, .brk = { 0xe0, 0xF0, 0xE1, 0 } }, /* 1e1 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1e2 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1e3 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1e4 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1e5 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1e6 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1e7 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1e8 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1e9 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1ea */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1eb */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1ec */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1ed */
+    { .mk = {0xe0, 0xee, 0 }, .brk = { 0xe0, 0xF0, 0xEE, 0 } }, /* 1ee */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1ef */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1f0 */
+    { .mk = {0xe0, 0xf1, 0 }, .brk = { 0xe0, 0xF0, 0xF1, 0 } }, /* 1f1 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1f2 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1f3 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1f4 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1f5 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1f6 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1f7 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1f8 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1f9 */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1fa */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1fb */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1fc */
+    { .mk = {            0 }, .brk = {                   0 } }, /* 1fd */
+    { .mk = {0xe0, 0xfe, 0 }, .brk = { 0xe0, 0xF0, 0xFE, 0 } }, /* 1fe */
+    { .mk = {0xe0, 0xff, 0 }, .brk = { 0xe0, 0xF0, 0xFF, 0 } }  /* 1ff */
+  // clang-format on
+};
 /* Scancode set 8Ah : IBM 5556 keyboard compatible scancode set used by J-DOS */
 static scancode scancode_set8a[512] =
 {
@@ -1700,9 +2736,9 @@ static scancode scancode_set8a[512] =
       {.mk = { 0x14, 0 }, .brk = {       0 } }, /* 026 */
       {.mk = { 0x15, 0 }, .brk = {       0 } }, /* 027 */
       {.mk = { 0x16, 0 }, .brk = {       0 } }, /* 028* */
-      {.mk = { 0x45, 0 }, .brk = {       0 } }, /* 029 Hankaku, Zenkaku */
+      {.mk = { 0x45, 0 }, .brk = {       0 } }, /* 029 0x45 Hankaku, Zenkaku */
       {.mk = { 0x38, 0 }, .brk = { 0xb8, 0 } }, /* 02a LSHIFT */
-      {.mk = { 0x17, 0 }, .brk = {       0 } }, /* 02b Mu */
+      {.mk = { 0x17, 0 }, .brk = {       0 } }, /* 02b 0x17 Mu */
       {.mk = { 0x01, 0 }, .brk = {       0 } }, /* 02c */
       {.mk = { 0x02, 0 }, .brk = {       0 } }, /* 02d */
       {.mk = { 0x03, 0 }, .brk = {       0 } }, /* 02e */
@@ -1715,7 +2751,7 @@ static scancode scancode_set8a[512] =
       {.mk = { 0x0a, 0 }, .brk = {       0 } }, /* 035 */
       {.mk = { 0x39, 0 }, .brk = { 0xb9, 0 } }, /* 036 RSHIFT */
       {.mk = { 0x64, 0 }, .brk = {       0 } }, /* 037 * (asterisk) */
-      {.mk = { 0x3A, 0 }, .brk = { 0xba, 0 } }, /* 038 LALT = Kanji */
+      {.mk = { 0x3A, 0 }, .brk = { 0xba, 0 } }, /* 038 0x3A LALT = Kanji */
       {.mk = { 0x34, 0 }, .brk = {       0 } }, /* 039 */
       {.mk = { 0x32, 0 }, .brk = { 0xb2, 0 } }, /* 03a CAPSLOCK */
       {.mk = { 0x68, 0 }, .brk = {       0 } }, /* 03b F1 */
@@ -1728,8 +2764,8 @@ static scancode scancode_set8a[512] =
       {.mk = { 0x6f, 0 }, .brk = {       0 } }, /* 042 */
       {.mk = { 0x70, 0 }, .brk = {       0 } }, /* 043 */
       {.mk = { 0x71, 0 }, .brk = {       0 } }, /* 044 F10 */
-      {.mk = {       0 }, .brk = {       0 } }, /* 045 NUMLOCKCLEAR -> Shift + SCRLOCK :TODO */
-      {.mk = { 0x75, 0 }, .brk = {       0 } }, /* 046 SCROLLLOCK */
+      {.mk = { 0x47, 0 }, .brk = {       0 } }, /* 045 NUMLOCKCLEAR -> Shift + SCRLOCK :TODO */
+      {.mk = { 0x75, 0 }, .brk = {       0 } }, /* 046 0x75 SCROLLLOCK */
       {.mk = { 0x5d, 0 }, .brk = {       0 } }, /* 047 KP7 */
       {.mk = { 0x5e, 0 }, .brk = {       0 } }, /* 048 */
       {.mk = { 0x5f, 0 }, .brk = {       0 } }, /* 049 */
@@ -1771,20 +2807,20 @@ static scancode scancode_set8a[512] =
       {.mk = {       0 }, .brk = {       0 } }, /* 06d */
       {.mk = {       0 }, .brk = {       0 } }, /* 06e */
       {.mk = {       0 }, .brk = {       0 } }, /* 06f */
-      {.mk = { 0x36, 0 }, .brk = { 0xb6, 0 } }, /* 070 Kana */
+      {.mk = { 0x36, 0 }, .brk = { 0xb6, 0 } }, /* 070 0x36 Kana */
       {.mk = {       0 }, .brk = {       0 } }, /* 071 */
       {.mk = {       0 }, .brk = {       0 } }, /* 072 */
-      {.mk = { 0x0b, 0 }, .brk = {       0 } }, /* 073 Ro, Underline */
+      {.mk = { 0x0b, 0 }, .brk = {       0 } }, /* 073 0x0b Ro, Underline */
       {.mk = {       0 }, .brk = {       0 } }, /* 074 */
       {.mk = {       0 }, .brk = {       0 } }, /* 075 */
       {.mk = {       0 }, .brk = {       0 } }, /* 076 */
       {.mk = {       0 }, .brk = {       0 } }, /* 077 */
       {.mk = {       0 }, .brk = {       0 } }, /* 078 */
-      {.mk = { 0x35, 0 }, .brk = {       0 } }, /* 079 Henkan */
+      {.mk = { 0x35, 0 }, .brk = {       0 } }, /* 079 0x35 Henkan */
       {.mk = {       0 }, .brk = {       0 } }, /* 07a */
-      {.mk = { 0x33, 0 }, .brk = {       0 } }, /* 07b Muhenkan */
+      {.mk = { 0x33, 0 }, .brk = {       0 } }, /* 07b 0x33 Muhenkan */
       {.mk = {       0 }, .brk = {       0 } }, /* 07c */
-      {.mk = { 0x30, 0 }, .brk = {       0 } }, /* 07d Yen, Vertical line */
+      {.mk = { 0x30, 0 }, .brk = {       0 } }, /* 07d 0x30 Yen, Vertical line */
       {.mk = {       0 }, .brk = {       0 } }, /* 07e */
       {.mk = {       0 }, .brk = {       0 } }, /* 07f */
       {.mk = {       0 }, .brk = {       0 } }, /* 080 */
@@ -1915,7 +2951,7 @@ static scancode scancode_set8a[512] =
       {.mk = {       0 }, .brk = {       0 } }, /* 0fd */
       {.mk = {       0 }, .brk = {       0 } }, /* 0fe */
       {.mk = {       0 }, .brk = {       0 } }, /* 0ff */
-      {.mk = { 0x47, 0 }, .brk = {       0 } }, /* 100 Pause */
+      {.mk = {       0 }, .brk = {       0 } }, /* 100 */
       {.mk = {       0 }, .brk = {       0 } }, /* 101 */
       {.mk = {       0 }, .brk = {       0 } }, /* 102 */
       {.mk = {       0 }, .brk = {       0 } }, /* 103 */
@@ -1971,7 +3007,7 @@ static scancode scancode_set8a[512] =
       {.mk = { 0x65, 0 }, .brk = {       0 } }, /* 135 KP_DIVIDE */
       {.mk = {       0 }, .brk = {       0 } }, /* 136 */
       {.mk = { 0x74, 0 }, .brk = {       0 } }, /* 137 PRINTSCREEN */
-      {.mk = { 0x31, 0 }, .brk = { 0xb1, 0 } }, /* 138* R-Alt */
+      {.mk = { 0x31, 0 }, .brk = { 0xb1, 0 } }, /* 138* 0x31 R-Alt */
       {.mk = {       0 }, .brk = {       0 } }, /* 139 */
       {.mk = {       0 }, .brk = {       0 } }, /* 13a */
       {.mk = {       0 }, .brk = {       0 } }, /* 13b */
@@ -2006,9 +3042,9 @@ static scancode scancode_set8a[512] =
       {.mk = {       0 }, .brk = {       0 } }, /* 158 */
       {.mk = {       0 }, .brk = {       0 } }, /* 159 */
       {.mk = {       0 }, .brk = {       0 } }, /* 15a */
-      {.mk = { 0x33, 0 }, .brk = {       0 } }, /* 15b LGUI->Muhenkan (in emulator only) */
-      {.mk = { 0x35, 0 }, .brk = {       0 } }, /* 15c RGUI->Henkan (in emulator only) */
-      {.mk = { 0x36, 0 }, .brk = { 0xb6, 0 } }, /* 15d APPLICATION->Kana (in emulator only) */
+      {.mk = { 0x33, 0 }, .brk = {       0 } }, /* 15b 0x33 LGUI->Muhenkan (in emulator only) */
+      {.mk = { 0x35, 0 }, .brk = {       0 } }, /* 15c 0x35 RGUI->Henkan (in emulator only) */
+      {.mk = { 0x36, 0 }, .brk = { 0xb6, 0 } }, /* 15d 0x36 APPLICATION->Kana (in emulator only) */
       {.mk = {       0 }, .brk = {       0 } }, /* 15e */
       {.mk = {       0 }, .brk = {       0 } }, /* 15f */
       {.mk = {       0 }, .brk = {       0 } }, /* 160 */
@@ -2209,6 +3245,14 @@ keyboard_at_set_scancode_set(void)
             keyboard_set_table(scancode_set3);
             break;
 
+        case 0x81:
+            keyboard_set_table(scancode_set81);
+            break;
+
+        case 0x82:
+            keyboard_set_table(scancode_set82);
+            break;
+
         case 0x8a:
             keyboard_set_table(scancode_set8a);
             break;
@@ -2477,6 +3521,8 @@ keyboard_at_write(void *priv)
                         kbc_at_dev_queue_add(dev, keyboard_mode, 0);
                         break;
                     case 0x01 ... 0x03:
+                    case 0x81:
+                    case 0x82:
                     case 0x8a:
                         kbc_at_dev_queue_add(dev, 0xfa, 0); /* ACK */
                         keyboard_mode = val;
@@ -2560,7 +3606,7 @@ keyboard_at_write(void *priv)
                 break;
 
             case 0xf2: /* read ID */
-                keyboard_at_log("%s: read keyboard id\n", dev->name);
+                keyboard_at_log("%s: read keyboard id: ", dev->name);
                 /* TODO: After keyboard type selection is implemented, make this
                          return the correct keyboard ID for the selected type. */
                 kbc_at_dev_queue_add(dev, 0xfa, 0);
@@ -2569,7 +3615,9 @@ keyboard_at_write(void *priv)
                         break;
 
                     kbc_at_dev_queue_add(dev, id_bytes[dev->type][i], 0);
+                    keyboard_at_log("%02X ", id_bytes[dev->type][i]);
                 }
+                keyboard_at_log("\n");
                 break;
 
             case 0xf3: /* set command mode */
@@ -2695,6 +3743,13 @@ keyboard_at_init(const device_t *info)
        Key 65? = Japanese key between right Ctrl and right Alt, scan code: 87 (Hiragana/Katakana 70).
      */
     dev->type = FLAG_PS2 | KBD_102_KEY /* device_get_config_int("type") */;
+    /*
+        We assume that the IBM PS/55 machine uses the 5576-002 keyboard (JP/CN layout) here.
+        This is not smart but suitable for supporting a keyboard ID that is rarely used in standard PCs.
+        At least, the Taiwanese PS/55 uses the same keyboard ID and scancode set. The Korean one is unknown.
+    */
+    if (!!strstr(machine_getname(), "PS/55")) 
+        dev->type = FLAG_PS2 | KBD_JIS;
 
     keyboard_at_log("%s: type=%d\n", dev->name, dev->type);
 
diff --git a/src/device/mouse_bus.c b/src/device/mouse_bus.c
index 7074a71ac..c81bc6aba 100644
--- a/src/device/mouse_bus.c
+++ b/src/device/mouse_bus.c
@@ -815,7 +815,7 @@ static const device_config_t ms_config[] = {
 const device_t mouse_logibus_device = {
     .name          = "Logitech/Microsoft Bus Mouse",
     .internal_name = "logibus",
-    .flags         = DEVICE_ISA,
+    .flags         = DEVICE_ISA | DEVICE_SIDECAR,
     .local         = MOUSE_TYPE_LOGIBUS,
     .init          = bm_init,
     .close         = bm_close,
@@ -843,7 +843,7 @@ const device_t mouse_logibus_onboard_device = {
 const device_t mouse_msinport_device = {
     .name          = "Microsoft Bus Mouse (InPort)",
     .internal_name = "msbus",
-    .flags         = DEVICE_ISA,
+    .flags         = DEVICE_ISA | DEVICE_SIDECAR,
     .local         = MOUSE_TYPE_INPORT,
     .init          = bm_init,
     .close         = bm_close,
diff --git a/src/disk/mo.c b/src/disk/mo.c
index 5494fc9a8..7808e524e 100644
--- a/src/disk/mo.c
+++ b/src/disk/mo.c
@@ -1461,6 +1461,7 @@ mo_command(scsi_common_t *sc, const uint8_t *cdb)
             break;
 
         case GPCMD_WRITE_SAME_10:
+            mo_set_phase(dev, SCSI_PHASE_DATA_OUT);
             alloc_length = 512;
 
             if ((cdb[1] & 6) == 6)
diff --git a/src/disk/zip.c b/src/disk/zip.c
index 72781281a..f579f23ec 100644
--- a/src/disk/zip.c
+++ b/src/disk/zip.c
@@ -1506,6 +1506,7 @@ zip_command(scsi_common_t *sc, const uint8_t *cdb)
             break;
 
         case GPCMD_WRITE_SAME_10:
+            zip_set_phase(dev, SCSI_PHASE_DATA_OUT);
             alloc_length = 512;
 
             if ((cdb[1] & 6) == 6)
diff --git a/src/include/86box/device.h b/src/include/86box/device.h
index 1c3ef1ef3..4cc283a25 100644
--- a/src/include/86box/device.h
+++ b/src/include/86box/device.h
@@ -79,6 +79,7 @@
 // #define CONFIG_STANDALONE 257      /* not available on the on-board variant */
 
 enum {
+    DEVICE_CASETTE   = 1,          /* requires a Casette Port */
     DEVICE_SIDECAR   = 2,          /* requires an IBM PCjr */
     DEVICE_ISA       = 4,          /* requires the ISA bus */
     DEVICE_XT_KBC    = 8,          /* requires an XT-compatible keyboard controller */
diff --git a/src/include/86box/keyboard.h b/src/include/86box/keyboard.h
index ec5c05775..110e4f760 100644
--- a/src/include/86box/keyboard.h
+++ b/src/include/86box/keyboard.h
@@ -269,6 +269,7 @@ extern void     keyboard_poll_host(void);
 extern void     keyboard_process(void);
 extern uint16_t keyboard_convert(int ch);
 extern void     keyboard_input(int down, uint16_t scan);
+extern void     keyboard_all_up(void);
 extern void     keyboard_update_states(uint8_t cl, uint8_t nl, uint8_t sl);
 extern uint8_t  keyboard_get_shift(void);
 extern void     keyboard_get_states(uint8_t *cl, uint8_t *nl, uint8_t *sl);
diff --git a/src/include/86box/machine.h b/src/include/86box/machine.h
index 78f4902eb..b2e4c01f2 100644
--- a/src/include/86box/machine.h
+++ b/src/include/86box/machine.h
@@ -48,7 +48,7 @@
 #define MACHINE_BUS_AGP       0x00080000 /* sys has AGP bus */
 #define MACHINE_BUS_AC97      0x00100000 /* sys has AC97 bus (ACR/AMR/CNR slot) */
 /* Aliases. */
-#define MACHINE_CASSETTE    (MACHINE_BUS_CASSETTE)  /* sys has cassette port */
+#define MACHINE_CASSETTE    (MACHINE_BUS_CASSETTE) /* sys has cassette port */
 /* Combined flags. */
 #define MACHINE_PC          (MACHINE_BUS_ISA)                     /* sys is PC/XT-compatible (ISA) */
 #define MACHINE_AT          (MACHINE_BUS_ISA | MACHINE_BUS_ISA16) /* sys is AT-compatible (ISA + ISA16) */
@@ -67,18 +67,19 @@
 #define MACHINE_AGP         (MACHINE_BUS_AGP | MACHINE_PCI)       /* sys is AT-compatible with AGP  */
 #define MACHINE_AGP98       (MACHINE_BUS_AGP | MACHINE_PCI98)     /* sys is NEC PC-98x1 series with AGP (did that even exist?) */
 
-#define MACHINE_PC5150      (MACHINE_PC | MACHINE_CASSETTE)                       /* sys is IBM PC 5150 */
-#define MACHINE_PCJR        (MACHINE_PC | MACHINE_CASSETTE | MACHINE_BUS_SIDECAR) /* sys is PCjr */
-#define MACHINE_PS2         (MACHINE_AT | MACHINE_BUS_PS2)                        /* sys is PS/2 */
-#define MACHINE_PS2_MCA     (MACHINE_MCA | MACHINE_BUS_PS2)                       /* sys is MCA PS/2 */
-#define MACHINE_PS2_VLB     (MACHINE_VLB | MACHINE_BUS_PS2)                       /* sys is VLB PS/2 */
-#define MACHINE_PS2_PCI     (MACHINE_PCI | MACHINE_BUS_PS2)                       /* sys is PCI PS/2 */
-#define MACHINE_PS2_PCIV    (MACHINE_PCIV | MACHINE_BUS_PS2)                      /* sys is VLB/PCI PS/2 */
-#define MACHINE_PS2_AGP     (MACHINE_AGP | MACHINE_BUS_PS2)                       /* sys is AGP PS/2 */
-#define MACHINE_PS2_A97     (MACHINE_PS2_AGP | MACHINE_BUS_AC97)                  /* sys is AGP/AC97 PS/2 */
-#define MACHINE_PS2_NOISA   (MACHINE_PS2_AGP & ~MACHINE_AT)                       /* sys is AGP PS/2 without ISA */
-#define MACHINE_PS2_PCIONLY (MACHINE_PS2_NOISA & ~MACHINE_BUS_AGP)                /* sys is PCI PS/2 without ISA */
-#define MACHINE_PS2_NOI97   (MACHINE_PS2_A97 & ~MACHINE_AT)                       /* sys is AGP/AC97 PS/2 without ISA */
+#define MACHINE_PC5150      (MACHINE_CASSETTE | MACHINE_PC)          /* sys is IBM PC 5150 */
+#define MACHINE_PCJR        (MACHINE_CASSETTE | MACHINE_BUS_SIDECAR) /* sys is PCjr */
+#define MACHINE_PS2         (MACHINE_AT | MACHINE_BUS_PS2)           /* sys is PS/2 */
+#define MACHINE_PS2_MCA     (MACHINE_MCA | MACHINE_BUS_PS2)          /* sys is MCA PS/2 */
+#define MACHINE_PS2_VLB     (MACHINE_VLB | MACHINE_BUS_PS2)          /* sys is VLB PS/2 */
+#define MACHINE_PS2_PCI     (MACHINE_PCI | MACHINE_BUS_PS2)          /* sys is PCI PS/2 */
+#define MACHINE_PS2_PCIV    (MACHINE_PCIV | MACHINE_BUS_PS2)         /* sys is VLB/PCI PS/2 */
+#define MACHINE_PS2_AGP     (MACHINE_AGP | MACHINE_BUS_PS2)          /* sys is AGP PS/2 */
+#define MACHINE_PS2_A97     (MACHINE_PS2_AGP | MACHINE_BUS_AC97)     /* sys is AGP/AC97 PS/2 */
+#define MACHINE_PS2_NOISA   (MACHINE_PS2_AGP & ~MACHINE_AT)          /* sys is AGP PS/2 without ISA */
+#define MACHINE_PS2_PCIONLY (MACHINE_PS2_NOISA & ~MACHINE_BUS_AGP)   /* sys is PCI PS/2 without ISA */
+#define MACHINE_PS2_NOI97   (MACHINE_PS2_A97 & ~MACHINE_AT)          /* sys is AGP/AC97 PS/2 without ISA */
+
 /* Feature flags for miscellaneous internal devices. */
 #define MACHINE_FLAGS_NONE        0x00000000 /* sys has no int devices */
 #define MACHINE_SOFTFLOAT_ONLY    0x00000001 /* sys requires SoftFloat FPU */
diff --git a/src/include/86box/vid_voodoo_banshee.h b/src/include/86box/vid_voodoo_banshee.h
index 89298e94e..257a549dd 100644
--- a/src/include/86box/vid_voodoo_banshee.h
+++ b/src/include/86box/vid_voodoo_banshee.h
@@ -18,6 +18,7 @@
 #ifndef VIDEO_VOODOO_BANSHEE_H
 #define VIDEO_VOODOO_BANSHEE_H
 
+void banshee_cmd_write(void *priv, uint32_t addr, uint32_t val);
 void banshee_set_overlay_addr(void *priv, uint32_t addr);
 
 #endif /*VIDEO_VOODOO_BANSHEE_H*/
diff --git a/src/include/86box/vid_voodoo_common.h b/src/include/86box/vid_voodoo_common.h
index 5ab63ec3a..4201562c2 100644
--- a/src/include/86box/vid_voodoo_common.h
+++ b/src/include/86box/vid_voodoo_common.h
@@ -420,6 +420,7 @@ typedef struct voodoo_t {
     int        cmdfifo_rp;
     int        cmdfifo_ret_addr;
     int        cmdfifo_in_sub;
+    int        cmdfifo_in_agp;
     atomic_int cmdfifo_depth_rd;
     atomic_int cmdfifo_depth_wr;
     atomic_int cmdfifo_enabled;
@@ -433,6 +434,7 @@ typedef struct voodoo_t {
     int        cmdfifo_rp_2;
     int        cmdfifo_ret_addr_2;
     int        cmdfifo_in_sub_2;
+    int        cmdfifo_in_agp_2;
     atomic_int cmdfifo_depth_rd_2;
     atomic_int cmdfifo_depth_wr_2;
     atomic_int cmdfifo_enabled_2;
diff --git a/src/machine/m_at_286_386sx.c b/src/machine/m_at_286_386sx.c
index 24cb88f09..9086f7c8a 100644
--- a/src/machine/m_at_286_386sx.c
+++ b/src/machine/m_at_286_386sx.c
@@ -742,7 +742,7 @@ machine_at_acer100t_init(const machine_t *model)
 {
     int ret;
 
-    ret = bios_load_linear("roms/machines/acer100t/acer386.bin",
+    ret = bios_load_linear("roms/machines/acer100t/acer386.BIN",
                            0x000f0000, 65536, 0);
 
     if (bios_only || !ret)
diff --git a/src/qt/qt_main.cpp b/src/qt/qt_main.cpp
index 72b0eef53..7723261b4 100644
--- a/src/qt/qt_main.cpp
+++ b/src/qt/qt_main.cpp
@@ -211,8 +211,121 @@ emu_LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
                          (GetForegroundWindow() == ((HWND) secondaryRenderer->winId())));
     }
 
-    if ((nCode < 0) || (nCode != HC_ACTION) || !is_over_window)
+    bool skip = ((nCode < 0) || (nCode != HC_ACTION) || !is_over_window);
+
+    if (skip)
         return CallNextHookEx(NULL, nCode, wParam, lParam);
+
+    /* USB keyboards send a scancode of 0x00 for multimedia keys. */
+    if (lpKdhs->scanCode == 0x00) {
+        /* Handle USB keyboard multimedia keys where possible.
+           Only a handful of keys can be handled via Virtual Key
+           detection; rest can't be reliably detected. */
+        DWORD vkCode = lpKdhs->vkCode;
+        bool up = !!(lpKdhs->flags & LLKHF_UP);
+        ret = CallNextHookEx(NULL, nCode, wParam, lParam);;
+
+        switch (vkCode)
+        {
+            case VK_MEDIA_PLAY_PAUSE:
+            {
+                win_keyboard_handle(0x22, up, 1, 0);
+                break;
+            }
+            case VK_MEDIA_STOP:
+            {
+                win_keyboard_handle(0x24, up, 1, 0);
+                break;
+            }
+            case VK_VOLUME_UP:
+            {
+                win_keyboard_handle(0x30, up, 1, 0);
+                break;
+            }
+            case VK_VOLUME_DOWN:
+            {
+                win_keyboard_handle(0x2E, up, 1, 0);
+                break;
+            }
+            case VK_VOLUME_MUTE:
+            {
+                win_keyboard_handle(0x20, up, 1, 0);
+                break;
+            }
+            case VK_MEDIA_NEXT_TRACK:
+            {
+                win_keyboard_handle(0x19, up, 1, 0);
+                break;
+            }
+            case VK_MEDIA_PREV_TRACK:
+            {
+                win_keyboard_handle(0x10, up, 1, 0);
+                break;
+            }
+            case VK_LAUNCH_MEDIA_SELECT:
+            {
+                win_keyboard_handle(0x6D, up, 1, 0);
+                break;
+            }
+            case VK_LAUNCH_MAIL:
+            {
+                win_keyboard_handle(0x6C, up, 1, 0);
+                break;
+            }
+            case VK_LAUNCH_APP1:
+            {
+                win_keyboard_handle(0x6B, up, 1, 0);
+                break;
+            }
+            case VK_LAUNCH_APP2:
+            {
+                win_keyboard_handle(0x21, up, 1, 0);
+                break;
+            }
+            case VK_BROWSER_BACK:
+            {
+                win_keyboard_handle(0x6A, up, 1, 0);
+                break;
+            }
+            case VK_BROWSER_FORWARD:
+            {
+                win_keyboard_handle(0x69, up, 1, 0);
+                break;
+            }
+            case VK_BROWSER_STOP:
+            {
+                win_keyboard_handle(0x68, up, 1, 0);
+                break;
+            }
+            case VK_BROWSER_HOME:
+            {
+                win_keyboard_handle(0x32, up, 1, 0);
+                break;
+            }
+            case VK_BROWSER_SEARCH:
+            {
+                win_keyboard_handle(0x65, up, 1, 0);
+                break;
+            }
+            case VK_BROWSER_REFRESH:
+            {
+                win_keyboard_handle(0x67, up, 1, 0);
+                break;
+            }
+            case VK_BROWSER_FAVORITES:
+            {
+                win_keyboard_handle(0x66, up, 1, 0);
+                break;
+            }
+            case VK_HELP:
+            {
+                win_keyboard_handle(0x3b, up, 1, 0);
+                break;
+            }
+        }
+
+        return ret;
+    }
     else if ((lpKdhs->scanCode == 0x01) && (lpKdhs->flags & LLKHF_ALTDOWN) &&
         !(lpKdhs->flags & (LLKHF_UP | LLKHF_EXTENDED)))
         ret = TRUE;
diff --git a/src/qt/qt_mainwindow.cpp b/src/qt/qt_mainwindow.cpp
index 3ee58f23b..89d17a07c 100644
--- a/src/qt/qt_mainwindow.cpp
+++ b/src/qt/qt_mainwindow.cpp
@@ -262,8 +262,10 @@ MainWindow::MainWindow(QWidget *parent)
                 ui->stackedWidget->mouse_capture_func(this->windowHandle());
         } else {
             this->releaseKeyboard();
-            if (ui->stackedWidget->mouse_uncapture_func)
+            if (ui->stackedWidget->mouse_uncapture_func) {
                 ui->stackedWidget->mouse_uncapture_func();
+            }
+            ui->stackedWidget->unsetCursor();
         }
     });
 
@@ -277,6 +279,8 @@ MainWindow::MainWindow(QWidget *parent)
             if (mouse_capture)
                 emit setMouseCapture(false);
 
+            keyboard_all_up();
+
             if (do_auto_pause && !dopause) {
                 auto_paused = 1;
                 plat_pause(1);
diff --git a/src/qt/qt_rendererstack.cpp b/src/qt/qt_rendererstack.cpp
index a8bd47a79..8c31da2b2 100644
--- a/src/qt/qt_rendererstack.cpp
+++ b/src/qt/qt_rendererstack.cpp
@@ -155,7 +155,7 @@ RendererStack::mouseReleaseEvent(QMouseEvent *event)
     }
     if (mouse_capture && (event->button() == Qt::MiddleButton) && (mouse_get_buttons() < 3)) {
         plat_mouse_capture(0);
-        this->setCursor(Qt::ArrowCursor);
+        this->unsetCursor();
         isMouseDown &= ~1;
         return;
     }
diff --git a/src/scsi/scsi_ncr53c400.c b/src/scsi/scsi_ncr53c400.c
index 10934880f..c83e75442 100644
--- a/src/scsi/scsi_ncr53c400.c
+++ b/src/scsi/scsi_ncr53c400.c
@@ -1024,7 +1024,7 @@ const device_t scsi_t130b_device = {
 const device_t scsi_ls2000_device = {
     .name          = "Corel LS2000",
     .internal_name = "ls2000",
-    .flags         = DEVICE_ISA,
+    .flags         = DEVICE_ISA | DEVICE_SIDECAR,
     .local         = ROM_LS2000,
     .init          = ncr53c400_init,
     .close         = ncr53c400_close,
diff --git a/src/scsi/scsi_spock.c b/src/scsi/scsi_spock.c
index d6a26b7d0..567879a12 100644
--- a/src/scsi/scsi_spock.c
+++ b/src/scsi/scsi_spock.c
@@ -196,6 +196,7 @@ typedef struct {
 #define CMD_UNKNOWN_1C11            0x1c11
 #define CMD_WRITE_DATA              0x1c02
 #define CMD_VERIFY                  0x1c03
+#define CMD_WRITE_VERIFY            0x1c04
 
 #define IRQ_TYPE_NONE               0x0
 #define IRQ_TYPE_SCB_COMPLETE       0x1
@@ -291,7 +292,7 @@ spock_write(uint16_t port, uint8_t val, void *priv)
 {
     spock_t *scsi = (spock_t *) priv;
 
-    spock_log("spock_write: port=%04x val=%02x %04x:%04x\n", port, val, CS, cpu_state.pc);
+    spock_log("spock_writeb: port=%04x, val=%02x, %04x:%04x.\n", port & 7, val, CS, cpu_state.pc);
 
     switch (port & 7) {
         case 0:
@@ -332,6 +333,8 @@ spock_writew(uint16_t port, uint16_t val, void *priv)
 {
     spock_t *scsi = (spock_t *) priv;
 
+    spock_log("spock_writew: port=%04x, val=%04x, %04x:%04x.\n", port & 7, val, CS, cpu_state.pc);
+
     switch (port & 7) {
         case 0: /*Command Interface Register*/
             scsi->cir_pending[0] = val & 0xff;
@@ -347,8 +350,6 @@ spock_writew(uint16_t port, uint16_t val, void *priv)
         default:
             break;
     }
-
-    spock_log("spock_writew: port=%04x val=%04x\n", port, val);
 }
 
 static uint8_t
@@ -390,7 +391,7 @@ spock_read(uint16_t port, void *priv)
             break;
     }
 
-    spock_log("spock_read: port=%04x val=%02x %04x(%05x):%04x.\n", port, temp, CS, cs, cpu_state.pc);
+    spock_log("spock_readb: port=%04x, val=%02x, %04x:%04x.\n", port & 7, temp, CS, cpu_state.pc);
     return temp;
 }
 
@@ -412,7 +413,7 @@ spock_readw(uint16_t port, void *priv)
             break;
     }
 
-    spock_log("spock_readw: port=%04x val=%04x\n", port, temp);
+    spock_log("spock_readw: port=%04x, val=%04x, %04x:%04x.\n", port & 7, temp, CS, cpu_state.pc);
     return temp;
 }
 
@@ -534,7 +535,7 @@ spock_execute_cmd(spock_t *scsi, scb_t *scb)
     int old_scb_state;
 
     if (scsi->in_reset) {
-        spock_log("Reset type = %d\n", scsi->in_reset);
+        spock_log("Reset type=%d\n", scsi->in_reset);
 
         scsi->status &= ~STATUS_BUSY;
         scsi->irq_status = 0;
@@ -542,9 +543,8 @@ spock_execute_cmd(spock_t *scsi, scb_t *scb)
         for (c = 0; c < SCSI_ID_MAX; c++)
             spock_clear_irq(scsi, c);
 
-        if (scsi->in_reset == 1) {
+        if (scsi->in_reset == 1)
             scsi->basic_ctrl |= CTRL_IRQ_ENA;
-        }
 
         spock_set_irq(scsi, 0x0f, IRQ_TYPE_RESET_COMPLETE);
 
@@ -585,6 +585,7 @@ spock_execute_cmd(spock_t *scsi, scb_t *scb)
 
         switch (scsi->scb_state) {
             case 0: /* Idle */
+                spock_log("Start Idle.\n");
                 break;
 
             case 1: /* Select */
@@ -820,6 +821,28 @@ spock_execute_cmd(spock_t *scsi, scb_t *scb)
                         scsi->scb_state  = 2;
                         return;
 
+                    case CMD_WRITE_VERIFY:
+                        if (scsi->present[scsi->scb_id] != 0xff)
+                            scsi->cdb_id = scsi->dev_id[scsi->scb_id].phys_id;
+                        else
+                            scsi->cdb_id = 0xff;
+
+                        spock_log("Device Write with Verify\n");
+                        scsi->cdb[0]     = GPCMD_WRITE_AND_VERIFY_10;
+                        scsi->cdb[1]     = scsi->dev_id[scsi->scb_id].lun_id << 5; /*LUN*/
+                        scsi->cdb[2]     = (scb->lba_addr >> 24) & 0xff;           /*LBA*/
+                        scsi->cdb[3]     = (scb->lba_addr >> 16) & 0xff;
+                        scsi->cdb[4]     = (scb->lba_addr >> 8) & 0xff;
+                        scsi->cdb[5]     = scb->lba_addr & 0xff;
+                        scsi->cdb[6]     = 0; /*Reserved*/
+                        scsi->cdb[7]     = (scb->block_count >> 8) & 0xff;
+                        scsi->cdb[8]     = scb->block_count & 0xff;
+                        scsi->cdb[9]     = 0; /*Control*/
+                        scsi->cdb_len    = 10;
+                        scsi->scsi_state = SCSI_STATE_SELECT;
+                        scsi->scb_state  = 2;
+                        return;
+
                     case CMD_REQUEST_SENSE:
                         if (scsi->present[scsi->scb_id] != 0xff)
                             scsi->cdb_id = scsi->dev_id[scsi->scb_id].phys_id;
@@ -943,7 +966,7 @@ spock_process_scsi(spock_t *scsi, scb_t *scb)
                 sd->buffer_length = spock_get_len(scsi, scb);
 
             scsi_device_command_phase0(sd, scsi->temp_cdb);
-            spock_log("SCSI ID %i: Current CDB[0] = %02x, LUN = %i, data len = %i, max len = %i, phase val = %02x\n", scsi->cdb_id, scsi->temp_cdb[0], scsi->temp_cdb[1] >> 5, sd->buffer_length, spock_get_len(scsi, scb), sd->phase);
+            spock_log("SCSI ID %i: Current CDB[0]=%02x, LUN=%i, buffer len=%i, max len=%i, phase val=%02x, data len=%d, enable bit 10=%03x\n", scsi->cdb_id, scsi->temp_cdb[0], scsi->temp_cdb[1] >> 5, sd->buffer_length, spock_get_len(scsi, scb), sd->phase, scsi->data_len, scb->enable & 0x400);
 
             if ((sd->phase != SCSI_PHASE_STATUS) && (sd->buffer_length > 0)) {
                 p = scsi_device_get_callback(sd);
@@ -1018,12 +1041,11 @@ spock_callback(void *priv)
 
     if (scsi->cmd_timer) {
         scsi->cmd_timer--;
-        if (!scsi->cmd_timer) {
+        if (!scsi->cmd_timer)
             spock_execute_cmd(scsi, scb);
-        }
     }
 
-    if (scsi->attention_wait && (scsi->scb_state == 0 || (scsi->attention_pending & 0xf0) == 0xe0)) {
+    if (scsi->attention_wait && ((scsi->scb_state == 0) || (scsi->attention_pending & 0xf0) == 0xe0)) {
         scsi->attention_wait--;
         if (!scsi->attention_wait) {
             scsi->attention = scsi->attention_pending;
diff --git a/src/sound/snd_adlib.c b/src/sound/snd_adlib.c
index 1f307596c..17990e842 100644
--- a/src/sound/snd_adlib.c
+++ b/src/sound/snd_adlib.c
@@ -145,7 +145,7 @@ adlib_close(void *priv)
 const device_t adlib_device = {
     .name          = "AdLib",
     .internal_name = "adlib",
-    .flags         = DEVICE_ISA,
+    .flags         = DEVICE_ISA | DEVICE_SIDECAR,
     .local         = 0,
     .init          = adlib_init,
     .close         = adlib_close,
diff --git a/src/video/vid_ati_mach8.c b/src/video/vid_ati_mach8.c
index 06a60449f..71dd973da 100644
--- a/src/video/vid_ati_mach8.c
+++ b/src/video/vid_ati_mach8.c
@@ -336,7 +336,7 @@ mach_accel_start(int cmd_type, int cpu_input, int count, uint32_t mix_dat, uint3
     }
 
     if ((dev->accel_bpp == 8) || (dev->accel_bpp == 15) || (dev->accel_bpp == 16) || (dev->accel_bpp == 24))
-        mach_log("RdMask=%04x, DPCONFIG=%04x, Clipping: l=%d, r=%d, t=%d, b=%d, LineDrawOpt=%04x, BPP=%d, CMDType = %d, offs=%08x, cnt = %d, input = %d, mono_src = %d, frgdsel = %d, d(%d,%d), dstxend = %d, pitch = %d, extcrt = %d, rw = %x, monpattern = %x.\n",
+        mach_log("RdMask=%04x, DPCONFIG=%04x, Clipping: l=%d, r=%d, t=%d, b=%d, LineDrawOpt=%04x, BPP=%d, CMDType = %d, offs=%08x, cnt = %d, input = %d, mono_src = %d, frgdsel = %d, d(%d,%d), dstxend = %d, pitch = %d, extcrt = %d, rw = %x, monopattern = %x.\n",
                  dev->accel.rd_mask, mach->accel.dp_config, clip_l, clip_r, clip_t, clip_b, mach->accel.linedraw_opt, dev->accel_bpp, cmd_type, mach->accel.ge_offset, count, cpu_input, mono_src, frgd_sel, dev->accel.cur_x, dev->accel.cur_y,
                  mach->accel.dest_x_end, dev->ext_pitch, dev->ext_crt_pitch, mach->accel.dp_config & 1, mach->accel.mono_pattern_enable);
 
@@ -1039,7 +1039,7 @@ mach_accel_start(int cmd_type, int cpu_input, int count, uint32_t mix_dat, uint3
                         }
                         break;
                     case 2:
-                        if (mach->accel.dp_config & 0x1000) {
+                        if ((mach->accel.dp_config & 0x1000) || (mach->accel.dp_config & 0x04)) {
                             mix = mix_dat >> 0x1f;
                             mix_dat <<= 1;
                         } else {
@@ -2185,7 +2185,7 @@ mach_accel_out_pixtrans(svga_t *svga, mach_t *mach, ibm8514_t *dev, uint16_t val
         case 0x200: /*16-bit size*/
             if (mono_src == 2) {
                 if ((frgd_sel != 2) && (bkgd_sel != 2)) {
-                    if ((mach->accel.dp_config & 0x1000) && !swap) {
+                    if (((mach->accel.dp_config & 0x1000) && !swap) || swap) {
                         mach_log("16-bit bus size swap.\n");
                         val = (val >> 8) | (val << 8);
                     }
@@ -5184,11 +5184,11 @@ mach32_ap_writeb(uint32_t addr, uint8_t val, void *priv)
     mach_t          *mach  = (mach_t *) priv;
     svga_t          *svga  = &mach->svga;
     const ibm8514_t *dev   = (ibm8514_t *) svga->dev8514;
-    uint8_t port_dword     = addr & 0xfc;
+    uint8_t port_dword     = (addr - mach->linear_base) & 0xfc;
 
     if (((mach->local_cntl & 0x20) || (mach->pci_cntl_reg & 0x80)) &&
-        ((addr >= ((mach->ap_size << 20) - 0x200)) && (addr < (mach->ap_size << 20)))) {
-        if (addr & 0x100) {
+        (((addr - mach->linear_base) >= ((mach->ap_size << 20) - 0x200)) && (addr < (mach->ap_size << 20)))) {
+        if ((addr - mach->linear_base) & 0x100) {
             mach_log("Port WORDB Write=%04x.\n", 0x02ee + (port_dword << 8));
             mach_accel_outb(0x02ee + (addr & 1) + (port_dword << 8), val, mach);
         } else {
@@ -5199,9 +5199,9 @@ mach32_ap_writeb(uint32_t addr, uint8_t val, void *priv)
         mach_log("Linear WORDB Write=%08x, val=%02x, ON=%x, dpconfig=%04x, apsize=%08x.\n",
                  addr & dev->vram_mask, val, dev->on, mach->accel.dp_config, mach->ap_size << 20);
         if (dev->on)
-            mach32_write_common(addr, val, 1, mach, svga);
+            mach32_write_common(addr - mach->linear_base, val, 1, mach, svga);
         else
-            svga_write_linear(addr, val, svga);
+            svga_write_linear(addr - mach->linear_base, val, svga);
     }
 }
 
@@ -5211,11 +5211,11 @@ mach32_ap_writew(uint32_t addr, uint16_t val, void *priv)
     mach_t          *mach  = (mach_t *) priv;
     svga_t          *svga  = &mach->svga;
     const ibm8514_t *dev   = (ibm8514_t *) svga->dev8514;
-    uint8_t port_dword     = addr & 0xfc;
+    uint8_t port_dword     = (addr - mach->linear_base) & 0xfc;
 
     if (((mach->local_cntl & 0x20) || (mach->pci_cntl_reg & 0x80)) &&
-        ((addr >= ((mach->ap_size << 20) - 0x200)) && (addr < (mach->ap_size << 20)))) {
-        if (addr & 0x100) {
+        (((addr - mach->linear_base) >= ((mach->ap_size << 20) - 0x200)) && ((addr - mach->linear_base) < (mach->ap_size << 20)))) {
+        if ((addr - mach->linear_base) & 0x100) {
             mach_log("Port WORDW Write=%04x.\n", 0x02ee + (port_dword << 8));
             mach_accel_outw(0x02ee + (port_dword << 8), val, mach);
         } else {
@@ -5224,11 +5224,11 @@ mach32_ap_writew(uint32_t addr, uint16_t val, void *priv)
         }
     } else {
         mach_log("Linear WORDW Write=%08x, val=%04x, ON=%x, dpconfig=%04x, apsize=%08x.\n",
-                 addr & dev->vram_mask, val, dev->on, mach->accel.dp_config, mach->ap_size << 20);
+                 addr - mach->linear_base, val, dev->on, mach->accel.dp_config, mach->ap_size << 20);
         if (dev->on)
-            mach32_writew_linear(addr, val, mach);
+            mach32_writew_linear(addr - mach->linear_base, val, mach);
         else
-            svga_writew_linear(addr, val, svga);
+            svga_writew_linear(addr - mach->linear_base, val, svga);
     }
 }
 
@@ -5238,11 +5238,11 @@ mach32_ap_writel(uint32_t addr, uint32_t val, void *priv)
     mach_t          *mach  = (mach_t *) priv;
     svga_t          *svga  = &mach->svga;
     const ibm8514_t *dev   = (ibm8514_t *) svga->dev8514;
-    uint8_t port_dword     = addr & 0xfc;
+    uint8_t port_dword     = (addr - mach->linear_base) & 0xfc;
 
     if (((mach->local_cntl & 0x20) || (mach->pci_cntl_reg & 0x80)) &&
-        ((addr >= ((mach->ap_size << 20) - 0x200)) && (addr < (mach->ap_size << 20)))) {
-        if (addr & 0x100) {
+        (((addr - mach->linear_base) >= ((mach->ap_size << 20) - 0x200)) && ((addr - mach->linear_base) < (mach->ap_size << 20)))) {
+        if ((addr - mach->linear_base) & 0x100) {
             mach_log("Port WORDL Write=%04x.\n", 0x02ee + (port_dword << 8));
             mach_accel_outw(0x02ee + (port_dword << 8), val & 0xffff, mach);
             mach_accel_outw(0x02ee + (port_dword << 8) + 4, val >> 16, mach);
@@ -5253,11 +5253,11 @@ mach32_ap_writel(uint32_t addr, uint32_t val, void *priv)
         }
     } else {
         mach_log("Linear WORDL Write=%08x, val=%08x, ON=%x, dpconfig=%04x, apsize=%08x.\n",
-                 addr & dev->vram_mask, val, dev->on, mach->accel.dp_config, mach->ap_size << 20);
+                 addr - mach->linear_base, val, dev->on, mach->accel.dp_config, mach->ap_size << 20);
         if (dev->on)
-            mach32_writel_linear(addr, val, mach);
+            mach32_writel_linear(addr - mach->linear_base, val, mach);
         else
-            svga_writel_linear(addr, val, svga);
+            svga_writel_linear(addr - mach->linear_base, val, svga);
     }
 }
 
@@ -5268,19 +5268,19 @@ mach32_ap_readb(uint32_t addr, void *priv)
     svga_t          *svga  = &mach->svga;
     const ibm8514_t *dev   = (ibm8514_t *) svga->dev8514;
     uint8_t temp;
-    uint8_t port_dword     = addr & 0xfc;
+    uint8_t port_dword     = (addr - mach->linear_base) & 0xfc;
 
     if (((mach->local_cntl & 0x20) || (mach->pci_cntl_reg & 0x80)) &&
-        ((addr >= ((mach->ap_size << 20) - 0x200)) && (addr < (mach->ap_size << 20)))) {
-        if (addr & 0x100)
+        (((addr - mach->linear_base) >= ((mach->ap_size << 20) - 0x200)) && ((addr - mach->linear_base) < (mach->ap_size << 20)))) {
+        if ((addr - mach->linear_base) & 0x100)
             temp = mach_accel_inb(0x02ee + (addr & 1) + (port_dword << 8), mach);
         else
             temp = mach_accel_inb(0x02e8 + (addr & 1) + (port_dword << 8), mach);
     } else {
         if (dev->on)
-            temp = mach32_read_common(addr, 1, mach, svga);
+            temp = mach32_read_common(addr - mach->linear_base, 1, mach, svga);
         else
-            temp = svga_read_linear(addr, svga);
+            temp = svga_read_linear(addr - mach->linear_base, svga);
 
         mach_log("Linear WORDB Read=%08x, ret=%02x, fast=%d.\n", addr, temp, svga->fast);
     }
@@ -5295,19 +5295,19 @@ mach32_ap_readw(uint32_t addr, void *priv)
     svga_t          *svga  = &mach->svga;
     const ibm8514_t *dev   = (ibm8514_t *) svga->dev8514;
     uint16_t temp;
-    uint8_t port_dword     = addr & 0xfc;
+    uint8_t port_dword     = (addr - mach->linear_base) & 0xfc;
 
     if (((mach->local_cntl & 0x20) || (mach->pci_cntl_reg & 0x80)) &&
-        ((addr >= ((mach->ap_size << 20) - 0x200)) && (addr < (mach->ap_size << 20)))) {
-        if (addr & 0x100)
+        (((addr - mach->linear_base) >= ((mach->ap_size << 20) - 0x200)) && ((addr - mach->linear_base) < (mach->ap_size << 20)))) {
+        if ((addr - mach->linear_base) & 0x100)
             temp = mach_accel_inw(0x02ee + (port_dword << 8), mach);
         else
             temp = mach_accel_inw(0x02e8 + (port_dword << 8), mach);
     } else {
         if (dev->on)
-            temp = mach32_readw_linear(addr, mach);
+            temp = mach32_readw_linear(addr - mach->linear_base, mach);
         else
-            temp = svga_readw_linear(addr, svga);
+            temp = svga_readw_linear(addr - mach->linear_base, svga);
 
         mach_log("Linear WORDW Read=%08x, ret=%04x.\n", addr, temp);
     }
@@ -5322,11 +5322,11 @@ mach32_ap_readl(uint32_t addr, void *priv)
     svga_t          *svga  = &mach->svga;
     const ibm8514_t *dev   = (ibm8514_t *) svga->dev8514;
     uint32_t temp;
-    uint8_t port_dword     = addr & 0xfc;
+    uint8_t port_dword     = (addr - mach->linear_base) & 0xfc;
 
     if (((mach->local_cntl & 0x20) || (mach->pci_cntl_reg & 0x80)) &&
-        ((addr >= ((mach->ap_size << 20) - 0x200)) && (addr < (mach->ap_size << 20)))) {
-        if (addr & 0x100) {
+        (((addr - mach->linear_base) >= ((mach->ap_size << 20) - 0x200)) && ((addr - mach->linear_base) < (mach->ap_size << 20)))) {
+        if ((addr - mach->linear_base) & 0x100) {
             temp = mach_accel_inw(0x02ee + (port_dword << 8), mach);
             temp |= (mach_accel_inw(0x02ee + (port_dword << 8) + 4, mach) << 8);
         } else {
@@ -5335,9 +5335,9 @@ mach32_ap_readl(uint32_t addr, void *priv)
         }
     } else {
         if (dev->on)
-            temp = mach32_readl_linear(addr, mach);
+            temp = mach32_readl_linear(addr - mach->linear_base, mach);
         else
-            temp = svga_readl_linear(addr, svga);
+            temp = svga_readl_linear(addr - mach->linear_base, svga);
 
         mach_log("Linear WORDL Read=%08x, ret=%08x, ON%d.\n", addr, temp, dev->on);
     }
diff --git a/src/video/vid_mga.c b/src/video/vid_mga.c
index 3937c2a7d..f11983a20 100644
--- a/src/video/vid_mga.c
+++ b/src/video/vid_mga.c
@@ -4677,6 +4677,7 @@ blit_trap(mystique_t *mystique)
     int       err_l = (int32_t)mystique->dwgreg.ar[1];
     int       err_r = (int32_t)mystique->dwgreg.ar[4];
     const int trans_sel = (mystique->dwgreg.dwgctrl_running & DWGCTRL_TRANS_MASK) >> DWGCTRL_TRANS_SHIFT;
+    bool transc = !!(mystique->dwgreg.dwgctrl_running & DWGCTRL_TRANSC);
 
     switch (mystique->dwgreg.dwgctrl_running & DWGCTRL_ATYPE_MASK) {
         case DWGCTRL_ATYPE_BLK:
@@ -4699,6 +4700,7 @@ blit_trap(mystique_t *mystique)
                         int      pattern = mystique->dwgreg.pattern[yoff][xoff];
                         uint32_t dst;
 
+                        if (!transc || (transc && pattern))
                         switch (mystique->maccess_running & MACCESS_PWIDTH_MASK) {
                             case MACCESS_PWIDTH_8:
                                 svga->vram[(mystique->dwgreg.ydst_lin + x_l) & mystique->vram_mask]                = (pattern ? mystique->dwgreg.fcol : mystique->dwgreg.bcol) & 0xff;
@@ -4770,6 +4772,7 @@ blit_trap(mystique_t *mystique)
                         uint32_t dst;
                         uint32_t old_dst;
 
+                        if (!transc || (transc && pattern))
                         switch (mystique->maccess_running & MACCESS_PWIDTH_MASK) {
                             case MACCESS_PWIDTH_8:
                                 dst = svga->vram[(mystique->dwgreg.ydst_lin + x_l) & mystique->vram_mask];
diff --git a/src/video/vid_ps55da2.c b/src/video/vid_ps55da2.c
index 288aca027..31559cc52 100644
--- a/src/video/vid_ps55da2.c
+++ b/src/video/vid_ps55da2.c
@@ -1075,14 +1075,10 @@ da2_out(uint16_t addr, uint16_t val, void *p)
             if (oldval != val) {
                 if (da2->ioctladdr == LS_RESET && val & 0x01) /* Reset register */
                     da2_reset_ioctl(da2);
-                else if (da2->ioctladdr == LS_MODE && ((oldval ^ val) & 0x03)) /* Mode register */
-                {
+                else if (da2->ioctladdr == LS_MODE && ((oldval ^ val) & 0x03)) { /* Mode register */
                     da2->fullchange = changeframecount;
                     da2_recalctimings(da2);
                     da2_updatevidselector(da2);
-                } else if (da2->ioctladdr == LS_MMIO && (!(val & 0x01))) /* MMIO register */
-                {
-                    // da2->bitblt.indata = 1;
                 }
             }
             break;
@@ -1117,7 +1113,7 @@ da2_out(uint16_t addr, uint16_t val, void *p)
                     // return;
                     break;
                 case LC_MAXIMUM_SCAN_LINE:
-                    if (!(da2->ioctl[LS_MODE] & 0x01))
+                    if (!(da2->ioctl[LS_MODE] & 0x01)) /* 16 or 256 color graphics mode */
                         val = 0;
                     break;
                 case LC_START_ADDRESS_HIGH:
@@ -2035,14 +2031,15 @@ da2_render_color_8bpp(da2_t *da2)
 void
 da2_updatevidselector(da2_t *da2)
 {
-    da2_log("DA2 selector: %d\n", da2->ioctl[LS_MODE]);
     if (da2->ioctl[LS_MODE] & 0x02) {
         /* VGA passthrough mode */
         da2->override = 1;
         svga_set_override(da2->mb_vga, 0);
+        da2_log("DA2 selector: VGA\n");
     } else {
         svga_set_override(da2->mb_vga, 1);
         da2->override = 0;
+        da2_log("DA2 selector: DA2\n");
     }
 }
 
@@ -2051,6 +2048,10 @@ da2_recalctimings(da2_t *da2)
 {
     double crtcconst;
     double _dispontime, _dispofftime, disptime;
+    
+    /* if output disabled or VGA passthrough */
+    if (!(da2->attrc[LV_COMPATIBILITY] & 0x08) || da2->ioctl[LS_MODE] & 0x02)
+        return;
 
     da2->vtotal      = da2->crtc[LC_VERTICAL_TOTALJ] & 0xfff;
     da2->dispend     = da2->crtc[LC_V_DISPLAY_ENABLE_END] & 0xfff;
@@ -2092,40 +2093,36 @@ da2_recalctimings(da2_t *da2)
     da2->render     = da2_render_blank;
     /* determine display mode */
     // if (da2->attr_palette_enable && (da2->attrc[0x1f] & 0x08))
-    if (da2->attrc[LV_COMPATIBILITY] & 0x08) {
-        /* 16 color graphics mode */
-        if (!(da2->ioctl[LS_MODE] & 0x01)) {
-            da2->hdisp *= 16;
-            da2->char_width = 13;
-            da2->hdisp_old  = da2->hdisp;
-            if (da2->crtc[LC_VIEWPORT_PRIORITY] & 0x80) {
-                da2_log("Set videomode to PS/55 8 bpp graphics.\n");
-                da2->render            = da2_render_color_8bpp;
-                da2->vram_display_mask = DA2_MASK_GRAM;
-            } else { /* PS/55 8-color */
-                da2_log("Set videomode to PS/55 4 bpp graphics.\n");
-                da2->vram_display_mask = DA2_MASK_GRAM;
-                da2->render            = da2_render_color_4bpp;
-            }
-        } else {
-            /* text mode */
-            if (da2->attrc[LV_ATTRIBUTE_CNTL] & 1) {
-                da2_log("Set videomode to PS/55 Mode 03 text.\n");
-                da2->render            = da2_render_textm3;
-                da2->vram_display_mask = DA2_MASK_CRAM;
-            }
-            /* PS/55 text(color/mono) */
-            else {
-                da2_log("Set videomode to PS/55 Mode 8/E text.\n");
-                da2->render            = da2_render_text;
-                da2->vram_display_mask = DA2_MASK_CRAM;
-            }
-            da2->hdisp *= 13;
-            da2->hdisp_old  = da2->hdisp;
-            da2->char_width = 13;
+    /* 16 color graphics mode */
+    if (!(da2->ioctl[LS_MODE] & 0x01)) {
+        da2->hdisp *= 16;
+        da2->char_width = 13;
+        da2->hdisp_old  = da2->hdisp;
+        if (da2->crtc[LC_VIEWPORT_PRIORITY] & 0x80) {
+            da2_log("Set videomode to PS/55 8 bpp graphics.\n");
+            da2->render            = da2_render_color_8bpp;
+            da2->vram_display_mask = DA2_MASK_GRAM;
+        } else { /* PS/55 8-color */
+            da2_log("Set videomode to PS/55 4 bpp graphics.\n");
+            da2->vram_display_mask = DA2_MASK_GRAM;
+            da2->render            = da2_render_color_4bpp;
         }
     } else {
-        da2_log("Set videomode to blank.\n");
+        /* text mode */
+        if (da2->attrc[LV_ATTRIBUTE_CNTL] & 1) {
+            da2_log("Set videomode to PS/55 Mode 03 text.\n");
+            da2->render            = da2_render_textm3;
+            da2->vram_display_mask = DA2_MASK_CRAM;
+        }
+        /* PS/55 text(color/mono) */
+        else {
+            da2_log("Set videomode to PS/55 Mode 8/E text.\n");
+            da2->render            = da2_render_text;
+            da2->vram_display_mask = DA2_MASK_CRAM;
+        }
+        da2->hdisp *= 13;
+        da2->hdisp_old  = da2->hdisp;
+        da2->char_width = 13;
     }
     // if (!da2->scrblank && da2->attr_palette_enable)
     //{
@@ -2344,7 +2341,7 @@ da2_mmio_read(uint32_t addr, void *p)
                 return DA2_INVALIDACCESS8; /* invalid memory access */
                 break;
         }
-    } else if (!(da2->ioctl[LS_MODE] & 1)) { /* 8 or 256 color mode */
+    } else if (!(da2->ioctl[LS_MODE] & 1)) { /* 16 or 256 color mode */
         cycles -= video_timing_read_b;
         for (int i = 0; i < 8; i++)
             da2->gdcla[i] = da2->vram[(addr << 3) | i]; /* read in byte */
@@ -2371,7 +2368,7 @@ da2_mmio_readw(uint32_t addr, void *p)
     //da2_log("da2_readW: %x %x %x %x %x\n", da2->ioctl[LS_MMIO], da2->fctl[LF_MMIO_SEL], da2->fctl[LF_MMIO_MODE], da2->fctl[LF_MMIO_ADDR], addr);
     if (da2->ioctl[LS_MMIO] & 0x10) {
         return (uint16_t) da2_mmio_read(addr, da2) | (uint16_t) (da2_mmio_read(addr + 1, da2) << 8);
-    } else if (!(da2->ioctl[LS_MODE] & 1)) /* 8 color or 256 color mode */
+    } else if (!(da2->ioctl[LS_MODE] & 1)) /* 16 color or 256 color mode */
     {
         cycles -= video_timing_read_w;
         addr &= DA2_MASK_MMIO;
@@ -2458,7 +2455,7 @@ da2_mmio_write(uint32_t addr, uint8_t val, void *p)
                 da2_log("da2_mmio_write failed mem %x, addr %x, val %x\n", da2->fctl[LF_MMIO_MODE], addr, val);
                 break;
         }
-    } else if (!(da2->ioctl[LS_MODE] & 1)) { /* 8 color or 256 color mode */
+    } else if (!(da2->ioctl[LS_MODE] & 1)) { /* 16 color or 256 color mode */
         uint8_t bitmask;
         /* align bitmask to even address */
         if (addr & 1) bitmask = da2->gdcreg[LG_BIT_MASK_HIGH];
@@ -2681,7 +2678,7 @@ da2_mmio_writew(uint32_t addr, uint16_t val, void *p)
         // da2_log("da2_mmio_writeW %x %x %x %x %x %x\n", da2->ioctl[LS_MMIO], da2->fctl[LF_MMIO_SEL], da2->fctl[LF_MMIO_MODE], da2->fctl[LF_MMIO_ADDR], addr, val);
         da2_mmio_write(addr, val & 0xff, da2);
         da2_mmio_write(addr + 1, val >> 8, da2);
-    } else if (!(da2->ioctl[LS_MODE] & 1)) { /* 8 color or 256 color mode */
+    } else if (!(da2->ioctl[LS_MODE] & 1)) { /* 16 color or 256 color mode */
         addr &= DA2_MASK_MMIO;
         // return;
         // da2_log("da2_mmio_writeGW %x %x %x %x %x %x\n", da2->ioctl[LS_MMIO], da2->fctl[LF_MMIO_SEL], da2->fctl[LF_MMIO_MODE], da2->fctl[LF_MMIO_ADDR], addr, val);
@@ -3027,17 +3024,17 @@ da2_init(UNUSED(const device_t *info))
     svga_t *mb_vga          = svga_get_pri();
     mb_vga->cable_connected = 0;
 
-    da2_t *da2  = malloc(sizeof(da2_t));
+    da2_t *da2  = calloc(1, sizeof(da2_t));
     da2->mb_vga = mb_vga;
 
     da2->dispontime        = 1000ull << 32;
     da2->dispofftime       = 1000ull << 32;
     int memsize            = 1024 * 1024;
-    da2->vram              = malloc(memsize);
+    da2->vram              = calloc(1, memsize);
     da2->vram_mask         = memsize - 1;
-    da2->cram              = malloc(0x1000);
+    da2->cram              = calloc(1, 0x1000);
     da2->vram_display_mask = DA2_MASK_CRAM;
-    da2->changedvram       = malloc(/*(memsize >> 12) << 1*/ 0x1000000 >> 12); /* XX000h */
+    da2->changedvram       = calloc(1, /*(memsize >> 12) << 1*/ 0x1000000 >> 12); /* XX000h */
     da2->monitorid         = device_get_config_int("montype");                 /* Configuration for Monitor ID (aaaa) -> (xxax xxxx, xxxx xaaa) */
 
     da2->mmio.charset = device_get_config_int("charset");
diff --git a/src/video/vid_s3_virge.c b/src/video/vid_s3_virge.c
index 91b186240..62ffcff0c 100644
--- a/src/video/vid_s3_virge.c
+++ b/src/video/vid_s3_virge.c
@@ -338,6 +338,7 @@ typedef struct virge_t {
     event_t *    fifo_not_full_event;
 
     atomic_int   virge_busy;
+    atomic_uint  virge_irq_req;
 
     uint8_t      subsys_stat;
     uint8_t      subsys_cntl;
@@ -373,6 +374,9 @@ typedef struct virge_t {
     uint32_t     dma_mmio_addr;
     uint32_t     dma_data_type;
 
+    pc_timer_t   wake_timer;
+    pc_timer_t   irq_timer;
+
     int          pci;
     int          is_agp;
 } virge_t;
@@ -383,6 +387,28 @@ wake_fifo_thread(virge_t *virge) {
     thread_set_event(virge->wake_fifo_thread);
 }
 
+void
+s3_virge_wake_fifo_timer(void* priv)
+{
+    virge_t *virge = (virge_t *) priv;
+
+    thread_set_event(virge->wake_fifo_thread); /*Wake up FIFO thread if moving from idle*/
+}
+
+void
+s3_virge_wake_fifo_thread(virge_t *virge)
+{
+    if (!timer_is_enabled(&virge->wake_timer)) {
+        /*Don't wake FIFO thread immediately - if we do that it will probably
+          process one word and go back to sleep, requiring it to be woken on
+          almost every write. Instead, wait a short while so that the CPU
+          emulation writes more data so we have more batched-up work.*/
+        timer_on_auto(&virge->wake_timer, 100.0);
+    }
+    if (!timer_is_enabled(&virge->irq_timer))
+        timer_on_auto(&virge->irq_timer, 100.0);
+}
+
 static virge_t         *reset_state = NULL;
 
 static video_timings_t timing_diamond_stealth3d_2000_pci = { .type = VIDEO_PCI, .write_b = 2, .write_w = 2, .write_l = 3, .read_b = 28, .read_w = 28, .read_l = 45 };
@@ -471,6 +497,19 @@ s3_virge_update_irqs(virge_t *virge)
         pci_clear_irq(virge->pci_slot, PCI_INTA, &virge->irq_state);
 }
 
+void
+s3_virge_update_irq_timer(void* priv)
+{
+    virge_t *virge = (virge_t *) priv;
+
+    if (virge->virge_irq_req) {
+        virge->virge_irq_req--;
+        s3_virge_update_irqs(virge);
+    }
+
+    timer_on_auto(&virge->irq_timer, 100.);
+}
+
 static void
 s3_virge_out(uint16_t addr, uint8_t val, void *priv)
 {
@@ -1101,6 +1140,9 @@ static void
 s3_virge_vblank_start(svga_t *svga) {
     virge_t *virge = (virge_t *) svga->priv;
 
+    if (virge->virge_irq_req)
+        virge->virge_irq_req--;
+
     virge->subsys_stat |= INT_VSY;
     s3_virge_update_irqs(virge);
 }
@@ -1795,7 +1837,8 @@ fifo_thread(void *param)
          if (virge->cmd_dma)
             virge->subsys_stat |= (INT_HOST_DONE | INT_CMD_DONE);
 
-         s3_virge_update_irqs(virge);
+         //s3_virge_update_irqs(virge);
+         virge->virge_irq_req++;
     }
 }
 
@@ -1835,10 +1878,8 @@ s3_virge_queue(virge_t *virge, uint32_t addr, uint32_t val, uint32_t type)
 
     virge->fifo_write_idx++;
 
-    if (FIFO_ENTRIES > 0xe000)
-        wake_fifo_thread(virge);
-    if (FIFO_ENTRIES > 0xe000 || FIFO_ENTRIES < 8)
-        wake_fifo_thread(virge);
+    if (FIFO_ENTRIES > 0xe000 || FIFO_ENTRIES < 16)
+        s3_virge_wake_fifo_thread(virge);
 }
 
 static void
@@ -2175,19 +2216,781 @@ s3_virge_mmio_write_l(uint32_t addr, uint32_t val, void *priv)
             }                                       \
         } while (0)
 
-#define MIX()                                  \
-    do {                                       \
-        int c;                                 \
-        for (c = 0; c < 24; c++) {             \
-            int d = (dest & (1 << c)) ? 1 : 0; \
-            if (source & (1 << c))             \
-                d |= 2;                        \
-            if (pattern & (1 << c))            \
-                d |= 4;                        \
-            if (virge->s3d.rop & (1 << d))     \
-                out |= (1 << c);               \
-        }                                      \
-    } while (0)
+#define ROPMIX(R, D, P, S, out)                    \
+    {                                              \
+        switch (R) {                               \
+            case 0x00:                             \
+                out = 0;                           \
+                break;                             \
+            case 0x01:                             \
+                out = ~(D | (P | S));              \
+                break;                             \
+            case 0x02:                             \
+                out = D & ~(P | S);                \
+                break;                             \
+            case 0x03:                             \
+                out = ~(P | S);                    \
+                break;                             \
+            case 0x04:                             \
+                out = S & ~(D | P);                \
+                break;                             \
+            case 0x05:                             \
+                out = ~(D | P);                    \
+                break;                             \
+            case 0x06:                             \
+                out = ~(P | ~(D ^ S));             \
+                break;                             \
+            case 0x07:                             \
+                out = ~(P | (D & S));              \
+                break;                             \
+            case 0x08:                             \
+                out = S & (D & ~P);                \
+                break;                             \
+            case 0x09:                             \
+                out = ~(P | (D ^ S));              \
+                break;                             \
+            case 0x0a:                             \
+                out = D & ~P;                      \
+                break;                             \
+            case 0x0b:                             \
+                out = ~(P | (S & ~D));             \
+                break;                             \
+            case 0x0c:                             \
+                out = S & ~P;                      \
+                break;                             \
+            case 0x0d:                             \
+                out = ~(P | (D & ~S));             \
+                break;                             \
+            case 0x0e:                             \
+                out = ~(P | ~(D | S));             \
+                break;                             \
+            case 0x0f:                             \
+                out = ~P;                          \
+                break;                             \
+            case 0x10:                             \
+                out = P & ~(D | S);                \
+                break;                             \
+            case 0x11:                             \
+                out = ~(D | S);                    \
+                break;                             \
+            case 0x12:                             \
+                out = ~(S | ~(D ^ P));             \
+                break;                             \
+            case 0x13:                             \
+                out = ~(S | (D & P));              \
+                break;                             \
+            case 0x14:                             \
+                out = ~(D | ~(P ^ S));             \
+                break;                             \
+            case 0x15:                             \
+                out = ~(D | (P & S));              \
+                break;                             \
+            case 0x16:                             \
+                out = P ^ (S ^ (D & ~(P & S)));    \
+                break;                             \
+            case 0x17:                             \
+                out = ~(S ^ ((S ^ P) & (D ^ S)));  \
+                break;                             \
+            case 0x18:                             \
+                out = (S ^ P) & (P ^ D);           \
+                break;                             \
+            case 0x19:                             \
+                out = ~(S ^ (D & ~(P & S)));       \
+                break;                             \
+            case 0x1a:                             \
+                out = P ^ (D | (S & P));           \
+                break;                             \
+            case 0x1b:                             \
+                out = ~(S ^ (D & (P ^ S)));        \
+                break;                             \
+            case 0x1c:                             \
+                out = P ^ (S | (D & P));           \
+                break;                             \
+            case 0x1d:                             \
+                out = ~(D ^ (S & (P ^ D)));        \
+                break;                             \
+            case 0x1e:                             \
+                out = P ^ (D | S);                 \
+                break;                             \
+            case 0x1f:                             \
+                out = ~(P & (D | S));              \
+                break;                             \
+            case 0x20:                             \
+                out = D & (P & ~S);                \
+                break;                             \
+            case 0x21:                             \
+                out = ~(S | (D ^ P));              \
+                break;                             \
+            case 0x22:                             \
+                out = D & ~S;                      \
+                break;                             \
+            case 0x23:                             \
+                out = ~(S | (P & ~D));             \
+                break;                             \
+            case 0x24:                             \
+                out = (S ^ P) & (D ^ S);           \
+                break;                             \
+            case 0x25:                             \
+                out = ~(P ^ (D & ~(S & P)));       \
+                break;                             \
+            case 0x26:                             \
+                out = S ^ (D | (P & S));           \
+                break;                             \
+            case 0x27:                             \
+                out = S ^ (D | ~(P ^ S));          \
+                break;                             \
+            case 0x28:                             \
+                out = D & (P ^ S);                 \
+                break;                             \
+            case 0x29:                             \
+                out = ~(P ^ (S ^ (D | (P & S))));  \
+                break;                             \
+            case 0x2a:                             \
+                out = D & ~(P & S);                \
+                break;                             \
+            case 0x2b:                             \
+                out = ~(S ^ ((S ^ P) & (P ^ D)));  \
+                break;                             \
+            case 0x2c:                             \
+                out = S ^ (P & (D | S));           \
+                break;                             \
+            case 0x2d:                             \
+                out = P ^ (S | ~D);                \
+                break;                             \
+            case 0x2e:                             \
+                out = P ^ (S | (D ^ P));           \
+                break;                             \
+            case 0x2f:                             \
+                out = ~(P & (S | ~D));             \
+                break;                             \
+            case 0x30:                             \
+                out = P & ~S;                      \
+                break;                             \
+            case 0x31:                             \
+                out = ~(S | (D & ~P));             \
+                break;                             \
+            case 0x32:                             \
+                out = S ^ (D | (P | S));           \
+                break;                             \
+            case 0x33:                             \
+                out = ~S;                          \
+                break;                             \
+            case 0x34:                             \
+                out = S ^ (P | (D & S));           \
+                break;                             \
+            case 0x35:                             \
+                out = S ^ (P | ~(D ^ S));          \
+                break;                             \
+            case 0x36:                             \
+                out = S ^ (D | P);                 \
+                break;                             \
+            case 0x37:                             \
+                out = ~(S & (D | P));              \
+                break;                             \
+            case 0x38:                             \
+                out = P ^ (S & (D | P));           \
+                break;                             \
+            case 0x39:                             \
+                out = S ^ (P | ~D);                \
+                break;                             \
+            case 0x3a:                             \
+                out = S ^ (P | (D ^ S));           \
+                break;                             \
+            case 0x3b:                             \
+                out = ~(S & (P | ~D));             \
+                break;                             \
+            case 0x3c:                             \
+                out = P ^ S;                       \
+                break;                             \
+            case 0x3d:                             \
+                out = S ^ (P | ~(D | S));          \
+                break;                             \
+            case 0x3e:                             \
+                out = S ^ (P | (D & ~S));          \
+                break;                             \
+            case 0x3f:                             \
+                out = ~(P & S);                    \
+                break;                             \
+            case 0x40:                             \
+                out = P & (S & ~D);                \
+                break;                             \
+            case 0x41:                             \
+                out = ~(D | (P ^ S));              \
+                break;                             \
+            case 0x42:                             \
+                out = (S ^ D) & (P ^ D);           \
+                break;                             \
+            case 0x43:                             \
+                out = ~(S ^ (P & ~(D & S)));       \
+                break;                             \
+            case 0x44:                             \
+                out = S & ~D;                      \
+                break;                             \
+            case 0x45:                             \
+                out = ~(D | (P & ~S));             \
+                break;                             \
+            case 0x46:                             \
+                out = D ^ (S | (P & D));           \
+                break;                             \
+            case 0x47:                             \
+                out = ~(P ^ (S & (D ^ P)));        \
+                break;                             \
+            case 0x48:                             \
+                out = S & (D ^ P);                 \
+                break;                             \
+            case 0x49:                             \
+                out = ~(P ^ (D ^ (S | (P & D))));  \
+                break;                             \
+            case 0x4a:                             \
+                out = D ^ (P & (S | D));           \
+                break;                             \
+            case 0x4b:                             \
+                out = P ^ (D | ~S);                \
+                break;                             \
+            case 0x4c:                             \
+                out = S & ~(D & P);                \
+                break;                             \
+            case 0x4d:                             \
+                out = ~(S ^ ((S ^ P) | (D ^ S)));  \
+                break;                             \
+            case 0x4e:                             \
+                out = P ^ (D | (S ^ P));           \
+                break;                             \
+            case 0x4f:                             \
+                out = ~(P & (D | ~S));             \
+                break;                             \
+            case 0x50:                             \
+                out = P & ~D;                      \
+                break;                             \
+            case 0x51:                             \
+                out = ~(D | (S & ~P));             \
+                break;                             \
+            case 0x52:                             \
+                out = D ^ (P | (S & D));           \
+                break;                             \
+            case 0x53:                             \
+                out = ~(S ^ (P & (D ^ S)));        \
+                break;                             \
+            case 0x54:                             \
+                out = ~(D | ~(P | S));             \
+                break;                             \
+            case 0x55:                             \
+                out = ~D;                          \
+                break;                             \
+            case 0x56:                             \
+                out = D ^ (P | S);                 \
+                break;                             \
+            case 0x57:                             \
+                out = ~(D & (P | S));              \
+                break;                             \
+            case 0x58:                             \
+                out = P ^ (D & (S | P));           \
+                break;                             \
+            case 0x59:                             \
+                out = D ^ (P | ~S);                \
+                break;                             \
+            case 0x5a:                             \
+                out = D ^ P;                       \
+                break;                             \
+            case 0x5b:                             \
+                out = D ^ (P | ~(S | D));          \
+                break;                             \
+            case 0x5c:                             \
+                out = D ^ (P | (S ^ D));           \
+                break;                             \
+            case 0x5d:                             \
+                out = ~(D & (P | ~S));             \
+                break;                             \
+            case 0x5e:                             \
+                out = D ^ (P | (S & ~D));          \
+                break;                             \
+            case 0x5f:                             \
+                out = ~(D & P);                    \
+                break;                             \
+            case 0x60:                             \
+                out = P & (D ^ S);                 \
+                break;                             \
+            case 0x61:                             \
+                out = ~(D ^ (S ^ (P | (D & S))));  \
+                break;                             \
+            case 0x62:                             \
+                out = D ^ (S & (P | D));           \
+                break;                             \
+            case 0x63:                             \
+                out = S ^ (D | ~P);                \
+                break;                             \
+            case 0x64:                             \
+                out = S ^ (D & (P | S));           \
+                break;                             \
+            case 0x65:                             \
+                out = D ^ (S | ~P);                \
+                break;                             \
+            case 0x66:                             \
+                out = D ^ S;                       \
+                break;                             \
+            case 0x67:                             \
+                out = S ^ (D | ~(P | S));          \
+                break;                             \
+            case 0x68:                             \
+                out = ~(D ^ (S ^ (P | ~(D | S)))); \
+                break;                             \
+            case 0x69:                             \
+                out = ~(P ^ (D ^ S));              \
+                break;                             \
+            case 0x6a:                             \
+                out = D ^ (P & S);                 \
+                break;                             \
+            case 0x6b:                             \
+                out = ~(P ^ (S ^ (D & (P | S))));  \
+                break;                             \
+            case 0x6c:                             \
+                out = S ^ (D & P);                 \
+                break;                             \
+            case 0x6d:                             \
+                out = ~(P ^ (D ^ (S & (P | D))));  \
+                break;                             \
+            case 0x6e:                             \
+                out = S ^ (D & (P | ~S));          \
+                break;                             \
+            case 0x6f:                             \
+                out = ~(P & ~(D ^ S));             \
+                break;                             \
+            case 0x70:                             \
+                out = P & ~(D & S);                \
+                break;                             \
+            case 0x71:                             \
+                out = ~(S ^ ((S ^ D) & (P ^ D)));  \
+                break;                             \
+            case 0x72:                             \
+                out = S ^ (D | (P ^ S));           \
+                break;                             \
+            case 0x73:                             \
+                out = ~(S & (D | ~P));             \
+                break;                             \
+            case 0x74:                             \
+                out = D ^ (S | (P ^ D));           \
+                break;                             \
+            case 0x75:                             \
+                out = ~(D & (S | ~P));             \
+                break;                             \
+            case 0x76:                             \
+                out = S ^ (D | (P & ~S));          \
+                break;                             \
+            case 0x77:                             \
+                out = ~(D & S);                    \
+                break;                             \
+            case 0x78:                             \
+                out = P ^ (D & S);                 \
+                break;                             \
+            case 0x79:                             \
+                out = ~(D ^ (S ^ (P & (D | S))));  \
+                break;                             \
+            case 0x7a:                             \
+                out = D ^ (P & (S | ~D));          \
+                break;                             \
+            case 0x7b:                             \
+                out = ~(S & ~(D ^ P));             \
+                break;                             \
+            case 0x7c:                             \
+                out = S ^ (P & (D | ~S));          \
+                break;                             \
+            case 0x7d:                             \
+                out = ~(D & ~(P ^ S));             \
+                break;                             \
+            case 0x7e:                             \
+                out = (S ^ P) | (D ^ S);           \
+                break;                             \
+            case 0x7f:                             \
+                out = ~(D & (P & S));              \
+                break;                             \
+            case 0x80:                             \
+                out = D & (P & S);                 \
+                break;                             \
+            case 0x81:                             \
+                out = ~((S ^ P) | (D ^ S));        \
+                break;                             \
+            case 0x82:                             \
+                out = D & ~(P ^ S);                \
+                break;                             \
+            case 0x83:                             \
+                out = ~(S ^ (P & (D | ~S)));       \
+                break;                             \
+            case 0x84:                             \
+                out = S & ~(D ^ P);                \
+                break;                             \
+            case 0x85:                             \
+                out = ~(P ^ (D & (S | ~P)));       \
+                break;                             \
+            case 0x86:                             \
+                out = D ^ (S ^ (P & (D | S)));     \
+                break;                             \
+            case 0x87:                             \
+                out = ~(P ^ (D & S));              \
+                break;                             \
+            case 0x88:                             \
+                out = D & S;                       \
+                break;                             \
+            case 0x89:                             \
+                out = ~(S ^ (D | (P & ~S)));       \
+                break;                             \
+            case 0x8a:                             \
+                out = D & (S | ~P);                \
+                break;                             \
+            case 0x8b:                             \
+                out = ~(D ^ (S | (P ^ D)));        \
+                break;                             \
+            case 0x8c:                             \
+                out = S & (D | ~P);                \
+                break;                             \
+            case 0x8d:                             \
+                out = ~(S ^ (D | (P ^ S)));        \
+                break;                             \
+            case 0x8e:                             \
+                out = S ^ ((S ^ D) & (P ^ D));     \
+                break;                             \
+            case 0x8f:                             \
+                out = ~(P & ~(D & S));             \
+                break;                             \
+            case 0x90:                             \
+                out = P & ~(D ^ S);                \
+                break;                             \
+            case 0x91:                             \
+                out = ~(S ^ (D & (P | ~S)));       \
+                break;                             \
+            case 0x92:                             \
+                out = D ^ (P ^ (S & (D | P)));     \
+                break;                             \
+            case 0x93:                             \
+                out = ~(S ^ (P & D));              \
+                break;                             \
+            case 0x94:                             \
+                out = P ^ (S ^ (D & (P | S)));     \
+                break;                             \
+            case 0x95:                             \
+                out = ~(D ^ (P & S));              \
+                break;                             \
+            case 0x96:                             \
+                out = D ^ (P ^ S);                 \
+                break;                             \
+            case 0x97:                             \
+                out = P ^ (S ^ (D | ~(P | S)));    \
+                break;                             \
+            case 0x98:                             \
+                out = ~(S ^ (D | ~(P | S)));       \
+                break;                             \
+            case 0x99:                             \
+                out = ~(D ^ S);                    \
+                break;                             \
+            case 0x9a:                             \
+                out = D ^ (P & ~S);                \
+                break;                             \
+            case 0x9b:                             \
+                out = ~(S ^ (D & (P | S)));        \
+                break;                             \
+            case 0x9c:                             \
+                out = S ^ (P & ~D);                \
+                break;                             \
+            case 0x9d:                             \
+                out = ~(D ^ (S & (P | D)));        \
+                break;                             \
+            case 0x9e:                             \
+                out = D ^ (S ^ (P | (D & S)));     \
+                break;                             \
+            case 0x9f:                             \
+                out = ~(P & (D ^ S));              \
+                break;                             \
+            case 0xa0:                             \
+                out = D & P;                       \
+                break;                             \
+            case 0xa1:                             \
+                out = ~(P ^ (D | (S & ~P)));       \
+                break;                             \
+            case 0xa2:                             \
+                out = D & (P | ~S);                \
+                break;                             \
+            case 0xa3:                             \
+                out = ~(D ^ (P | (S ^ D)));        \
+                break;                             \
+            case 0xa4:                             \
+                out = ~(P ^ (D | ~(S | P)));       \
+                break;                             \
+            case 0xa5:                             \
+                out = ~(P ^ D);                    \
+                break;                             \
+            case 0xa6:                             \
+                out = D ^ (S & ~P);                \
+                break;                             \
+            case 0xa7:                             \
+                out = ~(P ^ (D & (S | P)));        \
+                break;                             \
+            case 0xa8:                             \
+                out = D & (P | S);                 \
+                break;                             \
+            case 0xa9:                             \
+                out = ~(D ^ (P | S));              \
+                break;                             \
+            case 0xaa:                             \
+                out = D;                           \
+                break;                             \
+            case 0xab:                             \
+                out = D | ~(P | S);                \
+                break;                             \
+            case 0xac:                             \
+                out = S ^ (P & (D ^ S));           \
+                break;                             \
+            case 0xad:                             \
+                out = ~(D ^ (P | (S & D)));        \
+                break;                             \
+            case 0xae:                             \
+                out = D | (S & ~P);                \
+                break;                             \
+            case 0xaf:                             \
+                out = D | ~P;                      \
+                break;                             \
+            case 0xb0:                             \
+                out = P & (D | ~S);                \
+                break;                             \
+            case 0xb1:                             \
+                out = ~(P ^ (D | (S ^ P)));        \
+                break;                             \
+            case 0xb2:                             \
+                out = S ^ ((S ^ P) | (D ^ S));     \
+                break;                             \
+            case 0xb3:                             \
+                out = ~(S & ~(D & P));             \
+                break;                             \
+            case 0xb4:                             \
+                out = P ^ (S & ~D);                \
+                break;                             \
+            case 0xb5:                             \
+                out = ~(D ^ (P & (S | D)));        \
+                break;                             \
+            case 0xb6:                             \
+                out = D ^ (P ^ (S | (D & P)));     \
+                break;                             \
+            case 0xb7:                             \
+                out = ~(S & (D ^ P));              \
+                break;                             \
+            case 0xb8:                             \
+                out = P ^ (S & (D ^ P));           \
+                break;                             \
+            case 0xb9:                             \
+                out = ~(D ^ (S | (P & D)));        \
+                break;                             \
+            case 0xba:                             \
+                out = D | (P & ~S);                \
+                break;                             \
+            case 0xbb:                             \
+                out = D | ~S;                      \
+                break;                             \
+            case 0xbc:                             \
+                out = S ^ (P & ~(D & S));          \
+                break;                             \
+            case 0xbd:                             \
+                out = ~((S ^ D) & (P ^ D));        \
+                break;                             \
+            case 0xbe:                             \
+                out = D | (P ^ S);                 \
+                break;                             \
+            case 0xbf:                             \
+                out = D | ~(P & S);                \
+                break;                             \
+            case 0xc0:                             \
+                out = P & S;                       \
+                break;                             \
+            case 0xc1:                             \
+                out = ~(S ^ (P | (D & ~S)));       \
+                break;                             \
+            case 0xc2:                             \
+                out = ~(S ^ (P | ~(D | S)));       \
+                break;                             \
+            case 0xc3:                             \
+                out = ~(P ^ S);                    \
+                break;                             \
+            case 0xc4:                             \
+                out = S & (P | ~D);                \
+                break;                             \
+            case 0xc5:                             \
+                out = ~(S ^ (P | (D ^ S)));        \
+                break;                             \
+            case 0xc6:                             \
+                out = S ^ (D & ~P);                \
+                break;                             \
+            case 0xc7:                             \
+                out = ~(P ^ (S & (D | P)));        \
+                break;                             \
+            case 0xc8:                             \
+                out = S & (D | P);                 \
+                break;                             \
+            case 0xc9:                             \
+                out = ~(S ^ (P | D));              \
+                break;                             \
+            case 0xca:                             \
+                out = D ^ (P & (S ^ D));           \
+                break;                             \
+            case 0xcb:                             \
+                out = ~(S ^ (P | (D & S)));        \
+                break;                             \
+            case 0xcc:                             \
+                out = S;                           \
+                break;                             \
+            case 0xcd:                             \
+                out = S | ~(D | P);                \
+                break;                             \
+            case 0xce:                             \
+                out = S | (D & ~P);                \
+                break;                             \
+            case 0xcf:                             \
+                out = S | ~P;                      \
+                break;                             \
+            case 0xd0:                             \
+                out = P & (S | ~D);                \
+                break;                             \
+            case 0xd1:                             \
+                out = ~(P ^ (S | (D ^ P)));        \
+                break;                             \
+            case 0xd2:                             \
+                out = P ^ (D & ~S);                \
+                break;                             \
+            case 0xd3:                             \
+                out = ~(S ^ (P & (D | S)));        \
+                break;                             \
+            case 0xd4:                             \
+                out = S ^ ((S ^ P) & (P ^ D));     \
+                break;                             \
+            case 0xd5:                             \
+                out = ~(D & ~(P & S));             \
+                break;                             \
+            case 0xd6:                             \
+                out = P ^ (S ^ (D | (P & S)));     \
+                break;                             \
+            case 0xd7:                             \
+                out = ~(D & (P ^ S));              \
+                break;                             \
+            case 0xd8:                             \
+                out = P ^ (D & (S ^ P));           \
+                break;                             \
+            case 0xd9:                             \
+                out = ~(S ^ (D | (P & S)));        \
+                break;                             \
+            case 0xda:                             \
+                out = D ^ (P & ~(S & D));          \
+                break;                             \
+            case 0xdb:                             \
+                out = ~((S ^ P) & (D ^ S));        \
+                break;                             \
+            case 0xdc:                             \
+                out = S | (P & ~D);                \
+                break;                             \
+            case 0xdd:                             \
+                out = S | ~D;                      \
+                break;                             \
+            case 0xde:                             \
+                out = S | (D ^ P);                 \
+                break;                             \
+            case 0xdf:                             \
+                out = S | ~(D & P);                \
+                break;                             \
+            case 0xe0:                             \
+                out = P & (D | S);                 \
+                break;                             \
+            case 0xe1:                             \
+                out = ~(P ^ (D | S));              \
+                break;                             \
+            case 0xe2:                             \
+                out = D ^ (S & (P ^ D));           \
+                break;                             \
+            case 0xe3:                             \
+                out = ~(P ^ (S | (D & P)));        \
+                break;                             \
+            case 0xe4:                             \
+                out = S ^ (D & (P ^ S));           \
+                break;                             \
+            case 0xe5:                             \
+                out = ~(P ^ (D | (S & P)));        \
+                break;                             \
+            case 0xe6:                             \
+                out = S ^ (D & ~(P & S));          \
+                break;                             \
+            case 0xe7:                             \
+                out = ~((S ^ P) & (P ^ D));        \
+                break;                             \
+            case 0xe8:                             \
+                out = S ^ ((S ^ P) & (D ^ S));     \
+                break;                             \
+            case 0xe9:                             \
+                out = ~(D ^ (S ^ (P & ~(D & S)))); \
+                break;                             \
+            case 0xea:                             \
+                out = D | (P & S);                 \
+                break;                             \
+            case 0xeb:                             \
+                out = D | ~(P ^ S);                \
+                break;                             \
+            case 0xec:                             \
+                out = S | (D & P);                 \
+                break;                             \
+            case 0xed:                             \
+                out = S | ~(D ^ P);                \
+                break;                             \
+            case 0xee:                             \
+                out = D | S;                       \
+                break;                             \
+            case 0xef:                             \
+                out = S | (D | ~P);                \
+                break;                             \
+            case 0xf0:                             \
+                out = P;                           \
+                break;                             \
+            case 0xf1:                             \
+                out = P | ~(D | S);                \
+                break;                             \
+            case 0xf2:                             \
+                out = P | (D & ~S);                \
+                break;                             \
+            case 0xf3:                             \
+                out = P | ~S;                      \
+                break;                             \
+            case 0xf4:                             \
+                out = P | (S & ~D);                \
+                break;                             \
+            case 0xf5:                             \
+                out = P | ~D;                      \
+                break;                             \
+            case 0xf6:                             \
+                out = P | (D ^ S);                 \
+                break;                             \
+            case 0xf7:                             \
+                out = P | ~(D & S);                \
+                break;                             \
+            case 0xf8:                             \
+                out = P | (D & S);                 \
+                break;                             \
+            case 0xf9:                             \
+                out = P | ~(D ^ S);                \
+                break;                             \
+            case 0xfa:                             \
+                out = D | P;                       \
+                break;                             \
+            case 0xfb:                             \
+                out = D | (P | ~S);                \
+                break;                             \
+            case 0xfc:                             \
+                out = P | S;                       \
+                break;                             \
+            case 0xfd:                             \
+                out = P | (S | ~D);                \
+                break;                             \
+            case 0xfe:                             \
+                out = D | (P | S);                 \
+                break;                             \
+            case 0xff:                             \
+                out = ~0;                          \
+                break;                             \
+        }                                          \
+    }
+
+#define MIX() do { ROPMIX(virge->s3d.rop & 0xFF, dest, pattern, source, out); out &= 0xFFFFFF; } while (0)
 
 #define WRITE(addr, val)                                                         \
     do {                                                                         \
@@ -3642,7 +4445,8 @@ render_thread(void *param)
         }
         virge->s3d_busy = 0;
         virge->subsys_stat |= INT_S3D_DONE;
-        s3_virge_update_irqs(virge);
+        //s3_virge_update_irqs(virge);
+        virge->virge_irq_req++;
     }
 }
 
@@ -4571,6 +5375,9 @@ s3_virge_init(const device_t *info)
     virge->fifo_not_full_event = thread_create_event();
     virge->fifo_thread = thread_create(fifo_thread, virge);
 
+    timer_add(&virge->wake_timer, s3_virge_wake_fifo_timer, virge, 0);
+    timer_add(&virge->irq_timer, s3_virge_update_irq_timer, virge, 0);
+
     virge->local = info->local;
 
     *reset_state = *virge;
diff --git a/src/video/vid_tgui9440.c b/src/video/vid_tgui9440.c
index d1391f1d1..af203f327 100644
--- a/src/video/vid_tgui9440.c
+++ b/src/video/vid_tgui9440.c
@@ -1457,18 +1457,784 @@ enum {
     else                                               \
         dat = vram_l[(addr) & (tgui->vram_mask >> 2)];
 
-#define MIX()                                 \
-    do {                                      \
-        out = 0;                              \
-        for (c = 0; c < 32; c++) {            \
-            d = (dst_dat & (1 << c)) ? 1 : 0; \
-            if (src_dat & (1 << c))           \
-                d |= 2;                       \
-            if (pat_dat & (1 << c))           \
-                d |= 4;                       \
-            if (tgui->accel.rop & (1 << d))   \
-                out |= (1 << c);              \
-        }                                     \
+#define ROPMIX(R, D, P, S, out)                    \
+    {                                              \
+        switch (R) {                               \
+            case 0x00:                             \
+                out = 0;                           \
+                break;                             \
+            case 0x01:                             \
+                out = ~(D | (P | S));              \
+                break;                             \
+            case 0x02:                             \
+                out = D & ~(P | S);                \
+                break;                             \
+            case 0x03:                             \
+                out = ~(P | S);                    \
+                break;                             \
+            case 0x04:                             \
+                out = S & ~(D | P);                \
+                break;                             \
+            case 0x05:                             \
+                out = ~(D | P);                    \
+                break;                             \
+            case 0x06:                             \
+                out = ~(P | ~(D ^ S));             \
+                break;                             \
+            case 0x07:                             \
+                out = ~(P | (D & S));              \
+                break;                             \
+            case 0x08:                             \
+                out = S & (D & ~P);                \
+                break;                             \
+            case 0x09:                             \
+                out = ~(P | (D ^ S));              \
+                break;                             \
+            case 0x0a:                             \
+                out = D & ~P;                      \
+                break;                             \
+            case 0x0b:                             \
+                out = ~(P | (S & ~D));             \
+                break;                             \
+            case 0x0c:                             \
+                out = S & ~P;                      \
+                break;                             \
+            case 0x0d:                             \
+                out = ~(P | (D & ~S));             \
+                break;                             \
+            case 0x0e:                             \
+                out = ~(P | ~(D | S));             \
+                break;                             \
+            case 0x0f:                             \
+                out = ~P;                          \
+                break;                             \
+            case 0x10:                             \
+                out = P & ~(D | S);                \
+                break;                             \
+            case 0x11:                             \
+                out = ~(D | S);                    \
+                break;                             \
+            case 0x12:                             \
+                out = ~(S | ~(D ^ P));             \
+                break;                             \
+            case 0x13:                             \
+                out = ~(S | (D & P));              \
+                break;                             \
+            case 0x14:                             \
+                out = ~(D | ~(P ^ S));             \
+                break;                             \
+            case 0x15:                             \
+                out = ~(D | (P & S));              \
+                break;                             \
+            case 0x16:                             \
+                out = P ^ (S ^ (D & ~(P & S)));    \
+                break;                             \
+            case 0x17:                             \
+                out = ~(S ^ ((S ^ P) & (D ^ S)));  \
+                break;                             \
+            case 0x18:                             \
+                out = (S ^ P) & (P ^ D);           \
+                break;                             \
+            case 0x19:                             \
+                out = ~(S ^ (D & ~(P & S)));       \
+                break;                             \
+            case 0x1a:                             \
+                out = P ^ (D | (S & P));           \
+                break;                             \
+            case 0x1b:                             \
+                out = ~(S ^ (D & (P ^ S)));        \
+                break;                             \
+            case 0x1c:                             \
+                out = P ^ (S | (D & P));           \
+                break;                             \
+            case 0x1d:                             \
+                out = ~(D ^ (S & (P ^ D)));        \
+                break;                             \
+            case 0x1e:                             \
+                out = P ^ (D | S);                 \
+                break;                             \
+            case 0x1f:                             \
+                out = ~(P & (D | S));              \
+                break;                             \
+            case 0x20:                             \
+                out = D & (P & ~S);                \
+                break;                             \
+            case 0x21:                             \
+                out = ~(S | (D ^ P));              \
+                break;                             \
+            case 0x22:                             \
+                out = D & ~S;                      \
+                break;                             \
+            case 0x23:                             \
+                out = ~(S | (P & ~D));             \
+                break;                             \
+            case 0x24:                             \
+                out = (S ^ P) & (D ^ S);           \
+                break;                             \
+            case 0x25:                             \
+                out = ~(P ^ (D & ~(S & P)));       \
+                break;                             \
+            case 0x26:                             \
+                out = S ^ (D | (P & S));           \
+                break;                             \
+            case 0x27:                             \
+                out = S ^ (D | ~(P ^ S));          \
+                break;                             \
+            case 0x28:                             \
+                out = D & (P ^ S);                 \
+                break;                             \
+            case 0x29:                             \
+                out = ~(P ^ (S ^ (D | (P & S))));  \
+                break;                             \
+            case 0x2a:                             \
+                out = D & ~(P & S);                \
+                break;                             \
+            case 0x2b:                             \
+                out = ~(S ^ ((S ^ P) & (P ^ D)));  \
+                break;                             \
+            case 0x2c:                             \
+                out = S ^ (P & (D | S));           \
+                break;                             \
+            case 0x2d:                             \
+                out = P ^ (S | ~D);                \
+                break;                             \
+            case 0x2e:                             \
+                out = P ^ (S | (D ^ P));           \
+                break;                             \
+            case 0x2f:                             \
+                out = ~(P & (S | ~D));             \
+                break;                             \
+            case 0x30:                             \
+                out = P & ~S;                      \
+                break;                             \
+            case 0x31:                             \
+                out = ~(S | (D & ~P));             \
+                break;                             \
+            case 0x32:                             \
+                out = S ^ (D | (P | S));           \
+                break;                             \
+            case 0x33:                             \
+                out = ~S;                          \
+                break;                             \
+            case 0x34:                             \
+                out = S ^ (P | (D & S));           \
+                break;                             \
+            case 0x35:                             \
+                out = S ^ (P | ~(D ^ S));          \
+                break;                             \
+            case 0x36:                             \
+                out = S ^ (D | P);                 \
+                break;                             \
+            case 0x37:                             \
+                out = ~(S & (D | P));              \
+                break;                             \
+            case 0x38:                             \
+                out = P ^ (S & (D | P));           \
+                break;                             \
+            case 0x39:                             \
+                out = S ^ (P | ~D);                \
+                break;                             \
+            case 0x3a:                             \
+                out = S ^ (P | (D ^ S));           \
+                break;                             \
+            case 0x3b:                             \
+                out = ~(S & (P | ~D));             \
+                break;                             \
+            case 0x3c:                             \
+                out = P ^ S;                       \
+                break;                             \
+            case 0x3d:                             \
+                out = S ^ (P | ~(D | S));          \
+                break;                             \
+            case 0x3e:                             \
+                out = S ^ (P | (D & ~S));          \
+                break;                             \
+            case 0x3f:                             \
+                out = ~(P & S);                    \
+                break;                             \
+            case 0x40:                             \
+                out = P & (S & ~D);                \
+                break;                             \
+            case 0x41:                             \
+                out = ~(D | (P ^ S));              \
+                break;                             \
+            case 0x42:                             \
+                out = (S ^ D) & (P ^ D);           \
+                break;                             \
+            case 0x43:                             \
+                out = ~(S ^ (P & ~(D & S)));       \
+                break;                             \
+            case 0x44:                             \
+                out = S & ~D;                      \
+                break;                             \
+            case 0x45:                             \
+                out = ~(D | (P & ~S));             \
+                break;                             \
+            case 0x46:                             \
+                out = D ^ (S | (P & D));           \
+                break;                             \
+            case 0x47:                             \
+                out = ~(P ^ (S & (D ^ P)));        \
+                break;                             \
+            case 0x48:                             \
+                out = S & (D ^ P);                 \
+                break;                             \
+            case 0x49:                             \
+                out = ~(P ^ (D ^ (S | (P & D))));  \
+                break;                             \
+            case 0x4a:                             \
+                out = D ^ (P & (S | D));           \
+                break;                             \
+            case 0x4b:                             \
+                out = P ^ (D | ~S);                \
+                break;                             \
+            case 0x4c:                             \
+                out = S & ~(D & P);                \
+                break;                             \
+            case 0x4d:                             \
+                out = ~(S ^ ((S ^ P) | (D ^ S)));  \
+                break;                             \
+            case 0x4e:                             \
+                out = P ^ (D | (S ^ P));           \
+                break;                             \
+            case 0x4f:                             \
+                out = ~(P & (D | ~S));             \
+                break;                             \
+            case 0x50:                             \
+                out = P & ~D;                      \
+                break;                             \
+            case 0x51:                             \
+                out = ~(D | (S & ~P));             \
+                break;                             \
+            case 0x52:                             \
+                out = D ^ (P | (S & D));           \
+                break;                             \
+            case 0x53:                             \
+                out = ~(S ^ (P & (D ^ S)));        \
+                break;                             \
+            case 0x54:                             \
+                out = ~(D | ~(P | S));             \
+                break;                             \
+            case 0x55:                             \
+                out = ~D;                          \
+                break;                             \
+            case 0x56:                             \
+                out = D ^ (P | S);                 \
+                break;                             \
+            case 0x57:                             \
+                out = ~(D & (P | S));              \
+                break;                             \
+            case 0x58:                             \
+                out = P ^ (D & (S | P));           \
+                break;                             \
+            case 0x59:                             \
+                out = D ^ (P | ~S);                \
+                break;                             \
+            case 0x5a:                             \
+                out = D ^ P;                       \
+                break;                             \
+            case 0x5b:                             \
+                out = D ^ (P | ~(S | D));          \
+                break;                             \
+            case 0x5c:                             \
+                out = D ^ (P | (S ^ D));           \
+                break;                             \
+            case 0x5d:                             \
+                out = ~(D & (P | ~S));             \
+                break;                             \
+            case 0x5e:                             \
+                out = D ^ (P | (S & ~D));          \
+                break;                             \
+            case 0x5f:                             \
+                out = ~(D & P);                    \
+                break;                             \
+            case 0x60:                             \
+                out = P & (D ^ S);                 \
+                break;                             \
+            case 0x61:                             \
+                out = ~(D ^ (S ^ (P | (D & S))));  \
+                break;                             \
+            case 0x62:                             \
+                out = D ^ (S & (P | D));           \
+                break;                             \
+            case 0x63:                             \
+                out = S ^ (D | ~P);                \
+                break;                             \
+            case 0x64:                             \
+                out = S ^ (D & (P | S));           \
+                break;                             \
+            case 0x65:                             \
+                out = D ^ (S | ~P);                \
+                break;                             \
+            case 0x66:                             \
+                out = D ^ S;                       \
+                break;                             \
+            case 0x67:                             \
+                out = S ^ (D | ~(P | S));          \
+                break;                             \
+            case 0x68:                             \
+                out = ~(D ^ (S ^ (P | ~(D | S)))); \
+                break;                             \
+            case 0x69:                             \
+                out = ~(P ^ (D ^ S));              \
+                break;                             \
+            case 0x6a:                             \
+                out = D ^ (P & S);                 \
+                break;                             \
+            case 0x6b:                             \
+                out = ~(P ^ (S ^ (D & (P | S))));  \
+                break;                             \
+            case 0x6c:                             \
+                out = S ^ (D & P);                 \
+                break;                             \
+            case 0x6d:                             \
+                out = ~(P ^ (D ^ (S & (P | D))));  \
+                break;                             \
+            case 0x6e:                             \
+                out = S ^ (D & (P | ~S));          \
+                break;                             \
+            case 0x6f:                             \
+                out = ~(P & ~(D ^ S));             \
+                break;                             \
+            case 0x70:                             \
+                out = P & ~(D & S);                \
+                break;                             \
+            case 0x71:                             \
+                out = ~(S ^ ((S ^ D) & (P ^ D)));  \
+                break;                             \
+            case 0x72:                             \
+                out = S ^ (D | (P ^ S));           \
+                break;                             \
+            case 0x73:                             \
+                out = ~(S & (D | ~P));             \
+                break;                             \
+            case 0x74:                             \
+                out = D ^ (S | (P ^ D));           \
+                break;                             \
+            case 0x75:                             \
+                out = ~(D & (S | ~P));             \
+                break;                             \
+            case 0x76:                             \
+                out = S ^ (D | (P & ~S));          \
+                break;                             \
+            case 0x77:                             \
+                out = ~(D & S);                    \
+                break;                             \
+            case 0x78:                             \
+                out = P ^ (D & S);                 \
+                break;                             \
+            case 0x79:                             \
+                out = ~(D ^ (S ^ (P & (D | S))));  \
+                break;                             \
+            case 0x7a:                             \
+                out = D ^ (P & (S | ~D));          \
+                break;                             \
+            case 0x7b:                             \
+                out = ~(S & ~(D ^ P));             \
+                break;                             \
+            case 0x7c:                             \
+                out = S ^ (P & (D | ~S));          \
+                break;                             \
+            case 0x7d:                             \
+                out = ~(D & ~(P ^ S));             \
+                break;                             \
+            case 0x7e:                             \
+                out = (S ^ P) | (D ^ S);           \
+                break;                             \
+            case 0x7f:                             \
+                out = ~(D & (P & S));              \
+                break;                             \
+            case 0x80:                             \
+                out = D & (P & S);                 \
+                break;                             \
+            case 0x81:                             \
+                out = ~((S ^ P) | (D ^ S));        \
+                break;                             \
+            case 0x82:                             \
+                out = D & ~(P ^ S);                \
+                break;                             \
+            case 0x83:                             \
+                out = ~(S ^ (P & (D | ~S)));       \
+                break;                             \
+            case 0x84:                             \
+                out = S & ~(D ^ P);                \
+                break;                             \
+            case 0x85:                             \
+                out = ~(P ^ (D & (S | ~P)));       \
+                break;                             \
+            case 0x86:                             \
+                out = D ^ (S ^ (P & (D | S)));     \
+                break;                             \
+            case 0x87:                             \
+                out = ~(P ^ (D & S));              \
+                break;                             \
+            case 0x88:                             \
+                out = D & S;                       \
+                break;                             \
+            case 0x89:                             \
+                out = ~(S ^ (D | (P & ~S)));       \
+                break;                             \
+            case 0x8a:                             \
+                out = D & (S | ~P);                \
+                break;                             \
+            case 0x8b:                             \
+                out = ~(D ^ (S | (P ^ D)));        \
+                break;                             \
+            case 0x8c:                             \
+                out = S & (D | ~P);                \
+                break;                             \
+            case 0x8d:                             \
+                out = ~(S ^ (D | (P ^ S)));        \
+                break;                             \
+            case 0x8e:                             \
+                out = S ^ ((S ^ D) & (P ^ D));     \
+                break;                             \
+            case 0x8f:                             \
+                out = ~(P & ~(D & S));             \
+                break;                             \
+            case 0x90:                             \
+                out = P & ~(D ^ S);                \
+                break;                             \
+            case 0x91:                             \
+                out = ~(S ^ (D & (P | ~S)));       \
+                break;                             \
+            case 0x92:                             \
+                out = D ^ (P ^ (S & (D | P)));     \
+                break;                             \
+            case 0x93:                             \
+                out = ~(S ^ (P & D));              \
+                break;                             \
+            case 0x94:                             \
+                out = P ^ (S ^ (D & (P | S)));     \
+                break;                             \
+            case 0x95:                             \
+                out = ~(D ^ (P & S));              \
+                break;                             \
+            case 0x96:                             \
+                out = D ^ (P ^ S);                 \
+                break;                             \
+            case 0x97:                             \
+                out = P ^ (S ^ (D | ~(P | S)));    \
+                break;                             \
+            case 0x98:                             \
+                out = ~(S ^ (D | ~(P | S)));       \
+                break;                             \
+            case 0x99:                             \
+                out = ~(D ^ S);                    \
+                break;                             \
+            case 0x9a:                             \
+                out = D ^ (P & ~S);                \
+                break;                             \
+            case 0x9b:                             \
+                out = ~(S ^ (D & (P | S)));        \
+                break;                             \
+            case 0x9c:                             \
+                out = S ^ (P & ~D);                \
+                break;                             \
+            case 0x9d:                             \
+                out = ~(D ^ (S & (P | D)));        \
+                break;                             \
+            case 0x9e:                             \
+                out = D ^ (S ^ (P | (D & S)));     \
+                break;                             \
+            case 0x9f:                             \
+                out = ~(P & (D ^ S));              \
+                break;                             \
+            case 0xa0:                             \
+                out = D & P;                       \
+                break;                             \
+            case 0xa1:                             \
+                out = ~(P ^ (D | (S & ~P)));       \
+                break;                             \
+            case 0xa2:                             \
+                out = D & (P | ~S);                \
+                break;                             \
+            case 0xa3:                             \
+                out = ~(D ^ (P | (S ^ D)));        \
+                break;                             \
+            case 0xa4:                             \
+                out = ~(P ^ (D | ~(S | P)));       \
+                break;                             \
+            case 0xa5:                             \
+                out = ~(P ^ D);                    \
+                break;                             \
+            case 0xa6:                             \
+                out = D ^ (S & ~P);                \
+                break;                             \
+            case 0xa7:                             \
+                out = ~(P ^ (D & (S | P)));        \
+                break;                             \
+            case 0xa8:                             \
+                out = D & (P | S);                 \
+                break;                             \
+            case 0xa9:                             \
+                out = ~(D ^ (P | S));              \
+                break;                             \
+            case 0xaa:                             \
+                out = D;                           \
+                break;                             \
+            case 0xab:                             \
+                out = D | ~(P | S);                \
+                break;                             \
+            case 0xac:                             \
+                out = S ^ (P & (D ^ S));           \
+                break;                             \
+            case 0xad:                             \
+                out = ~(D ^ (P | (S & D)));        \
+                break;                             \
+            case 0xae:                             \
+                out = D | (S & ~P);                \
+                break;                             \
+            case 0xaf:                             \
+                out = D | ~P;                      \
+                break;                             \
+            case 0xb0:                             \
+                out = P & (D | ~S);                \
+                break;                             \
+            case 0xb1:                             \
+                out = ~(P ^ (D | (S ^ P)));        \
+                break;                             \
+            case 0xb2:                             \
+                out = S ^ ((S ^ P) | (D ^ S));     \
+                break;                             \
+            case 0xb3:                             \
+                out = ~(S & ~(D & P));             \
+                break;                             \
+            case 0xb4:                             \
+                out = P ^ (S & ~D);                \
+                break;                             \
+            case 0xb5:                             \
+                out = ~(D ^ (P & (S | D)));        \
+                break;                             \
+            case 0xb6:                             \
+                out = D ^ (P ^ (S | (D & P)));     \
+                break;                             \
+            case 0xb7:                             \
+                out = ~(S & (D ^ P));              \
+                break;                             \
+            case 0xb8:                             \
+                out = P ^ (S & (D ^ P));           \
+                break;                             \
+            case 0xb9:                             \
+                out = ~(D ^ (S | (P & D)));        \
+                break;                             \
+            case 0xba:                             \
+                out = D | (P & ~S);                \
+                break;                             \
+            case 0xbb:                             \
+                out = D | ~S;                      \
+                break;                             \
+            case 0xbc:                             \
+                out = S ^ (P & ~(D & S));          \
+                break;                             \
+            case 0xbd:                             \
+                out = ~((S ^ D) & (P ^ D));        \
+                break;                             \
+            case 0xbe:                             \
+                out = D | (P ^ S);                 \
+                break;                             \
+            case 0xbf:                             \
+                out = D | ~(P & S);                \
+                break;                             \
+            case 0xc0:                             \
+                out = P & S;                       \
+                break;                             \
+            case 0xc1:                             \
+                out = ~(S ^ (P | (D & ~S)));       \
+                break;                             \
+            case 0xc2:                             \
+                out = ~(S ^ (P | ~(D | S)));       \
+                break;                             \
+            case 0xc3:                             \
+                out = ~(P ^ S);                    \
+                break;                             \
+            case 0xc4:                             \
+                out = S & (P | ~D);                \
+                break;                             \
+            case 0xc5:                             \
+                out = ~(S ^ (P | (D ^ S)));        \
+                break;                             \
+            case 0xc6:                             \
+                out = S ^ (D & ~P);                \
+                break;                             \
+            case 0xc7:                             \
+                out = ~(P ^ (S & (D | P)));        \
+                break;                             \
+            case 0xc8:                             \
+                out = S & (D | P);                 \
+                break;                             \
+            case 0xc9:                             \
+                out = ~(S ^ (P | D));              \
+                break;                             \
+            case 0xca:                             \
+                out = D ^ (P & (S ^ D));           \
+                break;                             \
+            case 0xcb:                             \
+                out = ~(S ^ (P | (D & S)));        \
+                break;                             \
+            case 0xcc:                             \
+                out = S;                           \
+                break;                             \
+            case 0xcd:                             \
+                out = S | ~(D | P);                \
+                break;                             \
+            case 0xce:                             \
+                out = S | (D & ~P);                \
+                break;                             \
+            case 0xcf:                             \
+                out = S | ~P;                      \
+                break;                             \
+            case 0xd0:                             \
+                out = P & (S | ~D);                \
+                break;                             \
+            case 0xd1:                             \
+                out = ~(P ^ (S | (D ^ P)));        \
+                break;                             \
+            case 0xd2:                             \
+                out = P ^ (D & ~S);                \
+                break;                             \
+            case 0xd3:                             \
+                out = ~(S ^ (P & (D | S)));        \
+                break;                             \
+            case 0xd4:                             \
+                out = S ^ ((S ^ P) & (P ^ D));     \
+                break;                             \
+            case 0xd5:                             \
+                out = ~(D & ~(P & S));             \
+                break;                             \
+            case 0xd6:                             \
+                out = P ^ (S ^ (D | (P & S)));     \
+                break;                             \
+            case 0xd7:                             \
+                out = ~(D & (P ^ S));              \
+                break;                             \
+            case 0xd8:                             \
+                out = P ^ (D & (S ^ P));           \
+                break;                             \
+            case 0xd9:                             \
+                out = ~(S ^ (D | (P & S)));        \
+                break;                             \
+            case 0xda:                             \
+                out = D ^ (P & ~(S & D));          \
+                break;                             \
+            case 0xdb:                             \
+                out = ~((S ^ P) & (D ^ S));        \
+                break;                             \
+            case 0xdc:                             \
+                out = S | (P & ~D);                \
+                break;                             \
+            case 0xdd:                             \
+                out = S | ~D;                      \
+                break;                             \
+            case 0xde:                             \
+                out = S | (D ^ P);                 \
+                break;                             \
+            case 0xdf:                             \
+                out = S | ~(D & P);                \
+                break;                             \
+            case 0xe0:                             \
+                out = P & (D | S);                 \
+                break;                             \
+            case 0xe1:                             \
+                out = ~(P ^ (D | S));              \
+                break;                             \
+            case 0xe2:                             \
+                out = D ^ (S & (P ^ D));           \
+                break;                             \
+            case 0xe3:                             \
+                out = ~(P ^ (S | (D & P)));        \
+                break;                             \
+            case 0xe4:                             \
+                out = S ^ (D & (P ^ S));           \
+                break;                             \
+            case 0xe5:                             \
+                out = ~(P ^ (D | (S & P)));        \
+                break;                             \
+            case 0xe6:                             \
+                out = S ^ (D & ~(P & S));          \
+                break;                             \
+            case 0xe7:                             \
+                out = ~((S ^ P) & (P ^ D));        \
+                break;                             \
+            case 0xe8:                             \
+                out = S ^ ((S ^ P) & (D ^ S));     \
+                break;                             \
+            case 0xe9:                             \
+                out = ~(D ^ (S ^ (P & ~(D & S)))); \
+                break;                             \
+            case 0xea:                             \
+                out = D | (P & S);                 \
+                break;                             \
+            case 0xeb:                             \
+                out = D | ~(P ^ S);                \
+                break;                             \
+            case 0xec:                             \
+                out = S | (D & P);                 \
+                break;                             \
+            case 0xed:                             \
+                out = S | ~(D ^ P);                \
+                break;                             \
+            case 0xee:                             \
+                out = D | S;                       \
+                break;                             \
+            case 0xef:                             \
+                out = S | (D | ~P);                \
+                break;                             \
+            case 0xf0:                             \
+                out = P;                           \
+                break;                             \
+            case 0xf1:                             \
+                out = P | ~(D | S);                \
+                break;                             \
+            case 0xf2:                             \
+                out = P | (D & ~S);                \
+                break;                             \
+            case 0xf3:                             \
+                out = P | ~S;                      \
+                break;                             \
+            case 0xf4:                             \
+                out = P | (S & ~D);                \
+                break;                             \
+            case 0xf5:                             \
+                out = P | ~D;                      \
+                break;                             \
+            case 0xf6:                             \
+                out = P | (D ^ S);                 \
+                break;                             \
+            case 0xf7:                             \
+                out = P | ~(D & S);                \
+                break;                             \
+            case 0xf8:                             \
+                out = P | (D & S);                 \
+                break;                             \
+            case 0xf9:                             \
+                out = P | ~(D ^ S);                \
+                break;                             \
+            case 0xfa:                             \
+                out = D | P;                       \
+                break;                             \
+            case 0xfb:                             \
+                out = D | (P | ~S);                \
+                break;                             \
+            case 0xfc:                             \
+                out = P | S;                       \
+                break;                             \
+            case 0xfd:                             \
+                out = P | (S | ~D);                \
+                break;                             \
+            case 0xfe:                             \
+                out = D | (P | S);                 \
+                break;                             \
+            case 0xff:                             \
+                out = ~0;                          \
+                break;                             \
+        }                                          \
+    }
+
+#define MIX()                                                    \
+    do {                                                         \
+        out = 0;                                                 \
+        ROPMIX(tgui->accel.rop, dst_dat, pat_dat, src_dat, out); \
     } while (0)
 
 #define WRITE(addr, dat)                                                                                  \
@@ -1490,8 +2256,6 @@ tgui_accel_command(int count, uint32_t cpu_dat, tgui_t *tgui)
     const uint32_t *pattern_data;
     int             x;
     int             y;
-    int             c;
-    int             d;
     uint32_t        out;
     uint32_t        src_dat   = 0;
     uint32_t        dst_dat;
diff --git a/src/video/vid_voodoo_banshee.c b/src/video/vid_voodoo_banshee.c
index fadd782a5..3727ccf8e 100644
--- a/src/video/vid_voodoo_banshee.c
+++ b/src/video/vid_voodoo_banshee.c
@@ -30,6 +30,7 @@
 #include <86box/device.h>
 #include <86box/io.h>
 #include <86box/mem.h>
+#include <86box/dma.h>
 #include <86box/pci.h>
 #include <86box/rom.h>
 #include <86box/timer.h>
@@ -43,9 +44,11 @@
 #include <86box/vid_svga_render.h>
 #include <86box/vid_voodoo_common.h>
 #include <86box/vid_voodoo_display.h>
+#include <86box/vid_voodoo_fb.h>
 #include <86box/vid_voodoo_fifo.h>
 #include <86box/vid_voodoo_regs.h>
 #include <86box/vid_voodoo_render.h>
+#include <86box/vid_voodoo_texture.h>
 
 #define ROM_BANSHEE                 "roms/video/voodoo/Pci_sg.rom"
 #define ROM_CREATIVE_BANSHEE        "roms/video/voodoo/BlasterPCI.rom"
@@ -220,6 +223,7 @@ enum {
     Agp_agpHostAddressHigh = 0x08,
     Agp_agpGraphicsAddress = 0x0C,
     Agp_agpGraphicsStride  = 0x10,
+    Agp_agpMoveCMD         = 0x14,
 };
 
 #define VGAINIT0_RAMDAC_8BIT                (1 << 2)
@@ -1365,6 +1369,10 @@ banshee_cmd_read(banshee_t *banshee, uint32_t addr)
 
         case cmdBaseSize0:
             ret = voodoo->cmdfifo_size;
+            if (voodoo->cmdfifo_enabled)
+                ret |= 0x100;
+            if (voodoo->cmdfifo_in_agp)
+                ret |= 0x200;
             break;
 
         case cmdBaseAddr1:
@@ -1394,6 +1402,10 @@ banshee_cmd_read(banshee_t *banshee, uint32_t addr)
 
         case cmdBaseSize1:
             ret = voodoo->cmdfifo_size_2;
+            if (voodoo->cmdfifo_enabled_2)
+                ret |= 0x100;
+            if (voodoo->cmdfifo_in_agp_2)
+                ret |= 0x200;
             break;
 
         case 0x108:
@@ -1613,10 +1625,11 @@ banshee_reg_writew(uint32_t addr, uint16_t val, void *priv)
     }
 }
 
-static void
-banshee_cmd_write(banshee_t *banshee, uint32_t addr, uint32_t val)
+void
+banshee_cmd_write(void *priv, uint32_t addr, uint32_t val)
 {
-    voodoo_t *voodoo = banshee->voodoo;
+    banshee_t *banshee = (banshee_t *) priv;
+    voodoo_t *voodoo   = banshee->voodoo;
 #if 0
     banshee_log("banshee_cmd_write: addr=%03x val=%08x\n", addr & 0x1fc, val);
 #endif
@@ -1641,6 +1654,62 @@ banshee_cmd_write(banshee_t *banshee, uint32_t addr, uint32_t val)
             banshee->agpReqSize = val;
             break;
 
+        case Agp_agpMoveCMD: {
+            uint32_t src_addr = banshee->agpHostAddressLow;
+            uint32_t src_width = banshee->agpHostAddressHigh & 0x3fff;
+            uint32_t src_stride = (banshee->agpHostAddressHigh >> 14) & 0x3fff;
+            uint32_t src_end = src_addr + (banshee->agpReqSize & 0xfffff); /* don't know whether or not stride is accounted for! */
+            uint32_t dest_addr = banshee->agpGraphicsAddress & 0x3ffffff;
+            uint32_t dest_stride = banshee->agpGraphicsStride & 0x7fff;
+#if 0
+            banshee_log("AGP: %d bytes W%d from %08x S%d to %d:%08x S%d\n", src_end - src_addr, src_width, src_addr, src_stride, (val >> 3) & 3, dest_addr, dest_stride);
+#endif
+            switch ((val >> 3) & 3) {
+                case 0: /*Linear framebuffer (Banshee)*/
+                case 1: /*Planar YUV*/
+                    if (voodoo->texture_present[0][(dest_addr & voodoo->texture_mask) >> TEX_DIRTY_SHIFT]) {
+#if 0
+                        banshee_log("texture_present at %08x %i\n", dest_addr, (dest_addr & voodoo->texture_mask) >> TEX_DIRTY_SHIFT);
+#endif
+                        flush_texture_cache(voodoo, dest_addr & voodoo->texture_mask, 0);
+                    }
+                    if (voodoo->texture_present[1][(dest_addr & voodoo->texture_mask) >> TEX_DIRTY_SHIFT]) {
+#if 0
+                        banshee_log("texture_present at %08x %i\n", dest_addr, (dest_addr & voodoo->texture_mask) >> TEX_DIRTY_SHIFT);
+#endif
+                        flush_texture_cache(voodoo, dest_addr & voodoo->texture_mask, 1);
+                    }
+                    while ((src_addr < src_end) && (dest_addr <= voodoo->fb_mask)) {
+                        dma_bm_read(src_addr, &voodoo->fb_mem[dest_addr], MIN(src_width, voodoo->fb_mask - dest_addr), 4);
+                        src_addr += src_stride;
+                        dest_addr += dest_stride;
+                    }
+                    break;
+                case 2: /*Framebuffer*/
+                    src_width &= ~3;
+                    while (src_addr < src_end) {
+                        for (uint32_t i = 0; i < src_width; i += 4)
+                            voodoo_fb_writel(dest_addr + i, mem_readl_phys(src_addr + i), voodoo);
+                        src_addr += src_stride;
+                        dest_addr += dest_stride;
+                    }
+                    break;
+                case 3: /*Texture*/
+                    src_width &= ~3;
+                    while (src_addr < src_end) {
+                        for (uint32_t i = 0; i < src_width; i += 4)
+                            voodoo_tex_writel(dest_addr + i, mem_readl_phys(src_addr + i), voodoo);
+                        src_addr += src_stride;
+                        dest_addr += dest_stride;
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+            break;
+        }
+
         case cmdBaseAddr0:
             voodoo->cmdfifo_base = (val & 0xfff) << 12;
             voodoo->cmdfifo_end  = voodoo->cmdfifo_base + (((voodoo->cmdfifo_size & 0xff) + 1) << 12);
@@ -1655,6 +1724,7 @@ banshee_cmd_write(banshee_t *banshee, uint32_t addr, uint32_t val)
             voodoo->cmdfifo_enabled = val & 0x100;
             if (!voodoo->cmdfifo_enabled)
                 voodoo->cmdfifo_in_sub = 0; /*Not sure exactly when this should be reset*/
+            voodoo->cmdfifo_in_agp = val & 0x200;
 #if 0
             banshee_log("cmdfifo_base=%08x  cmdfifo_end=%08x\n", voodoo->cmdfifo_base, voodoo->cmdfifo_end);
 #endif
@@ -1694,6 +1764,7 @@ banshee_cmd_write(banshee_t *banshee, uint32_t addr, uint32_t val)
             voodoo->cmdfifo_enabled_2 = val & 0x100;
             if (!voodoo->cmdfifo_enabled_2)
                 voodoo->cmdfifo_in_sub_2 = 0; /*Not sure exactly when this should be reset*/
+            voodoo->cmdfifo_in_agp_2 = val & 0x200;
 #if 0
             banshee_log("cmdfifo_base=%08x  cmdfifo_end=%08x\n", voodoo->cmdfifo_base, voodoo->cmdfifo_end);
 #endif
diff --git a/src/video/vid_voodoo_fifo.c b/src/video/vid_voodoo_fifo.c
index 54a0140f6..83be0f7bb 100644
--- a/src/video/vid_voodoo_fifo.c
+++ b/src/video/vid_voodoo_fifo.c
@@ -35,6 +35,7 @@
 #include <86box/video.h>
 #include <86box/vid_svga.h>
 #include <86box/vid_voodoo_common.h>
+#include <86box/vid_voodoo_banshee.h>
 #include <86box/vid_voodoo_banshee_blitter.h>
 #include <86box/vid_voodoo_fb.h>
 #include <86box/vid_voodoo_fifo.h>
@@ -166,7 +167,10 @@ cmdfifo_get(voodoo_t *voodoo)
         }
     }
 
-    val = *(uint32_t *) &voodoo->fb_mem[voodoo->cmdfifo_rp & voodoo->fb_mask];
+    if (voodoo->cmdfifo_in_agp)
+        val = mem_readl_phys(voodoo->cmdfifo_rp);
+    else
+        val = *(uint32_t *) &voodoo->fb_mem[voodoo->cmdfifo_rp & voodoo->fb_mask];
 
     if (!voodoo->cmdfifo_in_sub)
         voodoo->cmdfifo_depth_rd++;
@@ -200,7 +204,10 @@ cmdfifo_get_2(voodoo_t *voodoo)
         }
     }
 
-    val = *(uint32_t *) &voodoo->fb_mem[voodoo->cmdfifo_rp_2 & voodoo->fb_mask];
+    if (voodoo->cmdfifo_in_agp_2)
+        val = mem_readl_phys(voodoo->cmdfifo_rp_2);
+    else
+        val = *(uint32_t *) &voodoo->fb_mem[voodoo->cmdfifo_rp_2 & voodoo->fb_mask];
 
     if (!voodoo->cmdfifo_in_sub_2)
         voodoo->cmdfifo_depth_rd_2++;
@@ -362,9 +369,21 @@ voodoo_fifo_thread(void *param)
                             break;
 
                         case 3: /*JMP local frame buffer*/
-                            voodoo->cmdfifo_rp = (header >> 4) & 0xfffffc;
+                            voodoo->cmdfifo_rp     = (header >> 4) & 0xfffffc;
+                            voodoo->cmdfifo_in_agp = 0;
 #if 0
-                            voodoo_fifo_log("JMP to %08x %04x\n", voodoo->cmdfifo_rp, header);
+                            voodoo_fifo_log("JMP LFB to %08x %04x\n", voodoo->cmdfifo_rp, header);
+#endif
+                            break;
+
+                        case 4: /*JMP AGP*/
+                            if (UNLIKELY(voodoo->type < VOODOO_BANSHEE))
+                                fatal("CMDFIFO0: Not Banshee %08x\n", header);
+
+                            voodoo->cmdfifo_rp     = ((header >> 4) & 0x1fffffc) | (cmdfifo_get(voodoo) << 25);
+                            voodoo->cmdfifo_in_agp = 1;
+#if 0
+                            voodoo_fifo_log("JMP AGP to %08x %04x\n", voodoo->cmdfifo_rp, header);
 #endif
                             break;
 
@@ -573,6 +592,23 @@ voodoo_fifo_thread(void *param)
                     }
                     break;
 
+                case 6:
+                    if (UNLIKELY(voodoo->type < VOODOO_BANSHEE)) {
+                        fatal("CMDFIFO6: Not Banshee %08x %08x\n", header, voodoo->cmdfifo_rp);
+                    } else {
+                        uint32_t val = cmdfifo_get(voodoo);
+                        banshee_cmd_write(voodoo->priv, 0x00, val >> 5);            /* agpReqSize */
+                        banshee_cmd_write(voodoo->priv, 0x04, cmdfifo_get(voodoo)); /* agpHostAddressLow */
+                        banshee_cmd_write(voodoo->priv, 0x08, cmdfifo_get(voodoo)); /* agpHostAddressHigh */
+                        banshee_cmd_write(voodoo->priv, 0x0c, cmdfifo_get(voodoo)); /* agpGraphicsAddress */
+                        banshee_cmd_write(voodoo->priv, 0x10, cmdfifo_get(voodoo)); /* agpGraphicsStride */
+                        banshee_cmd_write(voodoo->priv, 0x14, (val & 0x18) | 0x00); /* agpMoveCMD - start transfer */
+#if 0
+                        voodoo_fifo_log("CMDFIFO6 addr=%08x num=%i\n", addr, banshee->agpReqSize);
+#endif
+                    }
+                    break;
+
                 default:
                     fatal("Bad CMDFIFO packet %08x %08x\n", header, voodoo->cmdfifo_rp);
             }
@@ -624,9 +660,21 @@ voodoo_fifo_thread(void *param)
                             break;
 
                         case 3: /*JMP local frame buffer*/
-                            voodoo->cmdfifo_rp_2 = (header >> 4) & 0xfffffc;
+                            voodoo->cmdfifo_rp_2     = (header >> 4) & 0xfffffc;
+                            voodoo->cmdfifo_in_agp_2 = 0;
 #if 0
-                            voodoo_fifo_log("JMP to %08x %04x\n", voodoo->cmdfifo_rp, header);
+                            voodoo_fifo_log("JMP LFB to %08x %04x\n", voodoo->cmdfifo_rp_2, header);
+#endif
+                            break;
+
+                        case 4: /*JMP AGP*/
+                            if (UNLIKELY(voodoo->type < VOODOO_BANSHEE))
+                                fatal("CMDFIFO0: Not Banshee %08x\n", header);
+
+                            voodoo->cmdfifo_rp_2     = ((header >> 4) & 0x1fffffc) | (cmdfifo_get_2(voodoo) << 25);
+                            voodoo->cmdfifo_in_agp_2 = 1;
+#if 0
+                            voodoo_fifo_log("JMP AGP to %08x %04x\n", voodoo->cmdfifo_rp_2, header);
 #endif
                             break;
 
@@ -835,6 +883,23 @@ voodoo_fifo_thread(void *param)
                     }
                     break;
 
+                case 6:
+                    if (UNLIKELY(voodoo->type < VOODOO_BANSHEE)) {
+                        fatal("CMDFIFO6: Not Banshee %08x %08x\n", header, voodoo->cmdfifo_rp);
+                    } else {
+                        uint32_t val = cmdfifo_get_2(voodoo);
+                        banshee_cmd_write(voodoo->priv, 0x00, val >> 5);              /* agpReqSize */
+                        banshee_cmd_write(voodoo->priv, 0x04, cmdfifo_get_2(voodoo)); /* agpHostAddressLow */
+                        banshee_cmd_write(voodoo->priv, 0x08, cmdfifo_get_2(voodoo)); /* agpHostAddressHigh */
+                        banshee_cmd_write(voodoo->priv, 0x0c, cmdfifo_get_2(voodoo)); /* agpGraphicsAddress */
+                        banshee_cmd_write(voodoo->priv, 0x10, cmdfifo_get_2(voodoo)); /* agpGraphicsStride */
+                        banshee_cmd_write(voodoo->priv, 0x14, (val & 0x18) | 0x20);   /* agpMoveCMD - start transfer */
+#if 0
+                        voodoo_fifo_log("CMDFIFO6 addr=%08x num=%i\n", addr, banshee->agpReqSize);
+#endif
+                    }
+                    break;
+
                 default:
                     fatal("Bad CMDFIFO packet %08x %08x\n", header, voodoo->cmdfifo_rp);
             }