    -- | This module provides pattern synonyms for 'Char' in [Basic Latin block](https://compart.com/en/unicode/block/U+0000) (range @'\x00'-'\x7f'@).
    --
    -- The pattern names are inspired by Unicode (letter and digits) and PostScript names (symbols),
    -- e.g. @/@ is 'SLASH', not @SOLIDUS@.
    --
    -- This module is designed to be imported qualified
    --
    -- @
    -- import "Data.Char.Patterns" as C
    --
    -- hello = [C.'LOWER_H', C.'LOWER_E', C.'LOWER_L', C.'LOWER_L', C.'LOWER_O']
    -- @
    --
    -- but can also be used unqualified as well.
    --
    module Data.Char.Patterns where

    -------------------------------------------------------------------------------
    -- * Control characters, x00-x1f
    -------------------------------------------------------------------------------

    -- | Null character (NUL)
    pattern NUL :: Char
    pattern $mNUL :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNUL :: Char
    NUL = '\x00'

    -- | Start of Heading (SOH)
    pattern SOH :: Char
    pattern $mSOH :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bSOH :: Char
    SOH = '\x01'

    -- | Start of Text (STX)
    pattern STX :: Char
    pattern $mSTX :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bSTX :: Char
    STX = '\x02'

    -- | End of Text (ETX)
    pattern ETX :: Char
    pattern $mETX :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bETX :: Char
    ETX = '\x03'

    -- | End of Transmission (EOT)
    pattern EOT :: Char
    pattern $mEOT :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bEOT :: Char
    EOT = '\x04'

    -- | Enquiry (ENQ)
    pattern ENQ :: Char
    pattern $mENQ :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bENQ :: Char
    ENQ = '\x05'

    -- | Acknowledge (ACK)
    pattern ACK :: Char
    pattern $mACK :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bACK :: Char
    ACK = '\x06'

    -- | Alert (BEL)
    pattern BEL :: Char
    pattern $mBEL :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bBEL :: Char
    BEL = '\x07'

    -- | Backspace (BS)
    pattern BS :: Char
    pattern $mBS :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bBS :: Char
    BS = '\x08'

    -- | Character tabulation (TAB)
    pattern TAB :: Char
    pattern $mTAB :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bTAB :: Char
    TAB = '\x09'

    -- | End of line, line feed (LF)
    pattern LF :: Char
    pattern $mLF :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLF :: Char
    LF = '\x0a'

    -- | Line tabulation, vertical tab (VT)
    pattern VT :: Char
    pattern $mVT :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bVT :: Char
    VT = '\x0b'

    -- | Form feed (FF)
    pattern FF :: Char
    pattern $mFF :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bFF :: Char
    FF = '\x0c'

    -- | Carriage Return (CR)
    pattern CR :: Char
    pattern $mCR :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bCR :: Char
    CR = '\x0d'

    -- | Locking-Shift One, Shift Out (SO)
    pattern SO :: Char
    pattern $mSO :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bSO :: Char
    SO = '\x0e'

    -- | Locking-Shift Zero, Shift In (SI)
    pattern SI :: Char
    pattern $mSI :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bSI :: Char
    SI = '\x0f'

    -- | Data Link Escape (DLE)
    pattern DLE :: Char
    pattern $mDLE :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDLE :: Char
    DLE = '\x10'

    -- | Device Control One, XON (DC1)
    pattern DC1 :: Char
    pattern $mDC1 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDC1 :: Char
    DC1 = '\x11'

    -- | Device Control Two (DC2)
    pattern DC2 :: Char
    pattern $mDC2 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDC2 :: Char
    DC2 = '\x12'

    -- | Device Control Three, XOFF (DC3)
    pattern DC3 :: Char
    pattern $mDC3 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDC3 :: Char
    DC3 = '\x13'

    -- | Device Control Four (DC4)
    pattern DC4 :: Char
    pattern $mDC4 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDC4 :: Char
    DC4 = '\x14'

    -- | Negative Acknowledge (NAK)
    pattern NAK :: Char
    pattern $mNAK :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNAK :: Char
    NAK = '\x15'

    -- | Syncronous Idle (SYN)
    pattern SYN :: Char
    pattern $mSYN :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bSYN :: Char
    SYN = '\x16'

    -- | End of Transmission Block (ETB)
    pattern ETB :: Char
    pattern $mETB :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bETB :: Char
    ETB = '\x17'

    -- | Cancel (CAN)
    pattern CAN :: Char
    pattern $mCAN :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bCAN :: Char
    CAN = '\x18'

    -- | End of Medium (EOM)
    pattern EOM :: Char
    pattern $mEOM :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bEOM :: Char
    EOM = '\x19'

    -- | Substitute (SUB)
    pattern SUB :: Char
    pattern $mSUB :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bSUB :: Char
    SUB = '\x1a'

    -- | Escape (ESC)
    pattern ESC :: Char
    pattern $mESC :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bESC :: Char
    ESC = '\x1b'

    -- | File Separator (FS)
    pattern FS :: Char
    pattern $mFS :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bFS :: Char
    FS = '\x1c'

    -- | Group Separator (GS)
    pattern GS :: Char
    pattern $mGS :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bGS :: Char
    GS = '\x1d'

    -- | Information Separator One, Record Separator (RS)
    pattern RS :: Char
    pattern $mRS :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bRS :: Char
    RS = '\x1e'

    -- | Information Separator Two, Unit Separator (US)
    pattern US :: Char
    pattern $mUS :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUS :: Char
    US = '\x1f'

    -------------------------------------------------------------------------------
    -- * Symbols 1, x20-x2f
    -------------------------------------------------------------------------------

    -- | Space (SP), @' '@.
    pattern SPACE :: Char
    pattern $mSPACE :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bSPACE :: Char
    SPACE = '\x20'

    -- | Exclamation mark, @!@
    pattern EXCLAM :: Char
    pattern $mEXCLAM :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bEXCLAM :: Char
    EXCLAM = '\x21'

    -- | Quotation mark, double quote, @"@
    pattern DOUBLE_QUOTE :: Char
    pattern $mDOUBLE_QUOTE :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDOUBLE_QUOTE :: Char
    DOUBLE_QUOTE = '\x22'

    -- | Number sign, @#@
    pattern NUMBER :: Char
    pattern $mNUMBER :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bNUMBER :: Char
    NUMBER = '\x23'

    -- | Dollar sign, @$@
    pattern DOLLAR :: Char
    pattern $mDOLLAR :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDOLLAR :: Char
    DOLLAR = '\x24'

    -- | Percent sign, @%@
    pattern PERCENT :: Char
    pattern $mPERCENT :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bPERCENT :: Char
    PERCENT = '\x25'

    -- | Ampersand, @&@
    pattern AMPERSAND :: Char
    pattern $mAMPERSAND :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bAMPERSAND :: Char
    AMPERSAND = '\x26'

    -- | Apostrophe, single quote, @'@
    pattern SINGLE_QUOTE :: Char
    pattern $mSINGLE_QUOTE :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bSINGLE_QUOTE :: Char
    SINGLE_QUOTE = '\x27'

    -- | Left parenthesis, @(@
    pattern LEFT_PAREN :: Char
    pattern $mLEFT_PAREN :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLEFT_PAREN :: Char
    LEFT_PAREN = '\x28'

    -- | Right parenthesis, @)@
    pattern RIGHT_PAREN :: Char
    pattern $mRIGHT_PAREN :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bRIGHT_PAREN :: Char
    RIGHT_PAREN = '\x29'

    -- | Asterisk, @*@
    pattern ASTERISK :: Char
    pattern $mASTERISK :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bASTERISK :: Char
    ASTERISK = '\x2a'

    -- | Plus sign, @+@
    pattern PLUS :: Char
    pattern $mPLUS :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bPLUS :: Char
    PLUS = '\x2b'

    -- | Comma, @,@
    pattern COMMA :: Char
    pattern $mCOMMA :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bCOMMA :: Char
    COMMA = '\x2c'

    -- | Hyphen-minus, @-@
    pattern HYPHEN :: Char
    pattern $mHYPHEN :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bHYPHEN :: Char
    HYPHEN = '\x2d'

    -- | Full stop, period, @.@
    pattern PERIOD :: Char
    pattern $mPERIOD :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bPERIOD :: Char
    PERIOD = '\x2e'

    -- | Solidus, slash, @/@
    pattern SLASH :: Char
    pattern $mSLASH :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bSLASH :: Char
    SLASH = '\x2f'

    -------------------------------------------------------------------------------
    -- * Digits, x30-x39
    -------------------------------------------------------------------------------

    -- | Digit 0, @0@
    pattern DIGIT_0 :: Char
    pattern $mDIGIT_0 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDIGIT_0 :: Char
    DIGIT_0 = '\x30'

    -- | Digit 1, @1@
    pattern DIGIT_1 :: Char
    pattern $mDIGIT_1 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDIGIT_1 :: Char
    DIGIT_1 = '\x31'

    -- | Digit 2, @2@
    pattern DIGIT_2 :: Char
    pattern $mDIGIT_2 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDIGIT_2 :: Char
    DIGIT_2 = '\x32'

    -- | Digit 3, @3@
    pattern DIGIT_3 :: Char
    pattern $mDIGIT_3 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDIGIT_3 :: Char
    DIGIT_3 = '\x33'

    -- | Digit 4, @4@
    pattern DIGIT_4 :: Char
    pattern $mDIGIT_4 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDIGIT_4 :: Char
    DIGIT_4 = '\x34'

    -- | Digit 5, @5@
    pattern DIGIT_5 :: Char
    pattern $mDIGIT_5 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDIGIT_5 :: Char
    DIGIT_5 = '\x35'

    -- | Digit 6, @6@
    pattern DIGIT_6 :: Char
    pattern $mDIGIT_6 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDIGIT_6 :: Char
    DIGIT_6 = '\x36'

    -- | Digit 7, @7@
    pattern DIGIT_7 :: Char
    pattern $mDIGIT_7 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDIGIT_7 :: Char
    DIGIT_7 = '\x37'

    -- | Digit 8, @8@
    pattern DIGIT_8 :: Char
    pattern $mDIGIT_8 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDIGIT_8 :: Char
    DIGIT_8 = '\x38'

    -- | Digit 9, @9@
    pattern DIGIT_9 :: Char
    pattern $mDIGIT_9 :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDIGIT_9 :: Char
    DIGIT_9 = '\x39'

    -------------------------------------------------------------------------------
    -- * Symbols 2, x3a-x40
    -------------------------------------------------------------------------------

    -- | Colon, @:@
    pattern COLON :: Char
    pattern $mCOLON :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bCOLON :: Char
    COLON = '\x3a'

    -- | Semicolon, @;@
    pattern SEMICOLON :: Char
    pattern $mSEMICOLON :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bSEMICOLON :: Char
    SEMICOLON = '\x3b'

    -- | Less-than sign, @<@
    pattern LESS :: Char
    pattern $mLESS :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLESS :: Char
    LESS = '\x3c'

    -- | Equals sign, @=@
    pattern EQUAL :: Char
    pattern $mEQUAL :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bEQUAL :: Char
    EQUAL = '\x3d'

    -- | Greater-than sign, @>@
    pattern GREATER :: Char
    pattern $mGREATER :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bGREATER :: Char
    GREATER = '\x3e'

    -- | Question mark, @?@
    pattern QUESTION :: Char
    pattern $mQUESTION :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bQUESTION :: Char
    QUESTION = '\x3f'

    -- | Commercial At, @\@@
    pattern AT :: Char
    pattern $mAT :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bAT :: Char
    AT = '\x40'

    -------------------------------------------------------------------------------
    -- * Upper case letters, x41-x5a
    -------------------------------------------------------------------------------

    -- | Latin small letter A, @A@
    pattern UPPER_A :: Char
    pattern $mUPPER_A :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_A :: Char
    UPPER_A = '\x41'

    -- | Latin small letter B, @B@
    pattern UPPER_B :: Char
    pattern $mUPPER_B :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_B :: Char
    UPPER_B = '\x42'

    -- | Latin small letter C, @C@
    pattern UPPER_C :: Char
    pattern $mUPPER_C :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_C :: Char
    UPPER_C = '\x43'

    -- | Latin small letter D, @D@
    pattern UPPER_D :: Char
    pattern $mUPPER_D :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_D :: Char
    UPPER_D = '\x44'

    -- | Latin small letter E, @E@
    pattern UPPER_E :: Char
    pattern $mUPPER_E :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_E :: Char
    UPPER_E = '\x45'

    -- | Latin small letter F, @F@
    pattern UPPER_F :: Char
    pattern $mUPPER_F :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_F :: Char
    UPPER_F = '\x46'

    -- | Latin small letter G, @G@
    pattern UPPER_G :: Char
    pattern $mUPPER_G :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_G :: Char
    UPPER_G = '\x47'

    -- | Latin small letter H, @H@
    pattern UPPER_H :: Char
    pattern $mUPPER_H :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_H :: Char
    UPPER_H = '\x48'

    -- | Latin small letter I, @I@
    pattern UPPER_I :: Char
    pattern $mUPPER_I :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_I :: Char
    UPPER_I = '\x49'

    -- | Latin small letter J, @J@
    pattern UPPER_J :: Char
    pattern $mUPPER_J :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_J :: Char
    UPPER_J = '\x4a'

    -- | Latin small letter K, @K@
    pattern UPPER_K :: Char
    pattern $mUPPER_K :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_K :: Char
    UPPER_K = '\x4b'

    -- | Latin small letter L, @L@
    pattern UPPER_L :: Char
    pattern $mUPPER_L :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_L :: Char
    UPPER_L = '\x4c'

    -- | Latin small letter M, @M@
    pattern UPPER_M :: Char
    pattern $mUPPER_M :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_M :: Char
    UPPER_M = '\x4d'

    -- | Latin small letter N, @N@
    pattern UPPER_N :: Char
    pattern $mUPPER_N :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_N :: Char
    UPPER_N = '\x4e'

    -- | Latin small letter O, @O@
    pattern UPPER_O :: Char
    pattern $mUPPER_O :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_O :: Char
    UPPER_O = '\x4f'

    -- | Latin small letter P, @P@
    pattern UPPER_P :: Char
    pattern $mUPPER_P :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_P :: Char
    UPPER_P = '\x50'

    -- | Latin small letter Q, @Q@
    pattern UPPER_Q :: Char
    pattern $mUPPER_Q :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_Q :: Char
    UPPER_Q = '\x51'

    -- | Latin small letter R, @R@
    pattern UPPER_R :: Char
    pattern $mUPPER_R :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_R :: Char
    UPPER_R = '\x52'

    -- | Latin small letter S, @S@
    pattern UPPER_S :: Char
    pattern $mUPPER_S :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_S :: Char
    UPPER_S = '\x53'

    -- | Latin small letter T, @T@
    pattern UPPER_T :: Char
    pattern $mUPPER_T :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_T :: Char
    UPPER_T = '\x54'

    -- | Latin small letter U, @U@
    pattern UPPER_U :: Char
    pattern $mUPPER_U :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_U :: Char
    UPPER_U = '\x55'

    -- | Latin small letter V, @V@
    pattern UPPER_V :: Char
    pattern $mUPPER_V :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_V :: Char
    UPPER_V = '\x56'

    -- | Latin small letter W, @W@
    pattern UPPER_W :: Char
    pattern $mUPPER_W :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_W :: Char
    UPPER_W = '\x57'

    -- | Latin small letter X, @X@
    pattern UPPER_X :: Char
    pattern $mUPPER_X :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_X :: Char
    UPPER_X = '\x58'

    -- | Latin small letter Y, @Y@
    pattern UPPER_Y :: Char
    pattern $mUPPER_Y :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_Y :: Char
    UPPER_Y = '\x59'

    -- | Latin small letter Z, @Z@
    pattern UPPER_Z :: Char
    pattern $mUPPER_Z :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUPPER_Z :: Char
    UPPER_Z = '\x5a'

    -------------------------------------------------------------------------------
    -- * Symbols 3, x5b-x60
    -------------------------------------------------------------------------------

    -- | Left square bracket, @[@
    pattern LEFT_SQUARE :: Char
    pattern $mLEFT_SQUARE :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLEFT_SQUARE :: Char
    LEFT_SQUARE = '\x5b'

    -- | Reverse solidus, backslash, @\\@
    pattern BACKSLASH :: Char
    pattern $mBACKSLASH :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bBACKSLASH :: Char
    BACKSLASH = '\x5c'

    -- | Right square bracket, @]@
    pattern RIGHT_SQUARE :: Char
    pattern $mRIGHT_SQUARE :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bRIGHT_SQUARE :: Char
    RIGHT_SQUARE = '\x5d'

    -- | Circumflex accent, @^@
    pattern CIRCUM :: Char
    pattern $mCIRCUM :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bCIRCUM :: Char
    CIRCUM = '\x5e'

    -- | Low line, underscore, @_@
    pattern UNDERSCORE :: Char
    pattern $mUNDERSCORE :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bUNDERSCORE :: Char
    UNDERSCORE = '\x5f'

    -- | Grave accent, @`@
    pattern GRAVE :: Char
    pattern $mGRAVE :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bGRAVE :: Char
    GRAVE = '\x60'

    -------------------------------------------------------------------------------
    -- * Lower case letters, x61-x7a
    -------------------------------------------------------------------------------

    -- | Latin small letter A, @a@
    pattern LOWER_A :: Char
    pattern $mLOWER_A :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_A :: Char
    LOWER_A = '\x61'

    -- | Latin small letter B, @b@
    pattern LOWER_B :: Char
    pattern $mLOWER_B :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_B :: Char
    LOWER_B = '\x62'

    -- | Latin small letter C, @c@
    pattern LOWER_C :: Char
    pattern $mLOWER_C :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_C :: Char
    LOWER_C = '\x63'

    -- | Latin small letter D, @d@
    pattern LOWER_D :: Char
    pattern $mLOWER_D :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_D :: Char
    LOWER_D = '\x64'

    -- | Latin small letter E, @e@
    pattern LOWER_E :: Char
    pattern $mLOWER_E :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_E :: Char
    LOWER_E = '\x65'

    -- | Latin small letter F, @f@
    pattern LOWER_F :: Char
    pattern $mLOWER_F :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_F :: Char
    LOWER_F = '\x66'

    -- | Latin small letter G, @g@
    pattern LOWER_G :: Char
    pattern $mLOWER_G :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_G :: Char
    LOWER_G = '\x67'

    -- | Latin small letter H, @h@
    pattern LOWER_H :: Char
    pattern $mLOWER_H :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_H :: Char
    LOWER_H = '\x68'

    -- | Latin small letter I, @i@
    pattern LOWER_I :: Char
    pattern $mLOWER_I :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_I :: Char
    LOWER_I = '\x69'

    -- | Latin small letter J, @j@
    pattern LOWER_J :: Char
    pattern $mLOWER_J :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_J :: Char
    LOWER_J = '\x6a'

    -- | Latin small letter K, @k@
    pattern LOWER_K :: Char
    pattern $mLOWER_K :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_K :: Char
    LOWER_K = '\x6b'

    -- | Latin small letter L, @l@
    pattern LOWER_L :: Char
    pattern $mLOWER_L :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_L :: Char
    LOWER_L = '\x6c'

    -- | Latin small letter M, @m@
    pattern LOWER_M :: Char
    pattern $mLOWER_M :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_M :: Char
    LOWER_M = '\x6d'

    -- | Latin small letter N, @n@
    pattern LOWER_N :: Char
    pattern $mLOWER_N :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_N :: Char
    LOWER_N = '\x6e'

    -- | Latin small letter O, @o@
    pattern LOWER_O :: Char
    pattern $mLOWER_O :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_O :: Char
    LOWER_O = '\x6f'

    -- | Latin small letter P, @p@
    pattern LOWER_P :: Char
    pattern $mLOWER_P :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_P :: Char
    LOWER_P = '\x70'

    -- | Latin small letter Q, @q@
    pattern LOWER_Q :: Char
    pattern $mLOWER_Q :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_Q :: Char
    LOWER_Q = '\x71'

    -- | Latin small letter R, @r@
    pattern LOWER_R :: Char
    pattern $mLOWER_R :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_R :: Char
    LOWER_R = '\x72'

    -- | Latin small letter S, @s@
    pattern LOWER_S :: Char
    pattern $mLOWER_S :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_S :: Char
    LOWER_S = '\x73'

    -- | Latin small letter T, @t@
    pattern LOWER_T :: Char
    pattern $mLOWER_T :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_T :: Char
    LOWER_T = '\x74'

    -- | Latin small letter U, @u@
    pattern LOWER_U :: Char
    pattern $mLOWER_U :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_U :: Char
    LOWER_U = '\x75'

    -- | Latin small letter V, @v@
    pattern LOWER_V :: Char
    pattern $mLOWER_V :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_V :: Char
    LOWER_V = '\x76'

    -- | Latin small letter W, @w@
    pattern LOWER_W :: Char
    pattern $mLOWER_W :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_W :: Char
    LOWER_W = '\x77'

    -- | Latin small letter X, @x@
    pattern LOWER_X :: Char
    pattern $mLOWER_X :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_X :: Char
    LOWER_X = '\x78'

    -- | Latin small letter Y, @y@
    pattern LOWER_Y :: Char
    pattern $mLOWER_Y :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_Y :: Char
    LOWER_Y = '\x79'

    -- | Latin small letter Z, @z@
    pattern LOWER_Z :: Char
    pattern $mLOWER_Z :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLOWER_Z :: Char
    LOWER_Z = '\x7a'

    -------------------------------------------------------------------------------
    -- * Symbols 5, x7b-x7f
    -------------------------------------------------------------------------------

    -- | Left curly bracket, @{@
    pattern LEFT_CURLY :: Char
    pattern $mLEFT_CURLY :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bLEFT_CURLY :: Char
    LEFT_CURLY = '\x7b'

    -- | Vertical line, vecrtical bar, @|@
    pattern BAR :: Char
    pattern $mBAR :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bBAR :: Char
    BAR = '\x7c'

    -- | Right curly bracket, @}@
    pattern RIGHT_CURLY :: Char
    pattern $mRIGHT_CURLY :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bRIGHT_CURLY :: Char
    RIGHT_CURLY = '\x7d'

    -- | Tilde, @~@
    pattern TILDE :: Char
    pattern $mTILDE :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bTILDE :: Char
    TILDE = '\x7e'

    -- | Delete (DEL)
    pattern DEL :: Char
    pattern $mDEL :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
    $bDEL :: Char
    DEL = '\x7f'