    -- | This module provides pattern synonyms for 'Word8' in [Basic Latin block](https://compart.com/en/unicode/block/U+0000) (range @0x00-0x7f@).
    --
    -- 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.Word8.Patterns" as W8
    --
    -- hello = [W8.'LOWER_H', W8.'LOWER_E', W8.'LOWER_L', W8.'LOWER_L', W8.'LOWER_O']
    -- @
    --
    -- but can also be used unqualified as well.
    --
    module Data.Word8.Patterns where

    import Data.Word (Word8)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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