-- | Word8 library to be used with "Data.ByteString".
-- All functions assume that the 'Word8' is encoded in Latin-1 (ISO-8859-1).
-- All utility functions are supposed to work like those of "Data.Char".
-- Exceptions are described in the function documentations.
module Data.Word8 (
    -- * Re-exporting
    Word8,

    -- * Functions on bytes

    -- ** Character classification
    isControl,
    isSpace,
    isLower,
    isUpper,
    isAlpha,
    isAlphaNum,
    isPrint,
    isDigit,
    isOctDigit,
    isHexDigit,
    isLetter,
    isMark,
    isNumber,
    isPunctuation,
    isSymbol,
    isSeparator,

    -- ** Subranges
    isAscii,
    isLatin1,
    isAsciiUpper,
    isAsciiLower,

    -- ** Case conversion
    toUpper,
    toLower,
    toTitle,

    -- * Byte constants

    -- ** ASCII characters
    _nul,
    _tab,
    _lf,
    _vt,
    _np,
    _cr,
    _space,
    _exclam,
    _quotedbl,
    _numbersign,
    _dollar,
    _percent,
    _ampersand,
    _quotesingle,
    _parenleft,
    _parenright,
    _asterisk,
    _plus,
    _comma,
    _hyphen,
    _period,
    _slash,
    _0,
    _1,
    _2,
    _3,
    _4,
    _5,
    _6,
    _7,
    _8,
    _9,
    _colon,
    _semicolon,
    _less,
    _equal,
    _greater,
    _question,
    _at,
    _A,
    _B,
    _C,
    _D,
    _E,
    _F,
    _G,
    _H,
    _I,
    _J,
    _K,
    _L,
    _M,
    _N,
    _O,
    _P,
    _Q,
    _R,
    _S,
    _T,
    _U,
    _V,
    _W,
    _X,
    _Y,
    _Z,
    _bracketleft,
    _backslash,
    _bracketright,
    _circum,
    _underscore,
    _grave,
    _a,
    _b,
    _c,
    _d,
    _e,
    _f,
    _g,
    _h,
    _i,
    _j,
    _k,
    _l,
    _m,
    _n,
    _o,
    _p,
    _q,
    _r,
    _s,
    _t,
    _u,
    _v,
    _w,
    _x,
    _y,
    _z,
    _braceleft,
    _bar,
    _braceright,
    _tilde,
    _del,

    -- ** Some Latin-1 characters
    _nbsp,
    _ordfeminine,
    _softhyphen,
    _mu,
    _ordmasculine,
    _s2,
    _s3,
    _s1,
    _1'4,
    _1'2,
    _3'4,
    _Agrave,
    _Odieresis,
    _Oslash,
    _Thorn,
    _germandbls,
    _agrave,
    _odieresis,
    _oslash,
    _thorn,
    _ydieresis,
) where

import Data.Bits (unsafeShiftR, (.&.))
import Data.Word (Word64, Word8)

----------------------------------------------------------------

-- | Is the byte a control character
isControl :: Word8 -> Bool
isControl :: Word8 -> Bool
isControl Word8
w =
    Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
0x1f
        Bool -> Bool -> Bool
|| Word8
_del Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
0x9f

-- | Is the byte white space
isSpace :: Word8 -> Bool
isSpace :: Word8 -> Bool
isSpace Word8
w =
    Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_space
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_tab
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_lf
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_cr
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_np
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_vt
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_nbsp

-- | Is the byte a lower case character
--
-- This function returns 'False' for 170 (ª) and 186 (º).
isLower :: Word8 -> Bool
isLower :: Word8 -> Bool
isLower Word8
w =
    Word8 -> Bool
isLower' Word8
w
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_mu

isLowerCommon :: Word8 -> Bool
isLowerCommon :: Word8 -> Bool
isLowerCommon Word8
w =
    Word8 -> Bool
isLower' Word8
w
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_mu
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_ordfeminine
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_ordmasculine

isLower' :: Word8 -> Bool
isLower' :: Word8 -> Bool
isLower' Word8
w =
    Word8 -> Bool
isAsciiLower Word8
w
        Bool -> Bool -> Bool
|| Word8
_germandbls Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
_ydieresis Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
0xf7

-- | Is the byte an upper case character
isUpper :: Word8 -> Bool
isUpper :: Word8 -> Bool
isUpper Word8
w =
    Word8 -> Bool
isAsciiUpper Word8
w
        Bool -> Bool -> Bool
|| Word8
_Agrave Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
_Thorn Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
0xd7

-- | Is the byte an alphabet letter
--
-- Synonym for 'isLetter'
isAlpha :: Word8 -> Bool
isAlpha :: Word8 -> Bool
isAlpha Word8
w = Word8 -> Bool
isLowerCommon Word8
w Bool -> Bool -> Bool
|| Word8 -> Bool
isUpper Word8
w

-- | Is the byte an alphabet letter or a number
isAlphaNum :: Word8 -> Bool
isAlphaNum :: Word8 -> Bool
isAlphaNum Word8
w = Word8 -> Bool
isAlpha Word8
w Bool -> Bool -> Bool
|| Word8 -> Bool
isNumber Word8
w

-- | Is the byte printable
isPrint :: Word8 -> Bool
isPrint :: Word8 -> Bool
isPrint Word8
w
    | Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_softhyphen = Bool
False
isPrint Word8
w =
    Word8
_space Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
_tilde
        Bool -> Bool -> Bool
|| Word8
_nbsp Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
_ydieresis

-- | Is the byte a digit (@0-9@)
isDigit :: Word8 -> Bool
isDigit :: Word8 -> Bool
isDigit Word8
w = Word8
_0 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
_9

-- | Is the byte an octal digit (@0-7@)
isOctDigit :: Word8 -> Bool
isOctDigit :: Word8 -> Bool
isOctDigit Word8
w = Word8
_0 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
_7

-- | Is the byte a hexadecimal digit (@0-9a-fA-F@)
isHexDigit :: Word8 -> Bool
isHexDigit :: Word8 -> Bool
isHexDigit Word8
w =
    Word8 -> Bool
isDigit Word8
w
        Bool -> Bool -> Bool
|| Word8
_A Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
_F
        Bool -> Bool -> Bool
|| Word8
_a Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
_f

-- | Is the byte an alphabet letter
--
-- Synonym for 'isAlpha'
isLetter :: Word8 -> Bool
isLetter :: Word8 -> Bool
isLetter Word8
w = Word8 -> Bool
isLowerCommon Word8
w Bool -> Bool -> Bool
|| Word8 -> Bool
isUpper Word8
w

-- | A byte is never a mark
--
-- Synonymous with @const False@
isMark :: Word8 -> Bool
isMark :: Word8 -> Bool
isMark Word8
_ = Bool
False

-- | Is the byte a number
isNumber :: Word8 -> Bool
isNumber :: Word8 -> Bool
isNumber Word8
w =
    Word8 -> Bool
isDigit Word8
w
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_s1
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_s2
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_s3
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_1'4
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_1'2
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_3'4

-- | Is the byte a punctuation character
--
-- This function returns 'True' for 167 (§) and 182 (¶).
isPunctuation :: Word8 -> Bool
-- Bitmap of !"#%&'()*,-./:;?@[\]_{} and ¡§«¶·»¿
{-# INLINE isPunctuation #-}
isPunctuation :: Word8 -> Bool
isPunctuation Word8
w =
    Word64 -> Word64 -> Word64 -> Word64 -> Word8 -> Bool
inBitmap Word64
0x8c00f7ee00000000 Word64
0x28000000b8000001 Word64
0x88c0088200000000 Word64
0 Word8
w

-- | Is the byte a symbol character
--
-- This function returns 'False' for 167 (§) and 182 (¶).
isSymbol :: Word8 -> Bool
-- Bitmap of $+<=>^`|~ and ¢£¤¥¦¨©¬®¯°±´¸×÷
{-# INLINE isSymbol #-}
isSymbol :: Word8 -> Bool
isSymbol Word8
w =
    Word64 -> Word64 -> Word64 -> Word64 -> Word8 -> Bool
inBitmap
        Word64
0x7000081000000000
        Word64
0x5000000140000000
        Word64
0x0113d37c00000000
        Word64
0x0080000000800000
        Word8
w

-- Membership test for a 256-bit set given as four 64-bit words.
inBitmap :: Word64 -> Word64 -> Word64 -> Word64 -> Word8 -> Bool
inBitmap :: Word64 -> Word64 -> Word64 -> Word64 -> Word8 -> Bool
inBitmap Word64
b0 Word64
b1 Word64
b2 Word64
b3 Word8
w = (Word64
b Word64 -> Int -> Word64
forall a. Bits a => a -> Int -> a
`unsafeShiftR` Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8
w Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
63)) Word64 -> Word64 -> Word64
forall a. Bits a => a -> a -> a
.&. Word64
1 Word64 -> Word64 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word64
0
  where
    b :: Word64
b = case Word8
w Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
`unsafeShiftR` Int
6 of
        Word8
0 -> Word64
b0
        Word8
1 -> Word64
b1
        Word8
2 -> Word64
b2
        Word8
_ -> Word64
b3
{-# INLINE inBitmap #-}

-- | Is the byte a (non-breaking) space
isSeparator :: Word8 -> Bool
isSeparator :: Word8 -> Bool
isSeparator Word8
w =
    Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_space
        Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_nbsp

----------------------------------------------------------------

-- | Is the byte in the ASCII range
isAscii :: Word8 -> Bool
isAscii :: Word8 -> Bool
isAscii Word8
w = Word8
w Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x80 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0

-- | Every byte is in the Latin-1 range
--
-- Synonymous with @const True@
isLatin1 :: Word8 -> Bool
isLatin1 :: Word8 -> Bool
isLatin1 Word8
_ = Bool
True

-- | Is the byte an upper case ASCII letter (@A-Z@)
isAsciiUpper :: Word8 -> Bool
isAsciiUpper :: Word8 -> Bool
isAsciiUpper Word8
w = Word8
_A Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
_Z

-- | Is the byte a lower case ASCII letter (@a-z@)
isAsciiLower :: Word8 -> Bool
isAsciiLower :: Word8 -> Bool
isAsciiLower Word8
w = Word8
_a Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
_z

----------------------------------------------------------------

-- | Changes the byte to the upper case variant, if possible.
--
-- Micro sign/mu ('_mu') and small letter Y with diaeresis ('_ydieresis') remain the same.
toUpper :: Word8 -> Word8
toUpper :: Word8 -> Word8
toUpper Word8
w
    | Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_germandbls = Word8
w
    | Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
_ydieresis = Word8
w
    | Word8 -> Bool
isLower' Word8
w = Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
_space
    | Bool
otherwise = Word8
w

-- | Changes the byte to the lower case variant, if possible.
toLower :: Word8 -> Word8
toLower :: Word8 -> Word8
toLower Word8
w
    | Word8 -> Bool
isUpper Word8
w = Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
+ Word8
_space
    | Bool
otherwise = Word8
w

-- | Synonym for 'toUpper'
toTitle :: Word8 -> Word8
toTitle :: Word8 -> Word8
toTitle = Word8 -> Word8
toUpper

----------------------------------------------------------------

-- | Null character
--
-- > BIN:  0b00000000
-- > OCT:  0o000
-- > DEC:  0
-- > HEX:  0x00
-- > HTML: &#00;
-- > Char: '\NUL'
_nul :: Word8
_nul :: Word8
_nul = Word8
0x00

-- | Horizontal Tab
--
-- > BIN:  0b00001001
-- > OCT:  0o011
-- > DEC:  9
-- > HEX:  0x09
-- > HTML: &#09;
-- > Char: '\HT' or '\t'
_tab :: Word8
_tab :: Word8
_tab = Word8
0x09

-- | Line Feed
--
-- > BIN:  0b00001010
-- > OCT:  0o012
-- > DEC:  10
-- > HEX:  0x0A
-- > HTML: &#10;
-- > Char: '\LF' or '\n'
_lf :: Word8
_lf :: Word8
_lf = Word8
0x0a

-- | Vertical Tabulation
--
-- > BIN:  0b00001011
-- > OCT:  0o013
-- > DEC:  11
-- > HEX:  0x0B
-- > HTML: &#11;
-- > Char: '\VT'
_vt :: Word8
_vt :: Word8
_vt = Word8
0x0b

-- | Form Feed (New Page)
--
-- > BIN:  0b00001100
-- > OCT:  0o014
-- > DEC:  12
-- > HEX:  0x0C
-- > HTML: &#12;
-- > Char: '\FF'
_np :: Word8
_np :: Word8
_np = Word8
0x0c

-- | Carriage Return
--
-- > BIN:  0b00001101
-- > OCT:  0o015
-- > DEC:  13
-- > HEX:  0x0D
-- > HTML: &#13;
-- > Char: '\CR' or '\r'
_cr :: Word8
_cr :: Word8
_cr = Word8
0x0d

-- | Space
--
-- > BIN:  0b00100000
-- > OCT:  0o040
-- > DEC:  32
-- > HEX:  0x20
-- > HTML: &#32;
-- > Char: '\SP' or ' '
_space :: Word8
_space :: Word8
_space = Word8
0x20

-- | Exclamation mark
--
-- > BIN:  0b00100001
-- > OCT:  0o041
-- > DEC:  33
-- > HEX:  0x21
-- > HTML: &#33; or &excl;
-- > Char: '!'
_exclam :: Word8
_exclam :: Word8
_exclam = Word8
0x21

-- | Double quotes (or speech marks)
--
-- > BIN:  0b00100010
-- > OCT:  0o042
-- > DEC:  34
-- > HEX:  0x22
-- > HTML: &#34; or &quot;
-- > Char: '"'
_quotedbl :: Word8
_quotedbl :: Word8
_quotedbl = Word8
0x22

-- | Number sign (or hash sign, or pound sign)
--
-- > BIN:  0b00100011
-- > OCT:  0o043
-- > DEC:  35
-- > HEX:  0x23
-- > HTML: &#35; or &num;
-- > Char: '#'
_numbersign :: Word8
_numbersign :: Word8
_numbersign = Word8
0x23

-- | Dollar
--
-- > BIN:  0b00100100
-- > OCT:  0o044
-- > DEC:  36
-- > HEX:  0x24
-- > HTML: &#36; or &dollar;
-- > Char: '$'
_dollar :: Word8
_dollar :: Word8
_dollar = Word8
0x24

-- | Per cent sign
--
-- > BIN:  0b00100101
-- > OCT:  0o045
-- > DEC:  37
-- > HEX:  0x25
-- > HTML: &#37; or &percnt;
-- > Char: '%'
_percent :: Word8
_percent :: Word8
_percent = Word8
0x25

-- | Ampersand
--
-- > BIN:  0b00100110
-- > OCT:  0o046
-- > DEC:  38
-- > HEX:  0x26
-- > HTML: &#38; or &amp;
-- > Char: '&'
_ampersand :: Word8
_ampersand :: Word8
_ampersand = Word8
0x26

-- | Single quote
--
-- > BIN:  0b00100111
-- > OCT:  0o047
-- > DEC:  39
-- > HEX:  0x27
-- > HTML: &#39; or &apos;
-- > Char: '\''
_quotesingle :: Word8
_quotesingle :: Word8
_quotesingle = Word8
0x27

-- | Open parenthesis (or open bracket)
--
-- > BIN:  0b00101000
-- > OCT:  0o050
-- > DEC:  40
-- > HEX:  0x28
-- > HTML: &#40; or &lparen;
-- > Char: '('
_parenleft :: Word8
_parenleft :: Word8
_parenleft = Word8
0x28

-- | Close parenthesis (or close bracket)
--
-- > BIN:  0b00101001
-- > OCT:  0o051
-- > DEC:  41
-- > HEX:  0x29
-- > HTML: &#41; or &rparen;
-- > Char: ')'
_parenright :: Word8
_parenright :: Word8
_parenright = Word8
0x29

-- | Asterisk
--
-- > BIN:  0b00101010
-- > OCT:  0o052
-- > DEC:  42
-- > HEX:  0x2A
-- > HTML: &#42; or &ast;
-- > Char: '*'
_asterisk :: Word8
_asterisk :: Word8
_asterisk = Word8
0x2a

-- | Plus
--
-- > BIN:  0b00101011
-- > OCT:  0o053
-- > DEC:  43
-- > HEX:  0x2B
-- > HTML: &#43; or &plus;
-- > Char: '+'
_plus :: Word8
_plus :: Word8
_plus = Word8
0x2b

-- | Comma
--
-- > BIN:  0b00101100
-- > OCT:  0o054
-- > DEC:  44
-- > HEX:  0x2C
-- > HTML: &#44; or &comma;
-- > Char: ','
_comma :: Word8
_comma :: Word8
_comma = Word8
0x2c

-- | Hyphen (or minus, or dash)
--
-- > BIN:  0b00101101
-- > OCT:  0o055
-- > DEC:  45
-- > HEX:  0x2D
-- > HTML: &#45;
-- > Char: '-'
_hyphen :: Word8
_hyphen :: Word8
_hyphen = Word8
0x2d

-- | Period (or dot, or full stop)
--
-- > BIN:  0b00101110
-- > OCT:  0o056
-- > DEC:  46
-- > HEX:  0x2E
-- > HTML: &#46; or &period;
-- > Char: '.'
_period :: Word8
_period :: Word8
_period = Word8
0x2e

-- | Slash (or divide)
--
-- > BIN:  0b00101111
-- > OCT:  0o057
-- > DEC:  47
-- > HEX:  0x2F
-- > HTML: &#47; or &sol;
-- > Char: '/'
_slash :: Word8
_slash :: Word8
_slash = Word8
0x2f

-- | Zero
--
-- > BIN:  0b00110000
-- > OCT:  0o060
-- > DEC:  48
-- > HEX:  0x30
-- > HTML: &#48;
-- > Char: '0'
_0 :: Word8
_0 :: Word8
_0 = Word8
0x30

-- | One
--
-- > BIN:  0b00110001
-- > OCT:  0o061
-- > DEC:  49
-- > HEX:  0x31
-- > HTML: &#49;
-- > Char: '1'
_1 :: Word8
_1 :: Word8
_1 = Word8
0x31

-- | Two
--
-- > BIN:  0b00110010
-- > OCT:  0o062
-- > DEC:  50
-- > HEX:  0x32
-- > HTML: &#50;
-- > Char: '2'
_2 :: Word8
_2 :: Word8
_2 = Word8
0x32

-- | Three
--
-- > BIN:  0b00110011
-- > OCT:  0o063
-- > DEC:  51
-- > HEX:  0x33
-- > HTML: &#51;
-- > Char: '3'
_3 :: Word8
_3 :: Word8
_3 = Word8
0x33

-- | Four
--
-- > BIN:  0b00110100
-- > OCT:  0o064
-- > DEC:  52
-- > HEX:  0x34
-- > HTML: &#52;
-- > Char: '4'
_4 :: Word8
_4 :: Word8
_4 = Word8
0x34

-- | Five
--
-- > BIN:  0b00110101
-- > OCT:  0o065
-- > DEC:  53
-- > HEX:  0x35
-- > HTML: &#53;
-- > Char: '5'
_5 :: Word8
_5 :: Word8
_5 = Word8
0x35

-- | Six
--
-- > BIN:  0b00110110
-- > OCT:  0o066
-- > DEC:  54
-- > HEX:  0x36
-- > HTML: &#54;
-- > Char: '6'
_6 :: Word8
_6 :: Word8
_6 = Word8
0x36

-- | Seven
--
-- > BIN:  0b00110111
-- > OCT:  0o067
-- > DEC:  55
-- > HEX:  0x37
-- > HTML: &#55;
-- > Char: '7'
_7 :: Word8
_7 :: Word8
_7 = Word8
0x37

-- | Eight
--
-- > BIN:  0b00111000
-- > OCT:  0o070
-- > DEC:  56
-- > HEX:  0x38
-- > HTML: &#56;
-- > Char: '8'
_8 :: Word8
_8 :: Word8
_8 = Word8
0x38

-- | Nine
--
-- > BIN:  0b00111001
-- > OCT:  0o071
-- > DEC:  57
-- > HEX:  0x39
-- > HTML: &#57;
-- > Char: '9'
_9 :: Word8
_9 :: Word8
_9 = Word8
0x39

-- | Colon
--
-- > BIN:  0b00111010
-- > OCT:  0o072
-- > DEC:  58
-- > HEX:  0x3A
-- > HTML: &#58; or &colon;
-- > Char: ':'
_colon :: Word8
_colon :: Word8
_colon = Word8
0x3a

-- | Semicolon
--
-- > BIN:  0b00111011
-- > OCT:  0o073
-- > DEC:  59
-- > HEX:  0x3B
-- > HTML: &#59; or &semi;
-- > Char: ';'
_semicolon :: Word8
_semicolon :: Word8
_semicolon = Word8
0x3b

-- | Less than (or open angled bracket)
--
-- > BIN:  0b00111100
-- > OCT:  0o074
-- > DEC:  60
-- > HEX:  0x3C
-- > HTML: &#60; or &lt;
-- > Char: '<'
_less :: Word8
_less :: Word8
_less = Word8
0x3c

-- | Equals
--
-- > BIN:  0b00111101
-- > OCT:  0o075
-- > DEC:  61
-- > HEX:  0x3D
-- > HTML: &#61; or &equals;
-- > Char: '='
_equal :: Word8
_equal :: Word8
_equal = Word8
0x3d

-- | Greater than (or close angled bracket)
--
-- > BIN:  0b00111110
-- > OCT:  0o076
-- > DEC:  62
-- > HEX:  0x3E
-- > HTML: &#62; or &gt;
-- > Char: '>'
_greater :: Word8
_greater :: Word8
_greater = Word8
0x3e

-- | Question mark
--
-- > BIN:  0b00111111
-- > OCT:  0o077
-- > DEC:  63
-- > HEX:  0x3F
-- > HTML: &#63; or &quest;
-- > Char: '?'
_question :: Word8
_question :: Word8
_question = Word8
0x3f

-- | At sign
--
-- > BIN:  0b01000000
-- > OCT:  0o100
-- > DEC:  64
-- > HEX:  0x40
-- > HTML: &#64; or &commat;
-- > Char: '@'
_at :: Word8
_at :: Word8
_at = Word8
0x40

-- | Uppercase A
--
-- > BIN:  0b01000001
-- > OCT:  0o101
-- > DEC:  65
-- > HEX:  0x41
-- > HTML: &#65;
-- > Char: 'A'
_A :: Word8
_A :: Word8
_A = Word8
0x41

-- | Uppercase B
--
-- > BIN:  0b01000010
-- > OCT:  0o102
-- > DEC:  66
-- > HEX:  0x42
-- > HTML: &#66;
-- > Char: 'B'
_B :: Word8
_B :: Word8
_B = Word8
0x42

-- | Uppercase C
--
-- > BIN:  0b01000011
-- > OCT:  0o103
-- > DEC:  67
-- > HEX:  0x43
-- > HTML: &#67;
-- > Char: 'C'
_C :: Word8
_C :: Word8
_C = Word8
0x43

-- | Uppercase D
--
-- > BIN:  0b01000100
-- > OCT:  0o104
-- > DEC:  68
-- > HEX:  0x44
-- > HTML: &#68;
-- > Char: 'D'
_D :: Word8
_D :: Word8
_D = Word8
0x44

-- | Uppercase E
--
-- > BIN:  0b01000101
-- > OCT:  0o105
-- > DEC:  69
-- > HEX:  0x45
-- > HTML: &#69;
-- > Char: 'E'
_E :: Word8
_E :: Word8
_E = Word8
0x45

-- | Uppercase F
--
-- > BIN:  0b01000110
-- > OCT:  0o106
-- > DEC:  70
-- > HEX:  0x46
-- > HTML: &#70;
-- > Char: 'F'
_F :: Word8
_F :: Word8
_F = Word8
0x46

-- | Uppercase G
--
-- > BIN:  0b01000111
-- > OCT:  0o107
-- > DEC:  71
-- > HEX:  0x47
-- > HTML: &#71;
-- > Char: 'G'
_G :: Word8
_G :: Word8
_G = Word8
0x47

-- | Uppercase H
--
-- > BIN:  0b01001000
-- > OCT:  0o110
-- > DEC:  72
-- > HEX:  0x48
-- > HTML: &#72;
-- > Char: 'H'
_H :: Word8
_H :: Word8
_H = Word8
0x48

-- | Uppercase I
--
-- > BIN:  0b01001001
-- > OCT:  0o111
-- > DEC:  73
-- > HEX:  0x49
-- > HTML: &#73;
-- > Char: 'I'
_I :: Word8
_I :: Word8
_I = Word8
0x49

-- | Uppercase J
--
-- > BIN:  0b01001010
-- > OCT:  0o112
-- > DEC:  74
-- > HEX:  0x4A
-- > HTML: &#74;
-- > Char: 'J'
_J :: Word8
_J :: Word8
_J = Word8
0x4a

-- | Uppercase K
--
-- > BIN:  0b01001011
-- > OCT:  0o113
-- > DEC:  75
-- > HEX:  0x4B
-- > HTML: &#75;
-- > Char: 'K'
_K :: Word8
_K :: Word8
_K = Word8
0x4b

-- | Uppercase L
--
-- > BIN:  0b01001100
-- > OCT:  0o114
-- > DEC:  76
-- > HEX:  0x4C
-- > HTML: &#76;
-- > Char: 'L'
_L :: Word8
_L :: Word8
_L = Word8
0x4c

-- | Uppercase M
--
-- > BIN:  0b01001101
-- > OCT:  0o115
-- > DEC:  77
-- > HEX:  0x4D
-- > HTML: &#77;
-- > Char: 'M'
_M :: Word8
_M :: Word8
_M = Word8
0x4d

-- | Uppercase N
--
-- > BIN:  0b01001110
-- > OCT:  0o116
-- > DEC:  78
-- > HEX:  0x4E
-- > HTML: &#78;
-- > Char: 'N'
_N :: Word8
_N :: Word8
_N = Word8
0x4e

-- | Uppercase O
--
-- > BIN:  0b01001111
-- > OCT:  0o117
-- > DEC:  79
-- > HEX:  0x4F
-- > HTML: &#79;
-- > Char: 'O'
_O :: Word8
_O :: Word8
_O = Word8
0x4f

-- | Uppercase P
--
-- > BIN:  0b01010000
-- > OCT:  0o120
-- > DEC:  80
-- > HEX:  0x50
-- > HTML: &#80;
-- > Char: 'P'
_P :: Word8
_P :: Word8
_P = Word8
0x50

-- | Uppercase Q
--
-- > BIN:  0b01010001
-- > OCT:  0o121
-- > DEC:  81
-- > HEX:  0x51
-- > HTML: &#81;
-- > Char: 'Q'
_Q :: Word8
_Q :: Word8
_Q = Word8
0x51

-- | Uppercase R
--
-- > BIN:  0b01010010
-- > OCT:  0o122
-- > DEC:  82
-- > HEX:  0x52
-- > HTML: &#82;
-- > Char: 'R'
_R :: Word8
_R :: Word8
_R = Word8
0x52

-- | Uppercase S
--
-- > BIN:  0b01010011
-- > OCT:  0o123
-- > DEC:  83
-- > HEX:  0x53
-- > HTML: &#83;
-- > Char: 'S'
_S :: Word8
_S :: Word8
_S = Word8
0x53

-- | Uppercase T
--
-- > BIN:  0b01010100
-- > OCT:  0o124
-- > DEC:  84
-- > HEX:  0x54
-- > HTML: &#84;
-- > Char: 'T'
_T :: Word8
_T :: Word8
_T = Word8
0x54

-- | Uppercase U
--
-- > BIN:  0b01010101
-- > OCT:  0o125
-- > DEC:  85
-- > HEX:  0x55
-- > HTML: &#85;
-- > Char: 'U'
_U :: Word8
_U :: Word8
_U = Word8
0x55

-- | Uppercase V
--
-- > BIN:  0b01010110
-- > OCT:  0o126
-- > DEC:  86
-- > HEX:  0x56
-- > HTML: &#86;
-- > Char: 'V'
_V :: Word8
_V :: Word8
_V = Word8
0x56

-- | Uppercase W
--
-- > BIN:  0b01010111
-- > OCT:  0o127
-- > DEC:  87
-- > HEX:  0x57
-- > HTML: &#87;
-- > Char: 'W'
_W :: Word8
_W :: Word8
_W = Word8
0x57

-- | Uppercase X
--
-- > BIN:  0b01011000
-- > OCT:  0o130
-- > DEC:  88
-- > HEX:  0x58
-- > HTML: &#88;
-- > Char: 'X'
_X :: Word8
_X :: Word8
_X = Word8
0x58

-- | Uppercase Y
--
-- > BIN:  0b01011001
-- > OCT:  0o131
-- > DEC:  89
-- > HEX:  0x59
-- > HTML: &#89;
-- > Char: 'Y'
_Y :: Word8
_Y :: Word8
_Y = Word8
0x59

-- | Uppercase Z
--
-- > BIN:  0b01011010
-- > OCT:  0o132
-- > DEC:  90
-- > HEX:  0x5A
-- > HTML: &#90;
-- > Char: 'Z'
_Z :: Word8
_Z :: Word8
_Z = Word8
0x5a

-- | Opening bracket
--
-- > BIN:  0b01011011
-- > OCT:  0o133
-- > DEC:  91
-- > HEX:  0x5B
-- > HTML: &#91; or &lsqb;
-- > Char: '['
_bracketleft :: Word8
_bracketleft :: Word8
_bracketleft = Word8
0x5b

-- | Backslash
--
-- > BIN:  0b01011100
-- > OCT:  0o134
-- > DEC:  92
-- > HEX:  0x5C
-- > HTML: &#92; or &bsol;
-- > Char: '\'
_backslash :: Word8
_backslash :: Word8
_backslash = Word8
0x5c

-- | Closing bracket
--
-- > BIN:  0b01011101
-- > OCT:  0o135
-- > DEC:  93
-- > HEX:  0x5D
-- > HTML: &#93; or &rsqb;
-- > Char: ']'
_bracketright :: Word8
_bracketright :: Word8
_bracketright = Word8
0x5d

-- | Caret - circumflex
--
-- > BIN:  0b01011110
-- > OCT:  0o136
-- > DEC:  94
-- > HEX:  0x5E
-- > HTML: &#94; or &Hat;
-- > Char: '^'
_circum :: Word8
_circum :: Word8
_circum = Word8
0x5e

-- | Underscore
--
-- > BIN:  0b01011111
-- > OCT:  0o137
-- > DEC:  95
-- > HEX:  0x5F
-- > HTML: &#95; or &lowbar;
-- > Char: '_'
_underscore :: Word8
_underscore :: Word8
_underscore = Word8
0x5f

-- | Grave accent
--
-- > BIN:  0b01100000
-- > OCT:  0o140
-- > DEC:  96
-- > HEX:  0x60
-- > HTML: &#96; or &grave;
-- > Char: '`'
_grave :: Word8
_grave :: Word8
_grave = Word8
0x60

-- | Lowercase a
--
-- > BIN:  0b01100001
-- > OCT:  0o141
-- > DEC:  97
-- > HEX:  0x61
-- > HTML: &#97;
-- > Char: 'a'
_a :: Word8
_a :: Word8
_a = Word8
0x61

-- | Lowercase b
--
-- > BIN:  0b01100010
-- > OCT:  0o142
-- > DEC:  98
-- > HEX:  0x62
-- > HTML: &#98;
-- > Char: 'b'
_b :: Word8
_b :: Word8
_b = Word8
0x62

-- | Lowercase c
--
-- > BIN:  0b01100011
-- > OCT:  0o143
-- > DEC:  99
-- > HEX:  0x63
-- > HTML: &#99;
-- > Char: 'c'
_c :: Word8
_c :: Word8
_c = Word8
0x63

-- | Lowercase d
--
-- > BIN:  0b01100100
-- > OCT:  0o144
-- > DEC:  100
-- > HEX:  0x64
-- > HTML: &#100;
-- > Char: 'd'
_d :: Word8
_d :: Word8
_d = Word8
0x64

-- | Lowercase e
--
-- > BIN:  0b01100101
-- > OCT:  0o145
-- > DEC:  101
-- > HEX:  0x65
-- > HTML: &#101;
-- > Char: 'e'
_e :: Word8
_e :: Word8
_e = Word8
0x65

-- | Lowercase f
--
-- > BIN:  0b01100110
-- > OCT:  0o146
-- > DEC:  102
-- > HEX:  0x66
-- > HTML: &#102;
-- > Char: 'f'
_f :: Word8
_f :: Word8
_f = Word8
0x66

-- | Lowercase g
--
-- > BIN:  0b01100111
-- > OCT:  0o147
-- > DEC:  103
-- > HEX:  0x67
-- > HTML: &#103;
-- > Char: 'g'
_g :: Word8
_g :: Word8
_g = Word8
0x67

-- | Lowercase h
--
-- > BIN:  0b01101000
-- > OCT:  0o150
-- > DEC:  104
-- > HEX:  0x68
-- > HTML: &#104;
-- > Char: 'h'
_h :: Word8
_h :: Word8
_h = Word8
0x68

-- | Lowercase i
--
-- > BIN:  0b01101001
-- > OCT:  0o151
-- > DEC:  105
-- > HEX:  0x69
-- > HTML: &#105;
-- > Char: 'i'
_i :: Word8
_i :: Word8
_i = Word8
0x69

-- | Lowercase j
--
-- > BIN:  0b01101010
-- > OCT:  0o152
-- > DEC:  106
-- > HEX:  0x6A
-- > HTML: &#106;
-- > Char: 'j'
_j :: Word8
_j :: Word8
_j = Word8
0x6a

-- | Lowercase k
--
-- > BIN:  0b01101011
-- > OCT:  0o153
-- > DEC:  107
-- > HEX:  0x6B
-- > HTML: &#107;
-- > Char: 'k'
_k :: Word8
_k :: Word8
_k = Word8
0x6b

-- | Lowercase l
--
-- > BIN:  0b01101100
-- > OCT:  0o154
-- > DEC:  108
-- > HEX:  0x6C
-- > HTML: &#108;
-- > Char: 'l'
_l :: Word8
_l :: Word8
_l = Word8
0x6c

-- | Lowercase m
--
-- > BIN:  0b01101101
-- > OCT:  0o155
-- > DEC:  109
-- > HEX:  0x6D
-- > HTML: &#109;
-- > Char: 'm'
_m :: Word8
_m :: Word8
_m = Word8
0x6d

-- | Lowercase n
--
-- > BIN:  0b01101110
-- > OCT:  0o156
-- > DEC:  110
-- > HEX:  0x6E
-- > HTML: &#110;
-- > Char: 'n'
_n :: Word8
_n :: Word8
_n = Word8
0x6e

-- | Lowercase o
--
-- > BIN:  0b01101111
-- > OCT:  0o157
-- > DEC:  111
-- > HEX:  0x6F
-- > HTML: &#111;
-- > Char: 'o'
_o :: Word8
_o :: Word8
_o = Word8
0x6f

-- | Lowercase p
--
-- > BIN:  0b01110000
-- > OCT:  0o160
-- > DEC:  112
-- > HEX:  0x70
-- > HTML: &#112;
-- > Char: 'p'
_p :: Word8
_p :: Word8
_p = Word8
0x70

-- | Lowercase q
--
-- > BIN:  0b01110001
-- > OCT:  0o161
-- > DEC:  113
-- > HEX:  0x71
-- > HTML: &#113;
-- > Char: 'q'
_q :: Word8
_q :: Word8
_q = Word8
0x71

-- | Lowercase r
--
-- > BIN:  0b01110010
-- > OCT:  0o162
-- > DEC:  114
-- > HEX:  0x72
-- > HTML: &#114;
-- > Char: 'r'
_r :: Word8
_r :: Word8
_r = Word8
0x72

-- | Lowercase s
--
-- > BIN:  0b01110011
-- > OCT:  0o163
-- > DEC:  115
-- > HEX:  0x73
-- > HTML: &#115;
-- > Char: 's'
_s :: Word8
_s :: Word8
_s = Word8
0x73

-- | Lowercase t
--
-- > BIN:  0b01110100
-- > OCT:  0o164
-- > DEC:  116
-- > HEX:  0x74
-- > HTML: &#116;
-- > Char: 't'
_t :: Word8
_t :: Word8
_t = Word8
0x74

-- | Lowercase u
--
-- > BIN:  0b01110101
-- > OCT:  0o165
-- > DEC:  117
-- > HEX:  0x75
-- > HTML: &#117;
-- > Char: 'u'
_u :: Word8
_u :: Word8
_u = Word8
0x75

-- | Lowercase v
--
-- > BIN:  0b01110110
-- > OCT:  0o166
-- > DEC:  118
-- > HEX:  0x76
-- > HTML: &#118;
-- > Char: 'v'
_v :: Word8
_v :: Word8
_v = Word8
0x76

-- | Lowercase w
--
-- > BIN:  0b01110111
-- > OCT:  0o167
-- > DEC:  119
-- > HEX:  0x77
-- > HTML: &#119;
-- > Char: 'w'
_w :: Word8
_w :: Word8
_w = Word8
0x77

-- | Lowercase x
--
-- > BIN:  0b01111000
-- > OCT:  0o170
-- > DEC:  120
-- > HEX:  0x78
-- > HTML: &#120;
-- > Char: 'x'
_x :: Word8
_x :: Word8
_x = Word8
0x78

-- | Lowercase y
--
-- > BIN:  0b01111001
-- > OCT:  0o171
-- > DEC:  121
-- > HEX:  0x79
-- > HTML: &#121;
-- > Char: 'y'
_y :: Word8
_y :: Word8
_y = Word8
0x79

-- | Lowercase z
--
-- > BIN:  0b01111010
-- > OCT:  0o172
-- > DEC:  122
-- > HEX:  0x7A
-- > HTML: &#122;
-- > Char: 'z'
_z :: Word8
_z :: Word8
_z = Word8
0x7a

-- | Opening brace
--
-- > BIN:  0b01111011
-- > OCT:  0o173
-- > DEC:  123
-- > HEX:  0x7B
-- > HTML: &#123; or &lcub;
-- > Char: '{'
_braceleft :: Word8
_braceleft :: Word8
_braceleft = Word8
0x7b

-- | Vertical bar
--
-- > BIN:  0b01111100
-- > OCT:  0o174
-- > DEC:  124
-- > HEX:  0x7C
-- > HTML: &#124; or &verbar;
-- > Char: '|'
_bar :: Word8
_bar :: Word8
_bar = Word8
0x7c

-- | Closing brace
--
-- > BIN:  0b01111101
-- > OCT:  0o175
-- > DEC:  125
-- > HEX:  0x7D
-- > HTML: &#125; or &rcub;
-- > Char: '}'
_braceright :: Word8
_braceright :: Word8
_braceright = Word8
0x7d

-- | Equivalency sign - tilde
--
-- > BIN:  0b01111110
-- > OCT:  0o176
-- > DEC:  126
-- > HEX:  0x7E
-- > HTML: &#126; or &tilde;
-- > Char: '~'
_tilde :: Word8
_tilde :: Word8
_tilde = Word8
0x7e

-- | Delete
--
-- > BIN:  0b01111111
-- > OCT:  0o177
-- > DEC:  127
-- > HEX:  0x7F
-- > HTML: &#127;
-- > Char: '\DEL'
_del :: Word8
_del :: Word8
_del = Word8
0x7f

-- | Non-breaking space
--
-- > BIN:  0b10100000
-- > OCT:  0o240
-- > DEC:  160
-- > HEX:  0xA0
-- > HTML: &#160; or &nbsp;
_nbsp :: Word8
_nbsp :: Word8
_nbsp = Word8
0xa0

-- | Feminine ordinal indicator
--
-- > BIN:  0b10101010
-- > OCT:  0o252
-- > DEC:  170
-- > HEX:  0xAA
-- > HTML: &#170; or &ordf;
-- > Char: 'ª'
_ordfeminine :: Word8
_ordfeminine :: Word8
_ordfeminine = Word8
0xaa

-- | Soft hyphen
--
-- > BIN:  0b10101101
-- > OCT:  0o255
-- > DEC:  173
-- > HEX:  0xAD
-- > HTML: &#173; or &shy;
_softhyphen :: Word8
_softhyphen :: Word8
_softhyphen = Word8
0xad

-- | Micro sign (or greek letter mu)
--
-- > BIN:  0b10110101
-- > OCT:  0o265
-- > DEC:  181
-- > HEX:  0xB5
-- > HTML: &#181; or &micro;
-- > Char: 'µ'
_mu :: Word8
_mu :: Word8
_mu = Word8
0xb5

-- | Masculine ordinal indicator
--
-- > BIN:  0b10111010
-- > OCT:  0o272
-- > DEC:  186
-- > HEX:  0xBA
-- > HTML: &#186; or &ordm;
-- > Char: 'º'
_ordmasculine :: Word8
_ordmasculine :: Word8
_ordmasculine = Word8
0xba

-- | Superscript two - squared
--
-- > BIN:  0b10110010
-- > OCT:  0o262
-- > DEC:  178
-- > HEX:  0xB2
-- > HTML: &#178; or &sup2;
-- > Char: '²'
_s2 :: Word8
_s2 :: Word8
_s2 = Word8
0xb2

-- | Superscript three - cubed
--
-- > BIN:  0b10110011
-- > OCT:  0o263
-- > DEC:  179
-- > HEX:  0xB3
-- > HTML: &#179; or &sup3;
-- > Char: '³'
_s3 :: Word8
_s3 :: Word8
_s3 = Word8
0xb3

-- | Superscript one
--
-- > BIN:  0b10111001
-- > OCT:  0o271
-- > DEC:  185
-- > HEX:  0xB9
-- > HTML: &#185; or &sup1;
-- > Char: '¹'
_s1 :: Word8
_s1 :: Word8
_s1 = Word8
0xb9

-- | Fraction one quarter
--
-- > BIN:  0b10111100
-- > OCT:  0o274
-- > DEC:  188
-- > HEX:  0xBC
-- > HTML: &#188; or &frac14;
-- > Char: '¼'
_1'4 :: Word8
_1'4 :: Word8
_1'4 = Word8
0xbc

-- | Fraction one half
--
-- > BIN:  0b10111101
-- > OCT:  0o275
-- > DEC:  189
-- > HEX:  0xBD
-- > HTML: &#189; or &frac12;
-- > Char: '½'
_1'2 :: Word8
_1'2 :: Word8
_1'2 = Word8
0xbd

-- | Fraction three quarters
--
-- > BIN:  0b10111110
-- > OCT:  0o276
-- > DEC:  190
-- > HEX:  0xBE
-- > HTML: &#190; or &frac34;
-- > Char: '¾'
_3'4 :: Word8
_3'4 :: Word8
_3'4 = Word8
0xbe

-- | Latin capital letter A with grave
--
-- > BIN:  0b11000000
-- > OCT:  0o300
-- > DEC:  192
-- > HEX:  0xC0
-- > HTML: &#192; or &Agrave;
-- > Char: 'À'
_Agrave :: Word8
_Agrave :: Word8
_Agrave = Word8
0xc0

-- | Latin capital letter O with diaeresis
--
-- > BIN:  0b11010110
-- > OCT:  0o326
-- > DEC:  214
-- > HEX:  0xD6
-- > HTML: &#214; or &Ouml;
-- > Char: 'Ö'
_Odieresis :: Word8
_Odieresis :: Word8
_Odieresis = Word8
0xd6

-- | Latin capital letter O with slash
--
-- > BIN:  0b11011000
-- > OCT:  0o330
-- > DEC:  216
-- > HEX:  0xD8
-- > HTML: &#216; or &Oslash;
-- > Char: 'Ø'
_Oslash :: Word8
_Oslash :: Word8
_Oslash = Word8
0xd8

-- | Latin capital letter THORN
--
-- > BIN:  0b11011110
-- > OCT:  0o336
-- > DEC:  222
-- > HEX:  0xDE
-- > HTML: &#222; or &THORN;
-- > Char: 'Þ'
_Thorn :: Word8
_Thorn :: Word8
_Thorn = Word8
0xde

-- | Latin small letter sharp s - ess-zed
--
-- > BIN:  0b11011111
-- > OCT:  0o337
-- > DEC:  223
-- > HEX:  0xDF
-- > HTML: &#223; or &szlig;
-- > Char: 'ß'
_germandbls :: Word8
_germandbls :: Word8
_germandbls = Word8
0xdf

-- | Latin small letter a with grave
--
-- > BIN:  0b11100000
-- > OCT:  0o340
-- > DEC:  224
-- > HEX:  0xE0
-- > HTML: &#224; or &agrave;
-- > Char: 'à'
_agrave :: Word8
_agrave :: Word8
_agrave = Word8
0xe0

-- | Latin small letter o with diaeresis
--
-- > BIN:  0b11110110
-- > OCT:  0o366
-- > DEC:  246
-- > HEX:  0xF6
-- > HTML: &#246; or &ouml;
-- > Char: 'ö'
_odieresis :: Word8
_odieresis :: Word8
_odieresis = Word8
0xf6

-- | Latin small letter o with slash
--
-- > BIN:  0b11111000
-- > OCT:  0o370
-- > DEC:  248
-- > HEX:  0xF8
-- > HTML: &#248; or &oslash;
-- > Char: 'ø'
_oslash :: Word8
_oslash :: Word8
_oslash = Word8
0xf8

-- | Latin small letter thorn
--
-- > BIN:  0b11111110
-- > OCT:  0o376
-- > DEC:  254
-- > HEX:  0xFE
-- > HTML: &#254; or &thorn;
-- > Char: 'þ'
_thorn :: Word8
_thorn :: Word8
_thorn = Word8
0xfe

-- | Latin small letter y with diaeresis
--
-- > BIN:  0b11111111
-- > OCT:  0o377
-- > DEC:  255
-- > HEX:  0xFF
-- > HTML: &#255; or &yuml;
-- > Char: 'ÿ'
_ydieresis :: Word8
_ydieresis :: Word8
_ydieresis = Word8
0xff