diff --git a/gfx/common/win32_common.c b/gfx/common/win32_common.c
index b69937344d..ac1d28e9d8 100644
--- a/gfx/common/win32_common.c
+++ b/gfx/common/win32_common.c
@@ -1067,71 +1067,6 @@ static LRESULT CALLBACK wnd_proc_winraw_common_internal(HWND hwnd,
 
    switch (message)
    {
-      case WM_KEYUP:                /* Key released */
-      case WM_SYSKEYUP:             /* Key released */
-         keydown                  = false;
-         /* fall-through */
-      case WM_KEYDOWN:              /* Key pressed  */
-      case WM_SYSKEYDOWN:           /* Key pressed  */
-         quit                     = true;
-         {
-            uint16_t mod          = 0;
-            unsigned keycode      = 0;
-            unsigned keysym       = (unsigned)wparam;
-
-            /* fix key binding issues on winraw when 
-             * DirectInput is not available */
-            switch (keysym)
-            {
-               /* Mod & Keypad handling done in winraw_callback */
-               case VK_SHIFT:
-               case VK_CONTROL:
-               case VK_MENU:
-               case VK_INSERT:
-               case VK_DELETE:
-               case VK_HOME:
-               case VK_END:
-               case VK_PRIOR:
-               case VK_NEXT:
-               case VK_UP:
-               case VK_DOWN:
-               case VK_LEFT:
-               case VK_RIGHT:
-               case VK_CLEAR:
-               case VK_RETURN:
-                  return 0;
-            }
-
-            keycode = input_keymaps_translate_keysym_to_rk(keysym);
-
-            if (GetKeyState(VK_SHIFT)   & 0x80)
-               mod |= RETROKMOD_SHIFT;
-            if (GetKeyState(VK_CONTROL) & 0x80)
-               mod |= RETROKMOD_CTRL;
-            if (GetKeyState(VK_MENU)    & 0x80)
-               mod |= RETROKMOD_ALT;
-            if (GetKeyState(VK_CAPITAL) & 0x81)
-               mod |= RETROKMOD_CAPSLOCK;
-            if (GetKeyState(VK_SCROLL)  & 0x81)
-               mod |= RETROKMOD_SCROLLOCK;
-            if ((GetKeyState(VK_LWIN) | GetKeyState(VK_RWIN)) & 0x80)
-               mod |= RETROKMOD_META;
-
-
-            input_keyboard_event(keydown, keycode,
-                  0, mod, RETRO_DEVICE_KEYBOARD);
-
-            if (message != WM_SYSKEYDOWN)
-               return 0;
-
-            if (
-                  wparam == VK_F10  ||
-                  wparam == VK_MENU ||
-                  wparam == VK_RSHIFT
-               )
-               return 0;
-         }
-         break;
       case WM_MOUSEMOVE:
       case WM_POINTERDOWN:
       case WM_POINTERUP:
diff --git a/input/drivers/winraw_input.c b/input/drivers/winraw_input.c
index e7244c7121..00cf459306 100644
--- a/input/drivers/winraw_input.c
+++ b/input/drivers/winraw_input.c
@@ -41,7 +41,8 @@ extern "C" {
 
 typedef struct
 {
-   uint8_t keys[256];
+   uint8_t keys[SC_LAST];
+   bool pause;
 } winraw_keyboard_t;
 
 typedef struct
@@ -440,89 +441,11 @@ static void winraw_update_mouse_state(winraw_input_t *wr,
    }
 }
 
-static void winraw_keyboard_mods(RAWINPUT *ri)
-{
-   unsigned flags = ri->data.keyboard.Flags;
-
-   switch (ri->data.keyboard.MakeCode)
-   {
-      /* Left Control + Right Control */
-      case 29:
-         input_keyboard_event(
-               (flags & RI_KEY_BREAK) ? 0 : 1,
-               input_keymaps_translate_keysym_to_rk(
-                     (flags & RI_KEY_E0) ? VK_RCONTROL : VK_LCONTROL),
-               0, RETROKMOD_CTRL, RETRO_DEVICE_KEYBOARD);
-         break;
-
-      /* Left Shift */
-      case 42:
-         input_keyboard_event(
-               (flags & RI_KEY_BREAK) ? 0 : 1,
-               input_keymaps_translate_keysym_to_rk(VK_LSHIFT),
-               0, RETROKMOD_SHIFT, RETRO_DEVICE_KEYBOARD);
-         break;
-
-      /* Right Shift */
-      case 54:
-         input_keyboard_event(
-               (flags & RI_KEY_BREAK) ? 0 : 1,
-               input_keymaps_translate_keysym_to_rk(VK_RSHIFT),
-               0, RETROKMOD_SHIFT, RETRO_DEVICE_KEYBOARD);
-         break;
-
-      /* Left Alt + Right Alt */
-      case 56:
-         input_keyboard_event(
-               (flags & RI_KEY_BREAK) ? 0 : 1,
-               input_keymaps_translate_keysym_to_rk(
-                     (flags & RI_KEY_E0) ? VK_RMENU : VK_LMENU),
-               0, RETROKMOD_ALT, RETRO_DEVICE_KEYBOARD);
-         break;
-   }
-}
-
-static void winraw_keyboard_keypad(unsigned *vkey, unsigned flags)
-{
-   bool event = true;
-
-   /* Keypad key positions regardless of NumLock */
-   switch (*vkey)
-   {
-      case VK_INSERT: *vkey = (flags & RI_KEY_E0) ? VK_INSERT : VK_NUMPAD0; break;
-      case VK_DELETE: *vkey = (flags & RI_KEY_E0) ? VK_DELETE : VK_DECIMAL; break;
-
-      case VK_HOME:   *vkey = (flags & RI_KEY_E0) ? VK_HOME   : VK_NUMPAD7; break;
-      case VK_END:    *vkey = (flags & RI_KEY_E0) ? VK_END    : VK_NUMPAD1; break;
-
-      case VK_PRIOR:  *vkey = (flags & RI_KEY_E0) ? VK_PRIOR  : VK_NUMPAD9; break;
-      case VK_NEXT:   *vkey = (flags & RI_KEY_E0) ? VK_NEXT   : VK_NUMPAD3; break;
-
-      case VK_UP:     *vkey = (flags & RI_KEY_E0) ? VK_UP     : VK_NUMPAD8; break;
-      case VK_DOWN:   *vkey = (flags & RI_KEY_E0) ? VK_DOWN   : VK_NUMPAD2; break;
-
-      case VK_LEFT:   *vkey = (flags & RI_KEY_E0) ? VK_LEFT   : VK_NUMPAD4; break;
-      case VK_RIGHT:  *vkey = (flags & RI_KEY_E0) ? VK_RIGHT  : VK_NUMPAD6; break;
-
-      case VK_CLEAR:  *vkey = (flags & RI_KEY_E0) ? VK_CLEAR  : VK_NUMPAD5; break;
-      case VK_RETURN: *vkey = (flags & RI_KEY_E0) ? 0xE0      : VK_RETURN;  break;
-
-      default:
-         event = false;
-         break;
-   }
-
-   if (event)
-      input_keyboard_event(flags & RI_KEY_BREAK ? 0 : 1,
-            input_keymaps_translate_keysym_to_rk(*vkey),
-            0, 0, RETRO_DEVICE_KEYBOARD);
-}
-
 static LRESULT CALLBACK winraw_callback(
       HWND wnd, UINT msg, WPARAM wpar, LPARAM lpar)
 {
    unsigned i;
-   unsigned vkey, flags;
+   unsigned mcode, flags, kdown;
    static uint8_t data[1024];
    RAWINPUT       *ri = (RAWINPUT*)data;
    UINT size          = sizeof(data);
@@ -544,36 +467,42 @@ static LRESULT CALLBACK winraw_callback(
    switch (ri->header.dwType)
    {
       case RIM_TYPEKEYBOARD:
-         vkey  = ri->data.keyboard.VKey;
+         mcode = ri->data.keyboard.MakeCode;
          flags = ri->data.keyboard.Flags;
+         kdown = (flags & RI_KEY_BREAK) ? 0 : 1;
 
-         /* Stop sending forced Left Shift when NumLock is enabled
-          * (VKey 0xFF does not actually exist) */
-         if (vkey == 0xFF)
-            break;
+         /* Extended scancodes */
+         if (flags & RI_KEY_E0)
+            mcode |= 0xE000;
+         else if (flags & RI_KEY_E1)
+            mcode |= 0xE100;
 
-         /* following keys are not handled by windows raw input api */
-         wr->keyboard.keys[VK_LCONTROL] = GetAsyncKeyState(VK_LCONTROL) >> 1 ? 1 : 0;
-         wr->keyboard.keys[VK_RCONTROL] = GetAsyncKeyState(VK_RCONTROL) >> 1 ? 1 : 0;
-         wr->keyboard.keys[VK_LMENU]    = GetAsyncKeyState(VK_LMENU)    >> 1 ? 1 : 0;
-         wr->keyboard.keys[VK_RMENU]    = GetAsyncKeyState(VK_RMENU)    >> 1 ? 1 : 0;
-         wr->keyboard.keys[VK_LSHIFT]   = GetAsyncKeyState(VK_LSHIFT)   >> 1 ? 1 : 0;
-         wr->keyboard.keys[VK_RSHIFT]   = GetAsyncKeyState(VK_RSHIFT)   >> 1 ? 1 : 0;
-
-         winraw_keyboard_mods(ri);
-         winraw_keyboard_keypad(&vkey, flags);
-
-         switch (ri->data.keyboard.Message)
+         /* Special pause-key handling due to
+          * scancode 0xE11D45 incoming separately */
+         if (wr->keyboard.pause)
          {
-            case WM_KEYDOWN:
-            case WM_SYSKEYDOWN:
-               wr->keyboard.keys[vkey] = 1;
-               break;
-            case WM_KEYUP:
-            case WM_SYSKEYUP:
-               wr->keyboard.keys[vkey] = 0;
-               break;
+            wr->keyboard.pause = false;
+            if (mcode == SC_NUMLOCK)
+               mcode = SC_PAUSE;
          }
+         else if (mcode == 0xE11D)
+            wr->keyboard.pause = true;
+
+         /* Ignored scancodes */
+         switch (mcode)
+         {
+            case 0xE11D:
+            case 0xE02A:
+            case 0xE036:
+            case 0xE0AA:
+            case 0xE0B6:
+               return 0;
+         }
+
+         wr->keyboard.keys[mcode] = kdown;
+         input_keyboard_event(kdown,
+               input_keymaps_translate_keysym_to_rk(mcode),
+               0, 0, RETRO_DEVICE_KEYBOARD);
          break;
       case RIM_TYPEMOUSE:
          for (i = 0; i < wr->mouse_cnt; ++i)
diff --git a/input/input_keymaps.c b/input/input_keymaps.c
index 1cd2e66c32..e722e9772b 100644
--- a/input/input_keymaps.c
+++ b/input/input_keymaps.c
@@ -1698,117 +1698,116 @@ const struct rarch_key_map rarch_key_map_psl1ght[] = {
 
 #if defined(_WIN32) && _WIN32_WINNT >= 0x0501 && !defined(__WINRT__)
 const struct rarch_key_map rarch_key_map_winraw[] = {
-   { VK_BACK, RETROK_BACKSPACE },
-   { VK_TAB, RETROK_TAB },
-   { VK_CLEAR, RETROK_CLEAR },
-   { VK_RETURN, RETROK_RETURN },
-   { VK_PAUSE, RETROK_PAUSE },
-   { VK_ESCAPE, RETROK_ESCAPE },
-   { VK_MODECHANGE, RETROK_MODE },
-   { VK_SPACE, RETROK_SPACE },
-   { VK_PRIOR, RETROK_PAGEUP },
-   { VK_NEXT, RETROK_PAGEDOWN },
-   { VK_END, RETROK_END },
-   { VK_HOME, RETROK_HOME },
-   { VK_LEFT, RETROK_LEFT },
-   { VK_UP, RETROK_UP },
-   { VK_RIGHT, RETROK_RIGHT },
-   { VK_DOWN, RETROK_DOWN },
-   { VK_PRINT, RETROK_PRINT },
-   { VK_INSERT, RETROK_INSERT },
-   { VK_DELETE, RETROK_DELETE },
-   { VK_HELP, RETROK_HELP },
-   { 0x30, RETROK_0 },
-   { 0x31, RETROK_1 },
-   { 0x32, RETROK_2 },
-   { 0x33, RETROK_3 },
-   { 0x34, RETROK_4 },
-   { 0x35, RETROK_5 },
-   { 0x36, RETROK_6 },
-   { 0x37, RETROK_7 },
-   { 0x38, RETROK_8 },
-   { 0x39, RETROK_9 },
-   { 0x41, RETROK_a },
-   { 0x42, RETROK_b },
-   { 0x43, RETROK_c },
-   { 0x44, RETROK_d },
-   { 0x45, RETROK_e },
-   { 0x46, RETROK_f },
-   { 0x47, RETROK_g },
-   { 0x48, RETROK_h },
-   { 0x49, RETROK_i },
-   { 0x4A, RETROK_j },
-   { 0x4B, RETROK_k },
-   { 0x4C, RETROK_l },
-   { 0x4D, RETROK_m },
-   { 0x4E, RETROK_n },
-   { 0x4F, RETROK_o },
-   { 0x50, RETROK_p },
-   { 0x51, RETROK_q },
-   { 0x52, RETROK_r },
-   { 0x53, RETROK_s },
-   { 0x54, RETROK_t },
-   { 0x55, RETROK_u },
-   { 0x56, RETROK_v },
-   { 0x57, RETROK_w },
-   { 0x58, RETROK_x },
-   { 0x59, RETROK_y },
-   { 0x5A, RETROK_z },
-   { VK_LWIN, RETROK_LSUPER },
-   { VK_RWIN, RETROK_RSUPER },
-   { VK_APPS, RETROK_MENU },
-   { VK_NUMPAD0, RETROK_KP0 },
-   { VK_NUMPAD1, RETROK_KP1 },
-   { VK_NUMPAD2, RETROK_KP2 },
-   { VK_NUMPAD3, RETROK_KP3 },
-   { VK_NUMPAD4, RETROK_KP4 },
-   { VK_NUMPAD5, RETROK_KP5 },
-   { VK_NUMPAD6, RETROK_KP6 },
-   { VK_NUMPAD7, RETROK_KP7 },
-   { VK_NUMPAD8, RETROK_KP8 },
-   { VK_NUMPAD9, RETROK_KP9 },
-   { VK_MULTIPLY, RETROK_KP_MULTIPLY },
-   { VK_ADD, RETROK_KP_PLUS },
-   { VK_SUBTRACT, RETROK_KP_MINUS },
-   { VK_DECIMAL, RETROK_KP_PERIOD },
-   { VK_DIVIDE, RETROK_KP_DIVIDE },
-   { VK_F1, RETROK_F1 },
-   { VK_F2, RETROK_F2 },
-   { VK_F3, RETROK_F3 },
-   { VK_F4, RETROK_F4 },
-   { VK_F5, RETROK_F5 },
-   { VK_F6, RETROK_F6 },
-   { VK_F7, RETROK_F7 },
-   { VK_F8, RETROK_F8 },
-   { VK_F9, RETROK_F9 },
-   { VK_F10, RETROK_F10 },
-   { VK_F11, RETROK_F11 },
-   { VK_F12, RETROK_F12 },
-   { VK_F13, RETROK_F13 },
-   { VK_F14, RETROK_F14 },
-   { VK_F15, RETROK_F15 },
-   { VK_NUMLOCK, RETROK_NUMLOCK },
-   { VK_SCROLL, RETROK_SCROLLOCK },
-   { VK_LSHIFT, RETROK_LSHIFT },
-   { VK_RSHIFT, RETROK_RSHIFT },
-   { VK_LCONTROL, RETROK_LCTRL },
-   { VK_RCONTROL, RETROK_RCTRL },
-   { VK_LMENU, RETROK_LALT },
-   { VK_RMENU, RETROK_RALT },
-   { 0xE0, RETROK_KP_ENTER },
-   { VK_CAPITAL, RETROK_CAPSLOCK },
-   { VK_OEM_1, RETROK_SEMICOLON },
-   { VK_OEM_PLUS, RETROK_EQUALS },
-   { VK_OEM_COMMA, RETROK_COMMA },
-   { VK_OEM_MINUS, RETROK_MINUS },
-   { VK_OEM_PERIOD, RETROK_PERIOD },
-   { VK_OEM_2, RETROK_SLASH },
-   { VK_OEM_3, RETROK_BACKQUOTE },
-   { VK_OEM_4, RETROK_LEFTBRACKET },
-   { VK_OEM_5, RETROK_BACKSLASH },
-   { VK_OEM_6, RETROK_RIGHTBRACKET },
-   { VK_OEM_7, RETROK_QUOTE },
-   { VK_OEM_102, RETROK_OEM_102 },
+   { SC_BACKSPACE, RETROK_BACKSPACE },
+   { SC_TAB, RETROK_TAB },
+   { SC_CLEAR, RETROK_CLEAR },
+   { SC_RETURN, RETROK_RETURN },
+   { SC_PAUSE, RETROK_PAUSE },
+   { SC_ESCAPE, RETROK_ESCAPE },
+   { SC_SPACE, RETROK_SPACE },
+   { SC_PAGEUP, RETROK_PAGEUP },
+   { SC_PAGEDOWN, RETROK_PAGEDOWN },
+   { SC_END, RETROK_END },
+   { SC_HOME, RETROK_HOME },
+   { SC_LEFT, RETROK_LEFT },
+   { SC_UP, RETROK_UP },
+   { SC_RIGHT, RETROK_RIGHT },
+   { SC_DOWN, RETROK_DOWN },
+   { SC_PRINT, RETROK_PRINT },
+   { SC_INSERT, RETROK_INSERT },
+   { SC_DELETE, RETROK_DELETE },
+   { SC_HELP, RETROK_HELP },
+   { SC_0, RETROK_0 },
+   { SC_1, RETROK_1 },
+   { SC_2, RETROK_2 },
+   { SC_3, RETROK_3 },
+   { SC_4, RETROK_4 },
+   { SC_5, RETROK_5 },
+   { SC_6, RETROK_6 },
+   { SC_7, RETROK_7 },
+   { SC_8, RETROK_8 },
+   { SC_9, RETROK_9 },
+   { SC_a, RETROK_a },
+   { SC_b, RETROK_b },
+   { SC_c, RETROK_c },
+   { SC_d, RETROK_d },
+   { SC_e, RETROK_e },
+   { SC_f, RETROK_f },
+   { SC_g, RETROK_g },
+   { SC_h, RETROK_h },
+   { SC_i, RETROK_i },
+   { SC_j, RETROK_j },
+   { SC_k, RETROK_k },
+   { SC_l, RETROK_l },
+   { SC_m, RETROK_m },
+   { SC_n, RETROK_n },
+   { SC_o, RETROK_o },
+   { SC_p, RETROK_p },
+   { SC_q, RETROK_q },
+   { SC_r, RETROK_r },
+   { SC_s, RETROK_s },
+   { SC_t, RETROK_t },
+   { SC_u, RETROK_u },
+   { SC_v, RETROK_v },
+   { SC_w, RETROK_w },
+   { SC_x, RETROK_x },
+   { SC_y, RETROK_y },
+   { SC_z, RETROK_z },
+   { SC_LSUPER, RETROK_LSUPER },
+   { SC_RSUPER, RETROK_RSUPER },
+   { SC_MENU, RETROK_MENU },
+   { SC_KP0, RETROK_KP0 },
+   { SC_KP1, RETROK_KP1 },
+   { SC_KP2, RETROK_KP2 },
+   { SC_KP3, RETROK_KP3 },
+   { SC_KP4, RETROK_KP4 },
+   { SC_KP5, RETROK_KP5 },
+   { SC_KP6, RETROK_KP6 },
+   { SC_KP7, RETROK_KP7 },
+   { SC_KP8, RETROK_KP8 },
+   { SC_KP9, RETROK_KP9 },
+   { SC_KP_MULTIPLY, RETROK_KP_MULTIPLY },
+   { SC_KP_PLUS, RETROK_KP_PLUS },
+   { SC_KP_MINUS, RETROK_KP_MINUS },
+   { SC_KP_PERIOD, RETROK_KP_PERIOD },
+   { SC_KP_DIVIDE, RETROK_KP_DIVIDE },
+   { SC_F1, RETROK_F1 },
+   { SC_F2, RETROK_F2 },
+   { SC_F3, RETROK_F3 },
+   { SC_F4, RETROK_F4 },
+   { SC_F5, RETROK_F5 },
+   { SC_F6, RETROK_F6 },
+   { SC_F7, RETROK_F7 },
+   { SC_F8, RETROK_F8 },
+   { SC_F9, RETROK_F9 },
+   { SC_F10, RETROK_F10 },
+   { SC_F11, RETROK_F11 },
+   { SC_F12, RETROK_F12 },
+   { SC_F13, RETROK_F13 },
+   { SC_F14, RETROK_F14 },
+   { SC_F15, RETROK_F15 },
+   { SC_NUMLOCK, RETROK_NUMLOCK },
+   { SC_SCROLLLOCK, RETROK_SCROLLOCK },
+   { SC_LSHIFT, RETROK_LSHIFT },
+   { SC_RSHIFT, RETROK_RSHIFT },
+   { SC_LCTRL, RETROK_LCTRL },
+   { SC_RCTRL, RETROK_RCTRL },
+   { SC_LALT, RETROK_LALT },
+   { SC_RALT, RETROK_RALT },
+   { SC_KP_ENTER, RETROK_KP_ENTER },
+   { SC_CAPSLOCK, RETROK_CAPSLOCK },
+   { SC_COMMA, RETROK_COMMA },
+   { SC_PERIOD, RETROK_PERIOD },
+   { SC_MINUS, RETROK_MINUS },
+   { SC_EQUALS, RETROK_EQUALS },
+   { SC_LEFTBRACKET, RETROK_LEFTBRACKET },
+   { SC_RIGHTBRACKET, RETROK_RIGHTBRACKET },
+   { SC_SEMICOLON, RETROK_SEMICOLON },
+   { SC_BACKQUOTE, RETROK_BACKQUOTE },
+   { SC_BACKSLASH, RETROK_BACKSLASH },
+   { SC_SLASH, RETROK_SLASH },
+   { SC_APOSTROPHE, RETROK_QUOTE },
+   { SC_ANGLEBRACKET, RETROK_OEM_102 },
    { 0, RETROK_UNKNOWN }
 };
 #endif
diff --git a/input/input_keymaps.h b/input/input_keymaps.h
index a876e9a77d..d08cfd4a8c 100644
--- a/input/input_keymaps.h
+++ b/input/input_keymaps.h
@@ -62,6 +62,168 @@ extern const struct rarch_key_map rarch_key_map_switch[];
 extern const struct rarch_key_map rarch_key_map_vita[];
 #endif
 
+#if defined(_WIN32) && _WIN32_WINNT >= 0x0501 && !defined(__WINRT__)
+enum winraw_scancodes {
+   SC_ESCAPE = 0x01,
+   SC_1 = 0x02,
+   SC_2 = 0x03,
+   SC_3 = 0x04,
+   SC_4 = 0x05,
+   SC_5 = 0x06,
+   SC_6 = 0x07,
+   SC_7 = 0x08,
+   SC_8 = 0x09,
+   SC_9 = 0x0A,
+   SC_0 = 0x0B,
+   SC_MINUS = 0x0C,
+   SC_EQUALS = 0x0D,
+   SC_BACKSPACE = 0x0E,
+   SC_TAB = 0x0F,
+   SC_q = 0x10,
+   SC_w = 0x11,
+   SC_e = 0x12,
+   SC_r = 0x13,
+   SC_t = 0x14,
+   SC_y = 0x15,
+   SC_u = 0x16,
+   SC_i = 0x17,
+   SC_o = 0x18,
+   SC_p = 0x19,
+   SC_LEFTBRACKET = 0x1A,
+   SC_RIGHTBRACKET = 0x1B,
+   SC_RETURN = 0x1C,
+   SC_LCTRL = 0x1D,
+   SC_a = 0x1E,
+   SC_s = 0x1F,
+   SC_d = 0x20,
+   SC_f = 0x21,
+   SC_g = 0x22,
+   SC_h = 0x23,
+   SC_j = 0x24,
+   SC_k = 0x25,
+   SC_l = 0x26,
+   SC_SEMICOLON = 0x27,
+   SC_APOSTROPHE = 0x28,
+   SC_BACKQUOTE = 0x29,
+   SC_LSHIFT = 0x2A,
+   SC_BACKSLASH = 0x2B,
+   SC_z = 0x2C,
+   SC_x = 0x2D,
+   SC_c = 0x2E,
+   SC_v = 0x2F,
+   SC_b = 0x30,
+   SC_n = 0x31,
+   SC_m = 0x32,
+   SC_COMMA = 0x33,
+   SC_PERIOD = 0x34,
+   SC_SLASH = 0x35,
+   SC_RSHIFT = 0x36,
+   SC_KP_MULTIPLY = 0x37,
+   SC_LALT = 0x38,
+   SC_SPACE = 0x39,
+   SC_CAPSLOCK = 0x3A,
+   SC_F1 = 0x3B,
+   SC_F2 = 0x3C,
+   SC_F3 = 0x3D,
+   SC_F4 = 0x3E,
+   SC_F5 = 0x3F,
+   SC_F6 = 0x40,
+   SC_F7 = 0x41,
+   SC_F8 = 0x42,
+   SC_F9 = 0x43,
+   SC_F10 = 0x44,
+   SC_NUMLOCK = 0x45,
+   SC_SCROLLLOCK = 0x46,
+   SC_KP7 = 0x47,
+   SC_KP8 = 0x48,
+   SC_KP9 = 0x49,
+   SC_KP_MINUS = 0x4A,
+   SC_KP4 = 0x4B,
+   SC_KP5 = 0x4C,
+   SC_KP6 = 0x4D,
+   SC_KP_PLUS = 0x4E,
+   SC_KP1 = 0x4F,
+   SC_KP2 = 0x50,
+   SC_KP3 = 0x51,
+   SC_KP0 = 0x52,
+   SC_KP_PERIOD = 0x53,
+   SC_ALT_PRINT = 0x54,
+   SC_ANGLEBRACKET = 0x56,
+   SC_F11 = 0x57,
+   SC_F12 = 0x58,
+   SC_OEM_1 = 0x5a,
+   SC_OEM_2 = 0x5b,
+   SC_OEM_3 = 0x5c,
+   SC_ERASE_EOF = 0x5d,
+   SC_CLEAR = 0x5d,
+   SC_OEM_4 = 0x5e,
+   SC_OEM_5 = 0x5f,
+   SC_HELP = 0x63,
+   SC_F13 = 0x64,
+   SC_F14 = 0x65,
+   SC_F15 = 0x66,
+   SC_F16 = 0x67,
+   SC_F17 = 0x68,
+   SC_F18 = 0x69,
+   SC_F19 = 0x6a,
+   SC_F20 = 0x6b,
+   SC_F21 = 0x6c,
+   SC_F22 = 0x6d,
+   SC_F23 = 0x6e,
+   SC_OEM_6 = 0x6f,
+   SC_KATAKANA = 0x70,
+   SC_OEM_7 = 0x71,
+   SC_F24 = 0x76,
+   SC_SBCSCHAR = 0x77,
+   SC_CONVERT = 0x79,
+   SC_NONCONVERT = 0x7B,
+
+   SC_MEDIA_PREV = 0xE010,
+   SC_MEDIA_NEXT = 0xE019,
+   SC_KP_ENTER = 0xE01C,
+   SC_RCTRL = 0xE01D,
+   SC_VOLUME_MUTE = 0xE020,
+   SC_LAUNCH_APP2 = 0xE021,
+   SC_MEDIA_PLAY = 0xE022,
+   SC_MEDIA_STOP = 0xE024,
+   SC_VOLUME_DOWN = 0xE02E,
+   SC_VOLUME_UP = 0xE030,
+   SC_BROWSER_HOME = 0xE032,
+   SC_KP_DIVIDE = 0xE035,
+   SC_PRINT = 0xE037,
+   SC_RALT = 0xE038,
+   SC_BREAK = 0xE046,
+   SC_HOME = 0xE047,
+   SC_UP = 0xE048,
+   SC_PAGEUP = 0xE049,
+   SC_LEFT = 0xE04B,
+   SC_RIGHT = 0xE04D,
+   SC_END = 0xE04F,
+   SC_DOWN = 0xE050,
+   SC_PAGEDOWN = 0xE051,
+   SC_INSERT = 0xE052,
+   SC_DELETE = 0xE053,
+   SC_LSUPER = 0xE05B,
+   SC_RSUPER = 0xE05C,
+   SC_MENU = 0xE05D,
+   SC_POWER = 0xE05E,
+   SC_SLEEP = 0xE05F,
+   SC_WAKE = 0xE063,
+   SC_BROWSER_SEARCH = 0xE065,
+   SC_BROWSER_FAVORITES = 0xE066,
+   SC_BROWSER_REFRESH = 0xE067,
+   SC_BROWSER_STOP = 0xE068,
+   SC_BROWSER_FORWARD = 0xE069,
+   SC_BROWSER_BACK = 0xE06A,
+   SC_LAUNCH_APP1 = 0xE06B,
+   SC_LAUNCH_EMAIL = 0xE06C,
+   SC_LAUNCH_MEDIA = 0xE06D,
+
+   SC_PAUSE = 0xFFFE/*0xE11D45*/,
+   SC_LAST = 0xFFFF,
+};
+#endif
+
 /**
  * input_keymaps_init_keyboard_lut:
  * @map                   : Keyboard map.