-- | 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 $bNUL :: Char
$mNUL :: forall {r}. Char -> ((# #) -> r) -> ((# #) -> r) -> r
NUL = '\x00'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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