    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveGeneric #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE PatternSynonyms #-}

    {-|

    An enumeration of scancodes and keycodes, allowing you to pattern match on keyboard keys.

    This module uses a relatively new GHC feature called @PatternSynonyms@ in order to provide pattern
    matches over the underlying 'Scancode' or 'Keycode'. We do this so that you are also able to
    work with vendor-specific or otherwise unknown codes.

    -}

    module SDL.Input.Keyboard.Codes
           (-- * Scancodes
            -- | Scancodes are codes that correspond to the physical position of a key, independent of the current keyboard layout.
            -- Scancodes are meant to be layout-independent. Think of this as \"the user pressed the Q key as it would be on a US QWERTY keyboard\" regardless of whether this is actually a European keyboard or a Dvorak keyboard or whatever. The scancode is always the same key position.
            -- 'Scancode' makes sense when you want key presses based on their location on a keyboard - for example, the traditional \"WASD\" layout used in first-person shooters.
            Scancode(..),
            pattern ScancodeUnknown,
            pattern ScancodeA,
            pattern ScancodeB,
            pattern ScancodeC,
            pattern ScancodeD,
            pattern ScancodeE,
            pattern ScancodeF,
            pattern ScancodeG,
            pattern ScancodeH,
            pattern ScancodeI,
            pattern ScancodeJ,
            pattern ScancodeK,
            pattern ScancodeL,
            pattern ScancodeM,
            pattern ScancodeN,
            pattern ScancodeO,
            pattern ScancodeP,
            pattern ScancodeQ,
            pattern ScancodeR,
            pattern ScancodeS,
            pattern ScancodeT,
            pattern ScancodeU,
            pattern ScancodeV,
            pattern ScancodeW,
            pattern ScancodeX,
            pattern ScancodeY,
            pattern ScancodeZ,
            pattern Scancode1,
            pattern Scancode2,
            pattern Scancode3,
            pattern Scancode4,
            pattern Scancode5,
            pattern Scancode6,
            pattern Scancode7,
            pattern Scancode8,
            pattern Scancode9,
            pattern Scancode0,
            pattern ScancodeReturn,
            pattern ScancodeEscape,
            pattern ScancodeBackspace,
            pattern ScancodeTab,
            pattern ScancodeSpace,
            pattern ScancodeMinus,
            pattern ScancodeEquals,
            pattern ScancodeLeftBracket,
            pattern ScancodeRightBracket,
            pattern ScancodeBackslash,
            pattern ScancodeNonUSHash,
            pattern ScancodeSemicolon,
            pattern ScancodeApostrophe,
            pattern ScancodeGrave,
            pattern ScancodeComma,
            pattern ScancodePeriod,
            pattern ScancodeSlash,
            pattern ScancodeCapsLock,
            pattern ScancodeF1,
            pattern ScancodeF2,
            pattern ScancodeF3,
            pattern ScancodeF4,
            pattern ScancodeF5,
            pattern ScancodeF6,
            pattern ScancodeF7,
            pattern ScancodeF8,
            pattern ScancodeF9,
            pattern ScancodeF10,
            pattern ScancodeF11,
            pattern ScancodeF12,
            pattern ScancodePrintScreen,
            pattern ScancodeScrollLock,
            pattern ScancodePause,
            pattern ScancodeInsert,
            pattern ScancodeHome,
            pattern ScancodePageUp,
            pattern ScancodeDelete,
            pattern ScancodeEnd,
            pattern ScancodePageDown,
            pattern ScancodeRight,
            pattern ScancodeLeft,
            pattern ScancodeDown,
            pattern ScancodeUp,
            pattern ScancodeNumLockClear,
            pattern ScancodeKPDivide,
            pattern ScancodeKPMultiply,
            pattern ScancodeKPMinus,
            pattern ScancodeKPPlus,
            pattern ScancodeKPEnter,
            pattern ScancodeKP1,
            pattern ScancodeKP2,
            pattern ScancodeKP3,
            pattern ScancodeKP4,
            pattern ScancodeKP5,
            pattern ScancodeKP6,
            pattern ScancodeKP7,
            pattern ScancodeKP8,
            pattern ScancodeKP9,
            pattern ScancodeKP0,
            pattern ScancodeKPPeriod,
            pattern ScancodeNonUSBackslash,
            pattern ScancodeApplication,
            pattern ScancodePower,
            pattern ScancodeKPEquals,
            pattern ScancodeF13,
            pattern ScancodeF14,
            pattern ScancodeF15,
            pattern ScancodeF16,
            pattern ScancodeF17,
            pattern ScancodeF18,
            pattern ScancodeF19,
            pattern ScancodeF20,
            pattern ScancodeF21,
            pattern ScancodeF22,
            pattern ScancodeF23,
            pattern ScancodeF24,
            pattern ScancodeExecute,
            pattern ScancodeHelp,
            pattern ScancodeMenu,
            pattern ScancodeSelect,
            pattern ScancodeStop,
            pattern ScancodeAgain,
            pattern ScancodeUndo,
            pattern ScancodeCut,
            pattern ScancodeCopy,
            pattern ScancodePaste,
            pattern ScancodeFind,
            pattern ScancodeMute,
            pattern ScancodeVolumeUp,
            pattern ScancodeVolumeDown,
            pattern ScancodeKPComma,
            pattern ScancodeKPEqualsAS400,
            pattern ScancodeInternational1,
            pattern ScancodeInternational2,
            pattern ScancodeInternational3,
            pattern ScancodeInternational4,
            pattern ScancodeInternational5,
            pattern ScancodeInternational6,
            pattern ScancodeInternational7,
            pattern ScancodeInternational8,
            pattern ScancodeInternational9,
            pattern ScancodeLang1,
            pattern ScancodeLang2,
            pattern ScancodeLang3,
            pattern ScancodeLang4,
            pattern ScancodeLang5,
            pattern ScancodeLang6,
            pattern ScancodeLang7,
            pattern ScancodeLang8,
            pattern ScancodeLang9,
            pattern ScancodeAltErase,
            pattern ScancodeSysReq,
            pattern ScancodeCancel,
            pattern ScancodeClear,
            pattern ScancodePrior,
            pattern ScancodeReturn2,
            pattern ScancodeSeparator,
            pattern ScancodeOut,
            pattern ScancodeOper,
            pattern ScancodeClearAgain,
            pattern ScancodeCrSel,
            pattern ScancodeExSel,
            pattern ScancodeKP00,
            pattern ScancodeKP000,
            pattern ScancodeThousandsSeparator,
            pattern ScancodeDecimalSeparator,
            pattern ScancodeCurrencyUnit,
            pattern ScancodeCurrencySubunit,
            pattern ScancodeLeftParen,
            pattern ScancodeRightParen,
            pattern ScancodeLeftBrace,
            pattern ScancodeRightBrace,
            pattern ScancodeKPTab,
            pattern ScancodeKPBackspace,
            pattern ScancodeKPA,
            pattern ScancodeKPB,
            pattern ScancodeKPC,
            pattern ScancodeKPD,
            pattern ScancodeKPE,
            pattern ScancodeKPF,
            pattern ScancodeKPXOR,
            pattern ScancodeKPPower,
            pattern ScancodeKPPercent,
            pattern ScancodeKPLess,
            pattern ScancodeKPGreater,
            pattern ScancodeKPAmpersand,
            pattern ScancodeKPDblAmpersand,
            pattern ScancodeKPVerticalBar,
            pattern ScancodeKPDblVerticalBar,
            pattern ScancodeKPColon,
            pattern ScancodeKPHash,
            pattern ScancodeKPSpace,
            pattern ScancodeKPAt,
            pattern ScancodeKPExclam,
            pattern ScancodeKPMemStore,
            pattern ScancodeKPMemRecall,
            pattern ScancodeKPMemClear,
            pattern ScancodeKPMemAdd,
            pattern ScancodeKPMemSubtract,
            pattern ScancodeKPMemMultiply,
            pattern ScancodeKPMemDivide,
            pattern ScancodeKPPlusMinus,
            pattern ScancodeKPClear,
            pattern ScancodeKPClearEntry,
            pattern ScancodeKPBinary,
            pattern ScancodeKPOctal,
            pattern ScancodeKPDecimal,
            pattern ScancodeKPHexadecimal,
            pattern ScancodeLCtrl,
            pattern ScancodeLShift,
            pattern ScancodeLAlt,
            pattern ScancodeLGUI,
            pattern ScancodeRCtrl,
            pattern ScancodeRShift,
            pattern ScancodeRAlt,
            pattern ScancodeRGUI,
            pattern ScancodeMode,
            pattern ScancodeAudioNext,
            pattern ScancodeAudioPrev,
            pattern ScancodeAudioStop,
            pattern ScancodeAudioPlay,
            pattern ScancodeAudioMute,
            pattern ScancodeMediaSelect,
            pattern ScancodeWWW,
            pattern ScancodeMail,
            pattern ScancodeCalculator,
            pattern ScancodeComputer,
            pattern ScancodeACSearch,
            pattern ScancodeACHome,
            pattern ScancodeACBack,
            pattern ScancodeACForward,
            pattern ScancodeACStop,
            pattern ScancodeACRefresh,
            pattern ScancodeACBookmarks,
            pattern ScancodeBrightnessDown,
            pattern ScancodeBrightnessUp,
            pattern ScancodeDisplaySwitch,
            pattern ScancodeKBDIllumToggle,
            pattern ScancodeKBDIllumDown,
            pattern ScancodeKBDIllumUp,
            pattern ScancodeEject,
            pattern ScancodeSleep,
            pattern ScancodeApp1,
            pattern ScancodeApp2,

            -- * Keycode
            -- | Keycodes are layout-dependent codes, in that the code you receive can change for the same physical key depending on the users keyboard layout.
            -- Think of this as "the user pressed the key that is labelled 'Q' on a specific keyboard."
            -- 'Keycode' makes sense when you are anticipating the user to press either keys that match some mneumonic, or they are entering text.
            Keycode(..),
            pattern KeycodeUnknown,
            pattern KeycodeReturn,
            pattern KeycodeEscape,
            pattern KeycodeBackspace,
            pattern KeycodeTab,
            pattern KeycodeSpace,
            pattern KeycodeExclaim,
            pattern KeycodeQuoteDbl,
            pattern KeycodeHash,
            pattern KeycodePercent,
            pattern KeycodeDollar,
            pattern KeycodeAmpersand,
            pattern KeycodeQuote,
            pattern KeycodeLeftParen,
            pattern KeycodeRightParen,
            pattern KeycodeAsterisk,
            pattern KeycodePlus,
            pattern KeycodeComma,
            pattern KeycodeMinus,
            pattern KeycodePeriod,
            pattern KeycodeSlash,
            pattern Keycode0,
            pattern Keycode1,
            pattern Keycode2,
            pattern Keycode3,
            pattern Keycode4,
            pattern Keycode5,
            pattern Keycode6,
            pattern Keycode7,
            pattern Keycode8,
            pattern Keycode9,
            pattern KeycodeColon,
            pattern KeycodeSemicolon,
            pattern KeycodeLess,
            pattern KeycodeEquals,
            pattern KeycodeGreater,
            pattern KeycodeQuestion,
            pattern KeycodeAt,
            pattern KeycodeLeftBracket,
            pattern KeycodeBackslash,
            pattern KeycodeRightBracket,
            pattern KeycodeCaret,
            pattern KeycodeUnderscore,
            pattern KeycodeBackquote,
            pattern KeycodeA,
            pattern KeycodeB,
            pattern KeycodeC,
            pattern KeycodeD,
            pattern KeycodeE,
            pattern KeycodeF,
            pattern KeycodeG,
            pattern KeycodeH,
            pattern KeycodeI,
            pattern KeycodeJ,
            pattern KeycodeK,
            pattern KeycodeL,
            pattern KeycodeM,
            pattern KeycodeN,
            pattern KeycodeO,
            pattern KeycodeP,
            pattern KeycodeQ,
            pattern KeycodeR,
            pattern KeycodeS,
            pattern KeycodeT,
            pattern KeycodeU,
            pattern KeycodeV,
            pattern KeycodeW,
            pattern KeycodeX,
            pattern KeycodeY,
            pattern KeycodeZ,
            pattern KeycodeCapsLock,
            pattern KeycodeF1,
            pattern KeycodeF2,
            pattern KeycodeF3,
            pattern KeycodeF4,
            pattern KeycodeF5,
            pattern KeycodeF6,
            pattern KeycodeF7,
            pattern KeycodeF8,
            pattern KeycodeF9,
            pattern KeycodeF10,
            pattern KeycodeF11,
            pattern KeycodeF12,
            pattern KeycodePrintScreen,
            pattern KeycodeScrollLock,
            pattern KeycodePause,
            pattern KeycodeInsert,
            pattern KeycodeHome,
            pattern KeycodePageUp,
            pattern KeycodeDelete,
            pattern KeycodeEnd,
            pattern KeycodePageDown,
            pattern KeycodeRight,
            pattern KeycodeLeft,
            pattern KeycodeDown,
            pattern KeycodeUp,
            pattern KeycodeNumLockClear,
            pattern KeycodeKPDivide,
            pattern KeycodeKPMultiply,
            pattern KeycodeKPMinus,
            pattern KeycodeKPPlus,
            pattern KeycodeKPEnter,
            pattern KeycodeKP1,
            pattern KeycodeKP2,
            pattern KeycodeKP3,
            pattern KeycodeKP4,
            pattern KeycodeKP5,
            pattern KeycodeKP6,
            pattern KeycodeKP7,
            pattern KeycodeKP8,
            pattern KeycodeKP9,
            pattern KeycodeKP0,
            pattern KeycodeKPPeriod,
            pattern KeycodeApplication,
            pattern KeycodePower,
            pattern KeycodeKPEquals,
            pattern KeycodeF13,
            pattern KeycodeF14,
            pattern KeycodeF15,
            pattern KeycodeF16,
            pattern KeycodeF17,
            pattern KeycodeF18,
            pattern KeycodeF19,
            pattern KeycodeF20,
            pattern KeycodeF21,
            pattern KeycodeF22,
            pattern KeycodeF23,
            pattern KeycodeF24,
            pattern KeycodeExecute,
            pattern KeycodeHelp,
            pattern KeycodeMenu,
            pattern KeycodeSelect,
            pattern KeycodeStop,
            pattern KeycodeAgain,
            pattern KeycodeUndo,
            pattern KeycodeCut,
            pattern KeycodeCopy,
            pattern KeycodePaste,
            pattern KeycodeFind,
            pattern KeycodeMute,
            pattern KeycodeVolumeUp,
            pattern KeycodeVolumeDown,
            pattern KeycodeKPComma,
            pattern KeycodeKPEqualsAS400,
            pattern KeycodeAltErase,
            pattern KeycodeSysReq,
            pattern KeycodeCancel,
            pattern KeycodeClear,
            pattern KeycodePrior,
            pattern KeycodeReturn2,
            pattern KeycodeSeparator,
            pattern KeycodeOut,
            pattern KeycodeOper,
            pattern KeycodeClearAgain,
            pattern KeycodeCrSel,
            pattern KeycodeExSel,
            pattern KeycodeKP00,
            pattern KeycodeKP000,
            pattern KeycodeThousandsSeparator,
            pattern KeycodeDecimalSeparator,
            pattern KeycodeCurrencyUnit,
            pattern KeycodeCurrencySubunit,
            pattern KeycodeKPLeftParen,
            pattern KeycodeKPRightParen,
            pattern KeycodeKPLeftBrace,
            pattern KeycodeKPRightBrace,
            pattern KeycodeKPTab,
            pattern KeycodeKPBackspace,
            pattern KeycodeKPA,
            pattern KeycodeKPB,
            pattern KeycodeKPC,
            pattern KeycodeKPD,
            pattern KeycodeKPE,
            pattern KeycodeKPF,
            pattern KeycodeKPXor,
            pattern KeycodeKPPower,
            pattern KeycodeKPPercent,
            pattern KeycodeKPLess,
            pattern KeycodeKPGreater,
            pattern KeycodeKPAmpersand,
            pattern KeycodeKPDblAmpersand,
            pattern KeycodeKPVerticalBar,
            pattern KeycodeKPDblVerticalBar,
            pattern KeycodeKPColon,
            pattern KeycodeKPHash,
            pattern KeycodeKPSpace,
            pattern KeycodeKPAt,
            pattern KeycodeKPExclam,
            pattern KeycodeKPMemStore,
            pattern KeycodeKPMemRecall,
            pattern KeycodeKPMemClear,
            pattern KeycodeKPMemAdd,
            pattern KeycodeKPMemSubtract,
            pattern KeycodeKPMemMultiply,
            pattern KeycodeKPMemDivide,
            pattern KeycodeKPPlusMinus,
            pattern KeycodeKPClear,
            pattern KeycodeKPClearEntry,
            pattern KeycodeKPBinary,
            pattern KeycodeKPOctal,
            pattern KeycodeKPDecimal,
            pattern KeycodeKPHexadecimal,
            pattern KeycodeLCtrl,
            pattern KeycodeLShift,
            pattern KeycodeLAlt,
            pattern KeycodeLGUI,
            pattern KeycodeRCtrl,
            pattern KeycodeRShift,
            pattern KeycodeRAlt,
            pattern KeycodeRGUI,
            pattern KeycodeMode,
            pattern KeycodeAudioNext,
            pattern KeycodeAudioPrev,
            pattern KeycodeAudioStop,
            pattern KeycodeAudioPlay,
            pattern KeycodeAudioMute,
            pattern KeycodeMediaSelect,
            pattern KeycodeWWW,
            pattern KeycodeMail,
            pattern KeycodeCalculator,
            pattern KeycodeComputer,
            pattern KeycodeACSearch,
            pattern KeycodeACHome,
            pattern KeycodeACBack,
            pattern KeycodeACForward,
            pattern KeycodeACStop,
            pattern KeycodeACRefresh,
            pattern KeycodeACBookmarks,
            pattern KeycodeBrightnessDown,
            pattern KeycodeBrightnessUp,
            pattern KeycodeDisplaySwitch,
            pattern KeycodeKbdIllumToggle,
            pattern KeycodeKbdIllumDown,
            pattern KeycodeKbdIllumUp,
            pattern KeycodeEject,
            pattern KeycodeSleep)

           where

    import GHC.Generics (Generic)
    import Data.Data (Data)
    import Data.Int
    import Data.Typeable
    import Data.Word
    import SDL.Internal.Numbered
    import qualified SDL.Raw.Enum as Raw

    newtype Scancode = Scancode { Scancode -> Word32
    unwrapScancode :: Word32 }
      deriving (Scancode
    Scancode -> Scancode -> Bounded Scancode
    forall a. a -> a -> Bounded a
    maxBound :: Scancode
    $cmaxBound :: Scancode
    minBound :: Scancode
    $cminBound :: Scancode
    Bounded, Typeable Scancode
    Constr
    DataType
    Typeable Scancode =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Scancode -> c Scancode)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Scancode)
    -> (Scancode -> Constr)
    -> (Scancode -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Scancode))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scancode))
    -> ((forall b. Data b => b -> b) -> Scancode -> Scancode)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Scancode -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Scancode -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Scancode -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Scancode -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Scancode -> m Scancode)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Scancode -> m Scancode)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Scancode -> m Scancode)
    -> Data Scancode
    Scancode -> Constr
    Scancode -> DataType
    (forall b. Data b => b -> b) -> Scancode -> Scancode
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Scancode -> c Scancode
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Scancode
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Scancode -> u
    forall u. (forall d. Data d => d -> u) -> Scancode -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Scancode -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Scancode -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Scancode -> m Scancode
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Scancode -> m Scancode
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Scancode
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Scancode -> c Scancode
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Scancode)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scancode)
    $cScancode :: Constr
    $tScancode :: DataType
    gmapMo :: (forall d. Data d => d -> m d) -> Scancode -> m Scancode
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Scancode -> m Scancode
    gmapMp :: (forall d. Data d => d -> m d) -> Scancode -> m Scancode
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Scancode -> m Scancode
    gmapM :: (forall d. Data d => d -> m d) -> Scancode -> m Scancode
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Scancode -> m Scancode
    gmapQi :: Int -> (forall d. Data d => d -> u) -> Scancode -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Scancode -> u
    gmapQ :: (forall d. Data d => d -> u) -> Scancode -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Scancode -> [u]
    gmapQr :: (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Scancode -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Scancode -> r
    gmapQl :: (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Scancode -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Scancode -> r
    gmapT :: (forall b. Data b => b -> b) -> Scancode -> Scancode
    $cgmapT :: (forall b. Data b => b -> b) -> Scancode -> Scancode
    dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scancode)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scancode)
    dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Scancode)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Scancode)
    dataTypeOf :: Scancode -> DataType
    $cdataTypeOf :: Scancode -> DataType
    toConstr :: Scancode -> Constr
    $ctoConstr :: Scancode -> Constr
    gunfold :: (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Scancode
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Scancode
    gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Scancode -> c Scancode
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Scancode -> c Scancode
    $cp1Data :: Typeable Scancode
    Data, Scancode -> Scancode -> Bool
    (Scancode -> Scancode -> Bool)
    -> (Scancode -> Scancode -> Bool) -> Eq Scancode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Scancode -> Scancode -> Bool
    $c/= :: Scancode -> Scancode -> Bool
    == :: Scancode -> Scancode -> Bool
    $c== :: Scancode -> Scancode -> Bool
    Eq, Eq Scancode
    Eq Scancode =>
    (Scancode -> Scancode -> Ordering)
    -> (Scancode -> Scancode -> Bool)
    -> (Scancode -> Scancode -> Bool)
    -> (Scancode -> Scancode -> Bool)
    -> (Scancode -> Scancode -> Bool)
    -> (Scancode -> Scancode -> Scancode)
    -> (Scancode -> Scancode -> Scancode)
    -> Ord Scancode
    Scancode -> Scancode -> Bool
    Scancode -> Scancode -> Ordering
    Scancode -> Scancode -> Scancode
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: Scancode -> Scancode -> Scancode
    $cmin :: Scancode -> Scancode -> Scancode
    max :: Scancode -> Scancode -> Scancode
    $cmax :: Scancode -> Scancode -> Scancode
    >= :: Scancode -> Scancode -> Bool
    $c>= :: Scancode -> Scancode -> Bool
    > :: Scancode -> Scancode -> Bool
    $c> :: Scancode -> Scancode -> Bool
    <= :: Scancode -> Scancode -> Bool
    $c<= :: Scancode -> Scancode -> Bool
    < :: Scancode -> Scancode -> Bool
    $c< :: Scancode -> Scancode -> Bool
    compare :: Scancode -> Scancode -> Ordering
    $ccompare :: Scancode -> Scancode -> Ordering
    $cp1Ord :: Eq Scancode
    Ord, ReadPrec [Scancode]
    ReadPrec Scancode
    Int -> ReadS Scancode
    ReadS [Scancode]
    (Int -> ReadS Scancode)
    -> ReadS [Scancode]
    -> ReadPrec Scancode
    -> ReadPrec [Scancode]
    -> Read Scancode
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [Scancode]
    $creadListPrec :: ReadPrec [Scancode]
    readPrec :: ReadPrec Scancode
    $creadPrec :: ReadPrec Scancode
    readList :: ReadS [Scancode]
    $creadList :: ReadS [Scancode]
    readsPrec :: Int -> ReadS Scancode
    $creadsPrec :: Int -> ReadS Scancode
    Read, (forall x. Scancode -> Rep Scancode x)
    -> (forall x. Rep Scancode x -> Scancode) -> Generic Scancode
    forall x. Rep Scancode x -> Scancode
    forall x. Scancode -> Rep Scancode x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Scancode x -> Scancode
    $cfrom :: forall x. Scancode -> Rep Scancode x
    Generic, Int -> Scancode -> ShowS
    [Scancode] -> ShowS
    Scancode -> String
    (Int -> Scancode -> ShowS)
    -> (Scancode -> String) -> ([Scancode] -> ShowS) -> Show Scancode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Scancode] -> ShowS
    $cshowList :: [Scancode] -> ShowS
    show :: Scancode -> String
    $cshow :: Scancode -> String
    showsPrec :: Int -> Scancode -> ShowS
    $cshowsPrec :: Int -> Scancode -> ShowS
    Show, Typeable)

    pattern $bScancodeUnknown :: Scancode
    $mScancodeUnknown :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeUnknown = Scancode Raw.SDL_SCANCODE_UNKNOWN
    pattern $bScancodeA :: Scancode
    $mScancodeA :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeA = Scancode Raw.SDL_SCANCODE_A
    pattern $bScancodeB :: Scancode
    $mScancodeB :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeB = Scancode Raw.SDL_SCANCODE_B
    pattern $bScancodeC :: Scancode
    $mScancodeC :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeC = Scancode Raw.SDL_SCANCODE_C
    pattern $bScancodeD :: Scancode
    $mScancodeD :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeD = Scancode Raw.SDL_SCANCODE_D
    pattern $bScancodeE :: Scancode
    $mScancodeE :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeE = Scancode Raw.SDL_SCANCODE_E
    pattern $bScancodeF :: Scancode
    $mScancodeF :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF = Scancode Raw.SDL_SCANCODE_F
    pattern $bScancodeG :: Scancode
    $mScancodeG :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeG = Scancode Raw.SDL_SCANCODE_G
    pattern $bScancodeH :: Scancode
    $mScancodeH :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeH = Scancode Raw.SDL_SCANCODE_H
    pattern $bScancodeI :: Scancode
    $mScancodeI :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeI = Scancode Raw.SDL_SCANCODE_I
    pattern $bScancodeJ :: Scancode
    $mScancodeJ :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeJ = Scancode Raw.SDL_SCANCODE_J
    pattern $bScancodeK :: Scancode
    $mScancodeK :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeK = Scancode Raw.SDL_SCANCODE_K
    pattern $bScancodeL :: Scancode
    $mScancodeL :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeL = Scancode Raw.SDL_SCANCODE_L
    pattern $bScancodeM :: Scancode
    $mScancodeM :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeM = Scancode Raw.SDL_SCANCODE_M
    pattern $bScancodeN :: Scancode
    $mScancodeN :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeN = Scancode Raw.SDL_SCANCODE_N
    pattern $bScancodeO :: Scancode
    $mScancodeO :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeO = Scancode Raw.SDL_SCANCODE_O
    pattern $bScancodeP :: Scancode
    $mScancodeP :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeP = Scancode Raw.SDL_SCANCODE_P
    pattern $bScancodeQ :: Scancode
    $mScancodeQ :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeQ = Scancode Raw.SDL_SCANCODE_Q
    pattern $bScancodeR :: Scancode
    $mScancodeR :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeR = Scancode Raw.SDL_SCANCODE_R
    pattern $bScancodeS :: Scancode
    $mScancodeS :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeS = Scancode Raw.SDL_SCANCODE_S
    pattern $bScancodeT :: Scancode
    $mScancodeT :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeT = Scancode Raw.SDL_SCANCODE_T
    pattern $bScancodeU :: Scancode
    $mScancodeU :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeU = Scancode Raw.SDL_SCANCODE_U
    pattern $bScancodeV :: Scancode
    $mScancodeV :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeV = Scancode Raw.SDL_SCANCODE_V
    pattern $bScancodeW :: Scancode
    $mScancodeW :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeW = Scancode Raw.SDL_SCANCODE_W
    pattern $bScancodeX :: Scancode
    $mScancodeX :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeX = Scancode Raw.SDL_SCANCODE_X
    pattern $bScancodeY :: Scancode
    $mScancodeY :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeY = Scancode Raw.SDL_SCANCODE_Y
    pattern $bScancodeZ :: Scancode
    $mScancodeZ :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeZ = Scancode Raw.SDL_SCANCODE_Z
    pattern $bScancode1 :: Scancode
    $mScancode1 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    Scancode1 = Scancode Raw.SDL_SCANCODE_1
    pattern $bScancode2 :: Scancode
    $mScancode2 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    Scancode2 = Scancode Raw.SDL_SCANCODE_2
    pattern $bScancode3 :: Scancode
    $mScancode3 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    Scancode3 = Scancode Raw.SDL_SCANCODE_3
    pattern $bScancode4 :: Scancode
    $mScancode4 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    Scancode4 = Scancode Raw.SDL_SCANCODE_4
    pattern $bScancode5 :: Scancode
    $mScancode5 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    Scancode5 = Scancode Raw.SDL_SCANCODE_5
    pattern $bScancode6 :: Scancode
    $mScancode6 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    Scancode6 = Scancode Raw.SDL_SCANCODE_6
    pattern $bScancode7 :: Scancode
    $mScancode7 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    Scancode7 = Scancode Raw.SDL_SCANCODE_7
    pattern $bScancode8 :: Scancode
    $mScancode8 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    Scancode8 = Scancode Raw.SDL_SCANCODE_8
    pattern $bScancode9 :: Scancode
    $mScancode9 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    Scancode9 = Scancode Raw.SDL_SCANCODE_9
    pattern $bScancode0 :: Scancode
    $mScancode0 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    Scancode0 = Scancode Raw.SDL_SCANCODE_0
    pattern $bScancodeReturn :: Scancode
    $mScancodeReturn :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeReturn = Scancode Raw.SDL_SCANCODE_RETURN
    pattern $bScancodeEscape :: Scancode
    $mScancodeEscape :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeEscape = Scancode Raw.SDL_SCANCODE_ESCAPE
    pattern $bScancodeBackspace :: Scancode
    $mScancodeBackspace :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeBackspace = Scancode Raw.SDL_SCANCODE_BACKSPACE
    pattern $bScancodeTab :: Scancode
    $mScancodeTab :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeTab = Scancode Raw.SDL_SCANCODE_TAB
    pattern $bScancodeSpace :: Scancode
    $mScancodeSpace :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeSpace = Scancode Raw.SDL_SCANCODE_SPACE
    pattern $bScancodeMinus :: Scancode
    $mScancodeMinus :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeMinus = Scancode Raw.SDL_SCANCODE_MINUS
    pattern $bScancodeEquals :: Scancode
    $mScancodeEquals :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeEquals = Scancode Raw.SDL_SCANCODE_EQUALS
    pattern $bScancodeLeftBracket :: Scancode
    $mScancodeLeftBracket :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLeftBracket = Scancode Raw.SDL_SCANCODE_LEFTBRACKET
    pattern $bScancodeRightBracket :: Scancode
    $mScancodeRightBracket :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeRightBracket = Scancode Raw.SDL_SCANCODE_RIGHTBRACKET
    pattern $bScancodeBackslash :: Scancode
    $mScancodeBackslash :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeBackslash = Scancode Raw.SDL_SCANCODE_BACKSLASH
    pattern $bScancodeNonUSHash :: Scancode
    $mScancodeNonUSHash :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeNonUSHash = Scancode Raw.SDL_SCANCODE_NONUSHASH
    pattern $bScancodeSemicolon :: Scancode
    $mScancodeSemicolon :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeSemicolon = Scancode Raw.SDL_SCANCODE_SEMICOLON
    pattern $bScancodeApostrophe :: Scancode
    $mScancodeApostrophe :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeApostrophe = Scancode Raw.SDL_SCANCODE_APOSTROPHE
    pattern $bScancodeGrave :: Scancode
    $mScancodeGrave :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeGrave = Scancode Raw.SDL_SCANCODE_GRAVE
    pattern $bScancodeComma :: Scancode
    $mScancodeComma :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeComma = Scancode Raw.SDL_SCANCODE_COMMA
    pattern $bScancodePeriod :: Scancode
    $mScancodePeriod :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodePeriod = Scancode Raw.SDL_SCANCODE_PERIOD
    pattern $bScancodeSlash :: Scancode
    $mScancodeSlash :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeSlash = Scancode Raw.SDL_SCANCODE_SLASH
    pattern $bScancodeCapsLock :: Scancode
    $mScancodeCapsLock :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeCapsLock = Scancode Raw.SDL_SCANCODE_CAPSLOCK
    pattern $bScancodeF1 :: Scancode
    $mScancodeF1 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF1 = Scancode Raw.SDL_SCANCODE_F1
    pattern $bScancodeF2 :: Scancode
    $mScancodeF2 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF2 = Scancode Raw.SDL_SCANCODE_F2
    pattern $bScancodeF3 :: Scancode
    $mScancodeF3 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF3 = Scancode Raw.SDL_SCANCODE_F3
    pattern $bScancodeF4 :: Scancode
    $mScancodeF4 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF4 = Scancode Raw.SDL_SCANCODE_F4
    pattern $bScancodeF5 :: Scancode
    $mScancodeF5 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF5 = Scancode Raw.SDL_SCANCODE_F5
    pattern $bScancodeF6 :: Scancode
    $mScancodeF6 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF6 = Scancode Raw.SDL_SCANCODE_F6
    pattern $bScancodeF7 :: Scancode
    $mScancodeF7 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF7 = Scancode Raw.SDL_SCANCODE_F7
    pattern $bScancodeF8 :: Scancode
    $mScancodeF8 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF8 = Scancode Raw.SDL_SCANCODE_F8
    pattern $bScancodeF9 :: Scancode
    $mScancodeF9 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF9 = Scancode Raw.SDL_SCANCODE_F9
    pattern $bScancodeF10 :: Scancode
    $mScancodeF10 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF10 = Scancode Raw.SDL_SCANCODE_F10
    pattern $bScancodeF11 :: Scancode
    $mScancodeF11 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF11 = Scancode Raw.SDL_SCANCODE_F11
    pattern $bScancodeF12 :: Scancode
    $mScancodeF12 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF12 = Scancode Raw.SDL_SCANCODE_F12
    pattern $bScancodePrintScreen :: Scancode
    $mScancodePrintScreen :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodePrintScreen = Scancode Raw.SDL_SCANCODE_PRINTSCREEN
    pattern $bScancodeScrollLock :: Scancode
    $mScancodeScrollLock :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeScrollLock = Scancode Raw.SDL_SCANCODE_SCROLLLOCK
    pattern $bScancodePause :: Scancode
    $mScancodePause :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodePause = Scancode Raw.SDL_SCANCODE_PAUSE
    pattern $bScancodeInsert :: Scancode
    $mScancodeInsert :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeInsert = Scancode Raw.SDL_SCANCODE_INSERT
    pattern $bScancodeHome :: Scancode
    $mScancodeHome :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeHome = Scancode Raw.SDL_SCANCODE_HOME
    pattern $bScancodePageUp :: Scancode
    $mScancodePageUp :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodePageUp = Scancode Raw.SDL_SCANCODE_PAGEUP
    pattern $bScancodeDelete :: Scancode
    $mScancodeDelete :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeDelete = Scancode Raw.SDL_SCANCODE_DELETE
    pattern $bScancodeEnd :: Scancode
    $mScancodeEnd :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeEnd = Scancode Raw.SDL_SCANCODE_END
    pattern $bScancodePageDown :: Scancode
    $mScancodePageDown :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodePageDown = Scancode Raw.SDL_SCANCODE_PAGEDOWN
    pattern $bScancodeRight :: Scancode
    $mScancodeRight :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeRight = Scancode Raw.SDL_SCANCODE_RIGHT
    pattern $bScancodeLeft :: Scancode
    $mScancodeLeft :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLeft = Scancode Raw.SDL_SCANCODE_LEFT
    pattern $bScancodeDown :: Scancode
    $mScancodeDown :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeDown = Scancode Raw.SDL_SCANCODE_DOWN
    pattern $bScancodeUp :: Scancode
    $mScancodeUp :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeUp = Scancode Raw.SDL_SCANCODE_UP
    pattern $bScancodeNumLockClear :: Scancode
    $mScancodeNumLockClear :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeNumLockClear = Scancode Raw.SDL_SCANCODE_NUMLOCKCLEAR
    pattern $bScancodeKPDivide :: Scancode
    $mScancodeKPDivide :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPDivide = Scancode Raw.SDL_SCANCODE_KP_DIVIDE
    pattern $bScancodeKPMultiply :: Scancode
    $mScancodeKPMultiply :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPMultiply = Scancode Raw.SDL_SCANCODE_KP_MULTIPLY
    pattern $bScancodeKPMinus :: Scancode
    $mScancodeKPMinus :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPMinus = Scancode Raw.SDL_SCANCODE_KP_MINUS
    pattern $bScancodeKPPlus :: Scancode
    $mScancodeKPPlus :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPPlus = Scancode Raw.SDL_SCANCODE_KP_PLUS
    pattern $bScancodeKPEnter :: Scancode
    $mScancodeKPEnter :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPEnter = Scancode Raw.SDL_SCANCODE_KP_ENTER
    pattern $bScancodeKP1 :: Scancode
    $mScancodeKP1 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKP1 = Scancode Raw.SDL_SCANCODE_KP_1
    pattern $bScancodeKP2 :: Scancode
    $mScancodeKP2 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKP2 = Scancode Raw.SDL_SCANCODE_KP_2
    pattern $bScancodeKP3 :: Scancode
    $mScancodeKP3 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKP3 = Scancode Raw.SDL_SCANCODE_KP_3
    pattern $bScancodeKP4 :: Scancode
    $mScancodeKP4 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKP4 = Scancode Raw.SDL_SCANCODE_KP_4
    pattern $bScancodeKP5 :: Scancode
    $mScancodeKP5 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKP5 = Scancode Raw.SDL_SCANCODE_KP_5
    pattern $bScancodeKP6 :: Scancode
    $mScancodeKP6 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKP6 = Scancode Raw.SDL_SCANCODE_KP_6
    pattern $bScancodeKP7 :: Scancode
    $mScancodeKP7 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKP7 = Scancode Raw.SDL_SCANCODE_KP_7
    pattern $bScancodeKP8 :: Scancode
    $mScancodeKP8 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKP8 = Scancode Raw.SDL_SCANCODE_KP_8
    pattern $bScancodeKP9 :: Scancode
    $mScancodeKP9 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKP9 = Scancode Raw.SDL_SCANCODE_KP_9
    pattern $bScancodeKP0 :: Scancode
    $mScancodeKP0 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKP0 = Scancode Raw.SDL_SCANCODE_KP_0
    pattern $bScancodeKPPeriod :: Scancode
    $mScancodeKPPeriod :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPPeriod = Scancode Raw.SDL_SCANCODE_KP_PERIOD
    pattern $bScancodeNonUSBackslash :: Scancode
    $mScancodeNonUSBackslash :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeNonUSBackslash = Scancode Raw.SDL_SCANCODE_NONUSBACKSLASH
    pattern $bScancodeApplication :: Scancode
    $mScancodeApplication :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeApplication = Scancode Raw.SDL_SCANCODE_APPLICATION
    pattern $bScancodePower :: Scancode
    $mScancodePower :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodePower = Scancode Raw.SDL_SCANCODE_POWER
    pattern $bScancodeKPEquals :: Scancode
    $mScancodeKPEquals :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPEquals = Scancode Raw.SDL_SCANCODE_KP_EQUALS
    pattern $bScancodeF13 :: Scancode
    $mScancodeF13 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF13 = Scancode Raw.SDL_SCANCODE_F13
    pattern $bScancodeF14 :: Scancode
    $mScancodeF14 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF14 = Scancode Raw.SDL_SCANCODE_F14
    pattern $bScancodeF15 :: Scancode
    $mScancodeF15 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF15 = Scancode Raw.SDL_SCANCODE_F15
    pattern $bScancodeF16 :: Scancode
    $mScancodeF16 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF16 = Scancode Raw.SDL_SCANCODE_F16
    pattern $bScancodeF17 :: Scancode
    $mScancodeF17 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF17 = Scancode Raw.SDL_SCANCODE_F17
    pattern $bScancodeF18 :: Scancode
    $mScancodeF18 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF18 = Scancode Raw.SDL_SCANCODE_F18
    pattern $bScancodeF19 :: Scancode
    $mScancodeF19 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF19 = Scancode Raw.SDL_SCANCODE_F19
    pattern $bScancodeF20 :: Scancode
    $mScancodeF20 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF20 = Scancode Raw.SDL_SCANCODE_F20
    pattern $bScancodeF21 :: Scancode
    $mScancodeF21 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF21 = Scancode Raw.SDL_SCANCODE_F21
    pattern $bScancodeF22 :: Scancode
    $mScancodeF22 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF22 = Scancode Raw.SDL_SCANCODE_F22
    pattern $bScancodeF23 :: Scancode
    $mScancodeF23 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF23 = Scancode Raw.SDL_SCANCODE_F23
    pattern $bScancodeF24 :: Scancode
    $mScancodeF24 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeF24 = Scancode Raw.SDL_SCANCODE_F24
    pattern $bScancodeExecute :: Scancode
    $mScancodeExecute :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeExecute = Scancode Raw.SDL_SCANCODE_EXECUTE
    pattern $bScancodeHelp :: Scancode
    $mScancodeHelp :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeHelp = Scancode Raw.SDL_SCANCODE_HELP
    pattern $bScancodeMenu :: Scancode
    $mScancodeMenu :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeMenu = Scancode Raw.SDL_SCANCODE_MENU
    pattern $bScancodeSelect :: Scancode
    $mScancodeSelect :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeSelect = Scancode Raw.SDL_SCANCODE_SELECT
    pattern $bScancodeStop :: Scancode
    $mScancodeStop :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeStop = Scancode Raw.SDL_SCANCODE_STOP
    pattern $bScancodeAgain :: Scancode
    $mScancodeAgain :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeAgain = Scancode Raw.SDL_SCANCODE_AGAIN
    pattern $bScancodeUndo :: Scancode
    $mScancodeUndo :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeUndo = Scancode Raw.SDL_SCANCODE_UNDO
    pattern $bScancodeCut :: Scancode
    $mScancodeCut :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeCut = Scancode Raw.SDL_SCANCODE_CUT
    pattern $bScancodeCopy :: Scancode
    $mScancodeCopy :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeCopy = Scancode Raw.SDL_SCANCODE_COPY
    pattern $bScancodePaste :: Scancode
    $mScancodePaste :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodePaste = Scancode Raw.SDL_SCANCODE_PASTE
    pattern $bScancodeFind :: Scancode
    $mScancodeFind :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeFind = Scancode Raw.SDL_SCANCODE_FIND
    pattern $bScancodeMute :: Scancode
    $mScancodeMute :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeMute = Scancode Raw.SDL_SCANCODE_MUTE
    pattern $bScancodeVolumeUp :: Scancode
    $mScancodeVolumeUp :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeVolumeUp = Scancode Raw.SDL_SCANCODE_VOLUMEUP
    pattern $bScancodeVolumeDown :: Scancode
    $mScancodeVolumeDown :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeVolumeDown = Scancode Raw.SDL_SCANCODE_VOLUMEDOWN
    pattern $bScancodeKPComma :: Scancode
    $mScancodeKPComma :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPComma = Scancode Raw.SDL_SCANCODE_KP_COMMA
    pattern $bScancodeKPEqualsAS400 :: Scancode
    $mScancodeKPEqualsAS400 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPEqualsAS400 = Scancode Raw.SDL_SCANCODE_KP_EQUALSAS400
    pattern $bScancodeInternational1 :: Scancode
    $mScancodeInternational1 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeInternational1 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL1
    pattern $bScancodeInternational2 :: Scancode
    $mScancodeInternational2 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeInternational2 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL2
    pattern $bScancodeInternational3 :: Scancode
    $mScancodeInternational3 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeInternational3 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL3
    pattern $bScancodeInternational4 :: Scancode
    $mScancodeInternational4 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeInternational4 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL4
    pattern $bScancodeInternational5 :: Scancode
    $mScancodeInternational5 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeInternational5 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL5
    pattern $bScancodeInternational6 :: Scancode
    $mScancodeInternational6 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeInternational6 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL6
    pattern $bScancodeInternational7 :: Scancode
    $mScancodeInternational7 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeInternational7 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL7
    pattern $bScancodeInternational8 :: Scancode
    $mScancodeInternational8 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeInternational8 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL8
    pattern $bScancodeInternational9 :: Scancode
    $mScancodeInternational9 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeInternational9 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL9
    pattern $bScancodeLang1 :: Scancode
    $mScancodeLang1 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLang1 = Scancode Raw.SDL_SCANCODE_LANG1
    pattern $bScancodeLang2 :: Scancode
    $mScancodeLang2 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLang2 = Scancode Raw.SDL_SCANCODE_LANG2
    pattern $bScancodeLang3 :: Scancode
    $mScancodeLang3 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLang3 = Scancode Raw.SDL_SCANCODE_LANG3
    pattern $bScancodeLang4 :: Scancode
    $mScancodeLang4 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLang4 = Scancode Raw.SDL_SCANCODE_LANG4
    pattern $bScancodeLang5 :: Scancode
    $mScancodeLang5 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLang5 = Scancode Raw.SDL_SCANCODE_LANG5
    pattern $bScancodeLang6 :: Scancode
    $mScancodeLang6 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLang6 = Scancode Raw.SDL_SCANCODE_LANG6
    pattern $bScancodeLang7 :: Scancode
    $mScancodeLang7 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLang7 = Scancode Raw.SDL_SCANCODE_LANG7
    pattern $bScancodeLang8 :: Scancode
    $mScancodeLang8 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLang8 = Scancode Raw.SDL_SCANCODE_LANG8
    pattern $bScancodeLang9 :: Scancode
    $mScancodeLang9 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLang9 = Scancode Raw.SDL_SCANCODE_LANG9
    pattern $bScancodeAltErase :: Scancode
    $mScancodeAltErase :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeAltErase = Scancode Raw.SDL_SCANCODE_ALTERASE
    pattern $bScancodeSysReq :: Scancode
    $mScancodeSysReq :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeSysReq = Scancode Raw.SDL_SCANCODE_SYSREQ
    pattern $bScancodeCancel :: Scancode
    $mScancodeCancel :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeCancel = Scancode Raw.SDL_SCANCODE_CANCEL
    pattern $bScancodeClear :: Scancode
    $mScancodeClear :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeClear = Scancode Raw.SDL_SCANCODE_CLEAR
    pattern $bScancodePrior :: Scancode
    $mScancodePrior :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodePrior = Scancode Raw.SDL_SCANCODE_PRIOR
    pattern $bScancodeReturn2 :: Scancode
    $mScancodeReturn2 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeReturn2 = Scancode Raw.SDL_SCANCODE_RETURN2
    pattern $bScancodeSeparator :: Scancode
    $mScancodeSeparator :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeSeparator = Scancode Raw.SDL_SCANCODE_SEPARATOR
    pattern $bScancodeOut :: Scancode
    $mScancodeOut :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeOut = Scancode Raw.SDL_SCANCODE_OUT
    pattern $bScancodeOper :: Scancode
    $mScancodeOper :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeOper = Scancode Raw.SDL_SCANCODE_OPER
    pattern $bScancodeClearAgain :: Scancode
    $mScancodeClearAgain :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeClearAgain = Scancode Raw.SDL_SCANCODE_CLEARAGAIN
    pattern $bScancodeCrSel :: Scancode
    $mScancodeCrSel :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeCrSel = Scancode Raw.SDL_SCANCODE_CRSEL
    pattern $bScancodeExSel :: Scancode
    $mScancodeExSel :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeExSel = Scancode Raw.SDL_SCANCODE_EXSEL
    pattern $bScancodeKP00 :: Scancode
    $mScancodeKP00 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKP00 = Scancode Raw.SDL_SCANCODE_KP_00
    pattern $bScancodeKP000 :: Scancode
    $mScancodeKP000 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKP000 = Scancode Raw.SDL_SCANCODE_KP_000
    pattern $bScancodeThousandsSeparator :: Scancode
    $mScancodeThousandsSeparator :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeThousandsSeparator = Scancode Raw.SDL_SCANCODE_THOUSANDSSEPARATOR
    pattern $bScancodeDecimalSeparator :: Scancode
    $mScancodeDecimalSeparator :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeDecimalSeparator = Scancode Raw.SDL_SCANCODE_DECIMALSEPARATOR
    pattern $bScancodeCurrencyUnit :: Scancode
    $mScancodeCurrencyUnit :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeCurrencyUnit = Scancode Raw.SDL_SCANCODE_CURRENCYUNIT
    pattern $bScancodeCurrencySubunit :: Scancode
    $mScancodeCurrencySubunit :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeCurrencySubunit = Scancode Raw.SDL_SCANCODE_CURRENCYSUBUNIT
    pattern $bScancodeLeftParen :: Scancode
    $mScancodeLeftParen :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLeftParen = Scancode Raw.SDL_SCANCODE_KP_LEFTPAREN
    pattern $bScancodeRightParen :: Scancode
    $mScancodeRightParen :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeRightParen = Scancode Raw.SDL_SCANCODE_KP_RIGHTPAREN
    pattern $bScancodeLeftBrace :: Scancode
    $mScancodeLeftBrace :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLeftBrace = Scancode Raw.SDL_SCANCODE_KP_LEFTBRACE
    pattern $bScancodeRightBrace :: Scancode
    $mScancodeRightBrace :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeRightBrace = Scancode Raw.SDL_SCANCODE_KP_RIGHTBRACE
    pattern $bScancodeKPTab :: Scancode
    $mScancodeKPTab :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPTab = Scancode Raw.SDL_SCANCODE_KP_TAB
    pattern $bScancodeKPBackspace :: Scancode
    $mScancodeKPBackspace :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPBackspace = Scancode Raw.SDL_SCANCODE_KP_BACKSPACE
    pattern $bScancodeKPA :: Scancode
    $mScancodeKPA :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPA = Scancode Raw.SDL_SCANCODE_KP_A
    pattern $bScancodeKPB :: Scancode
    $mScancodeKPB :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPB = Scancode Raw.SDL_SCANCODE_KP_B
    pattern $bScancodeKPC :: Scancode
    $mScancodeKPC :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPC = Scancode Raw.SDL_SCANCODE_KP_C
    pattern $bScancodeKPD :: Scancode
    $mScancodeKPD :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPD = Scancode Raw.SDL_SCANCODE_KP_D
    pattern $bScancodeKPE :: Scancode
    $mScancodeKPE :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPE = Scancode Raw.SDL_SCANCODE_KP_E
    pattern $bScancodeKPF :: Scancode
    $mScancodeKPF :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPF = Scancode Raw.SDL_SCANCODE_KP_F
    pattern $bScancodeKPXOR :: Scancode
    $mScancodeKPXOR :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPXOR = Scancode Raw.SDL_SCANCODE_KP_XOR
    pattern $bScancodeKPPower :: Scancode
    $mScancodeKPPower :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPPower = Scancode Raw.SDL_SCANCODE_KP_POWER
    pattern $bScancodeKPPercent :: Scancode
    $mScancodeKPPercent :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPPercent = Scancode Raw.SDL_SCANCODE_KP_PERCENT
    pattern $bScancodeKPLess :: Scancode
    $mScancodeKPLess :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPLess = Scancode Raw.SDL_SCANCODE_KP_LESS
    pattern $bScancodeKPGreater :: Scancode
    $mScancodeKPGreater :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPGreater = Scancode Raw.SDL_SCANCODE_KP_GREATER
    pattern $bScancodeKPAmpersand :: Scancode
    $mScancodeKPAmpersand :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPAmpersand = Scancode Raw.SDL_SCANCODE_KP_AMPERSAND
    pattern $bScancodeKPDblAmpersand :: Scancode
    $mScancodeKPDblAmpersand :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPDblAmpersand = Scancode Raw.SDL_SCANCODE_KP_DBLAMPERSAND
    pattern $bScancodeKPVerticalBar :: Scancode
    $mScancodeKPVerticalBar :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPVerticalBar = Scancode Raw.SDL_SCANCODE_KP_VERTICALBAR
    pattern $bScancodeKPDblVerticalBar :: Scancode
    $mScancodeKPDblVerticalBar :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPDblVerticalBar = Scancode Raw.SDL_SCANCODE_KP_DBLVERTICALBAR
    pattern $bScancodeKPColon :: Scancode
    $mScancodeKPColon :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPColon = Scancode Raw.SDL_SCANCODE_KP_COLON
    pattern $bScancodeKPHash :: Scancode
    $mScancodeKPHash :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPHash = Scancode Raw.SDL_SCANCODE_KP_HASH
    pattern $bScancodeKPSpace :: Scancode
    $mScancodeKPSpace :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPSpace = Scancode Raw.SDL_SCANCODE_KP_SPACE
    pattern $bScancodeKPAt :: Scancode
    $mScancodeKPAt :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPAt = Scancode Raw.SDL_SCANCODE_KP_AT
    pattern $bScancodeKPExclam :: Scancode
    $mScancodeKPExclam :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPExclam = Scancode Raw.SDL_SCANCODE_KP_EXCLAM
    pattern $bScancodeKPMemStore :: Scancode
    $mScancodeKPMemStore :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPMemStore = Scancode Raw.SDL_SCANCODE_KP_MEMSTORE
    pattern $bScancodeKPMemRecall :: Scancode
    $mScancodeKPMemRecall :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPMemRecall = Scancode Raw.SDL_SCANCODE_KP_MEMRECALL
    pattern $bScancodeKPMemClear :: Scancode
    $mScancodeKPMemClear :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPMemClear = Scancode Raw.SDL_SCANCODE_KP_MEMCLEAR
    pattern $bScancodeKPMemAdd :: Scancode
    $mScancodeKPMemAdd :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPMemAdd = Scancode Raw.SDL_SCANCODE_KP_MEMADD
    pattern $bScancodeKPMemSubtract :: Scancode
    $mScancodeKPMemSubtract :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPMemSubtract = Scancode Raw.SDL_SCANCODE_KP_MEMSUBTRACT
    pattern $bScancodeKPMemMultiply :: Scancode
    $mScancodeKPMemMultiply :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPMemMultiply = Scancode Raw.SDL_SCANCODE_KP_MEMMULTIPLY
    pattern $bScancodeKPMemDivide :: Scancode
    $mScancodeKPMemDivide :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPMemDivide = Scancode Raw.SDL_SCANCODE_KP_MEMDIVIDE
    pattern $bScancodeKPPlusMinus :: Scancode
    $mScancodeKPPlusMinus :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPPlusMinus = Scancode Raw.SDL_SCANCODE_KP_PLUSMINUS
    pattern $bScancodeKPClear :: Scancode
    $mScancodeKPClear :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPClear = Scancode Raw.SDL_SCANCODE_KP_CLEAR
    pattern $bScancodeKPClearEntry :: Scancode
    $mScancodeKPClearEntry :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPClearEntry = Scancode Raw.SDL_SCANCODE_KP_CLEARENTRY
    pattern $bScancodeKPBinary :: Scancode
    $mScancodeKPBinary :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPBinary = Scancode Raw.SDL_SCANCODE_KP_BINARY
    pattern $bScancodeKPOctal :: Scancode
    $mScancodeKPOctal :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPOctal = Scancode Raw.SDL_SCANCODE_KP_OCTAL
    pattern $bScancodeKPDecimal :: Scancode
    $mScancodeKPDecimal :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPDecimal = Scancode Raw.SDL_SCANCODE_KP_DECIMAL
    pattern $bScancodeKPHexadecimal :: Scancode
    $mScancodeKPHexadecimal :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKPHexadecimal = Scancode Raw.SDL_SCANCODE_KP_HEXADECIMAL
    pattern $bScancodeLCtrl :: Scancode
    $mScancodeLCtrl :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLCtrl = Scancode Raw.SDL_SCANCODE_LCTRL
    pattern $bScancodeLShift :: Scancode
    $mScancodeLShift :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLShift = Scancode Raw.SDL_SCANCODE_LSHIFT
    pattern $bScancodeLAlt :: Scancode
    $mScancodeLAlt :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLAlt = Scancode Raw.SDL_SCANCODE_LALT
    pattern $bScancodeLGUI :: Scancode
    $mScancodeLGUI :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeLGUI = Scancode Raw.SDL_SCANCODE_LGUI
    pattern $bScancodeRCtrl :: Scancode
    $mScancodeRCtrl :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeRCtrl = Scancode Raw.SDL_SCANCODE_RCTRL
    pattern $bScancodeRShift :: Scancode
    $mScancodeRShift :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeRShift = Scancode Raw.SDL_SCANCODE_RSHIFT
    pattern $bScancodeRAlt :: Scancode
    $mScancodeRAlt :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeRAlt = Scancode Raw.SDL_SCANCODE_RALT
    pattern $bScancodeRGUI :: Scancode
    $mScancodeRGUI :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeRGUI = Scancode Raw.SDL_SCANCODE_RGUI
    pattern $bScancodeMode :: Scancode
    $mScancodeMode :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeMode = Scancode Raw.SDL_SCANCODE_MODE
    pattern $bScancodeAudioNext :: Scancode
    $mScancodeAudioNext :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeAudioNext = Scancode Raw.SDL_SCANCODE_AUDIONEXT
    pattern $bScancodeAudioPrev :: Scancode
    $mScancodeAudioPrev :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeAudioPrev = Scancode Raw.SDL_SCANCODE_AUDIOPREV
    pattern $bScancodeAudioStop :: Scancode
    $mScancodeAudioStop :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeAudioStop = Scancode Raw.SDL_SCANCODE_AUDIOSTOP
    pattern $bScancodeAudioPlay :: Scancode
    $mScancodeAudioPlay :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeAudioPlay = Scancode Raw.SDL_SCANCODE_AUDIOPLAY
    pattern $bScancodeAudioMute :: Scancode
    $mScancodeAudioMute :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeAudioMute = Scancode Raw.SDL_SCANCODE_AUDIOMUTE
    pattern $bScancodeMediaSelect :: Scancode
    $mScancodeMediaSelect :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeMediaSelect = Scancode Raw.SDL_SCANCODE_MEDIASELECT
    pattern $bScancodeWWW :: Scancode
    $mScancodeWWW :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeWWW = Scancode Raw.SDL_SCANCODE_WWW
    pattern $bScancodeMail :: Scancode
    $mScancodeMail :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeMail = Scancode Raw.SDL_SCANCODE_MAIL
    pattern $bScancodeCalculator :: Scancode
    $mScancodeCalculator :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeCalculator = Scancode Raw.SDL_SCANCODE_CALCULATOR
    pattern $bScancodeComputer :: Scancode
    $mScancodeComputer :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeComputer = Scancode Raw.SDL_SCANCODE_COMPUTER
    pattern $bScancodeACSearch :: Scancode
    $mScancodeACSearch :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeACSearch = Scancode Raw.SDL_SCANCODE_AC_SEARCH
    pattern $bScancodeACHome :: Scancode
    $mScancodeACHome :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeACHome = Scancode Raw.SDL_SCANCODE_AC_HOME
    pattern $bScancodeACBack :: Scancode
    $mScancodeACBack :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeACBack = Scancode Raw.SDL_SCANCODE_AC_BACK
    pattern $bScancodeACForward :: Scancode
    $mScancodeACForward :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeACForward = Scancode Raw.SDL_SCANCODE_AC_FORWARD
    pattern $bScancodeACStop :: Scancode
    $mScancodeACStop :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeACStop = Scancode Raw.SDL_SCANCODE_AC_STOP
    pattern $bScancodeACRefresh :: Scancode
    $mScancodeACRefresh :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeACRefresh = Scancode Raw.SDL_SCANCODE_AC_REFRESH
    pattern $bScancodeACBookmarks :: Scancode
    $mScancodeACBookmarks :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeACBookmarks = Scancode Raw.SDL_SCANCODE_AC_BOOKMARKS
    pattern $bScancodeBrightnessDown :: Scancode
    $mScancodeBrightnessDown :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeBrightnessDown = Scancode Raw.SDL_SCANCODE_BRIGHTNESSDOWN
    pattern $bScancodeBrightnessUp :: Scancode
    $mScancodeBrightnessUp :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeBrightnessUp = Scancode Raw.SDL_SCANCODE_BRIGHTNESSUP
    pattern $bScancodeDisplaySwitch :: Scancode
    $mScancodeDisplaySwitch :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeDisplaySwitch = Scancode Raw.SDL_SCANCODE_DISPLAYSWITCH
    pattern $bScancodeKBDIllumToggle :: Scancode
    $mScancodeKBDIllumToggle :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKBDIllumToggle = Scancode Raw.SDL_SCANCODE_KBDILLUMTOGGLE
    pattern $bScancodeKBDIllumDown :: Scancode
    $mScancodeKBDIllumDown :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKBDIllumDown = Scancode Raw.SDL_SCANCODE_KBDILLUMDOWN
    pattern $bScancodeKBDIllumUp :: Scancode
    $mScancodeKBDIllumUp :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeKBDIllumUp = Scancode Raw.SDL_SCANCODE_KBDILLUMUP
    pattern $bScancodeEject :: Scancode
    $mScancodeEject :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeEject = Scancode Raw.SDL_SCANCODE_EJECT
    pattern $bScancodeSleep :: Scancode
    $mScancodeSleep :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeSleep = Scancode Raw.SDL_SCANCODE_SLEEP
    pattern $bScancodeApp1 :: Scancode
    $mScancodeApp1 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeApp1 = Scancode Raw.SDL_SCANCODE_APP1
    pattern $bScancodeApp2 :: Scancode
    $mScancodeApp2 :: forall r. Scancode -> (Void# -> r) -> (Void# -> r) -> r
    ScancodeApp2 = Scancode Raw.SDL_SCANCODE_APP2

    instance FromNumber Scancode Word32 where
      fromNumber :: Word32 -> Scancode
    fromNumber = Word32 -> Scancode
    Scancode

    instance ToNumber Scancode Word32 where
      toNumber :: Scancode -> Word32
    toNumber = Scancode -> Word32
    unwrapScancode

    newtype Keycode = Keycode { Keycode -> Int32
    unwrapKeycode :: Int32 }
      deriving (Keycode
    Keycode -> Keycode -> Bounded Keycode
    forall a. a -> a -> Bounded a
    maxBound :: Keycode
    $cmaxBound :: Keycode
    minBound :: Keycode
    $cminBound :: Keycode
    Bounded, Typeable Keycode
    Constr
    DataType
    Typeable Keycode =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Keycode -> c Keycode)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Keycode)
    -> (Keycode -> Constr)
    -> (Keycode -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Keycode))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keycode))
    -> ((forall b. Data b => b -> b) -> Keycode -> Keycode)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Keycode -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Keycode -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Keycode -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Keycode -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Keycode -> m Keycode)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Keycode -> m Keycode)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Keycode -> m Keycode)
    -> Data Keycode
    Keycode -> Constr
    Keycode -> DataType
    (forall b. Data b => b -> b) -> Keycode -> Keycode
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Keycode -> c Keycode
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Keycode
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Keycode -> u
    forall u. (forall d. Data d => d -> u) -> Keycode -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Keycode -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Keycode -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Keycode -> m Keycode
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Keycode -> m Keycode
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Keycode
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Keycode -> c Keycode
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Keycode)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keycode)
    $cKeycode :: Constr
    $tKeycode :: DataType
    gmapMo :: (forall d. Data d => d -> m d) -> Keycode -> m Keycode
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Keycode -> m Keycode
    gmapMp :: (forall d. Data d => d -> m d) -> Keycode -> m Keycode
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Keycode -> m Keycode
    gmapM :: (forall d. Data d => d -> m d) -> Keycode -> m Keycode
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Keycode -> m Keycode
    gmapQi :: Int -> (forall d. Data d => d -> u) -> Keycode -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Keycode -> u
    gmapQ :: (forall d. Data d => d -> u) -> Keycode -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Keycode -> [u]
    gmapQr :: (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Keycode -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Keycode -> r
    gmapQl :: (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Keycode -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Keycode -> r
    gmapT :: (forall b. Data b => b -> b) -> Keycode -> Keycode
    $cgmapT :: (forall b. Data b => b -> b) -> Keycode -> Keycode
    dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keycode)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keycode)
    dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Keycode)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Keycode)
    dataTypeOf :: Keycode -> DataType
    $cdataTypeOf :: Keycode -> DataType
    toConstr :: Keycode -> Constr
    $ctoConstr :: Keycode -> Constr
    gunfold :: (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Keycode
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Keycode
    gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Keycode -> c Keycode
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Keycode -> c Keycode
    $cp1Data :: Typeable Keycode
    Data, Keycode -> Keycode -> Bool
    (Keycode -> Keycode -> Bool)
    -> (Keycode -> Keycode -> Bool) -> Eq Keycode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Keycode -> Keycode -> Bool
    $c/= :: Keycode -> Keycode -> Bool
    == :: Keycode -> Keycode -> Bool
    $c== :: Keycode -> Keycode -> Bool
    Eq, Eq Keycode
    Eq Keycode =>
    (Keycode -> Keycode -> Ordering)
    -> (Keycode -> Keycode -> Bool)
    -> (Keycode -> Keycode -> Bool)
    -> (Keycode -> Keycode -> Bool)
    -> (Keycode -> Keycode -> Bool)
    -> (Keycode -> Keycode -> Keycode)
    -> (Keycode -> Keycode -> Keycode)
    -> Ord Keycode
    Keycode -> Keycode -> Bool
    Keycode -> Keycode -> Ordering
    Keycode -> Keycode -> Keycode
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: Keycode -> Keycode -> Keycode
    $cmin :: Keycode -> Keycode -> Keycode
    max :: Keycode -> Keycode -> Keycode
    $cmax :: Keycode -> Keycode -> Keycode
    >= :: Keycode -> Keycode -> Bool
    $c>= :: Keycode -> Keycode -> Bool
    > :: Keycode -> Keycode -> Bool
    $c> :: Keycode -> Keycode -> Bool
    <= :: Keycode -> Keycode -> Bool
    $c<= :: Keycode -> Keycode -> Bool
    < :: Keycode -> Keycode -> Bool
    $c< :: Keycode -> Keycode -> Bool
    compare :: Keycode -> Keycode -> Ordering
    $ccompare :: Keycode -> Keycode -> Ordering
    $cp1Ord :: Eq Keycode
    Ord, ReadPrec [Keycode]
    ReadPrec Keycode
    Int -> ReadS Keycode
    ReadS [Keycode]
    (Int -> ReadS Keycode)
    -> ReadS [Keycode]
    -> ReadPrec Keycode
    -> ReadPrec [Keycode]
    -> Read Keycode
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [Keycode]
    $creadListPrec :: ReadPrec [Keycode]
    readPrec :: ReadPrec Keycode
    $creadPrec :: ReadPrec Keycode
    readList :: ReadS [Keycode]
    $creadList :: ReadS [Keycode]
    readsPrec :: Int -> ReadS Keycode
    $creadsPrec :: Int -> ReadS Keycode
    Read, (forall x. Keycode -> Rep Keycode x)
    -> (forall x. Rep Keycode x -> Keycode) -> Generic Keycode
    forall x. Rep Keycode x -> Keycode
    forall x. Keycode -> Rep Keycode x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Keycode x -> Keycode
    $cfrom :: forall x. Keycode -> Rep Keycode x
    Generic, Int -> Keycode -> ShowS
    [Keycode] -> ShowS
    Keycode -> String
    (Int -> Keycode -> ShowS)
    -> (Keycode -> String) -> ([Keycode] -> ShowS) -> Show Keycode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Keycode] -> ShowS
    $cshowList :: [Keycode] -> ShowS
    show :: Keycode -> String
    $cshow :: Keycode -> String
    showsPrec :: Int -> Keycode -> ShowS
    $cshowsPrec :: Int -> Keycode -> ShowS
    Show, Typeable)

    pattern $bKeycodeUnknown :: Keycode
    $mKeycodeUnknown :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeUnknown = Keycode Raw.SDLK_UNKNOWN
    pattern $bKeycodeReturn :: Keycode
    $mKeycodeReturn :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeReturn = Keycode Raw.SDLK_RETURN
    pattern $bKeycodeEscape :: Keycode
    $mKeycodeEscape :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeEscape = Keycode Raw.SDLK_ESCAPE
    pattern $bKeycodeBackspace :: Keycode
    $mKeycodeBackspace :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeBackspace = Keycode Raw.SDLK_BACKSPACE
    pattern $bKeycodeTab :: Keycode
    $mKeycodeTab :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeTab = Keycode Raw.SDLK_TAB
    pattern $bKeycodeSpace :: Keycode
    $mKeycodeSpace :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeSpace = Keycode Raw.SDLK_SPACE
    pattern $bKeycodeExclaim :: Keycode
    $mKeycodeExclaim :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeExclaim = Keycode Raw.SDLK_EXCLAIM
    pattern $bKeycodeQuoteDbl :: Keycode
    $mKeycodeQuoteDbl :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeQuoteDbl = Keycode Raw.SDLK_QUOTEDBL
    pattern $bKeycodeHash :: Keycode
    $mKeycodeHash :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeHash = Keycode Raw.SDLK_HASH
    pattern $bKeycodePercent :: Keycode
    $mKeycodePercent :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodePercent = Keycode Raw.SDLK_PERCENT
    pattern $bKeycodeDollar :: Keycode
    $mKeycodeDollar :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeDollar = Keycode Raw.SDLK_DOLLAR
    pattern $bKeycodeAmpersand :: Keycode
    $mKeycodeAmpersand :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeAmpersand = Keycode Raw.SDLK_AMPERSAND
    pattern $bKeycodeQuote :: Keycode
    $mKeycodeQuote :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeQuote = Keycode Raw.SDLK_QUOTE
    pattern $bKeycodeLeftParen :: Keycode
    $mKeycodeLeftParen :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeLeftParen = Keycode Raw.SDLK_LEFTPAREN
    pattern $bKeycodeRightParen :: Keycode
    $mKeycodeRightParen :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeRightParen = Keycode Raw.SDLK_RIGHTPAREN
    pattern $bKeycodeAsterisk :: Keycode
    $mKeycodeAsterisk :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeAsterisk = Keycode Raw.SDLK_ASTERISK
    pattern $bKeycodePlus :: Keycode
    $mKeycodePlus :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodePlus = Keycode Raw.SDLK_PLUS
    pattern $bKeycodeComma :: Keycode
    $mKeycodeComma :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeComma = Keycode Raw.SDLK_COMMA
    pattern $bKeycodeMinus :: Keycode
    $mKeycodeMinus :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeMinus = Keycode Raw.SDLK_MINUS
    pattern $bKeycodePeriod :: Keycode
    $mKeycodePeriod :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodePeriod = Keycode Raw.SDLK_PERIOD
    pattern $bKeycodeSlash :: Keycode
    $mKeycodeSlash :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeSlash = Keycode Raw.SDLK_SLASH
    pattern $bKeycode0 :: Keycode
    $mKeycode0 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    Keycode0 = Keycode Raw.SDLK_0
    pattern $bKeycode1 :: Keycode
    $mKeycode1 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    Keycode1 = Keycode Raw.SDLK_1
    pattern $bKeycode2 :: Keycode
    $mKeycode2 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    Keycode2 = Keycode Raw.SDLK_2
    pattern $bKeycode3 :: Keycode
    $mKeycode3 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    Keycode3 = Keycode Raw.SDLK_3
    pattern $bKeycode4 :: Keycode
    $mKeycode4 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    Keycode4 = Keycode Raw.SDLK_4
    pattern $bKeycode5 :: Keycode
    $mKeycode5 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    Keycode5 = Keycode Raw.SDLK_5
    pattern $bKeycode6 :: Keycode
    $mKeycode6 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    Keycode6 = Keycode Raw.SDLK_6
    pattern $bKeycode7 :: Keycode
    $mKeycode7 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    Keycode7 = Keycode Raw.SDLK_7
    pattern $bKeycode8 :: Keycode
    $mKeycode8 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    Keycode8 = Keycode Raw.SDLK_8
    pattern $bKeycode9 :: Keycode
    $mKeycode9 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    Keycode9 = Keycode Raw.SDLK_9
    pattern $bKeycodeColon :: Keycode
    $mKeycodeColon :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeColon = Keycode Raw.SDLK_COLON
    pattern $bKeycodeSemicolon :: Keycode
    $mKeycodeSemicolon :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeSemicolon = Keycode Raw.SDLK_SEMICOLON
    pattern $bKeycodeLess :: Keycode
    $mKeycodeLess :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeLess = Keycode Raw.SDLK_LESS
    pattern $bKeycodeEquals :: Keycode
    $mKeycodeEquals :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeEquals = Keycode Raw.SDLK_EQUALS
    pattern $bKeycodeGreater :: Keycode
    $mKeycodeGreater :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeGreater = Keycode Raw.SDLK_GREATER
    pattern $bKeycodeQuestion :: Keycode
    $mKeycodeQuestion :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeQuestion = Keycode Raw.SDLK_QUESTION
    pattern $bKeycodeAt :: Keycode
    $mKeycodeAt :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeAt = Keycode Raw.SDLK_AT
    pattern $bKeycodeLeftBracket :: Keycode
    $mKeycodeLeftBracket :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeLeftBracket = Keycode Raw.SDLK_LEFTBRACKET
    pattern $bKeycodeBackslash :: Keycode
    $mKeycodeBackslash :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeBackslash = Keycode Raw.SDLK_BACKSLASH
    pattern $bKeycodeRightBracket :: Keycode
    $mKeycodeRightBracket :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeRightBracket = Keycode Raw.SDLK_RIGHTBRACKET
    pattern $bKeycodeCaret :: Keycode
    $mKeycodeCaret :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeCaret = Keycode Raw.SDLK_CARET
    pattern $bKeycodeUnderscore :: Keycode
    $mKeycodeUnderscore :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeUnderscore = Keycode Raw.SDLK_UNDERSCORE
    pattern $bKeycodeBackquote :: Keycode
    $mKeycodeBackquote :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeBackquote = Keycode Raw.SDLK_BACKQUOTE
    pattern $bKeycodeA :: Keycode
    $mKeycodeA :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeA = Keycode Raw.SDLK_a
    pattern $bKeycodeB :: Keycode
    $mKeycodeB :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeB = Keycode Raw.SDLK_b
    pattern $bKeycodeC :: Keycode
    $mKeycodeC :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeC = Keycode Raw.SDLK_c
    pattern $bKeycodeD :: Keycode
    $mKeycodeD :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeD = Keycode Raw.SDLK_d
    pattern $bKeycodeE :: Keycode
    $mKeycodeE :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeE = Keycode Raw.SDLK_e
    pattern $bKeycodeF :: Keycode
    $mKeycodeF :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF = Keycode Raw.SDLK_f
    pattern $bKeycodeG :: Keycode
    $mKeycodeG :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeG = Keycode Raw.SDLK_g
    pattern $bKeycodeH :: Keycode
    $mKeycodeH :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeH = Keycode Raw.SDLK_h
    pattern $bKeycodeI :: Keycode
    $mKeycodeI :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeI = Keycode Raw.SDLK_i
    pattern $bKeycodeJ :: Keycode
    $mKeycodeJ :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeJ = Keycode Raw.SDLK_j
    pattern $bKeycodeK :: Keycode
    $mKeycodeK :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeK = Keycode Raw.SDLK_k
    pattern $bKeycodeL :: Keycode
    $mKeycodeL :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeL = Keycode Raw.SDLK_l
    pattern $bKeycodeM :: Keycode
    $mKeycodeM :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeM = Keycode Raw.SDLK_m
    pattern $bKeycodeN :: Keycode
    $mKeycodeN :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeN = Keycode Raw.SDLK_n
    pattern $bKeycodeO :: Keycode
    $mKeycodeO :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeO = Keycode Raw.SDLK_o
    pattern $bKeycodeP :: Keycode
    $mKeycodeP :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeP = Keycode Raw.SDLK_p
    pattern $bKeycodeQ :: Keycode
    $mKeycodeQ :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeQ = Keycode Raw.SDLK_q
    pattern $bKeycodeR :: Keycode
    $mKeycodeR :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeR = Keycode Raw.SDLK_r
    pattern $bKeycodeS :: Keycode
    $mKeycodeS :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeS = Keycode Raw.SDLK_s
    pattern $bKeycodeT :: Keycode
    $mKeycodeT :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeT = Keycode Raw.SDLK_t
    pattern $bKeycodeU :: Keycode
    $mKeycodeU :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeU = Keycode Raw.SDLK_u
    pattern $bKeycodeV :: Keycode
    $mKeycodeV :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeV = Keycode Raw.SDLK_v
    pattern $bKeycodeW :: Keycode
    $mKeycodeW :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeW = Keycode Raw.SDLK_w
    pattern $bKeycodeX :: Keycode
    $mKeycodeX :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeX = Keycode Raw.SDLK_x
    pattern $bKeycodeY :: Keycode
    $mKeycodeY :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeY = Keycode Raw.SDLK_y
    pattern $bKeycodeZ :: Keycode
    $mKeycodeZ :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeZ = Keycode Raw.SDLK_z
    pattern $bKeycodeCapsLock :: Keycode
    $mKeycodeCapsLock :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeCapsLock = Keycode Raw.SDLK_CAPSLOCK
    pattern $bKeycodeF1 :: Keycode
    $mKeycodeF1 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF1 = Keycode Raw.SDLK_F1
    pattern $bKeycodeF2 :: Keycode
    $mKeycodeF2 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF2 = Keycode Raw.SDLK_F2
    pattern $bKeycodeF3 :: Keycode
    $mKeycodeF3 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF3 = Keycode Raw.SDLK_F3
    pattern $bKeycodeF4 :: Keycode
    $mKeycodeF4 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF4 = Keycode Raw.SDLK_F4
    pattern $bKeycodeF5 :: Keycode
    $mKeycodeF5 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF5 = Keycode Raw.SDLK_F5
    pattern $bKeycodeF6 :: Keycode
    $mKeycodeF6 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF6 = Keycode Raw.SDLK_F6
    pattern $bKeycodeF7 :: Keycode
    $mKeycodeF7 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF7 = Keycode Raw.SDLK_F7
    pattern $bKeycodeF8 :: Keycode
    $mKeycodeF8 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF8 = Keycode Raw.SDLK_F8
    pattern $bKeycodeF9 :: Keycode
    $mKeycodeF9 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF9 = Keycode Raw.SDLK_F9
    pattern $bKeycodeF10 :: Keycode
    $mKeycodeF10 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF10 = Keycode Raw.SDLK_F10
    pattern $bKeycodeF11 :: Keycode
    $mKeycodeF11 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF11 = Keycode Raw.SDLK_F11
    pattern $bKeycodeF12 :: Keycode
    $mKeycodeF12 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF12 = Keycode Raw.SDLK_F12
    pattern $bKeycodePrintScreen :: Keycode
    $mKeycodePrintScreen :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodePrintScreen = Keycode Raw.SDLK_PRINTSCREEN
    pattern $bKeycodeScrollLock :: Keycode
    $mKeycodeScrollLock :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeScrollLock = Keycode Raw.SDLK_SCROLLLOCK
    pattern $bKeycodePause :: Keycode
    $mKeycodePause :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodePause = Keycode Raw.SDLK_PAUSE
    pattern $bKeycodeInsert :: Keycode
    $mKeycodeInsert :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeInsert = Keycode Raw.SDLK_INSERT
    pattern $bKeycodeHome :: Keycode
    $mKeycodeHome :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeHome = Keycode Raw.SDLK_HOME
    pattern $bKeycodePageUp :: Keycode
    $mKeycodePageUp :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodePageUp = Keycode Raw.SDLK_PAGEUP
    pattern $bKeycodeDelete :: Keycode
    $mKeycodeDelete :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeDelete = Keycode Raw.SDLK_DELETE
    pattern $bKeycodeEnd :: Keycode
    $mKeycodeEnd :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeEnd = Keycode Raw.SDLK_END
    pattern $bKeycodePageDown :: Keycode
    $mKeycodePageDown :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodePageDown = Keycode Raw.SDLK_PAGEDOWN
    pattern $bKeycodeRight :: Keycode
    $mKeycodeRight :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeRight = Keycode Raw.SDLK_RIGHT
    pattern $bKeycodeLeft :: Keycode
    $mKeycodeLeft :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeLeft = Keycode Raw.SDLK_LEFT
    pattern $bKeycodeDown :: Keycode
    $mKeycodeDown :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeDown = Keycode Raw.SDLK_DOWN
    pattern $bKeycodeUp :: Keycode
    $mKeycodeUp :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeUp = Keycode Raw.SDLK_UP
    pattern $bKeycodeNumLockClear :: Keycode
    $mKeycodeNumLockClear :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeNumLockClear = Keycode Raw.SDLK_NUMLOCKCLEAR
    pattern $bKeycodeKPDivide :: Keycode
    $mKeycodeKPDivide :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPDivide = Keycode Raw.SDLK_KP_DIVIDE
    pattern $bKeycodeKPMultiply :: Keycode
    $mKeycodeKPMultiply :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPMultiply = Keycode Raw.SDLK_KP_MULTIPLY
    pattern $bKeycodeKPMinus :: Keycode
    $mKeycodeKPMinus :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPMinus = Keycode Raw.SDLK_KP_MINUS
    pattern $bKeycodeKPPlus :: Keycode
    $mKeycodeKPPlus :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPPlus = Keycode Raw.SDLK_KP_PLUS
    pattern $bKeycodeKPEnter :: Keycode
    $mKeycodeKPEnter :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPEnter = Keycode Raw.SDLK_KP_ENTER
    pattern $bKeycodeKP1 :: Keycode
    $mKeycodeKP1 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKP1 = Keycode Raw.SDLK_KP_1
    pattern $bKeycodeKP2 :: Keycode
    $mKeycodeKP2 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKP2 = Keycode Raw.SDLK_KP_2
    pattern $bKeycodeKP3 :: Keycode
    $mKeycodeKP3 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKP3 = Keycode Raw.SDLK_KP_3
    pattern $bKeycodeKP4 :: Keycode
    $mKeycodeKP4 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKP4 = Keycode Raw.SDLK_KP_4
    pattern $bKeycodeKP5 :: Keycode
    $mKeycodeKP5 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKP5 = Keycode Raw.SDLK_KP_5
    pattern $bKeycodeKP6 :: Keycode
    $mKeycodeKP6 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKP6 = Keycode Raw.SDLK_KP_6
    pattern $bKeycodeKP7 :: Keycode
    $mKeycodeKP7 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKP7 = Keycode Raw.SDLK_KP_7
    pattern $bKeycodeKP8 :: Keycode
    $mKeycodeKP8 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKP8 = Keycode Raw.SDLK_KP_8
    pattern $bKeycodeKP9 :: Keycode
    $mKeycodeKP9 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKP9 = Keycode Raw.SDLK_KP_9
    pattern $bKeycodeKP0 :: Keycode
    $mKeycodeKP0 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKP0 = Keycode Raw.SDLK_KP_0
    pattern $bKeycodeKPPeriod :: Keycode
    $mKeycodeKPPeriod :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPPeriod = Keycode Raw.SDLK_KP_PERIOD
    pattern $bKeycodeApplication :: Keycode
    $mKeycodeApplication :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeApplication = Keycode Raw.SDLK_APPLICATION
    pattern $bKeycodePower :: Keycode
    $mKeycodePower :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodePower = Keycode Raw.SDLK_POWER
    pattern $bKeycodeKPEquals :: Keycode
    $mKeycodeKPEquals :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPEquals = Keycode Raw.SDLK_KP_EQUALS
    pattern $bKeycodeF13 :: Keycode
    $mKeycodeF13 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF13 = Keycode Raw.SDLK_F13
    pattern $bKeycodeF14 :: Keycode
    $mKeycodeF14 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF14 = Keycode Raw.SDLK_F14
    pattern $bKeycodeF15 :: Keycode
    $mKeycodeF15 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF15 = Keycode Raw.SDLK_F15
    pattern $bKeycodeF16 :: Keycode
    $mKeycodeF16 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF16 = Keycode Raw.SDLK_F16
    pattern $bKeycodeF17 :: Keycode
    $mKeycodeF17 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF17 = Keycode Raw.SDLK_F17
    pattern $bKeycodeF18 :: Keycode
    $mKeycodeF18 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF18 = Keycode Raw.SDLK_F18
    pattern $bKeycodeF19 :: Keycode
    $mKeycodeF19 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF19 = Keycode Raw.SDLK_F19
    pattern $bKeycodeF20 :: Keycode
    $mKeycodeF20 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF20 = Keycode Raw.SDLK_F20
    pattern $bKeycodeF21 :: Keycode
    $mKeycodeF21 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF21 = Keycode Raw.SDLK_F21
    pattern $bKeycodeF22 :: Keycode
    $mKeycodeF22 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF22 = Keycode Raw.SDLK_F22
    pattern $bKeycodeF23 :: Keycode
    $mKeycodeF23 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF23 = Keycode Raw.SDLK_F23
    pattern $bKeycodeF24 :: Keycode
    $mKeycodeF24 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeF24 = Keycode Raw.SDLK_F24
    pattern $bKeycodeExecute :: Keycode
    $mKeycodeExecute :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeExecute = Keycode Raw.SDLK_EXECUTE
    pattern $bKeycodeHelp :: Keycode
    $mKeycodeHelp :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeHelp = Keycode Raw.SDLK_HELP
    pattern $bKeycodeMenu :: Keycode
    $mKeycodeMenu :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeMenu = Keycode Raw.SDLK_MENU
    pattern $bKeycodeSelect :: Keycode
    $mKeycodeSelect :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeSelect = Keycode Raw.SDLK_SELECT
    pattern $bKeycodeStop :: Keycode
    $mKeycodeStop :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeStop = Keycode Raw.SDLK_STOP
    pattern $bKeycodeAgain :: Keycode
    $mKeycodeAgain :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeAgain = Keycode Raw.SDLK_AGAIN
    pattern $bKeycodeUndo :: Keycode
    $mKeycodeUndo :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeUndo = Keycode Raw.SDLK_UNDO
    pattern $bKeycodeCut :: Keycode
    $mKeycodeCut :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeCut = Keycode Raw.SDLK_CUT
    pattern $bKeycodeCopy :: Keycode
    $mKeycodeCopy :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeCopy = Keycode Raw.SDLK_COPY
    pattern $bKeycodePaste :: Keycode
    $mKeycodePaste :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodePaste = Keycode Raw.SDLK_PASTE
    pattern $bKeycodeFind :: Keycode
    $mKeycodeFind :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeFind = Keycode Raw.SDLK_FIND
    pattern $bKeycodeMute :: Keycode
    $mKeycodeMute :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeMute = Keycode Raw.SDLK_MUTE
    pattern $bKeycodeVolumeUp :: Keycode
    $mKeycodeVolumeUp :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeVolumeUp = Keycode Raw.SDLK_VOLUMEUP
    pattern $bKeycodeVolumeDown :: Keycode
    $mKeycodeVolumeDown :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeVolumeDown = Keycode Raw.SDLK_VOLUMEDOWN
    pattern $bKeycodeKPComma :: Keycode
    $mKeycodeKPComma :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPComma = Keycode Raw.SDLK_KP_COMMA
    pattern $bKeycodeKPEqualsAS400 :: Keycode
    $mKeycodeKPEqualsAS400 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPEqualsAS400 = Keycode Raw.SDLK_KP_EQUALSAS400
    pattern $bKeycodeAltErase :: Keycode
    $mKeycodeAltErase :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeAltErase = Keycode Raw.SDLK_ALTERASE
    pattern $bKeycodeSysReq :: Keycode
    $mKeycodeSysReq :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeSysReq = Keycode Raw.SDLK_SYSREQ
    pattern $bKeycodeCancel :: Keycode
    $mKeycodeCancel :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeCancel = Keycode Raw.SDLK_CANCEL
    pattern $bKeycodeClear :: Keycode
    $mKeycodeClear :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeClear = Keycode Raw.SDLK_CLEAR
    pattern $bKeycodePrior :: Keycode
    $mKeycodePrior :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodePrior = Keycode Raw.SDLK_PRIOR
    pattern $bKeycodeReturn2 :: Keycode
    $mKeycodeReturn2 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeReturn2 = Keycode Raw.SDLK_RETURN2
    pattern $bKeycodeSeparator :: Keycode
    $mKeycodeSeparator :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeSeparator = Keycode Raw.SDLK_SEPARATOR
    pattern $bKeycodeOut :: Keycode
    $mKeycodeOut :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeOut = Keycode Raw.SDLK_OUT
    pattern $bKeycodeOper :: Keycode
    $mKeycodeOper :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeOper = Keycode Raw.SDLK_OPER
    pattern $bKeycodeClearAgain :: Keycode
    $mKeycodeClearAgain :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeClearAgain = Keycode Raw.SDLK_CLEARAGAIN
    pattern $bKeycodeCrSel :: Keycode
    $mKeycodeCrSel :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeCrSel = Keycode Raw.SDLK_CRSEL
    pattern $bKeycodeExSel :: Keycode
    $mKeycodeExSel :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeExSel = Keycode Raw.SDLK_EXSEL
    pattern $bKeycodeKP00 :: Keycode
    $mKeycodeKP00 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKP00 = Keycode Raw.SDLK_KP_00
    pattern $bKeycodeKP000 :: Keycode
    $mKeycodeKP000 :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKP000 = Keycode Raw.SDLK_KP_000
    pattern $bKeycodeThousandsSeparator :: Keycode
    $mKeycodeThousandsSeparator :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeThousandsSeparator = Keycode Raw.SDLK_THOUSANDSSEPARATOR
    pattern $bKeycodeDecimalSeparator :: Keycode
    $mKeycodeDecimalSeparator :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeDecimalSeparator = Keycode Raw.SDLK_DECIMALSEPARATOR
    pattern $bKeycodeCurrencyUnit :: Keycode
    $mKeycodeCurrencyUnit :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeCurrencyUnit = Keycode Raw.SDLK_CURRENCYUNIT
    pattern $bKeycodeCurrencySubunit :: Keycode
    $mKeycodeCurrencySubunit :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeCurrencySubunit = Keycode Raw.SDLK_CURRENCYSUBUNIT
    pattern $bKeycodeKPLeftParen :: Keycode
    $mKeycodeKPLeftParen :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPLeftParen = Keycode Raw.SDLK_KP_LEFTPAREN
    pattern $bKeycodeKPRightParen :: Keycode
    $mKeycodeKPRightParen :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPRightParen = Keycode Raw.SDLK_KP_RIGHTPAREN
    pattern $bKeycodeKPLeftBrace :: Keycode
    $mKeycodeKPLeftBrace :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPLeftBrace = Keycode Raw.SDLK_KP_LEFTBRACE
    pattern $bKeycodeKPRightBrace :: Keycode
    $mKeycodeKPRightBrace :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPRightBrace = Keycode Raw.SDLK_KP_RIGHTBRACE
    pattern $bKeycodeKPTab :: Keycode
    $mKeycodeKPTab :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPTab = Keycode Raw.SDLK_KP_TAB
    pattern $bKeycodeKPBackspace :: Keycode
    $mKeycodeKPBackspace :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPBackspace = Keycode Raw.SDLK_KP_BACKSPACE
    pattern $bKeycodeKPA :: Keycode
    $mKeycodeKPA :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPA = Keycode Raw.SDLK_KP_A
    pattern $bKeycodeKPB :: Keycode
    $mKeycodeKPB :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPB = Keycode Raw.SDLK_KP_B
    pattern $bKeycodeKPC :: Keycode
    $mKeycodeKPC :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPC = Keycode Raw.SDLK_KP_C
    pattern $bKeycodeKPD :: Keycode
    $mKeycodeKPD :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPD = Keycode Raw.SDLK_KP_D
    pattern $bKeycodeKPE :: Keycode
    $mKeycodeKPE :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPE = Keycode Raw.SDLK_KP_E
    pattern $bKeycodeKPF :: Keycode
    $mKeycodeKPF :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPF = Keycode Raw.SDLK_KP_F
    pattern $bKeycodeKPXor :: Keycode
    $mKeycodeKPXor :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPXor = Keycode Raw.SDLK_KP_XOR
    pattern $bKeycodeKPPower :: Keycode
    $mKeycodeKPPower :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPPower = Keycode Raw.SDLK_KP_POWER
    pattern $bKeycodeKPPercent :: Keycode
    $mKeycodeKPPercent :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPPercent = Keycode Raw.SDLK_KP_PERCENT
    pattern $bKeycodeKPLess :: Keycode
    $mKeycodeKPLess :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPLess = Keycode Raw.SDLK_KP_LESS
    pattern $bKeycodeKPGreater :: Keycode
    $mKeycodeKPGreater :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPGreater = Keycode Raw.SDLK_KP_GREATER
    pattern $bKeycodeKPAmpersand :: Keycode
    $mKeycodeKPAmpersand :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPAmpersand = Keycode Raw.SDLK_KP_AMPERSAND
    pattern $bKeycodeKPDblAmpersand :: Keycode
    $mKeycodeKPDblAmpersand :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPDblAmpersand = Keycode Raw.SDLK_KP_DBLAMPERSAND
    pattern $bKeycodeKPVerticalBar :: Keycode
    $mKeycodeKPVerticalBar :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPVerticalBar = Keycode Raw.SDLK_KP_VERTICALBAR
    pattern $bKeycodeKPDblVerticalBar :: Keycode
    $mKeycodeKPDblVerticalBar :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPDblVerticalBar = Keycode Raw.SDLK_KP_DBLVERTICALBAR
    pattern $bKeycodeKPColon :: Keycode
    $mKeycodeKPColon :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPColon = Keycode Raw.SDLK_KP_COLON
    pattern $bKeycodeKPHash :: Keycode
    $mKeycodeKPHash :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPHash = Keycode Raw.SDLK_KP_HASH
    pattern $bKeycodeKPSpace :: Keycode
    $mKeycodeKPSpace :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPSpace = Keycode Raw.SDLK_KP_SPACE
    pattern $bKeycodeKPAt :: Keycode
    $mKeycodeKPAt :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPAt = Keycode Raw.SDLK_KP_AT
    pattern $bKeycodeKPExclam :: Keycode
    $mKeycodeKPExclam :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPExclam = Keycode Raw.SDLK_KP_EXCLAM
    pattern $bKeycodeKPMemStore :: Keycode
    $mKeycodeKPMemStore :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPMemStore = Keycode Raw.SDLK_KP_MEMSTORE
    pattern $bKeycodeKPMemRecall :: Keycode
    $mKeycodeKPMemRecall :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPMemRecall = Keycode Raw.SDLK_KP_MEMRECALL
    pattern $bKeycodeKPMemClear :: Keycode
    $mKeycodeKPMemClear :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPMemClear = Keycode Raw.SDLK_KP_MEMCLEAR
    pattern $bKeycodeKPMemAdd :: Keycode
    $mKeycodeKPMemAdd :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPMemAdd = Keycode Raw.SDLK_KP_MEMADD
    pattern $bKeycodeKPMemSubtract :: Keycode
    $mKeycodeKPMemSubtract :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPMemSubtract = Keycode Raw.SDLK_KP_MEMSUBTRACT
    pattern $bKeycodeKPMemMultiply :: Keycode
    $mKeycodeKPMemMultiply :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPMemMultiply = Keycode Raw.SDLK_KP_MEMMULTIPLY
    pattern $bKeycodeKPMemDivide :: Keycode
    $mKeycodeKPMemDivide :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPMemDivide = Keycode Raw.SDLK_KP_MEMDIVIDE
    pattern $bKeycodeKPPlusMinus :: Keycode
    $mKeycodeKPPlusMinus :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPPlusMinus = Keycode Raw.SDLK_KP_PLUSMINUS
    pattern $bKeycodeKPClear :: Keycode
    $mKeycodeKPClear :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPClear = Keycode Raw.SDLK_KP_CLEAR
    pattern $bKeycodeKPClearEntry :: Keycode
    $mKeycodeKPClearEntry :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPClearEntry = Keycode Raw.SDLK_KP_CLEARENTRY
    pattern $bKeycodeKPBinary :: Keycode
    $mKeycodeKPBinary :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPBinary = Keycode Raw.SDLK_KP_BINARY
    pattern $bKeycodeKPOctal :: Keycode
    $mKeycodeKPOctal :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPOctal = Keycode Raw.SDLK_KP_OCTAL
    pattern $bKeycodeKPDecimal :: Keycode
    $mKeycodeKPDecimal :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPDecimal = Keycode Raw.SDLK_KP_DECIMAL
    pattern $bKeycodeKPHexadecimal :: Keycode
    $mKeycodeKPHexadecimal :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKPHexadecimal = Keycode Raw.SDLK_KP_HEXADECIMAL
    pattern $bKeycodeLCtrl :: Keycode
    $mKeycodeLCtrl :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeLCtrl = Keycode Raw.SDLK_LCTRL
    pattern $bKeycodeLShift :: Keycode
    $mKeycodeLShift :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeLShift = Keycode Raw.SDLK_LSHIFT
    pattern $bKeycodeLAlt :: Keycode
    $mKeycodeLAlt :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeLAlt = Keycode Raw.SDLK_LALT
    pattern $bKeycodeLGUI :: Keycode
    $mKeycodeLGUI :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeLGUI = Keycode Raw.SDLK_LGUI
    pattern $bKeycodeRCtrl :: Keycode
    $mKeycodeRCtrl :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeRCtrl = Keycode Raw.SDLK_RCTRL
    pattern $bKeycodeRShift :: Keycode
    $mKeycodeRShift :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeRShift = Keycode Raw.SDLK_RSHIFT
    pattern $bKeycodeRAlt :: Keycode
    $mKeycodeRAlt :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeRAlt = Keycode Raw.SDLK_RALT
    pattern $bKeycodeRGUI :: Keycode
    $mKeycodeRGUI :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeRGUI = Keycode Raw.SDLK_RGUI
    pattern $bKeycodeMode :: Keycode
    $mKeycodeMode :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeMode = Keycode Raw.SDLK_MODE
    pattern $bKeycodeAudioNext :: Keycode
    $mKeycodeAudioNext :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeAudioNext = Keycode Raw.SDLK_AUDIONEXT
    pattern $bKeycodeAudioPrev :: Keycode
    $mKeycodeAudioPrev :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeAudioPrev = Keycode Raw.SDLK_AUDIOPREV
    pattern $bKeycodeAudioStop :: Keycode
    $mKeycodeAudioStop :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeAudioStop = Keycode Raw.SDLK_AUDIOSTOP
    pattern $bKeycodeAudioPlay :: Keycode
    $mKeycodeAudioPlay :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeAudioPlay = Keycode Raw.SDLK_AUDIOPLAY
    pattern $bKeycodeAudioMute :: Keycode
    $mKeycodeAudioMute :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeAudioMute = Keycode Raw.SDLK_AUDIOMUTE
    pattern $bKeycodeMediaSelect :: Keycode
    $mKeycodeMediaSelect :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeMediaSelect = Keycode Raw.SDLK_MEDIASELECT
    pattern $bKeycodeWWW :: Keycode
    $mKeycodeWWW :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeWWW = Keycode Raw.SDLK_WWW
    pattern $bKeycodeMail :: Keycode
    $mKeycodeMail :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeMail = Keycode Raw.SDLK_MAIL
    pattern $bKeycodeCalculator :: Keycode
    $mKeycodeCalculator :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeCalculator = Keycode Raw.SDLK_CALCULATOR
    pattern $bKeycodeComputer :: Keycode
    $mKeycodeComputer :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeComputer = Keycode Raw.SDLK_COMPUTER
    pattern $bKeycodeACSearch :: Keycode
    $mKeycodeACSearch :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeACSearch = Keycode Raw.SDLK_AC_SEARCH
    pattern $bKeycodeACHome :: Keycode
    $mKeycodeACHome :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeACHome = Keycode Raw.SDLK_AC_HOME
    pattern $bKeycodeACBack :: Keycode
    $mKeycodeACBack :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeACBack = Keycode Raw.SDLK_AC_BACK
    pattern $bKeycodeACForward :: Keycode
    $mKeycodeACForward :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeACForward = Keycode Raw.SDLK_AC_FORWARD
    pattern $bKeycodeACStop :: Keycode
    $mKeycodeACStop :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeACStop = Keycode Raw.SDLK_AC_STOP
    pattern $bKeycodeACRefresh :: Keycode
    $mKeycodeACRefresh :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeACRefresh = Keycode Raw.SDLK_AC_REFRESH
    pattern $bKeycodeACBookmarks :: Keycode
    $mKeycodeACBookmarks :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeACBookmarks = Keycode Raw.SDLK_AC_BOOKMARKS
    pattern $bKeycodeBrightnessDown :: Keycode
    $mKeycodeBrightnessDown :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeBrightnessDown = Keycode Raw.SDLK_BRIGHTNESSDOWN
    pattern $bKeycodeBrightnessUp :: Keycode
    $mKeycodeBrightnessUp :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeBrightnessUp = Keycode Raw.SDLK_BRIGHTNESSUP
    pattern $bKeycodeDisplaySwitch :: Keycode
    $mKeycodeDisplaySwitch :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeDisplaySwitch = Keycode Raw.SDLK_DISPLAYSWITCH
    pattern $bKeycodeKbdIllumToggle :: Keycode
    $mKeycodeKbdIllumToggle :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKbdIllumToggle = Keycode Raw.SDLK_KBDILLUMTOGGLE
    pattern $bKeycodeKbdIllumDown :: Keycode
    $mKeycodeKbdIllumDown :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKbdIllumDown = Keycode Raw.SDLK_KBDILLUMDOWN
    pattern $bKeycodeKbdIllumUp :: Keycode
    $mKeycodeKbdIllumUp :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeKbdIllumUp = Keycode Raw.SDLK_KBDILLUMUP
    pattern $bKeycodeEject :: Keycode
    $mKeycodeEject :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeEject = Keycode Raw.SDLK_EJECT
    pattern $bKeycodeSleep :: Keycode
    $mKeycodeSleep :: forall r. Keycode -> (Void# -> r) -> (Void# -> r) -> r
    KeycodeSleep = Keycode Raw.SDLK_SLEEP

    instance FromNumber Keycode Int32 where
      fromNumber :: Int32 -> Keycode
    fromNumber = Int32 -> Keycode
    Keycode

    instance ToNumber Keycode Int32 where
      toNumber :: Keycode -> Int32
    toNumber = Keycode -> Int32
    unwrapKeycode