{-# LANGUAGE Trustworthy #-}

{-|
Description:    Basic support for the Microsoft extension of Shift JIS.

Copyright:      (c) 2020-2021 Sam May
License:        GPL-3.0-or-later
Maintainer:     ag@eitilt.life

Stability:      stable
Portability:    portable

The CdText standard technically allows for data encoded as Shift JIS; I am
unaware of any discs produced with such data as no member of the libcdio-dev
mailing list (or any of the very few other resources) have Japanese imports,
but for completion the ability to read that encoding is required.  This module
provides a light-weight implementation modeled on the "Data.Text.Encoding"
UTF-8 interface.
-}
module Data.Text.Encoding.MsJIS
    ( -- * Types
      JISChar ( .. )
    , JISDecodeError ( .. )
    , JISEncodeError ( .. )
      -- * Transformations
      -- ** Decode
    , decodeMsJIS'
    , decodeMsJISWith
      -- ** Encode
    , encodeMsJIS'
    , encodeMsJISWith
    ) where


import qualified Data.ByteString as BS
import qualified Data.IntMap as M
import qualified Data.Maybe as Y
import qualified Data.Text as T
import qualified Data.Text.Encoding.Error as T
import qualified Data.Vector as V
import qualified Data.Word as W

import Data.Vector ( (!) )


-- | A shorthand categorization scheme for representing the effect of a single
-- byte in the absence of existing context.
data First
    = None
        -- ^ The byte is invalid, perhaps unless preceded by a lead byte.
    | Lone Char
        -- ^ It represents the given character when not preceded by a lead
        -- byte.
    | Lead
        -- ^ The representation is dependant on the next byte in the stream.
  deriving ( First -> First -> Bool
(First -> First -> Bool) -> (First -> First -> Bool) -> Eq First
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: First -> First -> Bool
$c/= :: First -> First -> Bool
== :: First -> First -> Bool
$c== :: First -> First -> Bool
Eq, Eq First
Eq First
-> (First -> First -> Ordering)
-> (First -> First -> Bool)
-> (First -> First -> Bool)
-> (First -> First -> Bool)
-> (First -> First -> Bool)
-> (First -> First -> First)
-> (First -> First -> First)
-> Ord First
First -> First -> Bool
First -> First -> Ordering
First -> First -> First
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: First -> First -> First
$cmin :: First -> First -> First
max :: First -> First -> First
$cmax :: First -> First -> First
>= :: First -> First -> Bool
$c>= :: First -> First -> Bool
> :: First -> First -> Bool
$c> :: First -> First -> Bool
<= :: First -> First -> Bool
$c<= :: First -> First -> Bool
< :: First -> First -> Bool
$c< :: First -> First -> Bool
compare :: First -> First -> Ordering
$ccompare :: First -> First -> Ordering
$cp1Ord :: Eq First
Ord, Int -> First -> ShowS
[First] -> ShowS
First -> String
(Int -> First -> ShowS)
-> (First -> String) -> ([First] -> ShowS) -> Show First
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [First] -> ShowS
$cshowList :: [First] -> ShowS
show :: First -> String
$cshow :: First -> String
showsPrec :: Int -> First -> ShowS
$cshowsPrec :: Int -> First -> ShowS
Show, ReadPrec [First]
ReadPrec First
Int -> ReadS First
ReadS [First]
(Int -> ReadS First)
-> ReadS [First]
-> ReadPrec First
-> ReadPrec [First]
-> Read First
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [First]
$creadListPrec :: ReadPrec [First]
readPrec :: ReadPrec First
$creadPrec :: ReadPrec First
readList :: ReadS [First]
$creadList :: ReadS [First]
readsPrec :: Int -> ReadS First
$creadsPrec :: Int -> ReadS First
Read )

-- | The characters which may be represented under the Shift JIS encoding.
-- Note that this type is only exposed as part of error reporting or recovery
-- functions, and is not intended as a replacement of 'Char'.
data JISChar
    = Single W.Word8
    | Double W.Word8 W.Word8
  deriving ( JISChar -> JISChar -> Bool
(JISChar -> JISChar -> Bool)
-> (JISChar -> JISChar -> Bool) -> Eq JISChar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JISChar -> JISChar -> Bool
$c/= :: JISChar -> JISChar -> Bool
== :: JISChar -> JISChar -> Bool
$c== :: JISChar -> JISChar -> Bool
Eq, Eq JISChar
Eq JISChar
-> (JISChar -> JISChar -> Ordering)
-> (JISChar -> JISChar -> Bool)
-> (JISChar -> JISChar -> Bool)
-> (JISChar -> JISChar -> Bool)
-> (JISChar -> JISChar -> Bool)
-> (JISChar -> JISChar -> JISChar)
-> (JISChar -> JISChar -> JISChar)
-> Ord JISChar
JISChar -> JISChar -> Bool
JISChar -> JISChar -> Ordering
JISChar -> JISChar -> JISChar
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: JISChar -> JISChar -> JISChar
$cmin :: JISChar -> JISChar -> JISChar
max :: JISChar -> JISChar -> JISChar
$cmax :: JISChar -> JISChar -> JISChar
>= :: JISChar -> JISChar -> Bool
$c>= :: JISChar -> JISChar -> Bool
> :: JISChar -> JISChar -> Bool
$c> :: JISChar -> JISChar -> Bool
<= :: JISChar -> JISChar -> Bool
$c<= :: JISChar -> JISChar -> Bool
< :: JISChar -> JISChar -> Bool
$c< :: JISChar -> JISChar -> Bool
compare :: JISChar -> JISChar -> Ordering
$ccompare :: JISChar -> JISChar -> Ordering
$cp1Ord :: Eq JISChar
Ord, Int -> JISChar -> ShowS
[JISChar] -> ShowS
JISChar -> String
(Int -> JISChar -> ShowS)
-> (JISChar -> String) -> ([JISChar] -> ShowS) -> Show JISChar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JISChar] -> ShowS
$cshowList :: [JISChar] -> ShowS
show :: JISChar -> String
$cshow :: JISChar -> String
showsPrec :: Int -> JISChar -> ShowS
$cshowsPrec :: Int -> JISChar -> ShowS
Show, ReadPrec [JISChar]
ReadPrec JISChar
Int -> ReadS JISChar
ReadS [JISChar]
(Int -> ReadS JISChar)
-> ReadS [JISChar]
-> ReadPrec JISChar
-> ReadPrec [JISChar]
-> Read JISChar
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [JISChar]
$creadListPrec :: ReadPrec [JISChar]
readPrec :: ReadPrec JISChar
$creadPrec :: ReadPrec JISChar
readList :: ReadS [JISChar]
$creadList :: ReadS [JISChar]
readsPrec :: Int -> ReadS JISChar
$creadsPrec :: Int -> ReadS JISChar
Read )
instance Bounded JISChar where
    minBound :: JISChar
minBound = Word8 -> JISChar
Single Word8
forall a. Bounded a => a
minBound
    maxBound :: JISChar
maxBound = Word8 -> Word8 -> JISChar
Double Word8
0xFC Word8
0xFC
-- | Ignores the three invalid single-byte characters @"\xFD\xFE\xFF"@, and any
-- double-byte characters outside the primary range
-- @([0x81..0x9F]++[0xE0..0xFC], [0x40..0xFC])@.  'fromEnum' any such "invalid"
-- characters will overlap with the canonical characters, and the result should
-- not be relied upon to remain consistent between versions.
-- 
-- >>> succ $ Single 0xFC
-- Double 0x81 0x40
-- 
-- >>> succ $ Double 0x9F 0xFC
-- Double 0xE0 0x40
instance Enum JISChar where
    toEnum :: Int -> JISChar
toEnum Int
i
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0xFC = Word8 -> JISChar
Single (Word8 -> JISChar) -> Word8 -> JISChar
forall a b. (a -> b) -> a -> b
$ Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i
        | Bool
otherwise = Word8 -> Word8 -> JISChar
Double Word8
l Word8
t
      where (Int
d, Int
m) = Int -> Int -> (Int, Int)
forall a. Integral a => a -> a -> (a, a)
divMod (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
0xFD) Int
0xBC
            l :: Word8
l = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
d Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
+ if Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0x1F
                -- First index of second table group (0xE0) minus first value of d here (0x1F)
                then Word8
0xC1
                -- First index of first table group
                else Word8
0x81
            -- First byte in trail tables
            t :: Word8
t = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
m Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
+ Word8
0x40
    fromEnum :: JISChar -> Int
fromEnum (Single Word8
c) = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
c
    -- Underlying: @s + (l' * x) + (t - y) + 1@
    -- 
    -- s = Last single char (0xFC)
    -- l' = Table index (in [0x81..0x9F]++[0xE0..0xFC]): @l - w@
    -- l = Lead byte
    -- w = First byte of either first group (0x81) or second (0xE0)
    -- x = Length of tables (0xBC)
    -- t = Trail byte
    -- y = First byte in trail tables (0x40)
    -- 
    -- s - y + 1 = 0xBD
    fromEnum (Double Word8
l Word8
t) = (Int
l' Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
0xBC) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
t Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
0xBD
      where l' :: Int
l' = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
l Int -> Int -> Int
forall a. Num a => a -> a -> a
- if Word8
l Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
> Word8
0x9F then Int
0xE0 else Int
0x81


-- | The given one- or two- byte sequence was unable to be decoded; the error
-- may be described by the unstructured text.
data JISDecodeError = JISDecodeError String (Maybe JISChar)
  deriving ( JISDecodeError -> JISDecodeError -> Bool
(JISDecodeError -> JISDecodeError -> Bool)
-> (JISDecodeError -> JISDecodeError -> Bool) -> Eq JISDecodeError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JISDecodeError -> JISDecodeError -> Bool
$c/= :: JISDecodeError -> JISDecodeError -> Bool
== :: JISDecodeError -> JISDecodeError -> Bool
$c== :: JISDecodeError -> JISDecodeError -> Bool
Eq, Int -> JISDecodeError -> ShowS
[JISDecodeError] -> ShowS
JISDecodeError -> String
(Int -> JISDecodeError -> ShowS)
-> (JISDecodeError -> String)
-> ([JISDecodeError] -> ShowS)
-> Show JISDecodeError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JISDecodeError] -> ShowS
$cshowList :: [JISDecodeError] -> ShowS
show :: JISDecodeError -> String
$cshow :: JISDecodeError -> String
showsPrec :: Int -> JISDecodeError -> ShowS
$cshowsPrec :: Int -> JISDecodeError -> ShowS
Show, ReadPrec [JISDecodeError]
ReadPrec JISDecodeError
Int -> ReadS JISDecodeError
ReadS [JISDecodeError]
(Int -> ReadS JISDecodeError)
-> ReadS [JISDecodeError]
-> ReadPrec JISDecodeError
-> ReadPrec [JISDecodeError]
-> Read JISDecodeError
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [JISDecodeError]
$creadListPrec :: ReadPrec [JISDecodeError]
readPrec :: ReadPrec JISDecodeError
$creadPrec :: ReadPrec JISDecodeError
readList :: ReadS [JISDecodeError]
$creadList :: ReadS [JISDecodeError]
readsPrec :: Int -> ReadS JISDecodeError
$creadsPrec :: Int -> ReadS JISDecodeError
Read )

-- | The given character was unable to be serialized in binary form; this is
-- almost certainly due to it not being included in Shift JIS, but the error is
-- described by the unstructured text anyway.
data JISEncodeError = JISEncodeError String (Maybe Char)
  deriving ( JISEncodeError -> JISEncodeError -> Bool
(JISEncodeError -> JISEncodeError -> Bool)
-> (JISEncodeError -> JISEncodeError -> Bool) -> Eq JISEncodeError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JISEncodeError -> JISEncodeError -> Bool
$c/= :: JISEncodeError -> JISEncodeError -> Bool
== :: JISEncodeError -> JISEncodeError -> Bool
$c== :: JISEncodeError -> JISEncodeError -> Bool
Eq, Int -> JISEncodeError -> ShowS
[JISEncodeError] -> ShowS
JISEncodeError -> String
(Int -> JISEncodeError -> ShowS)
-> (JISEncodeError -> String)
-> ([JISEncodeError] -> ShowS)
-> Show JISEncodeError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JISEncodeError] -> ShowS
$cshowList :: [JISEncodeError] -> ShowS
show :: JISEncodeError -> String
$cshow :: JISEncodeError -> String
showsPrec :: Int -> JISEncodeError -> ShowS
$cshowsPrec :: Int -> JISEncodeError -> ShowS
Show, ReadPrec [JISEncodeError]
ReadPrec JISEncodeError
Int -> ReadS JISEncodeError
ReadS [JISEncodeError]
(Int -> ReadS JISEncodeError)
-> ReadS [JISEncodeError]
-> ReadPrec JISEncodeError
-> ReadPrec [JISEncodeError]
-> Read JISEncodeError
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [JISEncodeError]
$creadListPrec :: ReadPrec [JISEncodeError]
readPrec :: ReadPrec JISEncodeError
$creadPrec :: ReadPrec JISEncodeError
readList :: ReadS [JISEncodeError]
$creadList :: ReadS [JISEncodeError]
readsPrec :: Int -> ReadS JISEncodeError
$creadsPrec :: Int -> ReadS JISEncodeError
Read )


-- | Lookup table for the broad category a byte falls into when not preceded
-- by a lead byte.
type FirstByteTable = V.Vector First

-- | The characters a two-byte sequence may decode to under the context of a
-- given lead byte.
type SecondByteTable = V.Vector (Maybe Char)


-- | Transform a 'BS.ByteString' into unambiguous 'Char's according to
-- Microsoft's extension of the Shift JIS encoding scheme.
--
-- If the input contains any invalid sequences under that scheme, the first
-- byte(s) which triggered an error will be returned instead.
decodeMsJIS' :: BS.ByteString -> Either JISDecodeError T.Text
decodeMsJIS' :: ByteString -> Either JISDecodeError Text
decodeMsJIS' = (String -> Text)
-> Either JISDecodeError String -> Either JISDecodeError Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> Text
T.pack (Either JISDecodeError String -> Either JISDecodeError Text)
-> (ByteString -> Either JISDecodeError String)
-> ByteString
-> Either JISDecodeError Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> Either JISDecodeError String
decodeMsJIS'' ([Word8] -> Either JISDecodeError String)
-> (ByteString -> [Word8])
-> ByteString
-> Either JISDecodeError String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Word8]
BS.unpack

-- | Iterate through the byte stream, consuming one or two bytes each cycle as
-- required to decode a Shift JIS character.
--
-- If the input contains any invalid sequences under that scheme, the first
-- byte(s) which triggered an error will be returned instead.
decodeMsJIS'' :: [W.Word8] -> Either JISDecodeError String
decodeMsJIS'' :: [Word8] -> Either JISDecodeError String
decodeMsJIS'' [] = String -> Either JISDecodeError String
forall a b. b -> Either a b
Right String
""
decodeMsJIS'' (Word8
b1:[Word8]
bs) = case Word8 -> Maybe Word8 -> (Either JISDecodeError Char, Bool)
lookupJIS Word8
b1 (Maybe Word8 -> (Either JISDecodeError Char, Bool))
-> Maybe Word8 -> (Either JISDecodeError Char, Bool)
forall a b. (a -> b) -> a -> b
$ [Word8] -> Maybe Word8
forall a. [a] -> Maybe a
Y.listToMaybe [Word8]
bs of
    (Left JISDecodeError
err, Bool
_) -> JISDecodeError -> Either JISDecodeError String
forall a b. a -> Either a b
Left JISDecodeError
err
    (Right Char
c, Bool
w) -> ShowS
-> Either JISDecodeError String -> Either JISDecodeError String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Char
c Char -> ShowS
forall a. a -> [a] -> [a]
:) (Either JISDecodeError String -> Either JISDecodeError String)
-> ([Word8] -> Either JISDecodeError String)
-> [Word8]
-> Either JISDecodeError String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> Either JISDecodeError String
decodeMsJIS'' ([Word8] -> Either JISDecodeError String)
-> [Word8] -> Either JISDecodeError String
forall a b. (a -> b) -> a -> b
$ if Bool
w then Int -> [Word8] -> [Word8]
forall a. Int -> [a] -> [a]
drop Int
1 [Word8]
bs else [Word8]
bs


-- | Transform a 'BS.ByteString' into unambiguous 'Char's according to
-- Microsoft's extension of the Shift JIS encoding scheme.
decodeMsJISWith :: T.OnError JISChar Char -> BS.ByteString -> T.Text
decodeMsJISWith :: OnError JISChar Char -> ByteString -> Text
decodeMsJISWith OnError JISChar Char
e = String -> Text
T.pack (String -> Text) -> (ByteString -> String) -> ByteString -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OnError JISChar Char -> [Word8] -> String
decodeMsJISWith' OnError JISChar Char
e ([Word8] -> String)
-> (ByteString -> [Word8]) -> ByteString -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Word8]
BS.unpack

-- | Iterate through the byte stream, consuming one or two bytes each cycle as
-- required to decode a Shift JIS character.
decodeMsJISWith' :: T.OnError JISChar Char -> [W.Word8] -> String
decodeMsJISWith' :: OnError JISChar Char -> [Word8] -> String
decodeMsJISWith' OnError JISChar Char
_ [] = String
""
decodeMsJISWith' OnError JISChar Char
e (Word8
b1:[Word8]
bs) = case Word8 -> Maybe Word8 -> (Either JISDecodeError Char, Bool)
lookupJIS Word8
b1 (Maybe Word8 -> (Either JISDecodeError Char, Bool))
-> Maybe Word8 -> (Either JISDecodeError Char, Bool)
forall a b. (a -> b) -> a -> b
$ [Word8] -> Maybe Word8
forall a. [a] -> Maybe a
Y.listToMaybe [Word8]
bs of
    (Left (JISDecodeError String
msg Maybe JISChar
err), Bool
w) -> String -> (Char -> String) -> Maybe Char -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Bool -> String
loop Bool
w) (Char -> ShowS
forall a. a -> [a] -> [a]
: Bool -> String
loop Bool
w) (Maybe Char -> String) -> Maybe Char -> String
forall a b. (a -> b) -> a -> b
$ OnError JISChar Char
e String
msg Maybe JISChar
err
    (Right Char
c, Bool
w) -> Char
c Char -> ShowS
forall a. a -> [a] -> [a]
: Bool -> String
loop Bool
w
  where loop :: Bool -> String
loop Bool
_ | [Word8] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Word8]
bs = String
""
        loop Bool
w = OnError JISChar Char -> [Word8] -> String
decodeMsJISWith' OnError JISChar Char
e ([Word8] -> String) -> [Word8] -> String
forall a b. (a -> b) -> a -> b
$ if Bool
w then Int -> [Word8] -> [Word8]
forall a. Int -> [a] -> [a]
drop Int
1 [Word8]
bs else [Word8]
bs


-- | Transform an unambiguous string into a binary stream according to
-- Microsoft's extension of the Shift JIS encoding scheme.
--
-- If the input contains any characters without an associated binary sequence
-- under that scheme, the first such character which triggers the error will be
-- returned instead.
encodeMsJIS' :: T.Text -> Either JISEncodeError BS.ByteString
encodeMsJIS' :: Text -> Either JISEncodeError ByteString
encodeMsJIS' = (Either JISEncodeError ByteString
 -> Char -> Either JISEncodeError ByteString)
-> Either JISEncodeError ByteString
-> Text
-> Either JISEncodeError ByteString
forall a. (a -> Char -> a) -> a -> Text -> a
T.foldl' (\Either JISEncodeError ByteString
bs -> Either JISEncodeError ByteString
-> Either (Maybe Char) ByteString
-> Either JISEncodeError ByteString
forall b.
Monoid b =>
Either JISEncodeError b
-> Either (Maybe Char) b -> Either JISEncodeError b
throwEncode Either JISEncodeError ByteString
bs (Either (Maybe Char) ByteString
 -> Either JISEncodeError ByteString)
-> (Char -> Either (Maybe Char) ByteString)
-> Char
-> Either JISEncodeError ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either Char [ByteString] -> Either (Maybe Char) ByteString
flatten (Either Char [ByteString] -> Either (Maybe Char) ByteString)
-> (Char -> Either Char [ByteString])
-> Char
-> Either (Maybe Char) ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Either Char [ByteString]
lookupUnicode) (ByteString -> Either JISEncodeError ByteString
forall a b. b -> Either a b
Right ByteString
BS.empty)
  where throwEncode :: Either JISEncodeError b
-> Either (Maybe Char) b -> Either JISEncodeError b
throwEncode e :: Either JISEncodeError b
e@(Left JISEncodeError
_) Either (Maybe Char) b
_ = Either JISEncodeError b
e
        throwEncode Either JISEncodeError b
_ (Left Maybe Char
c) = JISEncodeError -> Either JISEncodeError b
forall a b. a -> Either a b
Left (JISEncodeError -> Either JISEncodeError b)
-> JISEncodeError -> Either JISEncodeError b
forall a b. (a -> b) -> a -> b
$ String -> Maybe Char -> JISEncodeError
JISEncodeError (ShowS
encodeErrorString String
"encodeMsJIS'") Maybe Char
c
        throwEncode (Right b
bs) (Right b
bs') = b -> Either JISEncodeError b
forall a b. b -> Either a b
Right (b -> Either JISEncodeError b) -> b -> Either JISEncodeError b
forall a b. (a -> b) -> a -> b
$ b -> b -> b
forall a. Monoid a => a -> a -> a
mappend b
bs b
bs'

-- | Transform an unambiguous string into a binary stream according to
-- Microsoft's extension of the Shift JIS encoding scheme.
encodeMsJISWith :: T.OnError Char BS.ByteString -> T.Text -> BS.ByteString
encodeMsJISWith :: OnError Char ByteString -> Text -> ByteString
encodeMsJISWith OnError Char ByteString
e = (ByteString -> Char -> ByteString)
-> ByteString -> Text -> ByteString
forall a. (a -> Char -> a) -> a -> Text -> a
T.foldl' (\ByteString
bs -> ByteString -> Either (Maybe Char) ByteString -> ByteString
throwEncode ByteString
bs (Either (Maybe Char) ByteString -> ByteString)
-> (Char -> Either (Maybe Char) ByteString) -> Char -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either Char [ByteString] -> Either (Maybe Char) ByteString
flatten (Either Char [ByteString] -> Either (Maybe Char) ByteString)
-> (Char -> Either Char [ByteString])
-> Char
-> Either (Maybe Char) ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Either Char [ByteString]
lookupUnicode) ByteString
BS.empty
  where throwEncode :: ByteString -> Either (Maybe Char) ByteString -> ByteString
throwEncode ByteString
bs (Left Maybe Char
c) = ByteString -> Maybe ByteString -> ByteString
forall a. a -> Maybe a -> a
Y.fromMaybe ByteString
bs (Maybe ByteString -> ByteString) -> Maybe ByteString -> ByteString
forall a b. (a -> b) -> a -> b
$ OnError Char ByteString
e (ShowS
encodeErrorString String
"encodeMsJISWith") Maybe Char
c
        throwEncode ByteString
bs (Right ByteString
bs') = ByteString -> ByteString -> ByteString
forall a. Monoid a => a -> a -> a
mappend ByteString
bs ByteString
bs'

-- | There is only a single reason why encoding to Shift JIS may fail.
encodeErrorString :: String -> String
encodeErrorString :: ShowS
encodeErrorString String
func = String
func String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
": Character not in MS JIS"

-- | Rewrap the result of a character-to-binary lookup into a form suitable for
-- 'JISEncodeError'.
flatten :: Either Char [BS.ByteString] -> Either (Maybe Char) BS.ByteString
flatten :: Either Char [ByteString] -> Either (Maybe Char) ByteString
flatten (Right []) = Maybe Char -> Either (Maybe Char) ByteString
forall a b. a -> Either a b
Left Maybe Char
forall a. Maybe a
Nothing
flatten (Right (ByteString
bs:[ByteString]
_)) = ByteString -> Either (Maybe Char) ByteString
forall a b. b -> Either a b
Right ByteString
bs
flatten (Left Char
e) = Maybe Char -> Either (Maybe Char) ByteString
forall a b. a -> Either a b
Left (Maybe Char -> Either (Maybe Char) ByteString)
-> Maybe Char -> Either (Maybe Char) ByteString
forall a b. (a -> b) -> a -> b
$ Char -> Maybe Char
forall a. a -> Maybe a
Just Char
e


-- | The broad categories defining the behaviour of a byte in the Shift JIS
-- encoding scheme, in the absence of any existing context.  May be safely
-- indexed using any integer fitting into eight bits:
--
-- >>> length firstBytes
-- 255
firstBytes :: FirstByteTable
firstBytes :: FirstByteTable
firstBytes = [First] -> FirstByteTable
forall a. [a] -> Vector a
V.fromList ([First] -> FirstByteTable) -> [First] -> FirstByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x00..0x7F-}  (Char -> First) -> String -> [First]
forall a b. (a -> b) -> [a] -> [b]
map Char -> First
Lone [Char
'\NUL'..Char
'\DEL'] [First] -> [First] -> [First]
forall a. [a] -> [a] -> [a]
++
    {-0x80..0x9F-}  First
None First -> [First] -> [First]
forall a. a -> [a] -> [a]
: Int -> First -> [First]
forall a. Int -> a -> [a]
replicate Int
0x1F First
Lead [First] -> [First] -> [First]
forall a. [a] -> [a] -> [a]
++
    {-0xA0..0xDF-}  First
None First -> [First] -> [First]
forall a. a -> [a] -> [a]
: (Char -> First) -> String -> [First]
forall a b. (a -> b) -> [a] -> [b]
map Char -> First
Lone [Char
'\xFF61'..Char
'\xFF9F'] [First] -> [First] -> [First]
forall a. [a] -> [a] -> [a]
++
    {-0xE0..0xFC-}  Int -> First -> [First]
forall a. Int -> a -> [a]
replicate Int
0x1D First
Lead [First] -> [First] -> [First]
forall a. [a] -> [a] -> [a]
++
    {-0xFD..0xFF-}  Int -> First -> [First]
forall a. Int -> a -> [a]
replicate Int
3 First
None

-- | The lookup tables describing the representation of any valid two-byte
-- sequence in the Shift JIS encoding scheme.  As not every byte is a valid
-- lead byte (and thus may not have an indexed table), @lookupTrailTable@ is
-- recommended rather than direct indexing.  The presence or absence of a valid
-- character does not affect whether the subtable may be safely indexed:
--
-- >>> V.all ((==) 0xBC . length) secondBytes
-- True
secondBytes :: V.Vector SecondByteTable
secondBytes :: Vector SecondByteTable
secondBytes = [SecondByteTable] -> Vector SecondByteTable
forall a. [a] -> Vector a
V.fromList ([SecondByteTable] -> Vector SecondByteTable)
-> [SecondByteTable] -> Vector SecondByteTable
forall a b. (a -> b) -> a -> b
$
    [ SecondByteTable
second81, SecondByteTable
second82, SecondByteTable
second83, SecondByteTable
second84, SecondByteTable
second85, SecondByteTable
second86, SecondByteTable
second87 ] [SecondByteTable] -> [SecondByteTable] -> [SecondByteTable]
forall a. [a] -> [a] -> [a]
++
    [ SecondByteTable
second88, SecondByteTable
second89, SecondByteTable
second8A, SecondByteTable
second8B, SecondByteTable
second8C, SecondByteTable
second8D, SecondByteTable
second8E, SecondByteTable
second8F ] [SecondByteTable] -> [SecondByteTable] -> [SecondByteTable]
forall a. [a] -> [a] -> [a]
++
    [ SecondByteTable
second90, SecondByteTable
second91, SecondByteTable
second92, SecondByteTable
second93, SecondByteTable
second94, SecondByteTable
second95, SecondByteTable
second96, SecondByteTable
second97 ] [SecondByteTable] -> [SecondByteTable] -> [SecondByteTable]
forall a. [a] -> [a] -> [a]
++
    [ SecondByteTable
second98, SecondByteTable
second99, SecondByteTable
second9A, SecondByteTable
second9B, SecondByteTable
second9C, SecondByteTable
second9D, SecondByteTable
second9E, SecondByteTable
second9F ] [SecondByteTable] -> [SecondByteTable] -> [SecondByteTable]
forall a. [a] -> [a] -> [a]
++
    [ SecondByteTable
secondE0, SecondByteTable
secondE1, SecondByteTable
secondE2, SecondByteTable
secondE3, SecondByteTable
secondE4, SecondByteTable
secondE5, SecondByteTable
secondE6, SecondByteTable
secondE7 ] [SecondByteTable] -> [SecondByteTable] -> [SecondByteTable]
forall a. [a] -> [a] -> [a]
++
    [ SecondByteTable
secondE8, SecondByteTable
secondE9, SecondByteTable
secondEA, SecondByteTable
secondEB, SecondByteTable
secondEC, SecondByteTable
secondED, SecondByteTable
secondEE, SecondByteTable
secondEF ] [SecondByteTable] -> [SecondByteTable] -> [SecondByteTable]
forall a. [a] -> [a] -> [a]
++
    [ SecondByteTable
secondF0, SecondByteTable
secondF1, SecondByteTable
secondF2, SecondByteTable
secondF3, SecondByteTable
secondF4, SecondByteTable
secondF5, SecondByteTable
secondF6, SecondByteTable
secondF7 ] [SecondByteTable] -> [SecondByteTable] -> [SecondByteTable]
forall a. [a] -> [a] -> [a]
++
    [ SecondByteTable
secondF8, SecondByteTable
secondF9, SecondByteTable
secondFA, SecondByteTable
secondFB, SecondByteTable
secondFC ]

-- | Try to decode a one- or two-byte sequence to an unambiguous character
-- according to the Shift JIS encoding scheme.  Returns a 'Bool' indicating
-- whether the second byte was used in decoding the 'Char' (i.e., 'False'
-- indicates that the next character starts /on/ the second byte given rather
-- than /after/ it).
lookupJIS :: W.Word8 -> Maybe W.Word8 -> (Either JISDecodeError Char, Bool)
lookupJIS :: Word8 -> Maybe Word8 -> (Either JISDecodeError Char, Bool)
lookupJIS Word8
l Maybe Word8
t' = case (Word8 -> LeadResult
lookupLead Word8
l, Maybe Word8
t') of
    (SingleByte Char
c, Maybe Word8
_) -> (Char -> Either JISDecodeError Char
forall a b. b -> Either a b
Right Char
c, Bool
False)
    (MultiByte SecondByteTable
_, Maybe Word8
Nothing) -> (String -> JISChar -> Either JISDecodeError Char
forall b. String -> JISChar -> Either JISDecodeError b
err String
"Input ended without trail byte" (JISChar -> Either JISDecodeError Char)
-> JISChar -> Either JISDecodeError Char
forall a b. (a -> b) -> a -> b
$ Word8 -> JISChar
Single Word8
l, Bool
False)
    (MultiByte SecondByteTable
ts, Just Word8
t) ->
        let found :: Maybe Char
found = SecondByteTable
ts SecondByteTable -> Int -> Maybe Char
forall a. Vector a -> Int -> a
! (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
t Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
0x40)
        in (Either JISDecodeError Char
-> (Char -> Either JISDecodeError Char)
-> Maybe Char
-> Either JISDecodeError Char
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> JISChar -> Either JISDecodeError Char
forall b. String -> JISChar -> Either JISDecodeError b
err String
"Unassigned trail byte" (JISChar -> Either JISDecodeError Char)
-> JISChar -> Either JISDecodeError Char
forall a b. (a -> b) -> a -> b
$ Word8 -> Word8 -> JISChar
Double Word8
l Word8
t) Char -> Either JISDecodeError Char
forall a b. b -> Either a b
Right Maybe Char
found, Bool
True)
    (NoChar JISDecodeError
e, Maybe Word8
_) -> (JISDecodeError -> Either JISDecodeError Char
forall a b. a -> Either a b
Left JISDecodeError
e, Bool
False)
  where err :: String -> JISChar -> Either JISDecodeError b
err String
msg JISChar
char = JISDecodeError -> Either JISDecodeError b
forall a b. a -> Either a b
Left (JISDecodeError -> Either JISDecodeError b)
-> (Maybe JISChar -> JISDecodeError)
-> Maybe JISChar
-> Either JISDecodeError b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Maybe JISChar -> JISDecodeError
JISDecodeError (String
"lookupJIS: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
msg) (Maybe JISChar -> Either JISDecodeError b)
-> Maybe JISChar -> Either JISDecodeError b
forall a b. (a -> b) -> a -> b
$ JISChar -> Maybe JISChar
forall a. a -> Maybe a
Just JISChar
char

-- | Given the first byte in a (potentially multibyte) Shift JIS binary
-- representation, try to retrieve the associated character.
lookupLead :: W.Word8 -> LeadResult
lookupLead :: Word8 -> LeadResult
lookupLead Word8
w = case FirstByteTable
firstBytes FirstByteTable -> Int -> First
forall a. Vector a -> Int -> a
! Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
w of
    Lone Char
c -> Char -> LeadResult
SingleByte Char
c
    First
Lead -> LeadResult
-> (SecondByteTable -> LeadResult)
-> Maybe SecondByteTable
-> LeadResult
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> LeadResult
err String
"Invalid lead byte") SecondByteTable -> LeadResult
MultiByte (Maybe SecondByteTable -> LeadResult)
-> Maybe SecondByteTable -> LeadResult
forall a b. (a -> b) -> a -> b
$ Word8 -> Maybe SecondByteTable
lookupTrailTable Word8
w
    First
None -> String -> LeadResult
err String
"Unassigned lead byte"
  where err :: String -> LeadResult
err String
msg = JISDecodeError -> LeadResult
NoChar (JISDecodeError -> LeadResult)
-> (JISChar -> JISDecodeError) -> JISChar -> LeadResult
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Maybe JISChar -> JISDecodeError
JISDecodeError (String
"lookupJIS: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
msg) (Maybe JISChar -> JISDecodeError)
-> (JISChar -> Maybe JISChar) -> JISChar -> JISDecodeError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JISChar -> Maybe JISChar
forall a. a -> Maybe a
Just (JISChar -> LeadResult) -> JISChar -> LeadResult
forall a b. (a -> b) -> a -> b
$ Word8 -> JISChar
Single Word8
w

-- | The potential values which may result from looking up a single byte in the
-- Shift JIS scheme without any preceding context.
data LeadResult
    = SingleByte Char
        -- ^ The byte represents a complete character.
    | MultiByte SecondByteTable
        -- ^ The byte indicates one of a set of characters which may only be
        -- disambiguated by the next byte in the stream.
    | NoChar JISDecodeError
        -- ^ The byte itself is invalid.

-- | Given the first byte in a multibyte Shift JIS binary representation, look
-- up what characters may be represented depending on the following byte in the
-- stream.  If the input is not a valid lead byte, 'Nothing' is returned
-- instead.  The presence or absence of a valid character does not affect
-- whether the subtable may be safely indexed (but note that position @0@ is
-- associated with byte @0x40@):
--
-- >>> maybe True ((==) 0xBC . length) $ lookupTrailTable b
-- True
lookupTrailTable :: W.Word8 -> Maybe SecondByteTable
lookupTrailTable :: Word8 -> Maybe SecondByteTable
lookupTrailTable Word8
l
    | Word8
l Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
< Word8
0x81 Bool -> Bool -> Bool
||
        (Word8
l Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
> Word8
0x9F Bool -> Bool -> Bool
&& Word8
l Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
< Word8
0xE0) Bool -> Bool -> Bool
||
        Word8
l Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
> Word8
0xFC = Maybe SecondByteTable
forall a. Maybe a
Nothing
    | Word8
l Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
0x9F = SecondByteTable -> Maybe SecondByteTable
forall a. a -> Maybe a
Just (SecondByteTable -> Maybe SecondByteTable)
-> SecondByteTable -> Maybe SecondByteTable
forall a b. (a -> b) -> a -> b
$ Vector SecondByteTable
secondBytes Vector SecondByteTable -> Int -> SecondByteTable
forall a. Vector a -> Int -> a
! (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
l Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
0x81)
    | Bool
otherwise = SecondByteTable -> Maybe SecondByteTable
forall a. a -> Maybe a
Just (SecondByteTable -> Maybe SecondByteTable)
-> SecondByteTable -> Maybe SecondByteTable
forall a b. (a -> b) -> a -> b
$ Vector SecondByteTable
secondBytes Vector SecondByteTable -> Int -> SecondByteTable
forall a. Vector a -> Int -> a
! (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
l Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
0xC1)



-- | The lookup table from Unicode character reference number to Shift JIS
-- binary representation.
unicodeMap :: M.IntMap [JISChar]
unicodeMap :: IntMap [JISChar]
unicodeMap = ([JISChar] -> [JISChar] -> [JISChar])
-> [(Int, [JISChar])] -> IntMap [JISChar]
forall a. (a -> a -> a) -> [(Int, a)] -> IntMap a
M.fromListWith [JISChar] -> [JISChar] -> [JISChar]
forall a. [a] -> [a] -> [a]
(++) ([(Int, [JISChar])] -> IntMap [JISChar])
-> (Vector (Int, [JISChar]) -> [(Int, [JISChar])])
-> Vector (Int, [JISChar])
-> IntMap [JISChar]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector (Int, [JISChar]) -> [(Int, [JISChar])]
forall a. Vector a -> [a]
V.toList (Vector (Int, [JISChar]) -> IntMap [JISChar])
-> Vector (Int, [JISChar]) -> IntMap [JISChar]
forall a b. (a -> b) -> a -> b
$
    (Int -> First -> Maybe (Int, [JISChar]))
-> FirstByteTable -> Vector (Int, [JISChar])
forall a b. (Int -> a -> Maybe b) -> Vector a -> Vector b
V.imapMaybe Int -> First -> Maybe (Int, [JISChar])
keyFirsts FirstByteTable
firstBytes Vector (Int, [JISChar])
-> Vector (Int, [JISChar]) -> Vector (Int, [JISChar])
forall a. Vector a -> Vector a -> Vector a
V.++ [Vector (Int, [JISChar])] -> Vector (Int, [JISChar])
forall a. [Vector a] -> Vector a
V.concat (Vector (Vector (Int, [JISChar])) -> [Vector (Int, [JISChar])]
forall a. Vector a -> [a]
V.toList (Vector (Vector (Int, [JISChar])) -> [Vector (Int, [JISChar])])
-> Vector (Vector (Int, [JISChar])) -> [Vector (Int, [JISChar])]
forall a b. (a -> b) -> a -> b
$ (Int -> SecondByteTable -> Vector (Int, [JISChar]))
-> Vector SecondByteTable -> Vector (Vector (Int, [JISChar]))
forall a b. (Int -> a -> b) -> Vector a -> Vector b
V.imap Int -> SecondByteTable -> Vector (Int, [JISChar])
keySeconds Vector SecondByteTable
secondBytes)

-- | Transformation function to obtain a lookup-tuple from a single-byte Shift
-- JIS representation.
keyFirsts
    :: Int
        -- ^ The index (i.e., the byte itself) in the list of single- and
        -- lead-byte categories.
    -> First
        -- ^ The category associated with that byte; everything /except/ @Lone@
        -- bytes will be ignored.
    -> Maybe (M.Key, [JISChar])
keyFirsts :: Int -> First -> Maybe (Int, [JISChar])
keyFirsts Int
l (Lone Char
j) = (Int, [JISChar]) -> Maybe (Int, [JISChar])
forall a. a -> Maybe a
Just (Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
j, [Word8 -> JISChar
Single (Word8 -> JISChar) -> Word8 -> JISChar
forall a b. (a -> b) -> a -> b
$ Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
l])
keyFirsts Int
_ First
_ = Maybe (Int, [JISChar])
forall a. Maybe a
Nothing

-- | Transformation function to obtain all lookup-tuples of double-byte Shift
-- JIS representations beginning with the given byte.
keySeconds
    :: Int
        -- ^ The index (i.e., the byte itself) in the list of single- and
        -- lead-byte categories.
    -> SecondByteTable
        -- ^ The trailing-byte lookup table associated with that lead byte.
    -> V.Vector (M.Key, [JISChar])
keySeconds :: Int -> SecondByteTable -> Vector (Int, [JISChar])
keySeconds Int
l = (Int -> Maybe Char -> Maybe (Int, [JISChar]))
-> SecondByteTable -> Vector (Int, [JISChar])
forall a b. (Int -> a -> Maybe b) -> Vector a -> Vector b
V.imapMaybe (\Int
t Maybe Char
j -> JISChar -> Char -> (Int, [JISChar])
forall a a. Enum a => a -> a -> (Int, [a])
m (Word8 -> Word8 -> JISChar
Double Word8
l' (Word8 -> JISChar) -> Word8 -> JISChar
forall a b. (a -> b) -> a -> b
$ Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
t Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
+ Word8
0x40) (Char -> (Int, [JISChar])) -> Maybe Char -> Maybe (Int, [JISChar])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Char
j)
  where l' :: Word8
l' = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word8) -> Int -> Word8
forall a b. (a -> b) -> a -> b
$ Int
l Int -> Int -> Int
forall a. Num a => a -> a -> a
+ if Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0x1F then Int
0x81 else Int
0xC1
        m :: a -> a -> (Int, [a])
m a
t' a
j' = (a -> Int
forall a. Enum a => a -> Int
fromEnum a
j', [a
t'])


-- | Given a particular character, retrieve all its potential binary
-- representations in the Shift JIS encoding scheme.
lookupUnicode :: Char -> Either Char [BS.ByteString]
lookupUnicode :: Char -> Either Char [ByteString]
lookupUnicode Char
c = case Int -> IntMap [JISChar] -> Maybe [JISChar]
forall a. Int -> IntMap a -> Maybe a
M.lookup (Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
c) IntMap [JISChar]
unicodeMap of
    Just [JISChar]
js -> [ByteString] -> Either Char [ByteString]
forall a b. b -> Either a b
Right ([ByteString] -> Either Char [ByteString])
-> [ByteString] -> Either Char [ByteString]
forall a b. (a -> b) -> a -> b
$ (JISChar -> ByteString) -> [JISChar] -> [ByteString]
forall a b. (a -> b) -> [a] -> [b]
map JISChar -> ByteString
pack [JISChar]
js
    Maybe [JISChar]
Nothing -> Char -> Either Char [ByteString]
forall a b. a -> Either a b
Left Char
c
  where pack :: JISChar -> ByteString
pack (Single Word8
w) = Word8 -> ByteString
BS.singleton Word8
w
        pack (Double Word8
l Word8
t) = [Word8] -> ByteString
BS.pack [Word8
l, Word8
t]


-- * Multi-byte lookup tables

-- | A continuous sequence of valid multibyte characters.
chars :: String -> [Maybe Char]
chars :: String -> [Maybe Char]
chars = (Char -> Maybe Char) -> String -> [Maybe Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Maybe Char
forall a. a -> Maybe a
Just

-- | A continuous sequence of unassigned multibyte characters.
nothings :: Int -> [Maybe Char]
nothings :: Int -> [Maybe Char]
nothings = (Int -> Maybe Char -> [Maybe Char])
-> Maybe Char -> Int -> [Maybe Char]
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> Maybe Char -> [Maybe Char]
forall a. Int -> a -> [a]
replicate Maybe Char
forall a. Maybe a
Nothing

-- | Generate an entire table of "valid" multibyte characters, without any
-- actual assigned characters.
nothingSecond :: SecondByteTable
nothingSecond :: SecondByteTable
nothingSecond = Int -> Maybe Char -> SecondByteTable
forall a. Int -> a -> Vector a
V.replicate Int
0xC0 Maybe Char
forall a. Maybe a
Nothing

-- | Generate an entire table of multibyte characters which map to a portion of
-- the Private Use Area (i.e., are reserved for program- or company-internal
-- use).
privateUseSecond :: W.Word16 -> SecondByteTable
privateUseSecond :: Word16 -> SecondByteTable
privateUseSecond Word16
b = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40..0x7F-}  (Word16 -> Maybe Char) -> [Word16] -> [Maybe Char]
forall a b. (a -> b) -> [a] -> [b]
map (Char -> Maybe Char
forall a. a -> Maybe a
Just (Char -> Maybe Char) -> (Word16 -> Char) -> Word16 -> Maybe Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Char
forall a. Enum a => Int -> a
toEnum (Int -> Char) -> (Word16 -> Int) -> Word16 -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) [Word16
b..Word16
b Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
+ Word16
0x3E] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80..0xFC-}  (Word16 -> Maybe Char) -> [Word16] -> [Maybe Char]
forall a b. (a -> b) -> [a] -> [b]
map (Char -> Maybe Char
forall a. a -> Maybe a
Just (Char -> Maybe Char) -> (Word16 -> Char) -> Word16 -> Maybe Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Char
forall a. Enum a => Int -> a
toEnum (Int -> Char) -> (Word16 -> Int) -> Word16 -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) [Word16
b Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
+ Word16
0x3F..Word16
b Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
+ Word16
0xBB]


-- | The multibyte characters with a lead byte of @0x81@.
second81 :: SecondByteTable
second81 :: SecondByteTable
second81 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x3000\x3001\x3002\xFF0C\xFF0E\x30FB\xFF1A\xFF1B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\xFF1F\xFF01\x309B\x309C\x00B4\xFF40\x00A8\xFF3E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\xFFE3\xFF3F\x30FD\x30FE\x309D\x309E\x3003\x4EDD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x3005\x3006\x3007\x30FC\x2015\x2010\xFF0F\xFF3C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\xFF5E\x2225\xFF5C\x2026\x2025\x2018\x2019\x201C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x201D\xFF08\xFF09\x3014\x3015\xFF3B\xFF3D\xFF5B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\xFF5D\x3008\x3009\x300A\x300B\x300C\x300D\x300E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x300F\x3010\x3011\xFF0B\xFF0D\x00B1\x00D7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x00F7\xFF1D\x2260\xFF1C\xFF1E\x2266\x2267\x221E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x2234\x2642\x2640\x00B0\x2032\x2033\x2103\xFFE5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\xFF04\xFFE0\xFFE1\xFF05\xFF03\xFF06\xFF0A\xFF20" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x00A7\x2606\x2605\x25CB\x25CF\x25CE\x25C7\x25C6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x25A1\x25A0\x25B3\x25B2\x25BD\x25BC\x203B\x3012" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x2192\x2190\x2191\x2193\x3013" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Maybe Char]
nothings Int
3 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  Int -> [Maybe Char]
nothings Int
8 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x2208\x220B\x2286\x2287\x2282\x2283\x222A\x2229" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  Int -> [Maybe Char]
nothings Int
8 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x2227\x2228\xFFE2\x21D2\x21D4\x2200\x2203" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0xD0-}  Int -> [Maybe Char]
nothings Int
8 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  Int -> [Maybe Char]
nothings Int
2 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ String -> [Maybe Char]
chars String
"\x2220\x22A5\x2312\x2202\x2207\x2261" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x2252\x226A\x226B\x221A\x223D\x221D\x2235\x222B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  Char -> Maybe Char
forall a. a -> Maybe a
Just Char
'\x222C' Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
: Int -> [Maybe Char]
nothings Int
7 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x212B\x2030\x266F\x266D\x266A\x2020\x2021\x00B6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  Int -> [Maybe Char]
nothings Int
4 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ [Char -> Maybe Char
forall a. a -> Maybe a
Just Char
'\x25EF']

-- | The multibyte characters with a lead byte of @0x82@.
second82 :: SecondByteTable
second82 :: SecondByteTable
second82 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40..0x4E-}  Int -> [Maybe Char]
nothings Int
15 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x4F..0x58-}  String -> [Maybe Char]
chars [Char
'\xFF10'..Char
'\xFF19'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x59..0x5F-}  Int -> [Maybe Char]
nothings Int
7 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60..0x79-}  String -> [Maybe Char]
chars [Char
'\xFF21'..Char
'\xFF3A'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x7A..0x80-}  Int -> [Maybe Char]
nothings Int
7 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x81..0x9A-}  String -> [Maybe Char]
chars [Char
'\xFF41'..Char
'\xFF5A'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x9B..0x9E-}  Int -> [Maybe Char]
nothings Int
4 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x9F..0xF1-}  String -> [Maybe Char]
chars [Char
'\x3041'..Char
'\x3093'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF2..0xFC-}  Int -> [Maybe Char]
nothings Int
11

-- | The multibyte characters with a lead byte of @0x83@.
second83 :: SecondByteTable
second83 :: SecondByteTable
second83 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40..0x7F-}  String -> [Maybe Char]
chars [Char
'\x30A1'..Char
'\x30DF'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80..0x96-}  String -> [Maybe Char]
chars [Char
'\x30E0'..Char
'\x30F6'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x97..0x9E-}  Int -> [Maybe Char]
nothings Int
8 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x9F..0xAF-}  String -> [Maybe Char]
chars [Char
'\x0391'..Char
'\x03A1'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0..0xB6-}  String -> [Maybe Char]
chars [Char
'\x03A3'..Char
'\x03A9'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB7..0xBE-}  Int -> [Maybe Char]
nothings Int
8 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xBF..0xCF-}  String -> [Maybe Char]
chars [Char
'\x03B1'..Char
'\x03C1'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0..0xD6-}  String -> [Maybe Char]
chars [Char
'\x03C3'..Char
'\x03C9'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD7..0xFC-}  Int -> [Maybe Char]
nothings Int
0x26

-- | The multibyte characters with a lead byte of @0x84@.
second84 :: SecondByteTable
second84 :: SecondByteTable
second84 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40..0x46-}  String -> [Maybe Char]
chars [Char
'\x0410'..Char
'\x0415'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Char -> Maybe Char
forall a. a -> Maybe a
Just Char
'\x0401' Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x47..0x60-}  String -> [Maybe Char]
chars [Char
'\x0416'..Char
'\x042F'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x61..0x6F-}  Int -> [Maybe Char]
nothings Int
15 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60..0x66-}  String -> [Maybe Char]
chars [Char
'\x0430'..Char
'\x0435'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Char -> Maybe Char
forall a. a -> Maybe a
Just Char
'\x0451' Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x67..0x7F-}  String -> [Maybe Char]
chars [Char
'\x0436'..Char
'\x043D'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80..0x91-}  String -> [Maybe Char]
chars [Char
'\x043E'..Char
'\x044F'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x92..0x9F-}  Int -> [Maybe Char]
nothings Int
13 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Char -> Maybe Char
forall a. a -> Maybe a
Just Char
'\x2500' Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x2502\x250C\x2510\x2518\x2514\x251C\x252C\x2524" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x2534\x253C\x2501\x2503\x250F\x2513\x251B\x2517" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x2523\x2533\x252B\x253B\x254B\x2520\x252F\x2528" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x2537\x253F\x251D\x2530\x2525\x2538\x2542" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xBF..0xFC-}  Int -> [Maybe Char]
nothings Int
0x3E

-- | The multibyte characters with a lead byte of @0x85@.
second85 :: SecondByteTable
second85 :: SecondByteTable
second85 = SecondByteTable
nothingSecond

-- | The multibyte characters with a lead byte of @0x86@.
second86 :: SecondByteTable
second86 :: SecondByteTable
second86 = SecondByteTable
nothingSecond

-- | The multibyte characters with a lead byte of @0x87@.
second87 :: SecondByteTable
second87 :: SecondByteTable
second87 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40..0x53-}  String -> [Maybe Char]
chars [Char
'\x2460'..Char
'\x2473'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x54..0x5F-}  String -> [Maybe Char]
chars [Char
'\x2160'..Char
'\x2169'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
: Char -> Maybe Char
forall a. a -> Maybe a
Just Char
'\x3349' Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x60-}  String -> [Maybe Char]
chars String
"\x3314\x3322\x334D\x3318\x3327\x3303\x3336\x3351" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x3357\x330D\x3326\x3323\x332B\x334A\x333B\x339C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x339D\x339E\x338E\x338F\x33C4\x33A1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x76..0x7F-}  Int -> [Maybe Char]
nothings Int
8 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Char -> Maybe Char
forall a. a -> Maybe a
Just Char
'\x337B' Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
: Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x301D\x301F\x2116\x33CD\x2121\x32A4\x32A5\x32A6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x32A7\x32A8\x3231\x3232\x3239\x337E\x337D\x337C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x2252\x2261\x222B\x222E\x2211\x221A\x22A5\x2220" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x221F\x22BF\x2235\x2229\x222A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x9D..0xFC-}  Int -> [Maybe Char]
nothings Int
0x60

-- | The multibyte characters with a lead byte of @0x88@.
second88 :: SecondByteTable
second88 :: SecondByteTable
second88 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40..0x9F-}  Int -> [Maybe Char]
nothings Int
0x5F [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Char -> Maybe Char
forall a. a -> Maybe a
Just Char
'\x4E9C' Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x5516\x5A03\x963F\x54C0\x611B\x6328\x59F6\x9022" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x8475\x831C\x7A50\x60AA\x63E1\x6E25\x65ED\x8466" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x82A6\x9BF5\x6893\x5727\x65A1\x6271\x5B9B\x59D0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x867B\x98F4\x7D62\x7DBE\x9B8E\x6216\x7C9F\x88B7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x5B89\x5EB5\x6309\x6697\x6848\x95C7\x978D\x674F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x4EE5\x4F0A\x4F4D\x4F9D\x5049\x56F2\x5937\x59D4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x5A01\x5C09\x60DF\x610F\x6170\x6613\x6905\x70BA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x754F\x7570\x79FB\x7DAD\x7DEF\x80C3\x840E\x8863" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x8B02\x9055\x907A\x533B\x4E95\x4EA5\x57DF\x80B2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x90C1\x78EF\x4E00\x58F1\x6EA2\x9038\x7A32\x8328" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x828B\x9C2F\x5141\x5370\x54BD\x54E1\x56E0\x59FB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x5F15\x98F2\x6DEB\x80E4\x852D"

-- | The multibyte characters with a lead byte of @0x89@.
second89 :: SecondByteTable
second89 :: SecondByteTable
second89 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x9662\x9670\x96A0\x97FB\x540B\x53F3\x5B87\x70CF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x7FBD\x8FC2\x96E8\x536F\x9D5C\x7ABA\x4E11\x7893" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x81FC\x6E26\x5618\x5504\x6B1D\x851A\x9C3B\x59E5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x53A9\x6D66\x74DC\x958F\x5642\x4E91\x904B\x96F2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x834F\x990C\x53E1\x55B6\x5B30\x5F71\x6620\x66F3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x6804\x6C38\x6CF3\x6D29\x745B\x76C8\x7A4E\x9834" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x82F1\x885B\x8A60\x92ED\x6DB2\x75AB\x76CA\x99C5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x60A6\x8B01\x8D8A\x95B2\x698E\x53AD\x5186" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x5712\x5830\x5944\x5BB4\x5EF6\x6028\x63A9\x63F4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x6CBF\x6F14\x708E\x7114\x7159\x71D5\x733F\x7E01" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x8276\x82D1\x8597\x9060\x925B\x9D1B\x5869\x65BC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x6C5A\x7525\x51F9\x592E\x5965\x5F80\x5FDC\x62BC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x65FA\x6A2A\x6B27\x6BB4\x738B\x7FC1\x8956\x9D2C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x9D0E\x9EC4\x5CA1\x6C96\x837B\x5104\x5C4B\x61B6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x81C6\x6876\x7261\x4E59\x4FFA\x5378\x6069\x6E29" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x7A4F\x97F3\x4E0B\x5316\x4EEE\x4F55\x4F3D\x4FA1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x4F73\x52A0\x53EF\x5609\x590F\x5AC1\x5BB6\x5BE1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x79D1\x6687\x679C\x67B6\x6B4C\x6CB3\x706B\x73C2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x798D\x79BE\x7A3C\x7B87\x82B1\x82DB\x8304\x8377" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x83EF\x83D3\x8766\x8AB2\x5629\x8CA8\x8FE6\x904E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x971E\x868A\x4FC4\x5CE8\x6211\x7259\x753B\x81E5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x82BD\x86FE\x8CC0\x96C5\x9913\x99D5\x4ECB\x4F1A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x89E3\x56DE\x584A\x58CA\x5EFB\x5FEB\x602A\x6094" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x6062\x61D0\x6212\x62D0\x6539"

-- | The multibyte characters with a lead byte of @0x8A@.
second8A :: SecondByteTable
second8A :: SecondByteTable
second8A = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x9B41\x6666\x68B0\x6D77\x7070\x754C\x7686\x7D75" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x82A5\x87F9\x958B\x968E\x8C9D\x51F1\x52BE\x5916" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x54B3\x5BB3\x5D16\x6168\x6982\x6DAF\x788D\x84CB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x8857\x8A72\x93A7\x9AB8\x6D6C\x99A8\x86D9\x57A3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x67FF\x86CE\x920E\x5283\x5687\x5404\x5ED3\x62E1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x64B9\x683C\x6838\x6BBB\x7372\x78BA\x7A6B\x899A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x89D2\x8D6B\x8F03\x90ED\x95A3\x9694\x9769\x5B66" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x5CB3\x697D\x984D\x984E\x639B\x7B20\x6A2B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x6A7F\x68B6\x9C0D\x6F5F\x5272\x559D\x6070\x62EC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x6D3B\x6E07\x6ED1\x845B\x8910\x8F44\x4E14\x9C39" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x53F6\x691B\x6A3A\x9784\x682A\x515C\x7AC3\x84B2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x91DC\x938C\x565B\x9D28\x6822\x8305\x8431\x7CA5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x5208\x82C5\x74E6\x4E7E\x4F83\x51A0\x5BD2\x520A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x52D8\x52E7\x5DFB\x559A\x582A\x59E6\x5B8C\x5B98" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x5BDB\x5E72\x5E79\x60A3\x611F\x6163\x61BE\x63DB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x6562\x67D1\x6853\x68FA\x6B3E\x6B53\x6C57\x6F22" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x6F97\x6F45\x74B0\x7518\x76E3\x770B\x7AFF\x7BA1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x7C21\x7DE9\x7F36\x7FF0\x809D\x8266\x839E\x89B3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x8ACC\x8CAB\x9084\x9451\x9593\x9591\x95A2\x9665" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x97D3\x9928\x8218\x4E38\x542B\x5CB8\x5DCC\x73A9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x764C\x773C\x5CA9\x7FEB\x8D0B\x96C1\x9811\x9854" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x9858\x4F01\x4F0E\x5371\x559C\x5668\x57FA\x5947" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x5B09\x5BC4\x5C90\x5E0C\x5E7E\x5FCC\x63EE\x673A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x65D7\x65E2\x671F\x68CB\x68C4"

-- | The multibyte characters with a lead byte of @0x8B@.
second8B :: SecondByteTable
second8B :: SecondByteTable
second8B = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x6A5F\x5E30\x6BC5\x6C17\x6C7D\x757F\x7948\x5B63" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x7A00\x7D00\x5FBD\x898F\x8A18\x8CB4\x8D77\x8ECC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x8F1D\x98E2\x9A0E\x9B3C\x4E80\x507D\x5100\x5993" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x5B9C\x622F\x6280\x64EC\x6B3A\x72A0\x7591\x7947" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x7FA9\x87FB\x8ABC\x8B70\x63AC\x83CA\x97A0\x5409" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x5403\x55AB\x6854\x6A58\x8A70\x7827\x6775\x9ECD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x5374\x5BA2\x811A\x8650\x9006\x4E18\x4E45\x4EC7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x4F11\x53CA\x5438\x5BAE\x5F13\x6025\x6551" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x673D\x6C42\x6C72\x6CE3\x7078\x7403\x7A76\x7AAE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x7B08\x7D1A\x7CFE\x7D66\x65E7\x725B\x53BB\x5C45" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x5DE8\x62D2\x62E0\x6319\x6E20\x865A\x8A31\x8DDD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x92F8\x6F01\x79A6\x9B5A\x4EA8\x4EAB\x4EAC\x4F9B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x4FA0\x50D1\x5147\x7AF6\x5171\x51F6\x5354\x5321" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x537F\x53EB\x55AC\x5883\x5CE1\x5F37\x5F4A\x602F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x6050\x606D\x631F\x6559\x6A4B\x6CC1\x72C2\x72ED" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x77EF\x80F8\x8105\x8208\x854E\x90F7\x93E1\x97FF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x9957\x9A5A\x4EF0\x51DD\x5C2D\x6681\x696D\x5C40" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x66F2\x6975\x7389\x6850\x7C81\x50C5\x52E4\x5747" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x5DFE\x9326\x65A4\x6B23\x6B3D\x7434\x7981\x79BD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x7B4B\x7DCA\x82B9\x83CC\x887F\x895F\x8B39\x8FD1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x91D1\x541F\x9280\x4E5D\x5036\x53E5\x533A\x72D7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x7396\x77E9\x82E6\x8EAF\x99C6\x99C8\x99D2\x5177" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x611A\x865E\x55B0\x7A7A\x5076\x5BD3\x9047\x9685" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x4E32\x6ADB\x91E7\x5C51\x5C48"

-- | The multibyte characters with a lead byte of @0x8C@.
second8C :: SecondByteTable
second8C :: SecondByteTable
second8C = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x6398\x7A9F\x6C93\x9774\x8F61\x7AAA\x718A\x9688" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x7C82\x6817\x7E70\x6851\x936C\x52F2\x541B\x85AB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x8A13\x7FA4\x8ECD\x90E1\x5366\x8888\x7941\x4FC2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x50BE\x5211\x5144\x5553\x572D\x73EA\x578B\x5951" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x5F62\x5F84\x6075\x6176\x6167\x61A9\x63B2\x643A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x656C\x666F\x6842\x6E13\x7566\x7A3D\x7CFB\x7D4C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x7D99\x7E4B\x7F6B\x830E\x834A\x86CD\x8A08\x8A63" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x8B66\x8EFD\x981A\x9D8F\x82B8\x8FCE\x9BE8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x5287\x621F\x6483\x6FC0\x9699\x6841\x5091\x6B20" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x6C7A\x6F54\x7A74\x7D50\x8840\x8A23\x6708\x4EF6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x5039\x5026\x5065\x517C\x5238\x5263\x55A7\x570F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x5805\x5ACC\x5EFA\x61B2\x61F8\x62F3\x6372\x691C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x6A29\x727D\x72AC\x732E\x7814\x786F\x7D79\x770C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x80A9\x898B\x8B19\x8CE2\x8ED2\x9063\x9375\x967A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x9855\x9A13\x9E78\x5143\x539F\x53B3\x5E7B\x5F26" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x6E1B\x6E90\x7384\x73FE\x7D43\x8237\x8A00\x8AFA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x9650\x4E4E\x500B\x53E4\x547C\x56FA\x59D1\x5B64" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x5DF1\x5EAB\x5F27\x6238\x6545\x67AF\x6E56\x72D0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x7CCA\x88B4\x80A1\x80E1\x83F0\x864E\x8A87\x8DE8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x9237\x96C7\x9867\x9F13\x4E94\x4E92\x4F0D\x5348" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x5449\x543E\x5A2F\x5F8C\x5FA1\x609F\x68A7\x6A8E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x745A\x7881\x8A9E\x8AA4\x8B77\x9190\x4E5E\x9BC9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x4EA4\x4F7C\x4FAF\x5019\x5016\x5149\x516C\x529F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x52B9\x52FE\x539A\x53E3\x5411"

-- | The multibyte characters with a lead byte of @0x8D@.
second8D :: SecondByteTable
second8D :: SecondByteTable
second8D = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x540E\x5589\x5751\x57A2\x597D\x5B54\x5B5D\x5B8F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x5DE5\x5DE7\x5DF7\x5E78\x5E83\x5E9A\x5EB7\x5F18" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x6052\x614C\x6297\x62D8\x63A7\x653B\x6602\x6643" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x66F4\x676D\x6821\x6897\x69CB\x6C5F\x6D2A\x6D69" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x6E2F\x6E9D\x7532\x7687\x786C\x7A3F\x7CE0\x7D05" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x7D18\x7D5E\x7DB1\x8015\x8003\x80AF\x80B1\x8154" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x818F\x822A\x8352\x884C\x8861\x8B1B\x8CA2\x8CFC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x90CA\x9175\x9271\x783F\x92FC\x95A4\x964D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x9805\x9999\x9AD8\x9D3B\x525B\x52AB\x53F7\x5408" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x58D5\x62F7\x6FE0\x8C6A\x8F5F\x9EB9\x514B\x523B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x544A\x56FD\x7A40\x9177\x9D60\x9ED2\x7344\x6F09" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x8170\x7511\x5FFD\x60DA\x9AA8\x72DB\x8FBC\x6B64" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x9803\x4ECA\x56F0\x5764\x58BE\x5A5A\x6068\x61C7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x660F\x6606\x6839\x68B1\x6DF7\x75D5\x7D3A\x826E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x9B42\x4E9B\x4F50\x53C9\x5506\x5D6F\x5DE6\x5DEE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x67FB\x6C99\x7473\x7802\x8A50\x9396\x88DF\x5750" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x5EA7\x632B\x50B5\x50AC\x518D\x6700\x54C9\x585E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x59BB\x5BB0\x5F69\x624D\x63A1\x683D\x6B73\x6E08" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x707D\x91C7\x7280\x7815\x7826\x796D\x658E\x7D30" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x83DC\x88C1\x8F09\x969B\x5264\x5728\x6750\x7F6A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x8CA1\x51B4\x5742\x962A\x583A\x698A\x80B4\x54B2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x5D0E\x57FC\x7895\x9DFA\x4F5C\x524A\x548B\x643E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x6628\x6714\x67F5\x7A84\x7B56\x7D22\x932F\x685C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x9BAD\x7B39\x5319\x518A\x5237"

-- | The multibyte characters with a lead byte of @0x8E@.
second8E :: SecondByteTable
second8E :: SecondByteTable
second8E = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x5BDF\x62F6\x64AE\x64E6\x672D\x6BBA\x85A9\x96D1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x7690\x9BD6\x634C\x9306\x9BAB\x76BF\x6652\x4E09" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x5098\x53C2\x5C71\x60E8\x6492\x6563\x685F\x71E6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x73CA\x7523\x7B97\x7E82\x8695\x8B83\x8CDB\x9178" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x9910\x65AC\x66AB\x6B8B\x4ED5\x4ED4\x4F3A\x4F7F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x523A\x53F8\x53F2\x55E3\x56DB\x58EB\x59CB\x59C9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x59FF\x5B50\x5C4D\x5E02\x5E2B\x5FD7\x601D\x6307" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x652F\x5B5C\x65AF\x65BD\x65E8\x679D\x6B62" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x6B7B\x6C0F\x7345\x7949\x79C1\x7CF8\x7D19\x7D2B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x80A2\x8102\x81F3\x8996\x8A5E\x8A69\x8A66\x8A8C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x8AEE\x8CC7\x8CDC\x96CC\x98FC\x6B6F\x4E8B\x4F3C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x4F8D\x5150\x5B57\x5BFA\x6148\x6301\x6642\x6B21" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x6ECB\x6CBB\x723E\x74BD\x75D4\x78C1\x793A\x800C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x8033\x81EA\x8494\x8F9E\x6C50\x9E7F\x5F0F\x8B58" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x9D2B\x7AFA\x8EF8\x5B8D\x96EB\x4E03\x53F1\x57F7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x5931\x5AC9\x5BA4\x6089\x6E7F\x6F06\x75BE\x8CEA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x5B9F\x8500\x7BE0\x5072\x67F4\x829D\x5C61\x854A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x7E1E\x820E\x5199\x5C04\x6368\x8D66\x659C\x716E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x793E\x7D17\x8005\x8B1D\x8ECA\x906E\x86C7\x90AA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x501F\x52FA\x5C3A\x6753\x707C\x7235\x914C\x91C8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x932B\x82E5\x5BC2\x5F31\x60F9\x4E3B\x53D6\x5B88" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x624B\x6731\x6B8A\x72E9\x73E0\x7A2E\x816B\x8DA3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x9152\x9996\x5112\x53D7\x546A\x5BFF\x6388\x6A39" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x7DAC\x9700\x56DA\x53CE\x5468"

-- | The multibyte characters with a lead byte of @0x8F@.
second8F :: SecondByteTable
second8F :: SecondByteTable
second8F = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x5B97\x5C31\x5DDE\x4FEE\x6101\x62FE\x6D32\x79C0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x79CB\x7D42\x7E4D\x7FD2\x81ED\x821F\x8490\x8846" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x8972\x8B90\x8E74\x8F2F\x9031\x914B\x916C\x96C6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x919C\x4EC0\x4F4F\x5145\x5341\x5F93\x620E\x67D4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x6C41\x6E0B\x7363\x7E26\x91CD\x9283\x53D4\x5919" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x5BBF\x6DD1\x795D\x7E2E\x7C9B\x587E\x719F\x51FA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x8853\x8FF0\x4FCA\x5CFB\x6625\x77AC\x7AE3\x821C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x99FF\x51C6\x5FAA\x65EC\x696F\x6B89\x6DF3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x6E96\x6F64\x76FE\x7D14\x5DE1\x9075\x9187\x9806" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x51E6\x521D\x6240\x6691\x66D9\x6E1A\x5EB6\x7DD2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x7F72\x66F8\x85AF\x85F7\x8AF8\x52A9\x53D9\x5973" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x5E8F\x5F90\x6055\x92E4\x9664\x50B7\x511F\x52DD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x5320\x5347\x53EC\x54E8\x5546\x5531\x5617\x5968" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x59BE\x5A3C\x5BB5\x5C06\x5C0F\x5C11\x5C1A\x5E84" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x5E8A\x5EE0\x5F70\x627F\x6284\x62DB\x638C\x6377" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x6607\x660C\x662D\x6676\x677E\x68A2\x6A1F\x6A35" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x6CBC\x6D88\x6E09\x6E58\x713C\x7126\x7167\x75C7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x7701\x785D\x7901\x7965\x79F0\x7AE0\x7B11\x7CA7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x7D39\x8096\x83D6\x848B\x8549\x885D\x88F3\x8A1F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x8A3C\x8A54\x8A73\x8C61\x8CDE\x91A4\x9266\x937E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x9418\x969C\x9798\x4E0A\x4E08\x4E1E\x4E57\x5197" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x5270\x57CE\x5834\x58CC\x5B22\x5E38\x60C5\x64FE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x6761\x6756\x6D44\x72B6\x7573\x7A63\x84B8\x8B72" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x91B8\x9320\x5631\x57F4\x98FE"

-- | The multibyte characters with a lead byte of @0x90@.
second90 :: SecondByteTable
second90 :: SecondByteTable
second90 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x62ED\x690D\x6B96\x71ED\x7E54\x8077\x8272\x89E6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x98DF\x8755\x8FB1\x5C3B\x4F38\x4FE1\x4FB5\x5507" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x5A20\x5BDD\x5BE9\x5FC3\x614E\x632F\x65B0\x664B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x68EE\x699B\x6D78\x6DF1\x7533\x75B9\x771F\x795E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x79E6\x7D33\x81E3\x82AF\x85AA\x89AA\x8A3A\x8EAB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x8F9B\x9032\x91DD\x9707\x4EBA\x4EC1\x5203\x5875" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x58EC\x5C0B\x751A\x5C3D\x814E\x8A0A\x8FC5\x9663" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x976D\x7B25\x8ACF\x9808\x9162\x56F3\x53A8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x9017\x5439\x5782\x5E25\x63A8\x6C34\x708A\x7761" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x7C8B\x7FE0\x8870\x9042\x9154\x9310\x9318\x968F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x745E\x9AC4\x5D07\x5D69\x6570\x67A2\x8DA8\x96DB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x636E\x6749\x6919\x83C5\x9817\x96C0\x88FE\x6F84" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x647A\x5BF8\x4E16\x702C\x755D\x662F\x51C4\x5236" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x52E2\x59D3\x5F81\x6027\x6210\x653F\x6574\x661F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x6674\x68F2\x6816\x6B63\x6E05\x7272\x751F\x76DB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x7CBE\x8056\x58F0\x88FD\x897F\x8AA0\x8A93\x8ACB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x901D\x9192\x9752\x9759\x6589\x7A0E\x8106\x96BB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x5E2D\x60DC\x621A\x65A5\x6614\x6790\x77F3\x7A4D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x7C4D\x7E3E\x810A\x8CAC\x8D64\x8DE1\x8E5F\x78A9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x5207\x62D9\x63A5\x6442\x6298\x8A2D\x7A83\x7BC0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x8AAC\x96EA\x7D76\x820C\x8749\x4ED9\x5148\x5343" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x5360\x5BA3\x5C02\x5C16\x5DDD\x6226\x6247\x64B0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x6813\x6834\x6CC9\x6D45\x6D17\x67D3\x6F5C\x714E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x717D\x65CB\x7A7F\x7BAD\x7DDA"

-- | The multibyte characters with a lead byte of @0x91@.
second91 :: SecondByteTable
second91 :: SecondByteTable
second91 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x7E4A\x7FA8\x817A\x821B\x8239\x85A6\x8A6E\x8CCE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x8DF5\x9078\x9077\x92AD\x9291\x9583\x9BAE\x524D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x5584\x6F38\x7136\x5168\x7985\x7E55\x81B3\x7CCE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x564C\x5851\x5CA8\x63AA\x66FE\x66FD\x695A\x72D9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x758F\x758E\x790E\x7956\x79DF\x7C97\x7D20\x7D44" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x8607\x8A34\x963B\x9061\x9F20\x50E7\x5275\x53CC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x53E2\x5009\x55AA\x58EE\x594F\x723D\x5B8B\x5C64" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x531D\x60E3\x60F3\x635C\x6383\x633F\x63BB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x64CD\x65E9\x66F9\x5DE3\x69CD\x69FD\x6F15\x71E5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x4E89\x75E9\x76F8\x7A93\x7CDF\x7DCF\x7D9C\x8061" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x8349\x8358\x846C\x84BC\x85FB\x88C5\x8D70\x9001" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x906D\x9397\x971C\x9A12\x50CF\x5897\x618E\x81D3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x8535\x8D08\x9020\x4FC3\x5074\x5247\x5373\x606F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x6349\x675F\x6E2C\x8DB3\x901F\x4FD7\x5C5E\x8CCA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x65CF\x7D9A\x5352\x8896\x5176\x63C3\x5B58\x5B6B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x5C0A\x640D\x6751\x905C\x4ED6\x591A\x592A\x6C70" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x8A51\x553E\x5815\x59A5\x60F0\x6253\x67C1\x8235" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x6955\x9640\x99C4\x9A28\x4F53\x5806\x5BFE\x8010" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x5CB1\x5E2F\x5F85\x6020\x614B\x6234\x66FF\x6CF0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x6EDE\x80CE\x817F\x82D4\x888B\x8CB8\x9000\x902E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x968A\x9EDB\x9BDB\x4EE3\x53F0\x5927\x7B2C\x918D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x984C\x9DF9\x6EDD\x7027\x5353\x5544\x5B85\x6258" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x629E\x62D3\x6CA2\x6FEF\x7422\x8A17\x9438\x6FC1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x8AFE\x8338\x51E7\x86F8\x53EA"

-- | The multibyte characters with a lead byte of @0x92@.
second92 :: SecondByteTable
second92 :: SecondByteTable
second92 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x53E9\x4F46\x9054\x8FB0\x596A\x8131\x5DFD\x7AEA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x8FBF\x68DA\x8C37\x72F8\x9C48\x6A3D\x8AB0\x4E39" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x5358\x5606\x5766\x62C5\x63A2\x65E6\x6B4E\x6DE1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x6E5B\x70AD\x77ED\x7AEF\x7BAA\x7DBB\x803D\x80C6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x86CB\x8A95\x935B\x56E3\x58C7\x5F3E\x65AD\x6696" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x6A80\x6BB5\x7537\x8AC7\x5024\x77E5\x5730\x5F1B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x6065\x667A\x6C60\x75F4\x7A1A\x7F6E\x81F4\x8718" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x9045\x99B3\x7BC9\x755C\x7AF9\x7B51\x84C4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x9010\x79E9\x7A92\x8336\x5AE1\x7740\x4E2D\x4EF2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x5B99\x5FE0\x62BD\x663C\x67F1\x6CE8\x866B\x8877" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x8A3B\x914E\x92F3\x99D0\x6A17\x7026\x732A\x82E7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x8457\x8CAF\x4E01\x5146\x51CB\x558B\x5BF5\x5E16" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x5E33\x5E81\x5F14\x5F35\x5F6B\x5FB4\x61F2\x6311" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x66A2\x671D\x6F6E\x7252\x753A\x773A\x8074\x8139" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x8178\x8776\x8ABF\x8ADC\x8D85\x8DF3\x929A\x9577" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x9802\x9CE5\x52C5\x6357\x76F4\x6715\x6C88\x73CD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x8CC3\x93AE\x9673\x6D25\x589C\x690E\x69CC\x8FFD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x939A\x75DB\x901A\x585A\x6802\x63B4\x69FB\x4F43" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x6F2C\x67D8\x8FBB\x8526\x7DB4\x9354\x693F\x6F70" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x576A\x58F7\x5B2C\x7D2C\x722A\x540A\x91E3\x9DB4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x4EAD\x4F4E\x505C\x5075\x5243\x8C9E\x5448\x5824" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x5B9A\x5E1D\x5E95\x5EAD\x5EF7\x5F1F\x608C\x62B5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x633A\x63D0\x68AF\x6C40\x7887\x798E\x7A0B\x7DE0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x8247\x8A02\x8AE6\x8E44\x9013"

-- | The multibyte characters with a lead byte of @0x93@.
second93 :: SecondByteTable
second93 :: SecondByteTable
second93 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x90B8\x912D\x91D8\x9F0E\x6CE5\x6458\x64E2\x6575" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x6EF4\x7684\x7B1B\x9069\x93D1\x6EBA\x54F2\x5FB9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x64A4\x8F4D\x8FED\x9244\x5178\x586B\x5929\x5C55" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x5E97\x6DFB\x7E8F\x751C\x8CBC\x8EE2\x985B\x70B9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x4F1D\x6BBF\x6FB1\x7530\x96FB\x514E\x5410\x5835" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x5857\x59AC\x5C60\x5F92\x6597\x675C\x6E21\x767B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x83DF\x8CED\x9014\x90FD\x934D\x7825\x783A\x52AA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x5EA6\x571F\x5974\x6012\x5012\x515A\x51AC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x51CD\x5200\x5510\x5854\x5858\x5957\x5B95\x5CF6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x5D8B\x60BC\x6295\x642D\x6771\x6843\x68BC\x68DF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x76D7\x6DD8\x6E6F\x6D9B\x706F\x71C8\x5F53\x75D8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x7977\x7B49\x7B54\x7B52\x7CD6\x7D71\x5230\x8463" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x8569\x85E4\x8A0E\x8B04\x8C46\x8E0F\x9003\x900F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x9419\x9676\x982D\x9A30\x95D8\x50CD\x52D5\x540C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x5802\x5C0E\x61A7\x649E\x6D1E\x77B3\x7AE5\x80F4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x8404\x9053\x9285\x5CE0\x9D07\x533F\x5F97\x5FB3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x6D9C\x7279\x7763\x79BF\x7BE4\x6BD2\x72EC\x8AAD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x6803\x6A61\x51F8\x7A81\x6934\x5C4A\x9CF6\x82EB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x5BC5\x9149\x701E\x5678\x5C6F\x60C7\x6566\x6C8C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x8C5A\x9041\x9813\x5451\x66C7\x920D\x5948\x90A3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x5185\x4E4D\x51EA\x8599\x8B0E\x7058\x637A\x934B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x6962\x99B4\x7E04\x7577\x5357\x6960\x8EDF\x96E3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x6C5D\x4E8C\x5C3C\x5F10\x8FE9\x5302\x8CD1\x8089" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x8679\x5EFF\x65E5\x4E73\x5165"

-- | The multibyte characters with a lead byte of @0x94@.
second94 :: SecondByteTable
second94 :: SecondByteTable
second94 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x5982\x5C3F\x97EE\x4EFB\x598A\x5FCD\x8A8D\x6FE1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x79B0\x7962\x5BE7\x8471\x732B\x71B1\x5E74\x5FF5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x637B\x649A\x71C3\x7C98\x4E43\x5EFC\x4E4B\x57DC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x56A2\x60A9\x6FC3\x7D0D\x80FD\x8133\x81BF\x8FB2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x8997\x86A4\x5DF4\x628A\x64AD\x8987\x6777\x6CE2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x6D3E\x7436\x7834\x5A46\x7F75\x82AD\x99AC\x4FF3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x5EC3\x62DD\x6392\x6557\x676F\x76C3\x724C\x80CC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x80BA\x8F29\x914D\x500D\x57F9\x5A92\x6885" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x6973\x7164\x72FD\x8CB7\x58F2\x8CE0\x966A\x9019" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x877F\x79E4\x77E7\x8429\x4F2F\x5265\x535A\x62CD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x67CF\x6CCA\x767D\x7B94\x7C95\x8236\x8584\x8FEB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x66DD\x6F20\x7206\x7E1B\x83AB\x99C1\x9EA6\x51FD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x7BB1\x7872\x7BB8\x8087\x7B48\x6AE8\x5E61\x808C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x7551\x7560\x516B\x9262\x6E8C\x767A\x9197\x9AEA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x4F10\x7F70\x629C\x7B4F\x95A5\x9CE9\x567A\x5859" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x86E4\x96BC\x4F34\x5224\x534A\x53CD\x53DB\x5E06" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x642C\x6591\x677F\x6C3E\x6C4E\x7248\x72AF\x73ED" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x7554\x7E41\x822C\x85E9\x8CA9\x7BC4\x91C6\x7169" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x9812\x98EF\x633D\x6669\x756A\x76E4\x78D0\x8543" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x86EE\x532A\x5351\x5426\x5983\x5E87\x5F7C\x60B2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x6249\x6279\x62AB\x6590\x6BD4\x6CCC\x75B2\x76AE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x7891\x79D8\x7DCB\x7F77\x80A5\x88AB\x8AB9\x8CBB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x907F\x975E\x98DB\x6A0B\x7C38\x5099\x5C3E\x5FAE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x6787\x6BD8\x7435\x7709\x7F8E"

-- | The multibyte characters with a lead byte of @0x95@.
second95 :: SecondByteTable
second95 :: SecondByteTable
second95 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x9F3B\x67CA\x7A17\x5339\x758B\x9AED\x5F66\x819D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x83F1\x8098\x5F3C\x5FC5\x7562\x7B46\x903C\x6867" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x59EB\x5A9B\x7D10\x767E\x8B2C\x4FF5\x5F6A\x6A19" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x6C37\x6F02\x74E2\x7968\x8868\x8A55\x8C79\x5EDF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x63CF\x75C5\x79D2\x82D7\x9328\x92F2\x849C\x86ED" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x9C2D\x54C1\x5F6C\x658C\x6D5C\x7015\x8CA7\x8CD3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x983B\x654F\x74F6\x4E0D\x4ED8\x57E0\x592B\x5A66" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x5BCC\x51A8\x5E03\x5E9C\x6016\x6276\x6577" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x65A7\x666E\x6D6E\x7236\x7B26\x8150\x819A\x8299" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x8B5C\x8CA0\x8CE6\x8D74\x961C\x9644\x4FAE\x64AB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x6B66\x821E\x8461\x856A\x90E8\x5C01\x6953\x98A8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x847A\x8557\x4F0F\x526F\x5FA9\x5E45\x670D\x798F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x8179\x8907\x8986\x6DF5\x5F17\x6255\x6CB8\x4ECF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x7269\x9B92\x5206\x543B\x5674\x58B3\x61A4\x626E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x711A\x596E\x7C89\x7CDE\x7D1B\x96F0\x6587\x805E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x4E19\x4F75\x5175\x5840\x5E63\x5E73\x5F0A\x67C4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x4E26\x853D\x9589\x965B\x7C73\x9801\x50FB\x58C1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x7656\x78A7\x5225\x77A5\x8511\x7B86\x504F\x5909" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x7247\x7BC7\x7DE8\x8FBA\x8FD4\x904D\x4FBF\x52C9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x5A29\x5F01\x97AD\x4FDD\x8217\x92EA\x5703\x6355" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x6B69\x752B\x88DC\x8F14\x7A42\x52DF\x5893\x6155" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x620A\x66AE\x6BCD\x7C3F\x83E9\x5023\x4FF8\x5305" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x5446\x5831\x5949\x5B9D\x5CF0\x5CEF\x5D29\x5E96" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x62B1\x6367\x653E\x65B9\x670B"

-- | The multibyte characters with a lead byte of @0x96@.
second96 :: SecondByteTable
second96 :: SecondByteTable
second96 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x6CD5\x6CE1\x70F9\x7832\x7E2B\x80DE\x82B3\x840C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x84EC\x8702\x8912\x8A2A\x8C4A\x90A6\x92D2\x98FD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x9CF3\x9D6C\x4E4F\x4EA1\x508D\x5256\x574A\x59A8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x5E3D\x5FD8\x5FD9\x623F\x66B4\x671B\x67D0\x68D2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x5192\x7D21\x80AA\x81A8\x8B00\x8C8C\x8CBF\x927E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x9632\x5420\x982C\x5317\x50D5\x535C\x58A8\x64B2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x6734\x7267\x7766\x7A46\x91E6\x52C3\x6CA1\x6B86" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x5800\x5E4C\x5954\x672C\x7FFB\x51E1\x76C6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x6469\x78E8\x9B54\x9EBB\x57CB\x59B9\x6627\x679A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x6BCE\x54E9\x69D9\x5E55\x819C\x6795\x9BAA\x67FE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x9C52\x685D\x4EA6\x4FE3\x53C8\x62B9\x672B\x6CAB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x8FC4\x4FAD\x7E6D\x9EBF\x4E07\x6162\x6E80\x6F2B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x8513\x5473\x672A\x9B45\x5DF3\x7B95\x5CAC\x5BC6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x871C\x6E4A\x84D1\x7A14\x8108\x5999\x7C8D\x6C11" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x7720\x52D9\x5922\x7121\x725F\x77DB\x9727\x9D61" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x690B\x5A7F\x5A18\x51A5\x540D\x547D\x660E\x76DF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x8FF7\x9298\x9CF4\x59EA\x725D\x6EC5\x514D\x68C9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x7DBF\x7DEC\x9762\x9EBA\x6478\x6A21\x8302\x5984" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x5B5F\x6BDB\x731B\x76F2\x7DB2\x8017\x8499\x5132" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x6728\x9ED9\x76EE\x6762\x52FF\x9905\x5C24\x623B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x7C7E\x8CB0\x554F\x60B6\x7D0B\x9580\x5301\x4E5F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x51B6\x591C\x723A\x8036\x91CE\x5F25\x77E2\x5384" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x5F79\x7D04\x85AC\x8A33\x8E8D\x9756\x67F3\x85AE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x9453\x6109\x6108\x6CB9\x7652"

-- | The multibyte characters with a lead byte of @0x97@.
second97 :: SecondByteTable
second97 :: SecondByteTable
second97 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x8AED\x8F38\x552F\x4F51\x512A\x52C7\x53CB\x5BA5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x5E7D\x60A0\x6182\x63D6\x6709\x67DA\x6E67\x6D8C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x7336\x7337\x7531\x7950\x88D5\x8A98\x904A\x9091" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x90F5\x96C4\x878D\x5915\x4E88\x4F59\x4E0E\x8A89" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x8F3F\x9810\x50AD\x5E7C\x5996\x5BB9\x5EB8\x63DA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x63FA\x64C1\x66DC\x694A\x69D8\x6D0B\x6EB6\x7194" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x7528\x7AAF\x7F8A\x8000\x8449\x84C9\x8981\x8B21" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x8E0A\x9065\x967D\x990A\x617E\x6291\x6B32" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x6C83\x6D74\x7FCC\x7FFC\x6DC0\x7F85\x87BA\x88F8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x6765\x83B1\x983C\x96F7\x6D1B\x7D61\x843D\x916A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x4E71\x5375\x5D50\x6B04\x6FEB\x85CD\x862D\x89A7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x5229\x540F\x5C65\x674E\x68A8\x7406\x7483\x75E2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x88CF\x88E1\x91CC\x96E2\x9678\x5F8B\x7387\x7ACB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x844E\x63A0\x7565\x5289\x6D41\x6E9C\x7409\x7559" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x786B\x7C92\x9686\x7ADC\x9F8D\x4FB6\x616E\x65C5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x865C\x4E86\x4EAE\x50DA\x4E21\x51CC\x5BEE\x6599" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x6881\x6DBC\x731F\x7642\x77AD\x7A1C\x7CE7\x826F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x8AD2\x907C\x91CF\x9675\x9818\x529B\x7DD1\x502B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x5398\x6797\x6DCB\x71D0\x7433\x81E8\x8F2A\x96A3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x9C57\x9E9F\x7460\x5841\x6D99\x7D2F\x985E\x4EE4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x4F36\x4F8B\x51B7\x52B1\x5DBA\x601C\x73B2\x793C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x82D3\x9234\x96B7\x96F6\x970A\x9E97\x9F62\x66A6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x6B74\x5217\x52A3\x70C8\x88C2\x5EC9\x604B\x6190" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x6F23\x7149\x7C3E\x7DF4\x806F"

-- | The multibyte characters with a lead byte of @0x98@.
second98 :: SecondByteTable
second98 :: SecondByteTable
second98 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x84EE\x9023\x932C\x5442\x9B6F\x6AD3\x7089\x8CC2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x8DEF\x9732\x52B4\x5A41\x5ECA\x5F04\x6717\x697C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x6994\x6D6A\x6F0F\x7262\x72FC\x7BED\x8001\x807E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x874B\x90CE\x516D\x9E93\x7984\x808B\x9332\x8AD6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x502D\x548C\x8A71\x6B6A\x8CC4\x8107\x60D1\x67A0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x9DF2\x4E99\x4E98\x9C10\x8A6B\x85C1\x8568\x6900" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x6E7E\x7897\x8155" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x73..0x9F-} Int -> [Maybe Char]
nothings Int
0x2C [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Char -> Maybe Char
forall a. a -> Maybe a
Just Char
'\x5F0C' Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x4E10\x4E15\x4E2A\x4E31\x4E36\x4E3C\x4E3F\x4E42" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x4E56\x4E58\x4E82\x4E85\x8C6B\x4E8A\x8212\x5F0D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x4E8E\x4E9E\x4E9F\x4EA0\x4EA2\x4EB0\x4EB3\x4EB6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x4ECE\x4ECD\x4EC4\x4EC6\x4EC2\x4ED7\x4EDE\x4EED" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x4EDF\x4EF7\x4F09\x4F5A\x4F30\x4F5B\x4F5D\x4F57" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x4F47\x4F76\x4F88\x4F8F\x4F98\x4F7B\x4F69\x4F70" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x4F91\x4F6F\x4F86\x4F96\x5118\x4FD4\x4FDF\x4FCE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x4FD8\x4FDB\x4FD1\x4FDA\x4FD0\x4FE4\x4FE5\x501A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x5028\x5014\x502A\x5025\x5005\x4F1C\x4FF6\x5021" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x5029\x502C\x4FFE\x4FEF\x5011\x5006\x5043\x5047" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x6703\x5055\x5050\x5048\x505A\x5056\x506C\x5078" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x5080\x509A\x5085\x50B4\x50B2"

-- | The multibyte characters with a lead byte of @0x99@.
second99 :: SecondByteTable
second99 :: SecondByteTable
second99 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x50C9\x50CA\x50B3\x50C2\x50D6\x50DE\x50E5\x50ED" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x50E3\x50EE\x50F9\x50F5\x5109\x5101\x5102\x5116" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x5115\x5114\x511A\x5121\x513A\x5137\x513C\x513B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x513F\x5140\x5152\x514C\x5154\x5162\x7AF8\x5169" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x516A\x516E\x5180\x5182\x56D8\x518C\x5189\x518F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x5191\x5193\x5195\x5196\x51A4\x51A6\x51A2\x51A9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x51AA\x51AB\x51B3\x51B1\x51B2\x51B0\x51B5\x51BD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x51C5\x51C9\x51DB\x51E0\x8655\x51E9\x51ED" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x51F0\x51F5\x51FE\x5204\x520B\x5214\x520E\x5227" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x522A\x522E\x5233\x5239\x524F\x5244\x524B\x524C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x525E\x5254\x526A\x5274\x5269\x5273\x527F\x527D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x528D\x5294\x5292\x5271\x5288\x5291\x8FA8\x8FA7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x52AC\x52AD\x52BC\x52B5\x52C1\x52CD\x52D7\x52DE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x52E3\x52E6\x98ED\x52E0\x52F3\x52F5\x52F8\x52F9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x5306\x5308\x7538\x530D\x5310\x530F\x5315\x531A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x5323\x532F\x5331\x5333\x5338\x5340\x5346\x5345" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x4E17\x5349\x534D\x51D6\x535E\x5369\x536E\x5918" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x537B\x5377\x5382\x5396\x53A0\x53A6\x53A5\x53AE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x53B0\x53B6\x53C3\x7C12\x96D9\x53DF\x66FC\x71EE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x53EE\x53E8\x53ED\x53FA\x5401\x543D\x5440\x542C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x542D\x543C\x542E\x5436\x5429\x541D\x544E\x548F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x5475\x548E\x545F\x5471\x5477\x5470\x5492\x547B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x5480\x5476\x5484\x5490\x5486\x54C7\x54A2\x54B8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x54A5\x54AC\x54C4\x54C8\x54A8"

-- | The multibyte characters with a lead byte of @0x9A@.
second9A :: SecondByteTable
second9A :: SecondByteTable
second9A = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x54AB\x54C2\x54A4\x54BE\x54BC\x54D8\x54E5\x54E6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x550F\x5514\x54FD\x54EE\x54ED\x54FA\x54E2\x5539" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x5540\x5563\x554C\x552E\x555C\x5545\x5556\x5557" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x5538\x5533\x555D\x5599\x5580\x54AF\x558A\x559F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x557B\x557E\x5598\x559E\x55AE\x557C\x5583\x55A9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x5587\x55A8\x55DA\x55C5\x55DF\x55C4\x55DC\x55E4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x55D4\x5614\x55F7\x5616\x55FE\x55FD\x561B\x55F9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x564E\x5650\x71DF\x5634\x5636\x5632\x5638" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x566B\x5664\x562F\x566C\x566A\x5686\x5680\x568A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x56A0\x5694\x568F\x56A5\x56AE\x56B6\x56B4\x56C2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x56BC\x56C1\x56C3\x56C0\x56C8\x56CE\x56D1\x56D3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x56D7\x56EE\x56F9\x5700\x56FF\x5704\x5709\x5708" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x570B\x570D\x5713\x5718\x5716\x55C7\x571C\x5726" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x5737\x5738\x574E\x573B\x5740\x574F\x5769\x57C0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x5788\x5761\x577F\x5789\x5793\x57A0\x57B3\x57A4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x57AA\x57B0\x57C3\x57C6\x57D4\x57D2\x57D3\x580A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x57D6\x57E3\x580B\x5819\x581D\x5872\x5821\x5862" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x584B\x5870\x6BC0\x5852\x583D\x5879\x5885\x58B9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x589F\x58AB\x58BA\x58DE\x58BB\x58B8\x58AE\x58C5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x58D3\x58D1\x58D7\x58D9\x58D8\x58E5\x58DC\x58E4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x58DF\x58EF\x58FA\x58F9\x58FB\x58FC\x58FD\x5902" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x590A\x5910\x591B\x68A6\x5925\x592C\x592D\x5932" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x5938\x593E\x7AD2\x5955\x5950\x594E\x595A\x5958" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x5962\x5960\x5967\x596C\x5969"

-- | The multibyte characters with a lead byte of @0x9B@.
second9B :: SecondByteTable
second9B :: SecondByteTable
second9B = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x5978\x5981\x599D\x4F5E\x4FAB\x59A3\x59B2\x59C6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x59E8\x59DC\x598D\x59D9\x59DA\x5A25\x5A1F\x5A11" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x5A1C\x5A09\x5A1A\x5A40\x5A6C\x5A49\x5A35\x5A36" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x5A62\x5A6A\x5A9A\x5ABC\x5ABE\x5ACB\x5AC2\x5ABD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x5AE3\x5AD7\x5AE6\x5AE9\x5AD6\x5AFA\x5AFB\x5B0C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x5B0B\x5B16\x5B32\x5AD0\x5B2A\x5B36\x5B3E\x5B43" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x5B45\x5B40\x5B51\x5B55\x5B5A\x5B5B\x5B65\x5B69" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x5B70\x5B73\x5B75\x5B78\x6588\x5B7A\x5B80" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x5B83\x5BA6\x5BB8\x5BC3\x5BC7\x5BC9\x5BD4\x5BD0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x5BE4\x5BE6\x5BE2\x5BDE\x5BE5\x5BEB\x5BF0\x5BF6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x5BF3\x5C05\x5C07\x5C08\x5C0D\x5C13\x5C20\x5C22" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x5C28\x5C38\x5C39\x5C41\x5C46\x5C4E\x5C53\x5C50" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x5C4F\x5B71\x5C6C\x5C6E\x4E62\x5C76\x5C79\x5C8C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x5C91\x5C94\x599B\x5CAB\x5CBB\x5CB6\x5CBC\x5CB7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x5CC5\x5CBE\x5CC7\x5CD9\x5CE9\x5CFD\x5CFA\x5CED" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x5D8C\x5CEA\x5D0B\x5D15\x5D17\x5D5C\x5D1F\x5D1B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x5D11\x5D14\x5D22\x5D1A\x5D19\x5D18\x5D4C\x5D52" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x5D4E\x5D4B\x5D6C\x5D73\x5D76\x5D87\x5D84\x5D82" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x5DA2\x5D9D\x5DAC\x5DAE\x5DBD\x5D90\x5DB7\x5DBC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x5DC9\x5DCD\x5DD3\x5DD2\x5DD6\x5DDB\x5DEB\x5DF2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x5DF5\x5E0B\x5E1A\x5E19\x5E11\x5E1B\x5E36\x5E37" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x5E44\x5E43\x5E40\x5E4E\x5E57\x5E54\x5E5F\x5E62" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x5E64\x5E47\x5E75\x5E76\x5E7A\x9EBC\x5E7F\x5EA0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x5EC1\x5EC2\x5EC8\x5ED0\x5ECF"

-- | The multibyte characters with a lead byte of @0x9C@.
second9C :: SecondByteTable
second9C :: SecondByteTable
second9C = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x5ED6\x5EE3\x5EDD\x5EDA\x5EDB\x5EE2\x5EE1\x5EE8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x5EE9\x5EEC\x5EF1\x5EF3\x5EF0\x5EF4\x5EF8\x5EFE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x5F03\x5F09\x5F5D\x5F5C\x5F0B\x5F11\x5F16\x5F29" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x5F2D\x5F38\x5F41\x5F48\x5F4C\x5F4E\x5F2F\x5F51" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x5F56\x5F57\x5F59\x5F61\x5F6D\x5F73\x5F77\x5F83" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x5F82\x5F7F\x5F8A\x5F88\x5F91\x5F87\x5F9E\x5F99" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x5F98\x5FA0\x5FA8\x5FAD\x5FBC\x5FD6\x5FFB\x5FE4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x5FF8\x5FF1\x5FDD\x60B3\x5FFF\x6021\x6060" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x6019\x6010\x6029\x600E\x6031\x601B\x6015\x602B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x6026\x600F\x603A\x605A\x6041\x606A\x6077\x605F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x604A\x6046\x604D\x6063\x6043\x6064\x6042\x606C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x606B\x6059\x6081\x608D\x60E7\x6083\x609A\x6084" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x609B\x6096\x6097\x6092\x60A7\x608B\x60E1\x60B8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x60E0\x60D3\x60B4\x5FF0\x60BD\x60C6\x60B5\x60D8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x614D\x6115\x6106\x60F6\x60F7\x6100\x60F4\x60FA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x6103\x6121\x60FB\x60F1\x610D\x610E\x6147\x613E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x6128\x6127\x614A\x613F\x613C\x612C\x6134\x613D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x6142\x6144\x6173\x6177\x6158\x6159\x615A\x616B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x6174\x616F\x6165\x6171\x615F\x615D\x6153\x6175" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x6199\x6196\x6187\x61AC\x6194\x619A\x618A\x6191" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x61AB\x61AE\x61CC\x61CA\x61C9\x61F7\x61C8\x61C3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x61C6\x61BA\x61CB\x7F79\x61CD\x61E6\x61E3\x61F6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x61FA\x61F4\x61FF\x61FD\x61FC\x61FE\x6200\x6208" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x6209\x620D\x620C\x6214\x621B"

-- | The multibyte characters with a lead byte of @0x9D@.
second9D :: SecondByteTable
second9D :: SecondByteTable
second9D = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x621E\x6221\x622A\x622E\x6230\x6232\x6233\x6241" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x624E\x625E\x6263\x625B\x6260\x6268\x627C\x6282" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x6289\x627E\x6292\x6293\x6296\x62D4\x6283\x6294" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x62D7\x62D1\x62BB\x62CF\x62FF\x62C6\x64D4\x62C8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x62DC\x62CC\x62CA\x62C2\x62C7\x629B\x62C9\x630C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x62EE\x62F1\x6327\x6302\x6308\x62EF\x62F5\x6350" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x633E\x634D\x641C\x634F\x6396\x638E\x6380\x63AB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x6376\x63A3\x638F\x6389\x639F\x63B5\x636B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x6369\x63BE\x63E9\x63C0\x63C6\x63E3\x63C9\x63D2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x63F6\x63C4\x6416\x6434\x6406\x6413\x6426\x6436" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x651D\x6417\x6428\x640F\x6467\x646F\x6476\x644E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x652A\x6495\x6493\x64A5\x64A9\x6488\x64BC\x64DA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x64D2\x64C5\x64C7\x64BB\x64D8\x64C2\x64F1\x64E7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x8209\x64E0\x64E1\x62AC\x64E3\x64EF\x652C\x64F6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x64F4\x64F2\x64FA\x6500\x64FD\x6518\x651C\x6505" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x6524\x6523\x652B\x6534\x6535\x6537\x6536\x6538" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x754B\x6548\x6556\x6555\x654D\x6558\x655E\x655D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x6572\x6578\x6582\x6583\x8B8A\x659B\x659F\x65AB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x65B7\x65C3\x65C6\x65C1\x65C4\x65CC\x65D2\x65DB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x65D9\x65E0\x65E1\x65F1\x6772\x660A\x6603\x65FB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x6773\x6635\x6636\x6634\x661C\x664F\x6644\x6649" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x6641\x665E\x665D\x6664\x6667\x6668\x665F\x6662" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x6670\x6683\x6688\x668E\x6689\x6684\x6698\x669D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x66C1\x66B9\x66C9\x66BE\x66BC"

-- | The multibyte characters with a lead byte of @0x9E@.
second9E :: SecondByteTable
second9E :: SecondByteTable
second9E = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x66C4\x66B8\x66D6\x66DA\x66E0\x663F\x66E6\x66E9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x66F0\x66F5\x66F7\x670F\x6716\x671E\x6726\x6727" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x9738\x672E\x673F\x6736\x6741\x6738\x6737\x6746" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x675E\x6760\x6759\x6763\x6764\x6789\x6770\x67A9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x677C\x676A\x678C\x678B\x67A6\x67A1\x6785\x67B7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x67EF\x67B4\x67EC\x67B3\x67E9\x67B8\x67E4\x67DE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x67DD\x67E2\x67EE\x67B9\x67CE\x67C6\x67E7\x6A9C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x681E\x6846\x6829\x6840\x684D\x6832\x684E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x68B3\x682B\x6859\x6863\x6877\x687F\x689F\x688F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x68AD\x6894\x689D\x689B\x6883\x6AAE\x68B9\x6874" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x68B5\x68A0\x68BA\x690F\x688D\x687E\x6901\x68CA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x6908\x68D8\x6922\x6926\x68E1\x690C\x68CD\x68D4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x68E7\x68D5\x6936\x6912\x6904\x68D7\x68E3\x6925" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x68F9\x68E0\x68EF\x6928\x692A\x691A\x6923\x6921" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x68C6\x6979\x6977\x695C\x6978\x696B\x6954\x697E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x696E\x6939\x6974\x693D\x6959\x6930\x6961\x695E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x695D\x6981\x696A\x69B2\x69AE\x69D0\x69BF\x69C1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x69D3\x69BE\x69CE\x5BE8\x69CA\x69DD\x69BB\x69C3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x69A7\x6A2E\x6991\x69A0\x699C\x6995\x69B4\x69DE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x69E8\x6A02\x6A1B\x69FF\x6B0A\x69F9\x69F2\x69E7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x6A05\x69B1\x6A1E\x69ED\x6A14\x69EB\x6A0A\x6A12" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x6AC1\x6A23\x6A13\x6A44\x6A0C\x6A72\x6A36\x6A78" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x6A47\x6A62\x6A59\x6A66\x6A48\x6A38\x6A22\x6A90" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x6A8D\x6AA0\x6A84\x6AA2\x6AA3"

-- | The multibyte characters with a lead byte of @0x9F@.
second9F :: SecondByteTable
second9F :: SecondByteTable
second9F = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x6A97\x8617\x6ABB\x6AC3\x6AC2\x6AB8\x6AB3\x6AAC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x6ADE\x6AD1\x6ADF\x6AAA\x6ADA\x6AEA\x6AFB\x6B05" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x8616\x6AFA\x6B12\x6B16\x9B31\x6B1F\x6B38\x6B37" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x76DC\x6B39\x98EE\x6B47\x6B43\x6B49\x6B50\x6B59" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x6B54\x6B5B\x6B5F\x6B61\x6B78\x6B79\x6B7F\x6B80" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x6B84\x6B83\x6B8D\x6B98\x6B95\x6B9E\x6BA4\x6BAA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x6BAB\x6BAF\x6BB2\x6BB1\x6BB3\x6BB7\x6BBC\x6BC6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x6BCB\x6BD3\x6BDF\x6BEC\x6BEB\x6BF3\x6BEF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x9EBE\x6C08\x6C13\x6C14\x6C1B\x6C24\x6C23\x6C5E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x6C55\x6C62\x6C6A\x6C82\x6C8D\x6C9A\x6C81\x6C9B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x6C7E\x6C68\x6C73\x6C92\x6C90\x6CC4\x6CF1\x6CD3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x6CBD\x6CD7\x6CC5\x6CDD\x6CAE\x6CB1\x6CBE\x6CBA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x6CDB\x6CEF\x6CD9\x6CEA\x6D1F\x884D\x6D36\x6D2B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x6D3D\x6D38\x6D19\x6D35\x6D33\x6D12\x6D0C\x6D63" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x6D93\x6D64\x6D5A\x6D79\x6D59\x6D8E\x6D95\x6FE4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x6D85\x6DF9\x6E15\x6E0A\x6DB5\x6DC7\x6DE6\x6DB8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x6DC6\x6DEC\x6DDE\x6DCC\x6DE8\x6DD2\x6DC5\x6DFA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x6DD9\x6DE4\x6DD5\x6DEA\x6DEE\x6E2D\x6E6E\x6E2E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x6E19\x6E72\x6E5F\x6E3E\x6E23\x6E6B\x6E2B\x6E76" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x6E4D\x6E1F\x6E43\x6E3A\x6E4E\x6E24\x6EFF\x6E1D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x6E38\x6E82\x6EAA\x6E98\x6EC9\x6EB7\x6ED3\x6EBD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x6EAF\x6EC4\x6EB2\x6ED4\x6ED5\x6E8F\x6EA5\x6EC2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x6E9F\x6F41\x6F11\x704C\x6EEC\x6EF8\x6EFE\x6F3F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x6EF2\x6F31\x6EEF\x6F32\x6ECC"

-- | The multibyte characters with a lead byte of @0xE0@.
secondE0 :: SecondByteTable
secondE0 :: SecondByteTable
secondE0 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x6F3E\x6F13\x6EF7\x6F86\x6F7A\x6F78\x6F81\x6F80" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x6F6F\x6F5B\x6FF3\x6F6D\x6F82\x6F7C\x6F58\x6F8E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x6F91\x6FC2\x6F66\x6FB3\x6FA3\x6FA1\x6FA4\x6FB9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x6FC6\x6FAA\x6FDF\x6FD5\x6FEC\x6FD4\x6FD8\x6FF1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x6FEE\x6FDB\x7009\x700B\x6FFA\x7011\x7001\x700F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x6FFE\x701B\x701A\x6F74\x701D\x7018\x701F\x7030" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x703E\x7032\x7051\x7063\x7099\x7092\x70AF\x70F1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x70AC\x70B8\x70B3\x70AE\x70DF\x70CB\x70DD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x70D9\x7109\x70FD\x711C\x7119\x7165\x7155\x7188" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x7166\x7162\x714C\x7156\x716C\x718F\x71FB\x7184" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x7195\x71A8\x71AC\x71D7\x71B9\x71BE\x71D2\x71C9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x71D4\x71CE\x71E0\x71EC\x71E7\x71F5\x71FC\x71F9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x71FF\x720D\x7210\x721B\x7228\x722D\x722C\x7230" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x7232\x723B\x723C\x723F\x7240\x7246\x724B\x7258" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x7274\x727E\x7282\x7281\x7287\x7292\x7296\x72A2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x72A7\x72B9\x72B2\x72C3\x72C6\x72C4\x72CE\x72D2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x72E2\x72E0\x72E1\x72F9\x72F7\x500F\x7317\x730A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x731C\x7316\x731D\x7334\x732F\x7329\x7325\x733E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x734E\x734F\x9ED8\x7357\x736A\x7368\x7370\x7378" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x7375\x737B\x737A\x73C8\x73B3\x73CE\x73BB\x73C0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x73E5\x73EE\x73DE\x74A2\x7405\x746F\x7425\x73F8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x7432\x743A\x7455\x743F\x745F\x7459\x7441\x745C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x7469\x7470\x7463\x746A\x7476\x747E\x748B\x749E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x74A7\x74CA\x74CF\x74D4\x73F1"

-- | The multibyte characters with a lead byte of @0xE1@.
secondE1 :: SecondByteTable
secondE1 :: SecondByteTable
secondE1 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x74E0\x74E3\x74E7\x74E9\x74EE\x74F2\x74F0\x74F1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x74F8\x74F7\x7504\x7503\x7505\x750C\x750E\x750D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x7515\x7513\x751E\x7526\x752C\x753C\x7544\x754D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x754A\x7549\x755B\x7546\x755A\x7569\x7564\x7567" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x756B\x756D\x7578\x7576\x7586\x7587\x7574\x758A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x7589\x7582\x7594\x759A\x759D\x75A5\x75A3\x75C2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x75B3\x75C3\x75B5\x75BD\x75B8\x75BC\x75B1\x75CD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x75CA\x75D2\x75D9\x75E3\x75DE\x75FE\x75FF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x75FC\x7601\x75F0\x75FA\x75F2\x75F3\x760B\x760D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x7609\x761F\x7627\x7620\x7621\x7622\x7624\x7634" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x7630\x763B\x7647\x7648\x7646\x765C\x7658\x7661" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x7662\x7668\x7669\x766A\x7667\x766C\x7670\x7672" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x7676\x7678\x767C\x7680\x7683\x7688\x768B\x768E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x7696\x7693\x7699\x769A\x76B0\x76B4\x76B8\x76B9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x76BA\x76C2\x76CD\x76D6\x76D2\x76DE\x76E1\x76E5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x76E7\x76EA\x862F\x76FB\x7708\x7707\x7704\x7729" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x7724\x771E\x7725\x7726\x771B\x7737\x7738\x7747" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x775A\x7768\x776B\x775B\x7765\x777F\x777E\x7779" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x778E\x778B\x7791\x77A0\x779E\x77B0\x77B6\x77B9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x77BF\x77BC\x77BD\x77BB\x77C7\x77CD\x77D7\x77DA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x77DC\x77E3\x77EE\x77FC\x780C\x7812\x7926\x7820" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x792A\x7845\x788E\x7874\x7886\x787C\x789A\x788C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x78A3\x78B5\x78AA\x78AF\x78D1\x78C6\x78CB\x78D4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x78BE\x78BC\x78C5\x78CA\x78EC"

-- | The multibyte characters with a lead byte of @0xE2@.
secondE2 :: SecondByteTable
secondE2 :: SecondByteTable
secondE2 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x78E7\x78DA\x78FD\x78F4\x7907\x7912\x7911\x7919" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x792C\x792B\x7940\x7960\x7957\x795F\x795A\x7955" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x7953\x797A\x797F\x798A\x799D\x79A7\x9F4B\x79AA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x79AE\x79B3\x79B9\x79BA\x79C9\x79D5\x79E7\x79EC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x79E1\x79E3\x7A08\x7A0D\x7A18\x7A19\x7A20\x7A1F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x7980\x7A31\x7A3B\x7A3E\x7A37\x7A43\x7A57\x7A49" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x7A61\x7A62\x7A69\x9F9D\x7A70\x7A79\x7A7D\x7A88" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x7A97\x7A95\x7A98\x7A96\x7AA9\x7AC8\x7AB0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x7AB6\x7AC5\x7AC4\x7ABF\x9083\x7AC7\x7ACA\x7ACD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x7ACF\x7AD5\x7AD3\x7AD9\x7ADA\x7ADD\x7AE1\x7AE2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x7AE6\x7AED\x7AF0\x7B02\x7B0F\x7B0A\x7B06\x7B33" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x7B18\x7B19\x7B1E\x7B35\x7B28\x7B36\x7B50\x7B7A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x7B04\x7B4D\x7B0B\x7B4C\x7B45\x7B75\x7B65\x7B74" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x7B67\x7B70\x7B71\x7B6C\x7B6E\x7B9D\x7B98\x7B9F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x7B8D\x7B9C\x7B9A\x7B8B\x7B92\x7B8F\x7B5D\x7B99" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x7BCB\x7BC1\x7BCC\x7BCF\x7BB4\x7BC6\x7BDD\x7BE9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x7C11\x7C14\x7BE6\x7BE5\x7C60\x7C00\x7C07\x7C13" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x7BF3\x7BF7\x7C17\x7C0D\x7BF6\x7C23\x7C27\x7C2A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x7C1F\x7C37\x7C2B\x7C3D\x7C4C\x7C43\x7C54\x7C4F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x7C40\x7C50\x7C58\x7C5F\x7C64\x7C56\x7C65\x7C6C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x7C75\x7C83\x7C90\x7CA4\x7CAD\x7CA2\x7CAB\x7CA1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x7CA8\x7CB3\x7CB2\x7CB1\x7CAE\x7CB9\x7CBD\x7CC0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x7CC5\x7CC2\x7CD8\x7CD2\x7CDC\x7CE2\x9B3B\x7CEF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x7CF2\x7CF4\x7CF6\x7CFA\x7D06"

-- | The multibyte characters with a lead byte of @0xE3@.
secondE3 :: SecondByteTable
secondE3 :: SecondByteTable
secondE3 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x7D02\x7D1C\x7D15\x7D0A\x7D45\x7D4B\x7D2E\x7D32" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x7D3F\x7D35\x7D46\x7D73\x7D56\x7D4E\x7D72\x7D68" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x7D6E\x7D4F\x7D63\x7D93\x7D89\x7D5B\x7D8F\x7D7D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x7D9B\x7DBA\x7DAE\x7DA3\x7DB5\x7DC7\x7DBD\x7DAB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x7E3D\x7DA2\x7DAF\x7DDC\x7DB8\x7D9F\x7DB0\x7DD8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x7DDD\x7DE4\x7DDE\x7DFB\x7DF2\x7DE1\x7E05\x7E0A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x7E23\x7E21\x7E12\x7E31\x7E1F\x7E09\x7E0B\x7E22" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x7E46\x7E66\x7E3B\x7E35\x7E39\x7E43\x7E37" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x7E32\x7E3A\x7E67\x7E5D\x7E56\x7E5E\x7E59\x7E5A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x7E79\x7E6A\x7E69\x7E7C\x7E7B\x7E83\x7DD5\x7E7D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x8FAE\x7E7F\x7E88\x7E89\x7E8C\x7E92\x7E90\x7E93" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x7E94\x7E96\x7E8E\x7E9B\x7E9C\x7F38\x7F3A\x7F45" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x7F4C\x7F4D\x7F4E\x7F50\x7F51\x7F55\x7F54\x7F58" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x7F5F\x7F60\x7F68\x7F69\x7F67\x7F78\x7F82\x7F86" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x7F83\x7F88\x7F87\x7F8C\x7F94\x7F9E\x7F9D\x7F9A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x7FA3\x7FAF\x7FB2\x7FB9\x7FAE\x7FB6\x7FB8\x8B71" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x7FC5\x7FC6\x7FCA\x7FD5\x7FD4\x7FE1\x7FE6\x7FE9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x7FF3\x7FF9\x98DC\x8006\x8004\x800B\x8012\x8018" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x8019\x801C\x8021\x8028\x803F\x803B\x804A\x8046" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x8052\x8058\x805A\x805F\x8062\x8068\x8073\x8072" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x8070\x8076\x8079\x807D\x807F\x8084\x8086\x8085" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x809B\x8093\x809A\x80AD\x5190\x80AC\x80DB\x80E5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x80D9\x80DD\x80C4\x80DA\x80D6\x8109\x80EF\x80F1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x811B\x8129\x8123\x812F\x814B"

-- | The multibyte characters with a lead byte of @0xE4@.
secondE4 :: SecondByteTable
secondE4 :: SecondByteTable
secondE4 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x968B\x8146\x813E\x8153\x8151\x80FC\x8171\x816E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x8165\x8166\x8174\x8183\x8188\x818A\x8180\x8182" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x81A0\x8195\x81A4\x81A3\x815F\x8193\x81A9\x81B0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x81B5\x81BE\x81B8\x81BD\x81C0\x81C2\x81BA\x81C9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x81CD\x81D1\x81D9\x81D8\x81C8\x81DA\x81DF\x81E0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x81E7\x81FA\x81FB\x81FE\x8201\x8202\x8205\x8207" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x820A\x820D\x8210\x8216\x8229\x822B\x8238\x8233" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x8240\x8259\x8258\x825D\x825A\x825F\x8264" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x8262\x8268\x826A\x826B\x822E\x8271\x8277\x8278" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x827E\x828D\x8292\x82AB\x829F\x82BB\x82AC\x82E1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x82E3\x82DF\x82D2\x82F4\x82F3\x82FA\x8393\x8303" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x82FB\x82F9\x82DE\x8306\x82DC\x8309\x82D9\x8335" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x8334\x8316\x8332\x8331\x8340\x8339\x8350\x8345" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x832F\x832B\x8317\x8318\x8385\x839A\x83AA\x839F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x83A2\x8396\x8323\x838E\x8387\x838A\x837C\x83B5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x8373\x8375\x83A0\x8389\x83A8\x83F4\x8413\x83EB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x83CE\x83FD\x8403\x83D8\x840B\x83C1\x83F7\x8407" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x83E0\x83F2\x840D\x8422\x8420\x83BD\x8438\x8506" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x83FB\x846D\x842A\x843C\x855A\x8484\x8477\x846B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x84AD\x846E\x8482\x8469\x8446\x842C\x846F\x8479" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x8435\x84CA\x8462\x84B9\x84BF\x849F\x84D9\x84CD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x84BB\x84DA\x84D0\x84C1\x84C6\x84D6\x84A1\x8521" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x84FF\x84F4\x8517\x8518\x852C\x851F\x8515\x8514" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x84FC\x8540\x8563\x8558\x8548"

-- | The multibyte characters with a lead byte of @0xE5@.
secondE5 :: SecondByteTable
secondE5 :: SecondByteTable
secondE5 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x8541\x8602\x854B\x8555\x8580\x85A4\x8588\x8591" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x858A\x85A8\x856D\x8594\x859B\x85EA\x8587\x859C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x8577\x857E\x8590\x85C9\x85BA\x85CF\x85B9\x85D0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x85D5\x85DD\x85E5\x85DC\x85F9\x860A\x8613\x860B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x85FE\x85FA\x8606\x8622\x861A\x8630\x863F\x864D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x4E55\x8654\x865F\x8667\x8671\x8693\x86A3\x86A9" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x86AA\x868B\x868C\x86B6\x86AF\x86C4\x86C6\x86B0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x86C9\x8823\x86AB\x86D4\x86DE\x86E9\x86EC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x86DF\x86DB\x86EF\x8712\x8706\x8708\x8700\x8703" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x86FB\x8711\x8709\x870D\x86F9\x870A\x8734\x873F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x8737\x873B\x8725\x8729\x871A\x8760\x875F\x8778" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x874C\x874E\x8774\x8757\x8768\x876E\x8759\x8753" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x8763\x876A\x8805\x87A2\x879F\x8782\x87AF\x87CB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x87BD\x87C0\x87D0\x96D6\x87AB\x87C4\x87B3\x87C7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x87C6\x87BB\x87EF\x87F2\x87E0\x880F\x880D\x87FE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x87F6\x87F7\x880E\x87D2\x8811\x8816\x8815\x8822" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x8821\x8831\x8836\x8839\x8827\x883B\x8844\x8842" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x8852\x8859\x885E\x8862\x886B\x8881\x887E\x889E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x8875\x887D\x88B5\x8872\x8882\x8897\x8892\x88AE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x8899\x88A2\x888D\x88A4\x88B0\x88BF\x88B1\x88C3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x88C4\x88D4\x88D8\x88D9\x88DD\x88F9\x8902\x88FC" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x88F4\x88E8\x88F2\x8904\x890C\x890A\x8913\x8943" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x891E\x8925\x892A\x892B\x8941\x8944\x893B\x8936" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x8938\x894C\x891D\x8960\x895E"

-- | The multibyte characters with a lead byte of @0xE6@.
secondE6 :: SecondByteTable
secondE6 :: SecondByteTable
secondE6 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x8966\x8964\x896D\x896A\x896F\x8974\x8977\x897E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x8983\x8988\x898A\x8993\x8998\x89A1\x89A9\x89A6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x89AC\x89AF\x89B2\x89BA\x89BD\x89BF\x89C0\x89DA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x89DC\x89DD\x89E7\x89F4\x89F8\x8A03\x8A16\x8A10" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x8A0C\x8A1B\x8A1D\x8A25\x8A36\x8A41\x8A5B\x8A52" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x8A46\x8A48\x8A7C\x8A6D\x8A6C\x8A62\x8A85\x8A82" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x8A84\x8AA8\x8AA1\x8A91\x8AA5\x8AA6\x8A9A\x8AA3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x8AC4\x8ACD\x8AC2\x8ADA\x8AEB\x8AF3\x8AE7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x8AE4\x8AF1\x8B14\x8AE0\x8AE2\x8AF7\x8ADE\x8ADB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x8B0C\x8B07\x8B1A\x8AE1\x8B16\x8B10\x8B17\x8B20" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x8B33\x97AB\x8B26\x8B2B\x8B3E\x8B28\x8B41\x8B4C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x8B4F\x8B4E\x8B49\x8B56\x8B5B\x8B5A\x8B6B\x8B5F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x8B6C\x8B6F\x8B74\x8B7D\x8B80\x8B8C\x8B8E\x8B92" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x8B93\x8B96\x8B99\x8B9A\x8C3A\x8C41\x8C3F\x8C48" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x8C4C\x8C4E\x8C50\x8C55\x8C62\x8C6C\x8C78\x8C7A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x8C82\x8C89\x8C85\x8C8A\x8C8D\x8C8E\x8C94\x8C7C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x8C98\x621D\x8CAD\x8CAA\x8CBD\x8CB2\x8CB3\x8CAE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x8CB6\x8CC8\x8CC1\x8CE4\x8CE3\x8CDA\x8CFD\x8CFA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x8CFB\x8D04\x8D05\x8D0A\x8D07\x8D0F\x8D0D\x8D10" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x9F4E\x8D13\x8CCD\x8D14\x8D16\x8D67\x8D6D\x8D71" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x8D73\x8D81\x8D99\x8DC2\x8DBE\x8DBA\x8DCF\x8DDA" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x8DD6\x8DCC\x8DDB\x8DCB\x8DEA\x8DEB\x8DDF\x8DE3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x8DFC\x8E08\x8E09\x8DFF\x8E1D\x8E1E\x8E10\x8E1F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x8E42\x8E35\x8E30\x8E34\x8E4A"

-- | The multibyte characters with a lead byte of @0xE7@.
secondE7 :: SecondByteTable
secondE7 :: SecondByteTable
secondE7 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x8E47\x8E49\x8E4C\x8E50\x8E48\x8E59\x8E64\x8E60" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x8E2A\x8E63\x8E55\x8E76\x8E72\x8E7C\x8E81\x8E87" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x8E85\x8E84\x8E8B\x8E8A\x8E93\x8E91\x8E94\x8E99" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x8EAA\x8EA1\x8EAC\x8EB0\x8EC6\x8EB1\x8EBE\x8EC5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x8EC8\x8ECB\x8EDB\x8EE3\x8EFC\x8EFB\x8EEB\x8EFE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x8F0A\x8F05\x8F15\x8F12\x8F19\x8F13\x8F1C\x8F1F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x8F1B\x8F0C\x8F26\x8F33\x8F3B\x8F39\x8F45\x8F42" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x8F3E\x8F4C\x8F49\x8F46\x8F4E\x8F57\x8F5C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x8F62\x8F63\x8F64\x8F9C\x8F9F\x8FA3\x8FAD\x8FAF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x8FB7\x8FDA\x8FE5\x8FE2\x8FEA\x8FEF\x9087\x8FF4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x9005\x8FF9\x8FFA\x9011\x9015\x9021\x900D\x901E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x9016\x900B\x9027\x9036\x9035\x9039\x8FF8\x904F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x9050\x9051\x9052\x900E\x9049\x903E\x9056\x9058" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x905E\x9068\x906F\x9076\x96A8\x9072\x9082\x907D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x9081\x9080\x908A\x9089\x908F\x90A8\x90AF\x90B1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x90B5\x90E2\x90E4\x6248\x90DB\x9102\x9112\x9119" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x9132\x9130\x914A\x9156\x9158\x9163\x9165\x9169" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x9173\x9172\x918B\x9189\x9182\x91A2\x91AB\x91AF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x91AA\x91B5\x91B4\x91BA\x91C0\x91C1\x91C9\x91CB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x91D0\x91D6\x91DF\x91E1\x91DB\x91FC\x91F5\x91F6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x921E\x91FF\x9214\x922C\x9215\x9211\x925E\x9257" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x9245\x9249\x9264\x9248\x9295\x923F\x924B\x9250" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x929C\x9296\x9293\x929B\x925A\x92CF\x92B9\x92B7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x92E9\x930F\x92FA\x9344\x932E"

-- | The multibyte characters with a lead byte of @0xE8@.
secondE8 :: SecondByteTable
secondE8 :: SecondByteTable
secondE8 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x9319\x9322\x931A\x9323\x933A\x9335\x933B\x935C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x9360\x937C\x936E\x9356\x93B0\x93AC\x93AD\x9394" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x93B9\x93D6\x93D7\x93E8\x93E5\x93D8\x93C3\x93DD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x93D0\x93C8\x93E4\x941A\x9414\x9413\x9403\x9407" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x9410\x9436\x942B\x9435\x9421\x943A\x9441\x9452" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x9444\x945B\x9460\x9462\x945E\x946A\x9229\x9470" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x9475\x9477\x947D\x945A\x947C\x947E\x9481\x947F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x9582\x9587\x958A\x9594\x9596\x9598\x9599" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x95A0\x95A8\x95A7\x95AD\x95BC\x95BB\x95B9\x95BE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x95CA\x6FF6\x95C3\x95CD\x95CC\x95D5\x95D4\x95D6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x95DC\x95E1\x95E5\x95E2\x9621\x9628\x962E\x962F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x9642\x964C\x964F\x964B\x9677\x965C\x965E\x965D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x965F\x9666\x9672\x966C\x968D\x9698\x9695\x9697" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x96AA\x96A7\x96B1\x96B2\x96B0\x96B4\x96B6\x96B8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x96B9\x96CE\x96CB\x96C9\x96CD\x894D\x96DC\x970D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x96D5\x96F9\x9704\x9706\x9708\x9713\x970E\x9711" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x970F\x9716\x9719\x9724\x972A\x9730\x9739\x973D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x973E\x9744\x9746\x9748\x9742\x9749\x975C\x9760" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x9764\x9766\x9768\x52D2\x976B\x9771\x9779\x9785" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x977C\x9781\x977A\x9786\x978B\x978F\x9790\x979C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x97A8\x97A6\x97A3\x97B3\x97B4\x97C3\x97C6\x97C8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x97CB\x97DC\x97ED\x9F4F\x97F2\x7ADF\x97F6\x97F5" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x980F\x980C\x9838\x9824\x9821\x9837\x983D\x9846" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x984F\x984B\x986B\x986F\x9870"

-- | The multibyte characters with a lead byte of @0xE9@.
secondE9 :: SecondByteTable
secondE9 :: SecondByteTable
secondE9 = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x9871\x9874\x9873\x98AA\x98AF\x98B1\x98B6\x98C4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x98C3\x98C6\x98E9\x98EB\x9903\x9909\x9912\x9914" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x9918\x9921\x991D\x991E\x9924\x9920\x992C\x992E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x993D\x993E\x9942\x9949\x9945\x9950\x994B\x9951" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x9952\x994C\x9955\x9997\x9998\x99A5\x99AD\x99AE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x99BC\x99DF\x99DB\x99DD\x99D8\x99D1\x99ED\x99EE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x99F1\x99F2\x99FB\x99F8\x9A01\x9A0F\x9A05\x99E2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x9A19\x9A2B\x9A37\x9A45\x9A42\x9A40\x9A43" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x9A3E\x9A55\x9A4D\x9A5B\x9A57\x9A5F\x9A62\x9A65" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x9A64\x9A69\x9A6B\x9A6A\x9AAD\x9AB0\x9ABC\x9AC0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x9ACF\x9AD1\x9AD3\x9AD4\x9ADE\x9ADF\x9AE2\x9AE3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x9AE6\x9AEF\x9AEB\x9AEE\x9AF4\x9AF1\x9AF7\x9AFB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x9B06\x9B18\x9B1A\x9B1F\x9B22\x9B23\x9B25\x9B27" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x9B28\x9B29\x9B2A\x9B2E\x9B2F\x9B32\x9B44\x9B43" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x9B4F\x9B4D\x9B4E\x9B51\x9B58\x9B74\x9B93\x9B83" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x9B91\x9B96\x9B97\x9B9F\x9BA0\x9BA8\x9BB4\x9BC0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x9BCA\x9BB9\x9BC6\x9BCF\x9BD1\x9BD2\x9BE3\x9BE2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x9BE4\x9BD4\x9BE1\x9C3A\x9BF2\x9BF1\x9BF0\x9C15" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x9C14\x9C09\x9C13\x9C0C\x9C06\x9C08\x9C12\x9C0A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x9C04\x9C2E\x9C1B\x9C25\x9C24\x9C21\x9C30\x9C47" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x9C32\x9C46\x9C3E\x9C5A\x9C60\x9C67\x9C76\x9C78" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x9CE7\x9CEC\x9CF0\x9D09\x9D08\x9CEB\x9D03\x9D06" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x9D2A\x9D26\x9DAF\x9D23\x9D1F\x9D44\x9D15\x9D12" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x9D41\x9D3F\x9D3E\x9D46\x9D48"

-- | The multibyte characters with a lead byte of @0xEA@.
secondEA :: SecondByteTable
secondEA :: SecondByteTable
secondEA = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x9D5D\x9D5E\x9D64\x9D51\x9D50\x9D59\x9D72\x9D89" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x9D87\x9DAB\x9D6F\x9D7A\x9D9A\x9DA4\x9DA9\x9DB2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x9DC4\x9DC1\x9DBB\x9DB8\x9DBA\x9DC6\x9DCF\x9DC2" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x9DD9\x9DD3\x9DF8\x9DE6\x9DED\x9DEF\x9DFD\x9E1A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x9E1B\x9E1E\x9E75\x9E79\x9E7D\x9E81\x9E88\x9E8B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x9E8C\x9E92\x9E95\x9E91\x9E9D\x9EA5\x9EA9\x9EB8" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x9EAA\x9EAD\x9761\x9ECC\x9ECE\x9ECF\x9ED0\x9ED4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x9EDC\x9EDE\x9EDD\x9EE0\x9EE5\x9EE8\x9EEF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x9EF4\x9EF6\x9EF7\x9EF9\x9EFB\x9EFC\x9EFD\x9F07" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x9F08\x76B7\x9F15\x9F21\x9F2C\x9F3E\x9F4A\x9F52" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x9F54\x9F63\x9F5F\x9F60\x9F61\x9F66\x9F67\x9F6C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x9F6A\x9F77\x9F72\x9F76\x9F95\x9F9C\x9FA0\x582F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x69C7\x9059\x7464\x51DC\x7199" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA5..0xFC-} Int -> [Maybe Char]
nothings Int
0x58

-- | The multibyte characters with a lead byte of @0xEB@.
secondEB :: SecondByteTable
secondEB :: SecondByteTable
secondEB = SecondByteTable
nothingSecond

-- | The multibyte characters with a lead byte of @0xEC@.
secondEC :: SecondByteTable
secondEC :: SecondByteTable
secondEC = SecondByteTable
nothingSecond

-- | The multibyte characters with a lead byte of @0xED@.
secondED :: SecondByteTable
secondED :: SecondByteTable
secondED = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x7E8A\x891C\x9348\x9288\x84DC\x4FC9\x70BB\x6631" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x68C8\x92F9\x66FB\x5F45\x4E28\x4EE1\x4EFC\x4F00" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x4F03\x4F39\x4F56\x4F92\x4F8A\x4F9A\x4F94\x4FCD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x5040\x5022\x4FFF\x501E\x5046\x5070\x5042\x5094" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x50F4\x50D8\x514A\x5164\x519D\x51BE\x51EC\x5215" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x529C\x52A6\x52C0\x52DB\x5300\x5307\x5324\x5372" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x5393\x53B2\x53DD\xFA0E\x549C\x548A\x54A9\x54FF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x5586\x5759\x5765\x57AC\x57C8\x57C7\xFA0F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\xFA10\x589E\x58B2\x590B\x5953\x595B\x595D\x5963" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x59A4\x59BA\x5B56\x5BC0\x752F\x5BD8\x5BEC\x5C1E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x5CA6\x5CBA\x5CF5\x5D27\x5D53\xFA11\x5D42\x5D6D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x5DB8\x5DB9\x5DD0\x5F21\x5F34\x5F67\x5FB7\x5FDE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x605D\x6085\x608A\x60DE\x60D5\x6120\x60F2\x6111" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x6137\x6130\x6198\x6213\x62A6\x63F5\x6460\x649D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x64CE\x654E\x6600\x6615\x663B\x6609\x662E\x661E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x6624\x6665\x6657\x6659\xFA12\x6673\x6699\x66A0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x66B2\x66BF\x66FA\x670E\xF929\x6766\x67BB\x6852" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x67C0\x6801\x6844\x68CF\xFA13\x6968\xFA14\x6998" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x69E2\x6A30\x6A6B\x6A46\x6A73\x6A7E\x6AE2\x6AE4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x6BD6\x6C3F\x6C5C\x6C86\x6C6F\x6CDA\x6D04\x6D87" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x6D6F\x6D96\x6DAC\x6DCF\x6DF8\x6DF2\x6DFC\x6E39" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x6E5C\x6E27\x6E3C\x6EBF\x6F88\x6FB5\x6FF5\x7005" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x7007\x7028\x7085\x70AB\x710F\x7104\x715C\x7146" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x7147\xFA15\x71C1\x71FE\x72B1"

-- | The multibyte characters with a lead byte of @0xEE@.
secondEE :: SecondByteTable
secondEE :: SecondByteTable
secondEE = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x72BE\x7324\xFA16\x7377\x73BD\x73C9\x73D6\x73E3" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x73D2\x7407\x73F5\x7426\x742A\x7429\x742E\x7462" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x7489\x749F\x7501\x756F\x7682\x769C\x769E\x769B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x76A6\xFA17\x7746\x52AF\x7821\x784E\x7864\x787A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x40-}  String -> [Maybe Char]
chars String
"\x7930\xFA18\xFA19\xFA1A\x7994\xFA1B\x799B\x7AD1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x7AE7\xFA1C\x7AEB\x7B9E\xFA1D\x7D48\x7D5C\x7DB7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x7DA0\x7DD6\x7E52\x7F47\x7FA1\xFA1E\x8301\x8362" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x837F\x83C7\x83F6\x8448\x84B4\x8553\x8559" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x856B\xFA1F\x85B0\xFA20\xFA21\x8807\x88F5\x8A12" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x8A37\x8A79\x8AA7\x8ABE\x8ADF\xFA22\x8AF6\x8B53" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x8B7F\x8CF0\x8CF4\x8D12\x8D76\xFA23\x8ECF\xFA24" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\xFA25\x9067\x90DE\xFA26\x9115\x9127\x91DA\x91D7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x91DE\x91ED\x91EE\x91E4\x91E5\x9206\x9210\x920A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x923A\x9240\x923C\x924E\x9259\x9251\x9239\x9267" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x92A7\x9277\x9278\x92E7\x92D7\x92D9\x92D0\xFA27" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x92D5\x92E0\x92D3\x9325\x9321\x92FB\xFA28\x931E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x92FF\x931D\x9302\x9370\x9357\x93A4\x93C6\x93DE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x93F8\x9431\x9445\x9448\x9592\xF9DC\xFA29\x969D" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x96AF\x9733\x973B\x9743\x974D\x974F\x9751\x9755" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x9857\x9865\xFA2A\xFA2B\x9927\xFA2C\x999E\x9A4E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x9AD9\x9ADC\x9B75\x9B72\x9B8F\x9BB1\x9BBB\x9C00" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x9D70\x9D6B\xFA2D\x9E19\x9ED1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Maybe Char]
nothings Int
2 [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xEF..0xF8-}  String -> [Maybe Char]
chars [Char
'\x2170'..Char
'\x2179'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF9-}  String -> [Maybe Char]
chars String
"\xFFE2\xFFE4\xFF07\xFF02"

-- | The multibyte characters with a lead byte of @0xEF@.
secondEF :: SecondByteTable
secondEF :: SecondByteTable
secondEF = SecondByteTable
nothingSecond

-- | The multibyte characters with a lead byte of @0xF0@.
secondF0 :: SecondByteTable
secondF0 :: SecondByteTable
secondF0 = Word16 -> SecondByteTable
privateUseSecond Word16
0xE000

-- | The multibyte characters with a lead byte of @0xF1@.
secondF1 :: SecondByteTable
secondF1 :: SecondByteTable
secondF1 = Word16 -> SecondByteTable
privateUseSecond Word16
0xE0BC

-- | The multibyte characters with a lead byte of @0xF2@.
secondF2 :: SecondByteTable
secondF2 :: SecondByteTable
secondF2 = Word16 -> SecondByteTable
privateUseSecond Word16
0xE178

-- | The multibyte characters with a lead byte of @0xF3@.
secondF3 :: SecondByteTable
secondF3 :: SecondByteTable
secondF3 = Word16 -> SecondByteTable
privateUseSecond Word16
0xE234

-- | The multibyte characters with a lead byte of @0xF4@.
secondF4 :: SecondByteTable
secondF4 :: SecondByteTable
secondF4 = Word16 -> SecondByteTable
privateUseSecond Word16
0xE2F0

-- | The multibyte characters with a lead byte of @0xF5@.
secondF5 :: SecondByteTable
secondF5 :: SecondByteTable
secondF5 = Word16 -> SecondByteTable
privateUseSecond Word16
0xE3AC

-- | The multibyte characters with a lead byte of @0xF6@.
secondF6 :: SecondByteTable
secondF6 :: SecondByteTable
secondF6 = Word16 -> SecondByteTable
privateUseSecond Word16
0xE468

-- | The multibyte characters with a lead byte of @0xF7@.
secondF7 :: SecondByteTable
secondF7 :: SecondByteTable
secondF7 = Word16 -> SecondByteTable
privateUseSecond Word16
0xE524

-- | The multibyte characters with a lead byte of @0xF8@.
secondF8 :: SecondByteTable
secondF8 :: SecondByteTable
secondF8 = Word16 -> SecondByteTable
privateUseSecond Word16
0xE5E0

-- | The multibyte characters with a lead byte of @0xF9@.
secondF9 :: SecondByteTable
secondF9 :: SecondByteTable
secondF9 = Word16 -> SecondByteTable
privateUseSecond Word16
0xE69C

-- | The multibyte characters with a lead byte of @0xFA@.
secondFA :: SecondByteTable
secondFA :: SecondByteTable
secondFA = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40..0x49-}  String -> [Maybe Char]
chars [Char
'\x2170'..Char
'\x2179'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x4A..0x53-}  String -> [Maybe Char]
chars [Char
'\x2160'..Char
'\x2169'] [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x54-}  String -> [Maybe Char]
chars String
"\xFFE2\xFFE4\xFF07\xFF02" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\x3231\x2116\x2121\x2235\x7E8A\x891C\x9348\x9288" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x84DC\x4FC9\x70BB\x6631\x68C8\x92F9\x66FB\x5F45" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x4E28\x4EE1\x4EFC\x4F00\x4F03\x4F39\x4F56\x4F92" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x4F8A\x4F9A\x4F94\x4FCD\x5040\x5022\x4FFF\x501E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x5046\x5070\x5042\x5094\x50F4\x50D8\x514A" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\x5164\x519D\x51BE\x51EC\x5215\x529C\x52A6\x52C0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x52DB\x5300\x5307\x5324\x5372\x5393\x53B2\x53DD" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\xFA0E\x549C\x548A\x54A9\x54FF\x5586\x5759\x5765" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x57AC\x57C8\x57C7\xFA0F\xFA10\x589E\x58B2\x590B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\x5953\x595B\x595D\x5963\x59A4\x59BA\x5B56\x5BC0" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x752F\x5BD8\x5BEC\x5C1E\x5CA6\x5CBA\x5CF5\x5D27" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x5D53\xFA11\x5D42\x5D6D\x5DB8\x5DB9\x5DD0\x5F21" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x5F34\x5F67\x5FB7\x5FDE\x605D\x6085\x608A\x60DE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x60D5\x6120\x60F2\x6111\x6137\x6130\x6198\x6213" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x62A6\x63F5\x6460\x649D\x64CE\x654E\x6600\x6615" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x663B\x6609\x662E\x661E\x6624\x6665\x6657\x6659" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\xFA12\x6673\x6699\x66A0\x66B2\x66BF\x66FA\x670E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\xF929\x6766\x67BB\x6852\x67C0\x6801\x6844\x68CF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\xFA13\x6968\xFA14\x6998\x69E2\x6A30\x6A6B\x6A46" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x6A73\x6A7E\x6AE2\x6AE4\x6BD6\x6C3F\x6C5C\x6C86" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x6C6F\x6CDA\x6D04\x6D87\x6D6F"

-- | The multibyte characters with a lead byte of @0xFB@.
secondFB :: SecondByteTable
secondFB :: SecondByteTable
secondFB = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x6D96\x6DAC\x6DCF\x6DF8\x6DF2\x6DFC\x6E39\x6E5C" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x6E27\x6E3C\x6EBF\x6F88\x6FB5\x6FF5\x7005\x7007" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x50-}  String -> [Maybe Char]
chars String
"\x7028\x7085\x70AB\x710F\x7104\x715C\x7146\x7147" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x58-}  String -> [Maybe Char]
chars String
"\xFA15\x71C1\x71FE\x72B1\x72BE\x7324\xFA16\x7377" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x60-}  String -> [Maybe Char]
chars String
"\x73BD\x73C9\x73D6\x73E3\x73D2\x7407\x73F5\x7426" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x68-}  String -> [Maybe Char]
chars String
"\x742A\x7429\x742E\x7462\x7489\x749F\x7501\x756F" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x70-}  String -> [Maybe Char]
chars String
"\x7682\x769C\x769E\x769B\x76A6\xFA17\x7746\x52AF" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x78-}  String -> [Maybe Char]
chars String
"\x7821\x784E\x7864\x787A\x7930\xFA18\xFA19" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++ Maybe Char
forall a. Maybe a
Nothing Maybe Char -> [Maybe Char] -> [Maybe Char]
forall a. a -> [a] -> [a]
:
    {-0x80-}  String -> [Maybe Char]
chars String
"\xFA1A\x7994\xFA1B\x799B\x7AD1\x7AE7\xFA1C\x7AEB" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x88-}  String -> [Maybe Char]
chars String
"\x7B9E\xFA1D\x7D48\x7D5C\x7DB7\x7DA0\x7DD6\x7E52" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x90-}  String -> [Maybe Char]
chars String
"\x7F47\x7FA1\xFA1E\x8301\x8362\x837F\x83C7\x83F6" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x98-}  String -> [Maybe Char]
chars String
"\x8448\x84B4\x8553\x8559\x856B\xFA1F\x85B0\xFA20" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA0-}  String -> [Maybe Char]
chars String
"\xFA21\x8807\x88F5\x8A12\x8A37\x8A79\x8AA7\x8ABE" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xA8-}  String -> [Maybe Char]
chars String
"\x8ADF\xFA22\x8AF6\x8B53\x8B7F\x8CF0\x8CF4\x8D12" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB0-}  String -> [Maybe Char]
chars String
"\x8D76\xFA23\x8ECF\xFA24\xFA25\x9067\x90DE\xFA26" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xB8-}  String -> [Maybe Char]
chars String
"\x9115\x9127\x91DA\x91D7\x91DE\x91ED\x91EE\x91E4" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC0-}  String -> [Maybe Char]
chars String
"\x91E5\x9206\x9210\x920A\x923A\x9240\x923C\x924E" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xC8-}  String -> [Maybe Char]
chars String
"\x9259\x9251\x9239\x9267\x92A7\x9277\x9278\x92E7" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD0-}  String -> [Maybe Char]
chars String
"\x92D7\x92D9\x92D0\xFA27\x92D5\x92E0\x92D3\x9325" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xD8-}  String -> [Maybe Char]
chars String
"\x9321\x92FB\xFA28\x931E\x92FF\x931D\x9302\x9370" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE0-}  String -> [Maybe Char]
chars String
"\x9357\x93A4\x93C6\x93DE\x93F8\x9431\x9445\x9448" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xE8-}  String -> [Maybe Char]
chars String
"\x9592\xF9DC\xFA29\x969D\x96AF\x9733\x973B\x9743" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF0-}  String -> [Maybe Char]
chars String
"\x974D\x974F\x9751\x9755\x9857\x9865\xFA2A\xFA2B" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0xF8-}  String -> [Maybe Char]
chars String
"\x9927\xFA2C\x999E\x9A4E\x9AD9"

-- | The multibyte characters with a lead byte of @0xFC@.
secondFC :: SecondByteTable
secondFC :: SecondByteTable
secondFC = [Maybe Char] -> SecondByteTable
forall a. [a] -> Vector a
V.fromList ([Maybe Char] -> SecondByteTable)
-> [Maybe Char] -> SecondByteTable
forall a b. (a -> b) -> a -> b
$
    {-0x40-}  String -> [Maybe Char]
chars String
"\x9ADC\x9B75\x9B72\x9B8F\x9BB1\x9BBB\x9C00\x9D70" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x48-}  String -> [Maybe Char]
chars String
"\x9D6B\xFA2D\x9E19\x9ED1" [Maybe Char] -> [Maybe Char] -> [Maybe Char]
forall a. [a] -> [a] -> [a]
++
    {-0x4C..0xFC-} Int -> [Maybe Char]
nothings Int
0xB1