{-# 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 ( Eq, Ord, Show, 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 ( Eq, Ord, Show, Read ) instance Bounded JISChar where minBound = Single minBound maxBound = Double 0xFC 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 i | i <= 0xFC = Single $ fromIntegral i | otherwise = Double l t where (d, m) = divMod (i - 0xFD) 0xBC l = fromIntegral d + if d >= 0x1F -- First index of second table group (0xE0) minus first value of d here (0x1F) then 0xC1 -- First index of first table group else 0x81 -- First byte in trail tables t = fromIntegral m + 0x40 fromEnum (Single c) = fromIntegral 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 l t) = (l' * 0xBC) + fromIntegral t + 0xBD where l' = fromIntegral l - if l > 0x9F then 0xE0 else 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 ( Eq, Show, 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 ( Eq, Show, 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' = fmap T.pack . decodeMsJIS'' . 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'' [] = Right "" decodeMsJIS'' (b1:bs) = case lookupJIS b1 $ Y.listToMaybe bs of (Left err, _) -> Left err (Right c, w) -> fmap (c :) . decodeMsJIS'' $ if w then drop 1 bs else 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 e = T.pack . decodeMsJISWith' e . 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' _ [] = "" decodeMsJISWith' e (b1:bs) = case lookupJIS b1 $ Y.listToMaybe bs of (Left (JISDecodeError msg err), w) -> maybe (loop w) (: loop w) $ e msg err (Right c, w) -> c : loop w where loop _ | null bs = "" loop w = decodeMsJISWith' e $ if w then drop 1 bs else 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' = T.foldl' (\bs -> throwEncode bs . flatten . lookupUnicode) (Right BS.empty) where throwEncode e@(Left _) _ = e throwEncode _ (Left c) = Left $ JISEncodeError (encodeErrorString "encodeMsJIS'") c throwEncode (Right bs) (Right bs') = Right $ mappend bs 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 e = T.foldl' (\bs -> throwEncode bs . flatten . lookupUnicode) BS.empty where throwEncode bs (Left c) = Y.fromMaybe bs $ e (encodeErrorString "encodeMsJISWith") c throwEncode bs (Right bs') = mappend bs bs' -- | There is only a single reason why encoding to Shift JIS may fail. encodeErrorString :: String -> String encodeErrorString func = func ++ ": 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 (Right []) = Left Nothing flatten (Right (bs:_)) = Right bs flatten (Left e) = Left $ Just 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 = V.fromList $ {-0x00..0x7F-} map Lone ['\NUL'..'\DEL'] ++ {-0x80..0x9F-} None : replicate 0x1F Lead ++ {-0xA0..0xDF-} None : map Lone ['\xFF61'..'\xFF9F'] ++ {-0xE0..0xFC-} replicate 0x1D Lead ++ {-0xFD..0xFF-} replicate 3 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 = V.fromList $ [ second81, second82, second83, second84, second85, second86, second87 ] ++ [ second88, second89, second8A, second8B, second8C, second8D, second8E, second8F ] ++ [ second90, second91, second92, second93, second94, second95, second96, second97 ] ++ [ second98, second99, second9A, second9B, second9C, second9D, second9E, second9F ] ++ [ secondE0, secondE1, secondE2, secondE3, secondE4, secondE5, secondE6, secondE7 ] ++ [ secondE8, secondE9, secondEA, secondEB, secondEC, secondED, secondEE, secondEF ] ++ [ secondF0, secondF1, secondF2, secondF3, secondF4, secondF5, secondF6, secondF7 ] ++ [ secondF8, secondF9, secondFA, secondFB, 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 l t' = case (lookupLead l, t') of (SingleByte c, _) -> (Right c, False) (MultiByte _, Nothing) -> (err "Input ended without trail byte" $ Single l, False) (MultiByte ts, Just t) -> let found = ts ! (fromIntegral t - 0x40) in (maybe (err "Unassigned trail byte" $ Double l t) Right found, True) (NoChar e, _) -> (Left e, False) where err msg char = Left . JISDecodeError ("lookupJIS: " ++ msg) $ Just char -- | Given the first byte in a (potentially multibyte) Shift JIS binary -- representation, try to retrieve the associated character. lookupLead :: W.Word8 -> LeadResult lookupLead w = case firstBytes ! fromIntegral w of Lone c -> SingleByte c Lead -> maybe (err "Invalid lead byte") MultiByte $ lookupTrailTable w None -> err "Unassigned lead byte" where err msg = NoChar . JISDecodeError ("lookupJIS: " ++ msg) . Just $ Single 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 l | l < 0x81 || (l > 0x9F && l < 0xE0) || l > 0xFC = Nothing | l <= 0x9F = Just $ secondBytes ! (fromIntegral l - 0x81) | otherwise = Just $ secondBytes ! (fromIntegral l - 0xC1) -- | The lookup table from Unicode character reference number to Shift JIS -- binary representation. unicodeMap :: M.IntMap [JISChar] unicodeMap = M.fromListWith (++) . V.toList $ V.imapMaybe keyFirsts firstBytes V.++ V.concat (V.toList $ V.imap keySeconds 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 l (Lone j) = Just (fromEnum j, [Single $ fromIntegral l]) keyFirsts _ _ = 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 l = V.imapMaybe (\t j -> m (Double l' $ fromIntegral t + 0x40) <$> j) where l' = fromIntegral $ l + if l < 0x1F then 0x81 else 0xC1 m t' j' = (fromEnum j', [t']) -- | Given a particular character, retrieve all its potential binary -- representations in the Shift JIS encoding scheme. lookupUnicode :: Char -> Either Char [BS.ByteString] lookupUnicode c = case M.lookup (fromEnum c) unicodeMap of Just js -> Right $ map pack js Nothing -> Left c where pack (Single w) = BS.singleton w pack (Double l t) = BS.pack [l, t] -- * Multi-byte lookup tables -- | A continuous sequence of valid multibyte characters. chars :: String -> [Maybe Char] chars = map Just -- | A continuous sequence of unassigned multibyte characters. nothings :: Int -> [Maybe Char] nothings = flip replicate Nothing -- | Generate an entire table of "valid" multibyte characters, without any -- actual assigned characters. nothingSecond :: SecondByteTable nothingSecond = V.replicate 0xC0 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 b = V.fromList $ {-0x40..0x7F-} map (Just . toEnum . fromIntegral) [b..b + 0x3E] ++ Nothing : {-0x80..0xFC-} map (Just . toEnum . fromIntegral) [b + 0x3F..b + 0xBB] -- | The multibyte characters with a lead byte of @0x81@. second81 :: SecondByteTable second81 = V.fromList $ {-0x40-} chars "\x3000\x3001\x3002\xFF0C\xFF0E\x30FB\xFF1A\xFF1B" ++ {-0x48-} chars "\xFF1F\xFF01\x309B\x309C\x00B4\xFF40\x00A8\xFF3E" ++ {-0x50-} chars "\xFFE3\xFF3F\x30FD\x30FE\x309D\x309E\x3003\x4EDD" ++ {-0x58-} chars "\x3005\x3006\x3007\x30FC\x2015\x2010\xFF0F\xFF3C" ++ {-0x60-} chars "\xFF5E\x2225\xFF5C\x2026\x2025\x2018\x2019\x201C" ++ {-0x68-} chars "\x201D\xFF08\xFF09\x3014\x3015\xFF3B\xFF3D\xFF5B" ++ {-0x70-} chars "\xFF5D\x3008\x3009\x300A\x300B\x300C\x300D\x300E" ++ {-0x78-} chars "\x300F\x3010\x3011\xFF0B\xFF0D\x00B1\x00D7" ++ Nothing : {-0x80-} chars "\x00F7\xFF1D\x2260\xFF1C\xFF1E\x2266\x2267\x221E" ++ {-0x88-} chars "\x2234\x2642\x2640\x00B0\x2032\x2033\x2103\xFFE5" ++ {-0x90-} chars "\xFF04\xFFE0\xFFE1\xFF05\xFF03\xFF06\xFF0A\xFF20" ++ {-0x98-} chars "\x00A7\x2606\x2605\x25CB\x25CF\x25CE\x25C7\x25C6" ++ {-0xA0-} chars "\x25A1\x25A0\x25B3\x25B2\x25BD\x25BC\x203B\x3012" ++ {-0xA8-} chars "\x2192\x2190\x2191\x2193\x3013" ++ nothings 3 ++ {-0xB0-} nothings 8 ++ {-0xB8-} chars "\x2208\x220B\x2286\x2287\x2282\x2283\x222A\x2229" ++ {-0xC0-} nothings 8 ++ {-0xC8-} chars "\x2227\x2228\xFFE2\x21D2\x21D4\x2200\x2203" ++ Nothing : {-0xD0-} nothings 8 ++ {-0xD8-} nothings 2 ++ chars "\x2220\x22A5\x2312\x2202\x2207\x2261" ++ {-0xE0-} chars "\x2252\x226A\x226B\x221A\x223D\x221D\x2235\x222B" ++ {-0xE8-} Just '\x222C' : nothings 7 ++ {-0xF0-} chars "\x212B\x2030\x266F\x266D\x266A\x2020\x2021\x00B6" ++ {-0xF8-} nothings 4 ++ [Just '\x25EF'] -- | The multibyte characters with a lead byte of @0x82@. second82 :: SecondByteTable second82 = V.fromList $ {-0x40..0x4E-} nothings 15 ++ {-0x4F..0x58-} chars ['\xFF10'..'\xFF19'] ++ {-0x59..0x5F-} nothings 7 ++ {-0x60..0x79-} chars ['\xFF21'..'\xFF3A'] ++ {-0x7A..0x80-} nothings 7 ++ {-0x81..0x9A-} chars ['\xFF41'..'\xFF5A'] ++ {-0x9B..0x9E-} nothings 4 ++ {-0x9F..0xF1-} chars ['\x3041'..'\x3093'] ++ {-0xF2..0xFC-} nothings 11 -- | The multibyte characters with a lead byte of @0x83@. second83 :: SecondByteTable second83 = V.fromList $ {-0x40..0x7F-} chars ['\x30A1'..'\x30DF'] ++ Nothing : {-0x80..0x96-} chars ['\x30E0'..'\x30F6'] ++ {-0x97..0x9E-} nothings 8 ++ {-0x9F..0xAF-} chars ['\x0391'..'\x03A1'] ++ {-0xB0..0xB6-} chars ['\x03A3'..'\x03A9'] ++ {-0xB7..0xBE-} nothings 8 ++ {-0xBF..0xCF-} chars ['\x03B1'..'\x03C1'] ++ {-0xD0..0xD6-} chars ['\x03C3'..'\x03C9'] ++ {-0xD7..0xFC-} nothings 0x26 -- | The multibyte characters with a lead byte of @0x84@. second84 :: SecondByteTable second84 = V.fromList $ {-0x40..0x46-} chars ['\x0410'..'\x0415'] ++ Just '\x0401' : {-0x47..0x60-} chars ['\x0416'..'\x042F'] ++ {-0x61..0x6F-} nothings 15 ++ {-0x60..0x66-} chars ['\x0430'..'\x0435'] ++ Just '\x0451' : {-0x67..0x7F-} chars ['\x0436'..'\x043D'] ++ Nothing : {-0x80..0x91-} chars ['\x043E'..'\x044F'] ++ {-0x92..0x9F-} nothings 13 ++ Just '\x2500' : {-0xA0-} chars "\x2502\x250C\x2510\x2518\x2514\x251C\x252C\x2524" ++ {-0xA8-} chars "\x2534\x253C\x2501\x2503\x250F\x2513\x251B\x2517" ++ {-0xB0-} chars "\x2523\x2533\x252B\x253B\x254B\x2520\x252F\x2528" ++ {-0xB8-} chars "\x2537\x253F\x251D\x2530\x2525\x2538\x2542" ++ {-0xBF..0xFC-} nothings 0x3E -- | The multibyte characters with a lead byte of @0x85@. second85 :: SecondByteTable second85 = nothingSecond -- | The multibyte characters with a lead byte of @0x86@. second86 :: SecondByteTable second86 = nothingSecond -- | The multibyte characters with a lead byte of @0x87@. second87 :: SecondByteTable second87 = V.fromList $ {-0x40..0x53-} chars ['\x2460'..'\x2473'] ++ {-0x54..0x5F-} chars ['\x2160'..'\x2169'] ++ Nothing : Just '\x3349' : {-0x60-} chars "\x3314\x3322\x334D\x3318\x3327\x3303\x3336\x3351" ++ {-0x68-} chars "\x3357\x330D\x3326\x3323\x332B\x334A\x333B\x339C" ++ {-0x70-} chars "\x339D\x339E\x338E\x338F\x33C4\x33A1" ++ {-0x76..0x7F-} nothings 8 ++ Just '\x337B' : Nothing : {-0x80-} chars "\x301D\x301F\x2116\x33CD\x2121\x32A4\x32A5\x32A6" ++ {-0x88-} chars "\x32A7\x32A8\x3231\x3232\x3239\x337E\x337D\x337C" ++ {-0x90-} chars "\x2252\x2261\x222B\x222E\x2211\x221A\x22A5\x2220" ++ {-0x98-} chars "\x221F\x22BF\x2235\x2229\x222A" ++ {-0x9D..0xFC-} nothings 0x60 -- | The multibyte characters with a lead byte of @0x88@. second88 :: SecondByteTable second88 = V.fromList $ {-0x40..0x9F-} nothings 0x5F ++ Just '\x4E9C' : {-0xA0-} chars "\x5516\x5A03\x963F\x54C0\x611B\x6328\x59F6\x9022" ++ {-0xA8-} chars "\x8475\x831C\x7A50\x60AA\x63E1\x6E25\x65ED\x8466" ++ {-0xB0-} chars "\x82A6\x9BF5\x6893\x5727\x65A1\x6271\x5B9B\x59D0" ++ {-0xB8-} chars "\x867B\x98F4\x7D62\x7DBE\x9B8E\x6216\x7C9F\x88B7" ++ {-0xC0-} chars "\x5B89\x5EB5\x6309\x6697\x6848\x95C7\x978D\x674F" ++ {-0xC8-} chars "\x4EE5\x4F0A\x4F4D\x4F9D\x5049\x56F2\x5937\x59D4" ++ {-0xD0-} chars "\x5A01\x5C09\x60DF\x610F\x6170\x6613\x6905\x70BA" ++ {-0xD8-} chars "\x754F\x7570\x79FB\x7DAD\x7DEF\x80C3\x840E\x8863" ++ {-0xE0-} chars "\x8B02\x9055\x907A\x533B\x4E95\x4EA5\x57DF\x80B2" ++ {-0xE8-} chars "\x90C1\x78EF\x4E00\x58F1\x6EA2\x9038\x7A32\x8328" ++ {-0xF0-} chars "\x828B\x9C2F\x5141\x5370\x54BD\x54E1\x56E0\x59FB" ++ {-0xF8-} chars "\x5F15\x98F2\x6DEB\x80E4\x852D" -- | The multibyte characters with a lead byte of @0x89@. second89 :: SecondByteTable second89 = V.fromList $ {-0x40-} chars "\x9662\x9670\x96A0\x97FB\x540B\x53F3\x5B87\x70CF" ++ {-0x48-} chars "\x7FBD\x8FC2\x96E8\x536F\x9D5C\x7ABA\x4E11\x7893" ++ {-0x50-} chars "\x81FC\x6E26\x5618\x5504\x6B1D\x851A\x9C3B\x59E5" ++ {-0x58-} chars "\x53A9\x6D66\x74DC\x958F\x5642\x4E91\x904B\x96F2" ++ {-0x60-} chars "\x834F\x990C\x53E1\x55B6\x5B30\x5F71\x6620\x66F3" ++ {-0x68-} chars "\x6804\x6C38\x6CF3\x6D29\x745B\x76C8\x7A4E\x9834" ++ {-0x70-} chars "\x82F1\x885B\x8A60\x92ED\x6DB2\x75AB\x76CA\x99C5" ++ {-0x78-} chars "\x60A6\x8B01\x8D8A\x95B2\x698E\x53AD\x5186" ++ Nothing : {-0x80-} chars "\x5712\x5830\x5944\x5BB4\x5EF6\x6028\x63A9\x63F4" ++ {-0x88-} chars "\x6CBF\x6F14\x708E\x7114\x7159\x71D5\x733F\x7E01" ++ {-0x90-} chars "\x8276\x82D1\x8597\x9060\x925B\x9D1B\x5869\x65BC" ++ {-0x98-} chars "\x6C5A\x7525\x51F9\x592E\x5965\x5F80\x5FDC\x62BC" ++ {-0xA0-} chars "\x65FA\x6A2A\x6B27\x6BB4\x738B\x7FC1\x8956\x9D2C" ++ {-0xA8-} chars "\x9D0E\x9EC4\x5CA1\x6C96\x837B\x5104\x5C4B\x61B6" ++ {-0xB0-} chars "\x81C6\x6876\x7261\x4E59\x4FFA\x5378\x6069\x6E29" ++ {-0xB8-} chars "\x7A4F\x97F3\x4E0B\x5316\x4EEE\x4F55\x4F3D\x4FA1" ++ {-0xC0-} chars "\x4F73\x52A0\x53EF\x5609\x590F\x5AC1\x5BB6\x5BE1" ++ {-0xC8-} chars "\x79D1\x6687\x679C\x67B6\x6B4C\x6CB3\x706B\x73C2" ++ {-0xD0-} chars "\x798D\x79BE\x7A3C\x7B87\x82B1\x82DB\x8304\x8377" ++ {-0xD8-} chars "\x83EF\x83D3\x8766\x8AB2\x5629\x8CA8\x8FE6\x904E" ++ {-0xE0-} chars "\x971E\x868A\x4FC4\x5CE8\x6211\x7259\x753B\x81E5" ++ {-0xE8-} chars "\x82BD\x86FE\x8CC0\x96C5\x9913\x99D5\x4ECB\x4F1A" ++ {-0xF0-} chars "\x89E3\x56DE\x584A\x58CA\x5EFB\x5FEB\x602A\x6094" ++ {-0xF8-} chars "\x6062\x61D0\x6212\x62D0\x6539" -- | The multibyte characters with a lead byte of @0x8A@. second8A :: SecondByteTable second8A = V.fromList $ {-0x40-} chars "\x9B41\x6666\x68B0\x6D77\x7070\x754C\x7686\x7D75" ++ {-0x48-} chars "\x82A5\x87F9\x958B\x968E\x8C9D\x51F1\x52BE\x5916" ++ {-0x50-} chars "\x54B3\x5BB3\x5D16\x6168\x6982\x6DAF\x788D\x84CB" ++ {-0x58-} chars "\x8857\x8A72\x93A7\x9AB8\x6D6C\x99A8\x86D9\x57A3" ++ {-0x60-} chars "\x67FF\x86CE\x920E\x5283\x5687\x5404\x5ED3\x62E1" ++ {-0x68-} chars "\x64B9\x683C\x6838\x6BBB\x7372\x78BA\x7A6B\x899A" ++ {-0x70-} chars "\x89D2\x8D6B\x8F03\x90ED\x95A3\x9694\x9769\x5B66" ++ {-0x78-} chars "\x5CB3\x697D\x984D\x984E\x639B\x7B20\x6A2B" ++ Nothing : {-0x80-} chars "\x6A7F\x68B6\x9C0D\x6F5F\x5272\x559D\x6070\x62EC" ++ {-0x88-} chars "\x6D3B\x6E07\x6ED1\x845B\x8910\x8F44\x4E14\x9C39" ++ {-0x90-} chars "\x53F6\x691B\x6A3A\x9784\x682A\x515C\x7AC3\x84B2" ++ {-0x98-} chars "\x91DC\x938C\x565B\x9D28\x6822\x8305\x8431\x7CA5" ++ {-0xA0-} chars "\x5208\x82C5\x74E6\x4E7E\x4F83\x51A0\x5BD2\x520A" ++ {-0xA8-} chars "\x52D8\x52E7\x5DFB\x559A\x582A\x59E6\x5B8C\x5B98" ++ {-0xB0-} chars "\x5BDB\x5E72\x5E79\x60A3\x611F\x6163\x61BE\x63DB" ++ {-0xB8-} chars "\x6562\x67D1\x6853\x68FA\x6B3E\x6B53\x6C57\x6F22" ++ {-0xC0-} chars "\x6F97\x6F45\x74B0\x7518\x76E3\x770B\x7AFF\x7BA1" ++ {-0xC8-} chars "\x7C21\x7DE9\x7F36\x7FF0\x809D\x8266\x839E\x89B3" ++ {-0xD0-} chars "\x8ACC\x8CAB\x9084\x9451\x9593\x9591\x95A2\x9665" ++ {-0xD8-} chars "\x97D3\x9928\x8218\x4E38\x542B\x5CB8\x5DCC\x73A9" ++ {-0xE0-} chars "\x764C\x773C\x5CA9\x7FEB\x8D0B\x96C1\x9811\x9854" ++ {-0xE8-} chars "\x9858\x4F01\x4F0E\x5371\x559C\x5668\x57FA\x5947" ++ {-0xF0-} chars "\x5B09\x5BC4\x5C90\x5E0C\x5E7E\x5FCC\x63EE\x673A" ++ {-0xF8-} chars "\x65D7\x65E2\x671F\x68CB\x68C4" -- | The multibyte characters with a lead byte of @0x8B@. second8B :: SecondByteTable second8B = V.fromList $ {-0x40-} chars "\x6A5F\x5E30\x6BC5\x6C17\x6C7D\x757F\x7948\x5B63" ++ {-0x48-} chars "\x7A00\x7D00\x5FBD\x898F\x8A18\x8CB4\x8D77\x8ECC" ++ {-0x50-} chars "\x8F1D\x98E2\x9A0E\x9B3C\x4E80\x507D\x5100\x5993" ++ {-0x58-} chars "\x5B9C\x622F\x6280\x64EC\x6B3A\x72A0\x7591\x7947" ++ {-0x60-} chars "\x7FA9\x87FB\x8ABC\x8B70\x63AC\x83CA\x97A0\x5409" ++ {-0x68-} chars "\x5403\x55AB\x6854\x6A58\x8A70\x7827\x6775\x9ECD" ++ {-0x70-} chars "\x5374\x5BA2\x811A\x8650\x9006\x4E18\x4E45\x4EC7" ++ {-0x78-} chars "\x4F11\x53CA\x5438\x5BAE\x5F13\x6025\x6551" ++ Nothing : {-0x80-} chars "\x673D\x6C42\x6C72\x6CE3\x7078\x7403\x7A76\x7AAE" ++ {-0x88-} chars "\x7B08\x7D1A\x7CFE\x7D66\x65E7\x725B\x53BB\x5C45" ++ {-0x90-} chars "\x5DE8\x62D2\x62E0\x6319\x6E20\x865A\x8A31\x8DDD" ++ {-0x98-} chars "\x92F8\x6F01\x79A6\x9B5A\x4EA8\x4EAB\x4EAC\x4F9B" ++ {-0xA0-} chars "\x4FA0\x50D1\x5147\x7AF6\x5171\x51F6\x5354\x5321" ++ {-0xA8-} chars "\x537F\x53EB\x55AC\x5883\x5CE1\x5F37\x5F4A\x602F" ++ {-0xB0-} chars "\x6050\x606D\x631F\x6559\x6A4B\x6CC1\x72C2\x72ED" ++ {-0xB8-} chars "\x77EF\x80F8\x8105\x8208\x854E\x90F7\x93E1\x97FF" ++ {-0xC0-} chars "\x9957\x9A5A\x4EF0\x51DD\x5C2D\x6681\x696D\x5C40" ++ {-0xC8-} chars "\x66F2\x6975\x7389\x6850\x7C81\x50C5\x52E4\x5747" ++ {-0xD0-} chars "\x5DFE\x9326\x65A4\x6B23\x6B3D\x7434\x7981\x79BD" ++ {-0xD8-} chars "\x7B4B\x7DCA\x82B9\x83CC\x887F\x895F\x8B39\x8FD1" ++ {-0xE0-} chars "\x91D1\x541F\x9280\x4E5D\x5036\x53E5\x533A\x72D7" ++ {-0xE8-} chars "\x7396\x77E9\x82E6\x8EAF\x99C6\x99C8\x99D2\x5177" ++ {-0xF0-} chars "\x611A\x865E\x55B0\x7A7A\x5076\x5BD3\x9047\x9685" ++ {-0xF8-} chars "\x4E32\x6ADB\x91E7\x5C51\x5C48" -- | The multibyte characters with a lead byte of @0x8C@. second8C :: SecondByteTable second8C = V.fromList $ {-0x40-} chars "\x6398\x7A9F\x6C93\x9774\x8F61\x7AAA\x718A\x9688" ++ {-0x48-} chars "\x7C82\x6817\x7E70\x6851\x936C\x52F2\x541B\x85AB" ++ {-0x50-} chars "\x8A13\x7FA4\x8ECD\x90E1\x5366\x8888\x7941\x4FC2" ++ {-0x58-} chars "\x50BE\x5211\x5144\x5553\x572D\x73EA\x578B\x5951" ++ {-0x60-} chars "\x5F62\x5F84\x6075\x6176\x6167\x61A9\x63B2\x643A" ++ {-0x68-} chars "\x656C\x666F\x6842\x6E13\x7566\x7A3D\x7CFB\x7D4C" ++ {-0x70-} chars "\x7D99\x7E4B\x7F6B\x830E\x834A\x86CD\x8A08\x8A63" ++ {-0x78-} chars "\x8B66\x8EFD\x981A\x9D8F\x82B8\x8FCE\x9BE8" ++ Nothing : {-0x80-} chars "\x5287\x621F\x6483\x6FC0\x9699\x6841\x5091\x6B20" ++ {-0x88-} chars "\x6C7A\x6F54\x7A74\x7D50\x8840\x8A23\x6708\x4EF6" ++ {-0x90-} chars "\x5039\x5026\x5065\x517C\x5238\x5263\x55A7\x570F" ++ {-0x98-} chars "\x5805\x5ACC\x5EFA\x61B2\x61F8\x62F3\x6372\x691C" ++ {-0xA0-} chars "\x6A29\x727D\x72AC\x732E\x7814\x786F\x7D79\x770C" ++ {-0xA8-} chars "\x80A9\x898B\x8B19\x8CE2\x8ED2\x9063\x9375\x967A" ++ {-0xB0-} chars "\x9855\x9A13\x9E78\x5143\x539F\x53B3\x5E7B\x5F26" ++ {-0xB8-} chars "\x6E1B\x6E90\x7384\x73FE\x7D43\x8237\x8A00\x8AFA" ++ {-0xC0-} chars "\x9650\x4E4E\x500B\x53E4\x547C\x56FA\x59D1\x5B64" ++ {-0xC8-} chars "\x5DF1\x5EAB\x5F27\x6238\x6545\x67AF\x6E56\x72D0" ++ {-0xD0-} chars "\x7CCA\x88B4\x80A1\x80E1\x83F0\x864E\x8A87\x8DE8" ++ {-0xD8-} chars "\x9237\x96C7\x9867\x9F13\x4E94\x4E92\x4F0D\x5348" ++ {-0xE0-} chars "\x5449\x543E\x5A2F\x5F8C\x5FA1\x609F\x68A7\x6A8E" ++ {-0xE8-} chars "\x745A\x7881\x8A9E\x8AA4\x8B77\x9190\x4E5E\x9BC9" ++ {-0xF0-} chars "\x4EA4\x4F7C\x4FAF\x5019\x5016\x5149\x516C\x529F" ++ {-0xF8-} chars "\x52B9\x52FE\x539A\x53E3\x5411" -- | The multibyte characters with a lead byte of @0x8D@. second8D :: SecondByteTable second8D = V.fromList $ {-0x40-} chars "\x540E\x5589\x5751\x57A2\x597D\x5B54\x5B5D\x5B8F" ++ {-0x48-} chars "\x5DE5\x5DE7\x5DF7\x5E78\x5E83\x5E9A\x5EB7\x5F18" ++ {-0x50-} chars "\x6052\x614C\x6297\x62D8\x63A7\x653B\x6602\x6643" ++ {-0x58-} chars "\x66F4\x676D\x6821\x6897\x69CB\x6C5F\x6D2A\x6D69" ++ {-0x60-} chars "\x6E2F\x6E9D\x7532\x7687\x786C\x7A3F\x7CE0\x7D05" ++ {-0x68-} chars "\x7D18\x7D5E\x7DB1\x8015\x8003\x80AF\x80B1\x8154" ++ {-0x70-} chars "\x818F\x822A\x8352\x884C\x8861\x8B1B\x8CA2\x8CFC" ++ {-0x78-} chars "\x90CA\x9175\x9271\x783F\x92FC\x95A4\x964D" ++ Nothing : {-0x80-} chars "\x9805\x9999\x9AD8\x9D3B\x525B\x52AB\x53F7\x5408" ++ {-0x88-} chars "\x58D5\x62F7\x6FE0\x8C6A\x8F5F\x9EB9\x514B\x523B" ++ {-0x90-} chars "\x544A\x56FD\x7A40\x9177\x9D60\x9ED2\x7344\x6F09" ++ {-0x98-} chars "\x8170\x7511\x5FFD\x60DA\x9AA8\x72DB\x8FBC\x6B64" ++ {-0xA0-} chars "\x9803\x4ECA\x56F0\x5764\x58BE\x5A5A\x6068\x61C7" ++ {-0xA8-} chars "\x660F\x6606\x6839\x68B1\x6DF7\x75D5\x7D3A\x826E" ++ {-0xB0-} chars "\x9B42\x4E9B\x4F50\x53C9\x5506\x5D6F\x5DE6\x5DEE" ++ {-0xB8-} chars "\x67FB\x6C99\x7473\x7802\x8A50\x9396\x88DF\x5750" ++ {-0xC0-} chars "\x5EA7\x632B\x50B5\x50AC\x518D\x6700\x54C9\x585E" ++ {-0xC8-} chars "\x59BB\x5BB0\x5F69\x624D\x63A1\x683D\x6B73\x6E08" ++ {-0xD0-} chars "\x707D\x91C7\x7280\x7815\x7826\x796D\x658E\x7D30" ++ {-0xD8-} chars "\x83DC\x88C1\x8F09\x969B\x5264\x5728\x6750\x7F6A" ++ {-0xE0-} chars "\x8CA1\x51B4\x5742\x962A\x583A\x698A\x80B4\x54B2" ++ {-0xE8-} chars "\x5D0E\x57FC\x7895\x9DFA\x4F5C\x524A\x548B\x643E" ++ {-0xF0-} chars "\x6628\x6714\x67F5\x7A84\x7B56\x7D22\x932F\x685C" ++ {-0xF8-} chars "\x9BAD\x7B39\x5319\x518A\x5237" -- | The multibyte characters with a lead byte of @0x8E@. second8E :: SecondByteTable second8E = V.fromList $ {-0x40-} chars "\x5BDF\x62F6\x64AE\x64E6\x672D\x6BBA\x85A9\x96D1" ++ {-0x48-} chars "\x7690\x9BD6\x634C\x9306\x9BAB\x76BF\x6652\x4E09" ++ {-0x50-} chars "\x5098\x53C2\x5C71\x60E8\x6492\x6563\x685F\x71E6" ++ {-0x58-} chars "\x73CA\x7523\x7B97\x7E82\x8695\x8B83\x8CDB\x9178" ++ {-0x60-} chars "\x9910\x65AC\x66AB\x6B8B\x4ED5\x4ED4\x4F3A\x4F7F" ++ {-0x68-} chars "\x523A\x53F8\x53F2\x55E3\x56DB\x58EB\x59CB\x59C9" ++ {-0x70-} chars "\x59FF\x5B50\x5C4D\x5E02\x5E2B\x5FD7\x601D\x6307" ++ {-0x78-} chars "\x652F\x5B5C\x65AF\x65BD\x65E8\x679D\x6B62" ++ Nothing : {-0x80-} chars "\x6B7B\x6C0F\x7345\x7949\x79C1\x7CF8\x7D19\x7D2B" ++ {-0x88-} chars "\x80A2\x8102\x81F3\x8996\x8A5E\x8A69\x8A66\x8A8C" ++ {-0x90-} chars "\x8AEE\x8CC7\x8CDC\x96CC\x98FC\x6B6F\x4E8B\x4F3C" ++ {-0x98-} chars "\x4F8D\x5150\x5B57\x5BFA\x6148\x6301\x6642\x6B21" ++ {-0xA0-} chars "\x6ECB\x6CBB\x723E\x74BD\x75D4\x78C1\x793A\x800C" ++ {-0xA8-} chars "\x8033\x81EA\x8494\x8F9E\x6C50\x9E7F\x5F0F\x8B58" ++ {-0xB0-} chars "\x9D2B\x7AFA\x8EF8\x5B8D\x96EB\x4E03\x53F1\x57F7" ++ {-0xB8-} chars "\x5931\x5AC9\x5BA4\x6089\x6E7F\x6F06\x75BE\x8CEA" ++ {-0xC0-} chars "\x5B9F\x8500\x7BE0\x5072\x67F4\x829D\x5C61\x854A" ++ {-0xC8-} chars "\x7E1E\x820E\x5199\x5C04\x6368\x8D66\x659C\x716E" ++ {-0xD0-} chars "\x793E\x7D17\x8005\x8B1D\x8ECA\x906E\x86C7\x90AA" ++ {-0xD8-} chars "\x501F\x52FA\x5C3A\x6753\x707C\x7235\x914C\x91C8" ++ {-0xE0-} chars "\x932B\x82E5\x5BC2\x5F31\x60F9\x4E3B\x53D6\x5B88" ++ {-0xE8-} chars "\x624B\x6731\x6B8A\x72E9\x73E0\x7A2E\x816B\x8DA3" ++ {-0xF0-} chars "\x9152\x9996\x5112\x53D7\x546A\x5BFF\x6388\x6A39" ++ {-0xF8-} chars "\x7DAC\x9700\x56DA\x53CE\x5468" -- | The multibyte characters with a lead byte of @0x8F@. second8F :: SecondByteTable second8F = V.fromList $ {-0x40-} chars "\x5B97\x5C31\x5DDE\x4FEE\x6101\x62FE\x6D32\x79C0" ++ {-0x48-} chars "\x79CB\x7D42\x7E4D\x7FD2\x81ED\x821F\x8490\x8846" ++ {-0x50-} chars "\x8972\x8B90\x8E74\x8F2F\x9031\x914B\x916C\x96C6" ++ {-0x58-} chars "\x919C\x4EC0\x4F4F\x5145\x5341\x5F93\x620E\x67D4" ++ {-0x60-} chars "\x6C41\x6E0B\x7363\x7E26\x91CD\x9283\x53D4\x5919" ++ {-0x68-} chars "\x5BBF\x6DD1\x795D\x7E2E\x7C9B\x587E\x719F\x51FA" ++ {-0x70-} chars "\x8853\x8FF0\x4FCA\x5CFB\x6625\x77AC\x7AE3\x821C" ++ {-0x78-} chars "\x99FF\x51C6\x5FAA\x65EC\x696F\x6B89\x6DF3" ++ Nothing : {-0x80-} chars "\x6E96\x6F64\x76FE\x7D14\x5DE1\x9075\x9187\x9806" ++ {-0x88-} chars "\x51E6\x521D\x6240\x6691\x66D9\x6E1A\x5EB6\x7DD2" ++ {-0x90-} chars "\x7F72\x66F8\x85AF\x85F7\x8AF8\x52A9\x53D9\x5973" ++ {-0x98-} chars "\x5E8F\x5F90\x6055\x92E4\x9664\x50B7\x511F\x52DD" ++ {-0xA0-} chars "\x5320\x5347\x53EC\x54E8\x5546\x5531\x5617\x5968" ++ {-0xA8-} chars "\x59BE\x5A3C\x5BB5\x5C06\x5C0F\x5C11\x5C1A\x5E84" ++ {-0xB0-} chars "\x5E8A\x5EE0\x5F70\x627F\x6284\x62DB\x638C\x6377" ++ {-0xB8-} chars "\x6607\x660C\x662D\x6676\x677E\x68A2\x6A1F\x6A35" ++ {-0xC0-} chars "\x6CBC\x6D88\x6E09\x6E58\x713C\x7126\x7167\x75C7" ++ {-0xC8-} chars "\x7701\x785D\x7901\x7965\x79F0\x7AE0\x7B11\x7CA7" ++ {-0xD0-} chars "\x7D39\x8096\x83D6\x848B\x8549\x885D\x88F3\x8A1F" ++ {-0xD8-} chars "\x8A3C\x8A54\x8A73\x8C61\x8CDE\x91A4\x9266\x937E" ++ {-0xE0-} chars "\x9418\x969C\x9798\x4E0A\x4E08\x4E1E\x4E57\x5197" ++ {-0xE8-} chars "\x5270\x57CE\x5834\x58CC\x5B22\x5E38\x60C5\x64FE" ++ {-0xF0-} chars "\x6761\x6756\x6D44\x72B6\x7573\x7A63\x84B8\x8B72" ++ {-0xF8-} chars "\x91B8\x9320\x5631\x57F4\x98FE" -- | The multibyte characters with a lead byte of @0x90@. second90 :: SecondByteTable second90 = V.fromList $ {-0x40-} chars "\x62ED\x690D\x6B96\x71ED\x7E54\x8077\x8272\x89E6" ++ {-0x48-} chars "\x98DF\x8755\x8FB1\x5C3B\x4F38\x4FE1\x4FB5\x5507" ++ {-0x50-} chars "\x5A20\x5BDD\x5BE9\x5FC3\x614E\x632F\x65B0\x664B" ++ {-0x58-} chars "\x68EE\x699B\x6D78\x6DF1\x7533\x75B9\x771F\x795E" ++ {-0x60-} chars "\x79E6\x7D33\x81E3\x82AF\x85AA\x89AA\x8A3A\x8EAB" ++ {-0x68-} chars "\x8F9B\x9032\x91DD\x9707\x4EBA\x4EC1\x5203\x5875" ++ {-0x70-} chars "\x58EC\x5C0B\x751A\x5C3D\x814E\x8A0A\x8FC5\x9663" ++ {-0x78-} chars "\x976D\x7B25\x8ACF\x9808\x9162\x56F3\x53A8" ++ Nothing : {-0x80-} chars "\x9017\x5439\x5782\x5E25\x63A8\x6C34\x708A\x7761" ++ {-0x88-} chars "\x7C8B\x7FE0\x8870\x9042\x9154\x9310\x9318\x968F" ++ {-0x90-} chars "\x745E\x9AC4\x5D07\x5D69\x6570\x67A2\x8DA8\x96DB" ++ {-0x98-} chars "\x636E\x6749\x6919\x83C5\x9817\x96C0\x88FE\x6F84" ++ {-0xA0-} chars "\x647A\x5BF8\x4E16\x702C\x755D\x662F\x51C4\x5236" ++ {-0xA8-} chars "\x52E2\x59D3\x5F81\x6027\x6210\x653F\x6574\x661F" ++ {-0xB0-} chars "\x6674\x68F2\x6816\x6B63\x6E05\x7272\x751F\x76DB" ++ {-0xB8-} chars "\x7CBE\x8056\x58F0\x88FD\x897F\x8AA0\x8A93\x8ACB" ++ {-0xC0-} chars "\x901D\x9192\x9752\x9759\x6589\x7A0E\x8106\x96BB" ++ {-0xC8-} chars "\x5E2D\x60DC\x621A\x65A5\x6614\x6790\x77F3\x7A4D" ++ {-0xD0-} chars "\x7C4D\x7E3E\x810A\x8CAC\x8D64\x8DE1\x8E5F\x78A9" ++ {-0xD8-} chars "\x5207\x62D9\x63A5\x6442\x6298\x8A2D\x7A83\x7BC0" ++ {-0xE0-} chars "\x8AAC\x96EA\x7D76\x820C\x8749\x4ED9\x5148\x5343" ++ {-0xE8-} chars "\x5360\x5BA3\x5C02\x5C16\x5DDD\x6226\x6247\x64B0" ++ {-0xF0-} chars "\x6813\x6834\x6CC9\x6D45\x6D17\x67D3\x6F5C\x714E" ++ {-0xF8-} chars "\x717D\x65CB\x7A7F\x7BAD\x7DDA" -- | The multibyte characters with a lead byte of @0x91@. second91 :: SecondByteTable second91 = V.fromList $ {-0x40-} chars "\x7E4A\x7FA8\x817A\x821B\x8239\x85A6\x8A6E\x8CCE" ++ {-0x48-} chars "\x8DF5\x9078\x9077\x92AD\x9291\x9583\x9BAE\x524D" ++ {-0x50-} chars "\x5584\x6F38\x7136\x5168\x7985\x7E55\x81B3\x7CCE" ++ {-0x58-} chars "\x564C\x5851\x5CA8\x63AA\x66FE\x66FD\x695A\x72D9" ++ {-0x60-} chars "\x758F\x758E\x790E\x7956\x79DF\x7C97\x7D20\x7D44" ++ {-0x68-} chars "\x8607\x8A34\x963B\x9061\x9F20\x50E7\x5275\x53CC" ++ {-0x70-} chars "\x53E2\x5009\x55AA\x58EE\x594F\x723D\x5B8B\x5C64" ++ {-0x78-} chars "\x531D\x60E3\x60F3\x635C\x6383\x633F\x63BB" ++ Nothing : {-0x80-} chars "\x64CD\x65E9\x66F9\x5DE3\x69CD\x69FD\x6F15\x71E5" ++ {-0x88-} chars "\x4E89\x75E9\x76F8\x7A93\x7CDF\x7DCF\x7D9C\x8061" ++ {-0x90-} chars "\x8349\x8358\x846C\x84BC\x85FB\x88C5\x8D70\x9001" ++ {-0x98-} chars "\x906D\x9397\x971C\x9A12\x50CF\x5897\x618E\x81D3" ++ {-0xA0-} chars "\x8535\x8D08\x9020\x4FC3\x5074\x5247\x5373\x606F" ++ {-0xA8-} chars "\x6349\x675F\x6E2C\x8DB3\x901F\x4FD7\x5C5E\x8CCA" ++ {-0xB0-} chars "\x65CF\x7D9A\x5352\x8896\x5176\x63C3\x5B58\x5B6B" ++ {-0xB8-} chars "\x5C0A\x640D\x6751\x905C\x4ED6\x591A\x592A\x6C70" ++ {-0xC0-} chars "\x8A51\x553E\x5815\x59A5\x60F0\x6253\x67C1\x8235" ++ {-0xC8-} chars "\x6955\x9640\x99C4\x9A28\x4F53\x5806\x5BFE\x8010" ++ {-0xD0-} chars "\x5CB1\x5E2F\x5F85\x6020\x614B\x6234\x66FF\x6CF0" ++ {-0xD8-} chars "\x6EDE\x80CE\x817F\x82D4\x888B\x8CB8\x9000\x902E" ++ {-0xE0-} chars "\x968A\x9EDB\x9BDB\x4EE3\x53F0\x5927\x7B2C\x918D" ++ {-0xE8-} chars "\x984C\x9DF9\x6EDD\x7027\x5353\x5544\x5B85\x6258" ++ {-0xF0-} chars "\x629E\x62D3\x6CA2\x6FEF\x7422\x8A17\x9438\x6FC1" ++ {-0xF8-} chars "\x8AFE\x8338\x51E7\x86F8\x53EA" -- | The multibyte characters with a lead byte of @0x92@. second92 :: SecondByteTable second92 = V.fromList $ {-0x40-} chars "\x53E9\x4F46\x9054\x8FB0\x596A\x8131\x5DFD\x7AEA" ++ {-0x48-} chars "\x8FBF\x68DA\x8C37\x72F8\x9C48\x6A3D\x8AB0\x4E39" ++ {-0x50-} chars "\x5358\x5606\x5766\x62C5\x63A2\x65E6\x6B4E\x6DE1" ++ {-0x58-} chars "\x6E5B\x70AD\x77ED\x7AEF\x7BAA\x7DBB\x803D\x80C6" ++ {-0x60-} chars "\x86CB\x8A95\x935B\x56E3\x58C7\x5F3E\x65AD\x6696" ++ {-0x68-} chars "\x6A80\x6BB5\x7537\x8AC7\x5024\x77E5\x5730\x5F1B" ++ {-0x70-} chars "\x6065\x667A\x6C60\x75F4\x7A1A\x7F6E\x81F4\x8718" ++ {-0x78-} chars "\x9045\x99B3\x7BC9\x755C\x7AF9\x7B51\x84C4" ++ Nothing : {-0x80-} chars "\x9010\x79E9\x7A92\x8336\x5AE1\x7740\x4E2D\x4EF2" ++ {-0x88-} chars "\x5B99\x5FE0\x62BD\x663C\x67F1\x6CE8\x866B\x8877" ++ {-0x90-} chars "\x8A3B\x914E\x92F3\x99D0\x6A17\x7026\x732A\x82E7" ++ {-0x98-} chars "\x8457\x8CAF\x4E01\x5146\x51CB\x558B\x5BF5\x5E16" ++ {-0xA0-} chars "\x5E33\x5E81\x5F14\x5F35\x5F6B\x5FB4\x61F2\x6311" ++ {-0xA8-} chars "\x66A2\x671D\x6F6E\x7252\x753A\x773A\x8074\x8139" ++ {-0xB0-} chars "\x8178\x8776\x8ABF\x8ADC\x8D85\x8DF3\x929A\x9577" ++ {-0xB8-} chars "\x9802\x9CE5\x52C5\x6357\x76F4\x6715\x6C88\x73CD" ++ {-0xC0-} chars "\x8CC3\x93AE\x9673\x6D25\x589C\x690E\x69CC\x8FFD" ++ {-0xC8-} chars "\x939A\x75DB\x901A\x585A\x6802\x63B4\x69FB\x4F43" ++ {-0xD0-} chars "\x6F2C\x67D8\x8FBB\x8526\x7DB4\x9354\x693F\x6F70" ++ {-0xD8-} chars "\x576A\x58F7\x5B2C\x7D2C\x722A\x540A\x91E3\x9DB4" ++ {-0xE0-} chars "\x4EAD\x4F4E\x505C\x5075\x5243\x8C9E\x5448\x5824" ++ {-0xE8-} chars "\x5B9A\x5E1D\x5E95\x5EAD\x5EF7\x5F1F\x608C\x62B5" ++ {-0xF0-} chars "\x633A\x63D0\x68AF\x6C40\x7887\x798E\x7A0B\x7DE0" ++ {-0xF8-} chars "\x8247\x8A02\x8AE6\x8E44\x9013" -- | The multibyte characters with a lead byte of @0x93@. second93 :: SecondByteTable second93 = V.fromList $ {-0x40-} chars "\x90B8\x912D\x91D8\x9F0E\x6CE5\x6458\x64E2\x6575" ++ {-0x48-} chars "\x6EF4\x7684\x7B1B\x9069\x93D1\x6EBA\x54F2\x5FB9" ++ {-0x50-} chars "\x64A4\x8F4D\x8FED\x9244\x5178\x586B\x5929\x5C55" ++ {-0x58-} chars "\x5E97\x6DFB\x7E8F\x751C\x8CBC\x8EE2\x985B\x70B9" ++ {-0x60-} chars "\x4F1D\x6BBF\x6FB1\x7530\x96FB\x514E\x5410\x5835" ++ {-0x68-} chars "\x5857\x59AC\x5C60\x5F92\x6597\x675C\x6E21\x767B" ++ {-0x70-} chars "\x83DF\x8CED\x9014\x90FD\x934D\x7825\x783A\x52AA" ++ {-0x78-} chars "\x5EA6\x571F\x5974\x6012\x5012\x515A\x51AC" ++ Nothing : {-0x80-} chars "\x51CD\x5200\x5510\x5854\x5858\x5957\x5B95\x5CF6" ++ {-0x88-} chars "\x5D8B\x60BC\x6295\x642D\x6771\x6843\x68BC\x68DF" ++ {-0x90-} chars "\x76D7\x6DD8\x6E6F\x6D9B\x706F\x71C8\x5F53\x75D8" ++ {-0x98-} chars "\x7977\x7B49\x7B54\x7B52\x7CD6\x7D71\x5230\x8463" ++ {-0xA0-} chars "\x8569\x85E4\x8A0E\x8B04\x8C46\x8E0F\x9003\x900F" ++ {-0xA8-} chars "\x9419\x9676\x982D\x9A30\x95D8\x50CD\x52D5\x540C" ++ {-0xB0-} chars "\x5802\x5C0E\x61A7\x649E\x6D1E\x77B3\x7AE5\x80F4" ++ {-0xB8-} chars "\x8404\x9053\x9285\x5CE0\x9D07\x533F\x5F97\x5FB3" ++ {-0xC0-} chars "\x6D9C\x7279\x7763\x79BF\x7BE4\x6BD2\x72EC\x8AAD" ++ {-0xC8-} chars "\x6803\x6A61\x51F8\x7A81\x6934\x5C4A\x9CF6\x82EB" ++ {-0xD0-} chars "\x5BC5\x9149\x701E\x5678\x5C6F\x60C7\x6566\x6C8C" ++ {-0xD8-} chars "\x8C5A\x9041\x9813\x5451\x66C7\x920D\x5948\x90A3" ++ {-0xE0-} chars "\x5185\x4E4D\x51EA\x8599\x8B0E\x7058\x637A\x934B" ++ {-0xE8-} chars "\x6962\x99B4\x7E04\x7577\x5357\x6960\x8EDF\x96E3" ++ {-0xF0-} chars "\x6C5D\x4E8C\x5C3C\x5F10\x8FE9\x5302\x8CD1\x8089" ++ {-0xF8-} chars "\x8679\x5EFF\x65E5\x4E73\x5165" -- | The multibyte characters with a lead byte of @0x94@. second94 :: SecondByteTable second94 = V.fromList $ {-0x40-} chars "\x5982\x5C3F\x97EE\x4EFB\x598A\x5FCD\x8A8D\x6FE1" ++ {-0x48-} chars "\x79B0\x7962\x5BE7\x8471\x732B\x71B1\x5E74\x5FF5" ++ {-0x50-} chars "\x637B\x649A\x71C3\x7C98\x4E43\x5EFC\x4E4B\x57DC" ++ {-0x58-} chars "\x56A2\x60A9\x6FC3\x7D0D\x80FD\x8133\x81BF\x8FB2" ++ {-0x60-} chars "\x8997\x86A4\x5DF4\x628A\x64AD\x8987\x6777\x6CE2" ++ {-0x68-} chars "\x6D3E\x7436\x7834\x5A46\x7F75\x82AD\x99AC\x4FF3" ++ {-0x70-} chars "\x5EC3\x62DD\x6392\x6557\x676F\x76C3\x724C\x80CC" ++ {-0x78-} chars "\x80BA\x8F29\x914D\x500D\x57F9\x5A92\x6885" ++ Nothing : {-0x80-} chars "\x6973\x7164\x72FD\x8CB7\x58F2\x8CE0\x966A\x9019" ++ {-0x88-} chars "\x877F\x79E4\x77E7\x8429\x4F2F\x5265\x535A\x62CD" ++ {-0x90-} chars "\x67CF\x6CCA\x767D\x7B94\x7C95\x8236\x8584\x8FEB" ++ {-0x98-} chars "\x66DD\x6F20\x7206\x7E1B\x83AB\x99C1\x9EA6\x51FD" ++ {-0xA0-} chars "\x7BB1\x7872\x7BB8\x8087\x7B48\x6AE8\x5E61\x808C" ++ {-0xA8-} chars "\x7551\x7560\x516B\x9262\x6E8C\x767A\x9197\x9AEA" ++ {-0xB0-} chars "\x4F10\x7F70\x629C\x7B4F\x95A5\x9CE9\x567A\x5859" ++ {-0xB8-} chars "\x86E4\x96BC\x4F34\x5224\x534A\x53CD\x53DB\x5E06" ++ {-0xC0-} chars "\x642C\x6591\x677F\x6C3E\x6C4E\x7248\x72AF\x73ED" ++ {-0xC8-} chars "\x7554\x7E41\x822C\x85E9\x8CA9\x7BC4\x91C6\x7169" ++ {-0xD0-} chars "\x9812\x98EF\x633D\x6669\x756A\x76E4\x78D0\x8543" ++ {-0xD8-} chars "\x86EE\x532A\x5351\x5426\x5983\x5E87\x5F7C\x60B2" ++ {-0xE0-} chars "\x6249\x6279\x62AB\x6590\x6BD4\x6CCC\x75B2\x76AE" ++ {-0xE8-} chars "\x7891\x79D8\x7DCB\x7F77\x80A5\x88AB\x8AB9\x8CBB" ++ {-0xF0-} chars "\x907F\x975E\x98DB\x6A0B\x7C38\x5099\x5C3E\x5FAE" ++ {-0xF8-} chars "\x6787\x6BD8\x7435\x7709\x7F8E" -- | The multibyte characters with a lead byte of @0x95@. second95 :: SecondByteTable second95 = V.fromList $ {-0x40-} chars "\x9F3B\x67CA\x7A17\x5339\x758B\x9AED\x5F66\x819D" ++ {-0x48-} chars "\x83F1\x8098\x5F3C\x5FC5\x7562\x7B46\x903C\x6867" ++ {-0x50-} chars "\x59EB\x5A9B\x7D10\x767E\x8B2C\x4FF5\x5F6A\x6A19" ++ {-0x58-} chars "\x6C37\x6F02\x74E2\x7968\x8868\x8A55\x8C79\x5EDF" ++ {-0x60-} chars "\x63CF\x75C5\x79D2\x82D7\x9328\x92F2\x849C\x86ED" ++ {-0x68-} chars "\x9C2D\x54C1\x5F6C\x658C\x6D5C\x7015\x8CA7\x8CD3" ++ {-0x70-} chars "\x983B\x654F\x74F6\x4E0D\x4ED8\x57E0\x592B\x5A66" ++ {-0x78-} chars "\x5BCC\x51A8\x5E03\x5E9C\x6016\x6276\x6577" ++ Nothing : {-0x80-} chars "\x65A7\x666E\x6D6E\x7236\x7B26\x8150\x819A\x8299" ++ {-0x88-} chars "\x8B5C\x8CA0\x8CE6\x8D74\x961C\x9644\x4FAE\x64AB" ++ {-0x90-} chars "\x6B66\x821E\x8461\x856A\x90E8\x5C01\x6953\x98A8" ++ {-0x98-} chars "\x847A\x8557\x4F0F\x526F\x5FA9\x5E45\x670D\x798F" ++ {-0xA0-} chars "\x8179\x8907\x8986\x6DF5\x5F17\x6255\x6CB8\x4ECF" ++ {-0xA8-} chars "\x7269\x9B92\x5206\x543B\x5674\x58B3\x61A4\x626E" ++ {-0xB0-} chars "\x711A\x596E\x7C89\x7CDE\x7D1B\x96F0\x6587\x805E" ++ {-0xB8-} chars "\x4E19\x4F75\x5175\x5840\x5E63\x5E73\x5F0A\x67C4" ++ {-0xC0-} chars "\x4E26\x853D\x9589\x965B\x7C73\x9801\x50FB\x58C1" ++ {-0xC8-} chars "\x7656\x78A7\x5225\x77A5\x8511\x7B86\x504F\x5909" ++ {-0xD0-} chars "\x7247\x7BC7\x7DE8\x8FBA\x8FD4\x904D\x4FBF\x52C9" ++ {-0xD8-} chars "\x5A29\x5F01\x97AD\x4FDD\x8217\x92EA\x5703\x6355" ++ {-0xE0-} chars "\x6B69\x752B\x88DC\x8F14\x7A42\x52DF\x5893\x6155" ++ {-0xE8-} chars "\x620A\x66AE\x6BCD\x7C3F\x83E9\x5023\x4FF8\x5305" ++ {-0xF0-} chars "\x5446\x5831\x5949\x5B9D\x5CF0\x5CEF\x5D29\x5E96" ++ {-0xF8-} chars "\x62B1\x6367\x653E\x65B9\x670B" -- | The multibyte characters with a lead byte of @0x96@. second96 :: SecondByteTable second96 = V.fromList $ {-0x40-} chars "\x6CD5\x6CE1\x70F9\x7832\x7E2B\x80DE\x82B3\x840C" ++ {-0x48-} chars "\x84EC\x8702\x8912\x8A2A\x8C4A\x90A6\x92D2\x98FD" ++ {-0x50-} chars "\x9CF3\x9D6C\x4E4F\x4EA1\x508D\x5256\x574A\x59A8" ++ {-0x58-} chars "\x5E3D\x5FD8\x5FD9\x623F\x66B4\x671B\x67D0\x68D2" ++ {-0x60-} chars "\x5192\x7D21\x80AA\x81A8\x8B00\x8C8C\x8CBF\x927E" ++ {-0x68-} chars "\x9632\x5420\x982C\x5317\x50D5\x535C\x58A8\x64B2" ++ {-0x70-} chars "\x6734\x7267\x7766\x7A46\x91E6\x52C3\x6CA1\x6B86" ++ {-0x78-} chars "\x5800\x5E4C\x5954\x672C\x7FFB\x51E1\x76C6" ++ Nothing : {-0x80-} chars "\x6469\x78E8\x9B54\x9EBB\x57CB\x59B9\x6627\x679A" ++ {-0x88-} chars "\x6BCE\x54E9\x69D9\x5E55\x819C\x6795\x9BAA\x67FE" ++ {-0x90-} chars "\x9C52\x685D\x4EA6\x4FE3\x53C8\x62B9\x672B\x6CAB" ++ {-0x98-} chars "\x8FC4\x4FAD\x7E6D\x9EBF\x4E07\x6162\x6E80\x6F2B" ++ {-0xA0-} chars "\x8513\x5473\x672A\x9B45\x5DF3\x7B95\x5CAC\x5BC6" ++ {-0xA8-} chars "\x871C\x6E4A\x84D1\x7A14\x8108\x5999\x7C8D\x6C11" ++ {-0xB0-} chars "\x7720\x52D9\x5922\x7121\x725F\x77DB\x9727\x9D61" ++ {-0xB8-} chars "\x690B\x5A7F\x5A18\x51A5\x540D\x547D\x660E\x76DF" ++ {-0xC0-} chars "\x8FF7\x9298\x9CF4\x59EA\x725D\x6EC5\x514D\x68C9" ++ {-0xC8-} chars "\x7DBF\x7DEC\x9762\x9EBA\x6478\x6A21\x8302\x5984" ++ {-0xD0-} chars "\x5B5F\x6BDB\x731B\x76F2\x7DB2\x8017\x8499\x5132" ++ {-0xD8-} chars "\x6728\x9ED9\x76EE\x6762\x52FF\x9905\x5C24\x623B" ++ {-0xE0-} chars "\x7C7E\x8CB0\x554F\x60B6\x7D0B\x9580\x5301\x4E5F" ++ {-0xE8-} chars "\x51B6\x591C\x723A\x8036\x91CE\x5F25\x77E2\x5384" ++ {-0xF0-} chars "\x5F79\x7D04\x85AC\x8A33\x8E8D\x9756\x67F3\x85AE" ++ {-0xF8-} chars "\x9453\x6109\x6108\x6CB9\x7652" -- | The multibyte characters with a lead byte of @0x97@. second97 :: SecondByteTable second97 = V.fromList $ {-0x40-} chars "\x8AED\x8F38\x552F\x4F51\x512A\x52C7\x53CB\x5BA5" ++ {-0x48-} chars "\x5E7D\x60A0\x6182\x63D6\x6709\x67DA\x6E67\x6D8C" ++ {-0x50-} chars "\x7336\x7337\x7531\x7950\x88D5\x8A98\x904A\x9091" ++ {-0x58-} chars "\x90F5\x96C4\x878D\x5915\x4E88\x4F59\x4E0E\x8A89" ++ {-0x60-} chars "\x8F3F\x9810\x50AD\x5E7C\x5996\x5BB9\x5EB8\x63DA" ++ {-0x68-} chars "\x63FA\x64C1\x66DC\x694A\x69D8\x6D0B\x6EB6\x7194" ++ {-0x70-} chars "\x7528\x7AAF\x7F8A\x8000\x8449\x84C9\x8981\x8B21" ++ {-0x78-} chars "\x8E0A\x9065\x967D\x990A\x617E\x6291\x6B32" ++ Nothing : {-0x80-} chars "\x6C83\x6D74\x7FCC\x7FFC\x6DC0\x7F85\x87BA\x88F8" ++ {-0x88-} chars "\x6765\x83B1\x983C\x96F7\x6D1B\x7D61\x843D\x916A" ++ {-0x90-} chars "\x4E71\x5375\x5D50\x6B04\x6FEB\x85CD\x862D\x89A7" ++ {-0x98-} chars "\x5229\x540F\x5C65\x674E\x68A8\x7406\x7483\x75E2" ++ {-0xA0-} chars "\x88CF\x88E1\x91CC\x96E2\x9678\x5F8B\x7387\x7ACB" ++ {-0xA8-} chars "\x844E\x63A0\x7565\x5289\x6D41\x6E9C\x7409\x7559" ++ {-0xB0-} chars "\x786B\x7C92\x9686\x7ADC\x9F8D\x4FB6\x616E\x65C5" ++ {-0xB8-} chars "\x865C\x4E86\x4EAE\x50DA\x4E21\x51CC\x5BEE\x6599" ++ {-0xC0-} chars "\x6881\x6DBC\x731F\x7642\x77AD\x7A1C\x7CE7\x826F" ++ {-0xC8-} chars "\x8AD2\x907C\x91CF\x9675\x9818\x529B\x7DD1\x502B" ++ {-0xD0-} chars "\x5398\x6797\x6DCB\x71D0\x7433\x81E8\x8F2A\x96A3" ++ {-0xD8-} chars "\x9C57\x9E9F\x7460\x5841\x6D99\x7D2F\x985E\x4EE4" ++ {-0xE0-} chars "\x4F36\x4F8B\x51B7\x52B1\x5DBA\x601C\x73B2\x793C" ++ {-0xE8-} chars "\x82D3\x9234\x96B7\x96F6\x970A\x9E97\x9F62\x66A6" ++ {-0xF0-} chars "\x6B74\x5217\x52A3\x70C8\x88C2\x5EC9\x604B\x6190" ++ {-0xF8-} chars "\x6F23\x7149\x7C3E\x7DF4\x806F" -- | The multibyte characters with a lead byte of @0x98@. second98 :: SecondByteTable second98 = V.fromList $ {-0x40-} chars "\x84EE\x9023\x932C\x5442\x9B6F\x6AD3\x7089\x8CC2" ++ {-0x48-} chars "\x8DEF\x9732\x52B4\x5A41\x5ECA\x5F04\x6717\x697C" ++ {-0x50-} chars "\x6994\x6D6A\x6F0F\x7262\x72FC\x7BED\x8001\x807E" ++ {-0x58-} chars "\x874B\x90CE\x516D\x9E93\x7984\x808B\x9332\x8AD6" ++ {-0x60-} chars "\x502D\x548C\x8A71\x6B6A\x8CC4\x8107\x60D1\x67A0" ++ {-0x68-} chars "\x9DF2\x4E99\x4E98\x9C10\x8A6B\x85C1\x8568\x6900" ++ {-0x70-} chars "\x6E7E\x7897\x8155" ++ {-0x73..0x9F-} nothings 0x2C ++ Just '\x5F0C' : {-0xA0-} chars "\x4E10\x4E15\x4E2A\x4E31\x4E36\x4E3C\x4E3F\x4E42" ++ {-0xA8-} chars "\x4E56\x4E58\x4E82\x4E85\x8C6B\x4E8A\x8212\x5F0D" ++ {-0xB0-} chars "\x4E8E\x4E9E\x4E9F\x4EA0\x4EA2\x4EB0\x4EB3\x4EB6" ++ {-0xB8-} chars "\x4ECE\x4ECD\x4EC4\x4EC6\x4EC2\x4ED7\x4EDE\x4EED" ++ {-0xC0-} chars "\x4EDF\x4EF7\x4F09\x4F5A\x4F30\x4F5B\x4F5D\x4F57" ++ {-0xC8-} chars "\x4F47\x4F76\x4F88\x4F8F\x4F98\x4F7B\x4F69\x4F70" ++ {-0xD0-} chars "\x4F91\x4F6F\x4F86\x4F96\x5118\x4FD4\x4FDF\x4FCE" ++ {-0xD8-} chars "\x4FD8\x4FDB\x4FD1\x4FDA\x4FD0\x4FE4\x4FE5\x501A" ++ {-0xE0-} chars "\x5028\x5014\x502A\x5025\x5005\x4F1C\x4FF6\x5021" ++ {-0xE8-} chars "\x5029\x502C\x4FFE\x4FEF\x5011\x5006\x5043\x5047" ++ {-0xF0-} chars "\x6703\x5055\x5050\x5048\x505A\x5056\x506C\x5078" ++ {-0xF8-} chars "\x5080\x509A\x5085\x50B4\x50B2" -- | The multibyte characters with a lead byte of @0x99@. second99 :: SecondByteTable second99 = V.fromList $ {-0x40-} chars "\x50C9\x50CA\x50B3\x50C2\x50D6\x50DE\x50E5\x50ED" ++ {-0x48-} chars "\x50E3\x50EE\x50F9\x50F5\x5109\x5101\x5102\x5116" ++ {-0x50-} chars "\x5115\x5114\x511A\x5121\x513A\x5137\x513C\x513B" ++ {-0x58-} chars "\x513F\x5140\x5152\x514C\x5154\x5162\x7AF8\x5169" ++ {-0x60-} chars "\x516A\x516E\x5180\x5182\x56D8\x518C\x5189\x518F" ++ {-0x68-} chars "\x5191\x5193\x5195\x5196\x51A4\x51A6\x51A2\x51A9" ++ {-0x70-} chars "\x51AA\x51AB\x51B3\x51B1\x51B2\x51B0\x51B5\x51BD" ++ {-0x78-} chars "\x51C5\x51C9\x51DB\x51E0\x8655\x51E9\x51ED" ++ Nothing : {-0x80-} chars "\x51F0\x51F5\x51FE\x5204\x520B\x5214\x520E\x5227" ++ {-0x88-} chars "\x522A\x522E\x5233\x5239\x524F\x5244\x524B\x524C" ++ {-0x90-} chars "\x525E\x5254\x526A\x5274\x5269\x5273\x527F\x527D" ++ {-0x98-} chars "\x528D\x5294\x5292\x5271\x5288\x5291\x8FA8\x8FA7" ++ {-0xA0-} chars "\x52AC\x52AD\x52BC\x52B5\x52C1\x52CD\x52D7\x52DE" ++ {-0xA8-} chars "\x52E3\x52E6\x98ED\x52E0\x52F3\x52F5\x52F8\x52F9" ++ {-0xB0-} chars "\x5306\x5308\x7538\x530D\x5310\x530F\x5315\x531A" ++ {-0xB8-} chars "\x5323\x532F\x5331\x5333\x5338\x5340\x5346\x5345" ++ {-0xC0-} chars "\x4E17\x5349\x534D\x51D6\x535E\x5369\x536E\x5918" ++ {-0xC8-} chars "\x537B\x5377\x5382\x5396\x53A0\x53A6\x53A5\x53AE" ++ {-0xD0-} chars "\x53B0\x53B6\x53C3\x7C12\x96D9\x53DF\x66FC\x71EE" ++ {-0xD8-} chars "\x53EE\x53E8\x53ED\x53FA\x5401\x543D\x5440\x542C" ++ {-0xE0-} chars "\x542D\x543C\x542E\x5436\x5429\x541D\x544E\x548F" ++ {-0xE8-} chars "\x5475\x548E\x545F\x5471\x5477\x5470\x5492\x547B" ++ {-0xF0-} chars "\x5480\x5476\x5484\x5490\x5486\x54C7\x54A2\x54B8" ++ {-0xF8-} chars "\x54A5\x54AC\x54C4\x54C8\x54A8" -- | The multibyte characters with a lead byte of @0x9A@. second9A :: SecondByteTable second9A = V.fromList $ {-0x40-} chars "\x54AB\x54C2\x54A4\x54BE\x54BC\x54D8\x54E5\x54E6" ++ {-0x48-} chars "\x550F\x5514\x54FD\x54EE\x54ED\x54FA\x54E2\x5539" ++ {-0x50-} chars "\x5540\x5563\x554C\x552E\x555C\x5545\x5556\x5557" ++ {-0x58-} chars "\x5538\x5533\x555D\x5599\x5580\x54AF\x558A\x559F" ++ {-0x60-} chars "\x557B\x557E\x5598\x559E\x55AE\x557C\x5583\x55A9" ++ {-0x68-} chars "\x5587\x55A8\x55DA\x55C5\x55DF\x55C4\x55DC\x55E4" ++ {-0x70-} chars "\x55D4\x5614\x55F7\x5616\x55FE\x55FD\x561B\x55F9" ++ {-0x78-} chars "\x564E\x5650\x71DF\x5634\x5636\x5632\x5638" ++ Nothing : {-0x80-} chars "\x566B\x5664\x562F\x566C\x566A\x5686\x5680\x568A" ++ {-0x88-} chars "\x56A0\x5694\x568F\x56A5\x56AE\x56B6\x56B4\x56C2" ++ {-0x90-} chars "\x56BC\x56C1\x56C3\x56C0\x56C8\x56CE\x56D1\x56D3" ++ {-0x98-} chars "\x56D7\x56EE\x56F9\x5700\x56FF\x5704\x5709\x5708" ++ {-0xA0-} chars "\x570B\x570D\x5713\x5718\x5716\x55C7\x571C\x5726" ++ {-0xA8-} chars "\x5737\x5738\x574E\x573B\x5740\x574F\x5769\x57C0" ++ {-0xB0-} chars "\x5788\x5761\x577F\x5789\x5793\x57A0\x57B3\x57A4" ++ {-0xB8-} chars "\x57AA\x57B0\x57C3\x57C6\x57D4\x57D2\x57D3\x580A" ++ {-0xC0-} chars "\x57D6\x57E3\x580B\x5819\x581D\x5872\x5821\x5862" ++ {-0xC8-} chars "\x584B\x5870\x6BC0\x5852\x583D\x5879\x5885\x58B9" ++ {-0xD0-} chars "\x589F\x58AB\x58BA\x58DE\x58BB\x58B8\x58AE\x58C5" ++ {-0xD8-} chars "\x58D3\x58D1\x58D7\x58D9\x58D8\x58E5\x58DC\x58E4" ++ {-0xE0-} chars "\x58DF\x58EF\x58FA\x58F9\x58FB\x58FC\x58FD\x5902" ++ {-0xE8-} chars "\x590A\x5910\x591B\x68A6\x5925\x592C\x592D\x5932" ++ {-0xF0-} chars "\x5938\x593E\x7AD2\x5955\x5950\x594E\x595A\x5958" ++ {-0xF8-} chars "\x5962\x5960\x5967\x596C\x5969" -- | The multibyte characters with a lead byte of @0x9B@. second9B :: SecondByteTable second9B = V.fromList $ {-0x40-} chars "\x5978\x5981\x599D\x4F5E\x4FAB\x59A3\x59B2\x59C6" ++ {-0x48-} chars "\x59E8\x59DC\x598D\x59D9\x59DA\x5A25\x5A1F\x5A11" ++ {-0x50-} chars "\x5A1C\x5A09\x5A1A\x5A40\x5A6C\x5A49\x5A35\x5A36" ++ {-0x58-} chars "\x5A62\x5A6A\x5A9A\x5ABC\x5ABE\x5ACB\x5AC2\x5ABD" ++ {-0x60-} chars "\x5AE3\x5AD7\x5AE6\x5AE9\x5AD6\x5AFA\x5AFB\x5B0C" ++ {-0x68-} chars "\x5B0B\x5B16\x5B32\x5AD0\x5B2A\x5B36\x5B3E\x5B43" ++ {-0x70-} chars "\x5B45\x5B40\x5B51\x5B55\x5B5A\x5B5B\x5B65\x5B69" ++ {-0x78-} chars "\x5B70\x5B73\x5B75\x5B78\x6588\x5B7A\x5B80" ++ Nothing : {-0x80-} chars "\x5B83\x5BA6\x5BB8\x5BC3\x5BC7\x5BC9\x5BD4\x5BD0" ++ {-0x88-} chars "\x5BE4\x5BE6\x5BE2\x5BDE\x5BE5\x5BEB\x5BF0\x5BF6" ++ {-0x90-} chars "\x5BF3\x5C05\x5C07\x5C08\x5C0D\x5C13\x5C20\x5C22" ++ {-0x98-} chars "\x5C28\x5C38\x5C39\x5C41\x5C46\x5C4E\x5C53\x5C50" ++ {-0xA0-} chars "\x5C4F\x5B71\x5C6C\x5C6E\x4E62\x5C76\x5C79\x5C8C" ++ {-0xA8-} chars "\x5C91\x5C94\x599B\x5CAB\x5CBB\x5CB6\x5CBC\x5CB7" ++ {-0xB0-} chars "\x5CC5\x5CBE\x5CC7\x5CD9\x5CE9\x5CFD\x5CFA\x5CED" ++ {-0xB8-} chars "\x5D8C\x5CEA\x5D0B\x5D15\x5D17\x5D5C\x5D1F\x5D1B" ++ {-0xC0-} chars "\x5D11\x5D14\x5D22\x5D1A\x5D19\x5D18\x5D4C\x5D52" ++ {-0xC8-} chars "\x5D4E\x5D4B\x5D6C\x5D73\x5D76\x5D87\x5D84\x5D82" ++ {-0xD0-} chars "\x5DA2\x5D9D\x5DAC\x5DAE\x5DBD\x5D90\x5DB7\x5DBC" ++ {-0xD8-} chars "\x5DC9\x5DCD\x5DD3\x5DD2\x5DD6\x5DDB\x5DEB\x5DF2" ++ {-0xE0-} chars "\x5DF5\x5E0B\x5E1A\x5E19\x5E11\x5E1B\x5E36\x5E37" ++ {-0xE8-} chars "\x5E44\x5E43\x5E40\x5E4E\x5E57\x5E54\x5E5F\x5E62" ++ {-0xF0-} chars "\x5E64\x5E47\x5E75\x5E76\x5E7A\x9EBC\x5E7F\x5EA0" ++ {-0xF8-} chars "\x5EC1\x5EC2\x5EC8\x5ED0\x5ECF" -- | The multibyte characters with a lead byte of @0x9C@. second9C :: SecondByteTable second9C = V.fromList $ {-0x40-} chars "\x5ED6\x5EE3\x5EDD\x5EDA\x5EDB\x5EE2\x5EE1\x5EE8" ++ {-0x48-} chars "\x5EE9\x5EEC\x5EF1\x5EF3\x5EF0\x5EF4\x5EF8\x5EFE" ++ {-0x50-} chars "\x5F03\x5F09\x5F5D\x5F5C\x5F0B\x5F11\x5F16\x5F29" ++ {-0x58-} chars "\x5F2D\x5F38\x5F41\x5F48\x5F4C\x5F4E\x5F2F\x5F51" ++ {-0x60-} chars "\x5F56\x5F57\x5F59\x5F61\x5F6D\x5F73\x5F77\x5F83" ++ {-0x68-} chars "\x5F82\x5F7F\x5F8A\x5F88\x5F91\x5F87\x5F9E\x5F99" ++ {-0x70-} chars "\x5F98\x5FA0\x5FA8\x5FAD\x5FBC\x5FD6\x5FFB\x5FE4" ++ {-0x78-} chars "\x5FF8\x5FF1\x5FDD\x60B3\x5FFF\x6021\x6060" ++ Nothing : {-0x80-} chars "\x6019\x6010\x6029\x600E\x6031\x601B\x6015\x602B" ++ {-0x88-} chars "\x6026\x600F\x603A\x605A\x6041\x606A\x6077\x605F" ++ {-0x90-} chars "\x604A\x6046\x604D\x6063\x6043\x6064\x6042\x606C" ++ {-0x98-} chars "\x606B\x6059\x6081\x608D\x60E7\x6083\x609A\x6084" ++ {-0xA0-} chars "\x609B\x6096\x6097\x6092\x60A7\x608B\x60E1\x60B8" ++ {-0xA8-} chars "\x60E0\x60D3\x60B4\x5FF0\x60BD\x60C6\x60B5\x60D8" ++ {-0xB0-} chars "\x614D\x6115\x6106\x60F6\x60F7\x6100\x60F4\x60FA" ++ {-0xB8-} chars "\x6103\x6121\x60FB\x60F1\x610D\x610E\x6147\x613E" ++ {-0xC0-} chars "\x6128\x6127\x614A\x613F\x613C\x612C\x6134\x613D" ++ {-0xC8-} chars "\x6142\x6144\x6173\x6177\x6158\x6159\x615A\x616B" ++ {-0xD0-} chars "\x6174\x616F\x6165\x6171\x615F\x615D\x6153\x6175" ++ {-0xD8-} chars "\x6199\x6196\x6187\x61AC\x6194\x619A\x618A\x6191" ++ {-0xE0-} chars "\x61AB\x61AE\x61CC\x61CA\x61C9\x61F7\x61C8\x61C3" ++ {-0xE8-} chars "\x61C6\x61BA\x61CB\x7F79\x61CD\x61E6\x61E3\x61F6" ++ {-0xF0-} chars "\x61FA\x61F4\x61FF\x61FD\x61FC\x61FE\x6200\x6208" ++ {-0xF8-} chars "\x6209\x620D\x620C\x6214\x621B" -- | The multibyte characters with a lead byte of @0x9D@. second9D :: SecondByteTable second9D = V.fromList $ {-0x40-} chars "\x621E\x6221\x622A\x622E\x6230\x6232\x6233\x6241" ++ {-0x48-} chars "\x624E\x625E\x6263\x625B\x6260\x6268\x627C\x6282" ++ {-0x50-} chars "\x6289\x627E\x6292\x6293\x6296\x62D4\x6283\x6294" ++ {-0x58-} chars "\x62D7\x62D1\x62BB\x62CF\x62FF\x62C6\x64D4\x62C8" ++ {-0x60-} chars "\x62DC\x62CC\x62CA\x62C2\x62C7\x629B\x62C9\x630C" ++ {-0x68-} chars "\x62EE\x62F1\x6327\x6302\x6308\x62EF\x62F5\x6350" ++ {-0x70-} chars "\x633E\x634D\x641C\x634F\x6396\x638E\x6380\x63AB" ++ {-0x78-} chars "\x6376\x63A3\x638F\x6389\x639F\x63B5\x636B" ++ Nothing : {-0x80-} chars "\x6369\x63BE\x63E9\x63C0\x63C6\x63E3\x63C9\x63D2" ++ {-0x88-} chars "\x63F6\x63C4\x6416\x6434\x6406\x6413\x6426\x6436" ++ {-0x90-} chars "\x651D\x6417\x6428\x640F\x6467\x646F\x6476\x644E" ++ {-0x98-} chars "\x652A\x6495\x6493\x64A5\x64A9\x6488\x64BC\x64DA" ++ {-0xA0-} chars "\x64D2\x64C5\x64C7\x64BB\x64D8\x64C2\x64F1\x64E7" ++ {-0xA8-} chars "\x8209\x64E0\x64E1\x62AC\x64E3\x64EF\x652C\x64F6" ++ {-0xB0-} chars "\x64F4\x64F2\x64FA\x6500\x64FD\x6518\x651C\x6505" ++ {-0xB8-} chars "\x6524\x6523\x652B\x6534\x6535\x6537\x6536\x6538" ++ {-0xC0-} chars "\x754B\x6548\x6556\x6555\x654D\x6558\x655E\x655D" ++ {-0xC8-} chars "\x6572\x6578\x6582\x6583\x8B8A\x659B\x659F\x65AB" ++ {-0xD0-} chars "\x65B7\x65C3\x65C6\x65C1\x65C4\x65CC\x65D2\x65DB" ++ {-0xD8-} chars "\x65D9\x65E0\x65E1\x65F1\x6772\x660A\x6603\x65FB" ++ {-0xE0-} chars "\x6773\x6635\x6636\x6634\x661C\x664F\x6644\x6649" ++ {-0xE8-} chars "\x6641\x665E\x665D\x6664\x6667\x6668\x665F\x6662" ++ {-0xF0-} chars "\x6670\x6683\x6688\x668E\x6689\x6684\x6698\x669D" ++ {-0xF8-} chars "\x66C1\x66B9\x66C9\x66BE\x66BC" -- | The multibyte characters with a lead byte of @0x9E@. second9E :: SecondByteTable second9E = V.fromList $ {-0x40-} chars "\x66C4\x66B8\x66D6\x66DA\x66E0\x663F\x66E6\x66E9" ++ {-0x48-} chars "\x66F0\x66F5\x66F7\x670F\x6716\x671E\x6726\x6727" ++ {-0x50-} chars "\x9738\x672E\x673F\x6736\x6741\x6738\x6737\x6746" ++ {-0x58-} chars "\x675E\x6760\x6759\x6763\x6764\x6789\x6770\x67A9" ++ {-0x60-} chars "\x677C\x676A\x678C\x678B\x67A6\x67A1\x6785\x67B7" ++ {-0x68-} chars "\x67EF\x67B4\x67EC\x67B3\x67E9\x67B8\x67E4\x67DE" ++ {-0x70-} chars "\x67DD\x67E2\x67EE\x67B9\x67CE\x67C6\x67E7\x6A9C" ++ {-0x78-} chars "\x681E\x6846\x6829\x6840\x684D\x6832\x684E" ++ Nothing : {-0x80-} chars "\x68B3\x682B\x6859\x6863\x6877\x687F\x689F\x688F" ++ {-0x88-} chars "\x68AD\x6894\x689D\x689B\x6883\x6AAE\x68B9\x6874" ++ {-0x90-} chars "\x68B5\x68A0\x68BA\x690F\x688D\x687E\x6901\x68CA" ++ {-0x98-} chars "\x6908\x68D8\x6922\x6926\x68E1\x690C\x68CD\x68D4" ++ {-0xA0-} chars "\x68E7\x68D5\x6936\x6912\x6904\x68D7\x68E3\x6925" ++ {-0xA8-} chars "\x68F9\x68E0\x68EF\x6928\x692A\x691A\x6923\x6921" ++ {-0xB0-} chars "\x68C6\x6979\x6977\x695C\x6978\x696B\x6954\x697E" ++ {-0xB8-} chars "\x696E\x6939\x6974\x693D\x6959\x6930\x6961\x695E" ++ {-0xC0-} chars "\x695D\x6981\x696A\x69B2\x69AE\x69D0\x69BF\x69C1" ++ {-0xC8-} chars "\x69D3\x69BE\x69CE\x5BE8\x69CA\x69DD\x69BB\x69C3" ++ {-0xD0-} chars "\x69A7\x6A2E\x6991\x69A0\x699C\x6995\x69B4\x69DE" ++ {-0xD8-} chars "\x69E8\x6A02\x6A1B\x69FF\x6B0A\x69F9\x69F2\x69E7" ++ {-0xE0-} chars "\x6A05\x69B1\x6A1E\x69ED\x6A14\x69EB\x6A0A\x6A12" ++ {-0xE8-} chars "\x6AC1\x6A23\x6A13\x6A44\x6A0C\x6A72\x6A36\x6A78" ++ {-0xF0-} chars "\x6A47\x6A62\x6A59\x6A66\x6A48\x6A38\x6A22\x6A90" ++ {-0xF8-} chars "\x6A8D\x6AA0\x6A84\x6AA2\x6AA3" -- | The multibyte characters with a lead byte of @0x9F@. second9F :: SecondByteTable second9F = V.fromList $ {-0x40-} chars "\x6A97\x8617\x6ABB\x6AC3\x6AC2\x6AB8\x6AB3\x6AAC" ++ {-0x48-} chars "\x6ADE\x6AD1\x6ADF\x6AAA\x6ADA\x6AEA\x6AFB\x6B05" ++ {-0x50-} chars "\x8616\x6AFA\x6B12\x6B16\x9B31\x6B1F\x6B38\x6B37" ++ {-0x58-} chars "\x76DC\x6B39\x98EE\x6B47\x6B43\x6B49\x6B50\x6B59" ++ {-0x60-} chars "\x6B54\x6B5B\x6B5F\x6B61\x6B78\x6B79\x6B7F\x6B80" ++ {-0x68-} chars "\x6B84\x6B83\x6B8D\x6B98\x6B95\x6B9E\x6BA4\x6BAA" ++ {-0x70-} chars "\x6BAB\x6BAF\x6BB2\x6BB1\x6BB3\x6BB7\x6BBC\x6BC6" ++ {-0x78-} chars "\x6BCB\x6BD3\x6BDF\x6BEC\x6BEB\x6BF3\x6BEF" ++ Nothing : {-0x80-} chars "\x9EBE\x6C08\x6C13\x6C14\x6C1B\x6C24\x6C23\x6C5E" ++ {-0x88-} chars "\x6C55\x6C62\x6C6A\x6C82\x6C8D\x6C9A\x6C81\x6C9B" ++ {-0x90-} chars "\x6C7E\x6C68\x6C73\x6C92\x6C90\x6CC4\x6CF1\x6CD3" ++ {-0x98-} chars "\x6CBD\x6CD7\x6CC5\x6CDD\x6CAE\x6CB1\x6CBE\x6CBA" ++ {-0xA0-} chars "\x6CDB\x6CEF\x6CD9\x6CEA\x6D1F\x884D\x6D36\x6D2B" ++ {-0xA8-} chars "\x6D3D\x6D38\x6D19\x6D35\x6D33\x6D12\x6D0C\x6D63" ++ {-0xB0-} chars "\x6D93\x6D64\x6D5A\x6D79\x6D59\x6D8E\x6D95\x6FE4" ++ {-0xB8-} chars "\x6D85\x6DF9\x6E15\x6E0A\x6DB5\x6DC7\x6DE6\x6DB8" ++ {-0xC0-} chars "\x6DC6\x6DEC\x6DDE\x6DCC\x6DE8\x6DD2\x6DC5\x6DFA" ++ {-0xC8-} chars "\x6DD9\x6DE4\x6DD5\x6DEA\x6DEE\x6E2D\x6E6E\x6E2E" ++ {-0xD0-} chars "\x6E19\x6E72\x6E5F\x6E3E\x6E23\x6E6B\x6E2B\x6E76" ++ {-0xD8-} chars "\x6E4D\x6E1F\x6E43\x6E3A\x6E4E\x6E24\x6EFF\x6E1D" ++ {-0xE0-} chars "\x6E38\x6E82\x6EAA\x6E98\x6EC9\x6EB7\x6ED3\x6EBD" ++ {-0xE8-} chars "\x6EAF\x6EC4\x6EB2\x6ED4\x6ED5\x6E8F\x6EA5\x6EC2" ++ {-0xF0-} chars "\x6E9F\x6F41\x6F11\x704C\x6EEC\x6EF8\x6EFE\x6F3F" ++ {-0xF8-} chars "\x6EF2\x6F31\x6EEF\x6F32\x6ECC" -- | The multibyte characters with a lead byte of @0xE0@. secondE0 :: SecondByteTable secondE0 = V.fromList $ {-0x40-} chars "\x6F3E\x6F13\x6EF7\x6F86\x6F7A\x6F78\x6F81\x6F80" ++ {-0x48-} chars "\x6F6F\x6F5B\x6FF3\x6F6D\x6F82\x6F7C\x6F58\x6F8E" ++ {-0x50-} chars "\x6F91\x6FC2\x6F66\x6FB3\x6FA3\x6FA1\x6FA4\x6FB9" ++ {-0x58-} chars "\x6FC6\x6FAA\x6FDF\x6FD5\x6FEC\x6FD4\x6FD8\x6FF1" ++ {-0x60-} chars "\x6FEE\x6FDB\x7009\x700B\x6FFA\x7011\x7001\x700F" ++ {-0x68-} chars "\x6FFE\x701B\x701A\x6F74\x701D\x7018\x701F\x7030" ++ {-0x70-} chars "\x703E\x7032\x7051\x7063\x7099\x7092\x70AF\x70F1" ++ {-0x78-} chars "\x70AC\x70B8\x70B3\x70AE\x70DF\x70CB\x70DD" ++ Nothing : {-0x80-} chars "\x70D9\x7109\x70FD\x711C\x7119\x7165\x7155\x7188" ++ {-0x88-} chars "\x7166\x7162\x714C\x7156\x716C\x718F\x71FB\x7184" ++ {-0x90-} chars "\x7195\x71A8\x71AC\x71D7\x71B9\x71BE\x71D2\x71C9" ++ {-0x98-} chars "\x71D4\x71CE\x71E0\x71EC\x71E7\x71F5\x71FC\x71F9" ++ {-0xA0-} chars "\x71FF\x720D\x7210\x721B\x7228\x722D\x722C\x7230" ++ {-0xA8-} chars "\x7232\x723B\x723C\x723F\x7240\x7246\x724B\x7258" ++ {-0xB0-} chars "\x7274\x727E\x7282\x7281\x7287\x7292\x7296\x72A2" ++ {-0xB8-} chars "\x72A7\x72B9\x72B2\x72C3\x72C6\x72C4\x72CE\x72D2" ++ {-0xC0-} chars "\x72E2\x72E0\x72E1\x72F9\x72F7\x500F\x7317\x730A" ++ {-0xC8-} chars "\x731C\x7316\x731D\x7334\x732F\x7329\x7325\x733E" ++ {-0xD0-} chars "\x734E\x734F\x9ED8\x7357\x736A\x7368\x7370\x7378" ++ {-0xD8-} chars "\x7375\x737B\x737A\x73C8\x73B3\x73CE\x73BB\x73C0" ++ {-0xE0-} chars "\x73E5\x73EE\x73DE\x74A2\x7405\x746F\x7425\x73F8" ++ {-0xE8-} chars "\x7432\x743A\x7455\x743F\x745F\x7459\x7441\x745C" ++ {-0xF0-} chars "\x7469\x7470\x7463\x746A\x7476\x747E\x748B\x749E" ++ {-0xF8-} chars "\x74A7\x74CA\x74CF\x74D4\x73F1" -- | The multibyte characters with a lead byte of @0xE1@. secondE1 :: SecondByteTable secondE1 = V.fromList $ {-0x40-} chars "\x74E0\x74E3\x74E7\x74E9\x74EE\x74F2\x74F0\x74F1" ++ {-0x48-} chars "\x74F8\x74F7\x7504\x7503\x7505\x750C\x750E\x750D" ++ {-0x50-} chars "\x7515\x7513\x751E\x7526\x752C\x753C\x7544\x754D" ++ {-0x58-} chars "\x754A\x7549\x755B\x7546\x755A\x7569\x7564\x7567" ++ {-0x60-} chars "\x756B\x756D\x7578\x7576\x7586\x7587\x7574\x758A" ++ {-0x68-} chars "\x7589\x7582\x7594\x759A\x759D\x75A5\x75A3\x75C2" ++ {-0x70-} chars "\x75B3\x75C3\x75B5\x75BD\x75B8\x75BC\x75B1\x75CD" ++ {-0x78-} chars "\x75CA\x75D2\x75D9\x75E3\x75DE\x75FE\x75FF" ++ Nothing : {-0x80-} chars "\x75FC\x7601\x75F0\x75FA\x75F2\x75F3\x760B\x760D" ++ {-0x88-} chars "\x7609\x761F\x7627\x7620\x7621\x7622\x7624\x7634" ++ {-0x90-} chars "\x7630\x763B\x7647\x7648\x7646\x765C\x7658\x7661" ++ {-0x98-} chars "\x7662\x7668\x7669\x766A\x7667\x766C\x7670\x7672" ++ {-0xA0-} chars "\x7676\x7678\x767C\x7680\x7683\x7688\x768B\x768E" ++ {-0xA8-} chars "\x7696\x7693\x7699\x769A\x76B0\x76B4\x76B8\x76B9" ++ {-0xB0-} chars "\x76BA\x76C2\x76CD\x76D6\x76D2\x76DE\x76E1\x76E5" ++ {-0xB8-} chars "\x76E7\x76EA\x862F\x76FB\x7708\x7707\x7704\x7729" ++ {-0xC0-} chars "\x7724\x771E\x7725\x7726\x771B\x7737\x7738\x7747" ++ {-0xC8-} chars "\x775A\x7768\x776B\x775B\x7765\x777F\x777E\x7779" ++ {-0xD0-} chars "\x778E\x778B\x7791\x77A0\x779E\x77B0\x77B6\x77B9" ++ {-0xD8-} chars "\x77BF\x77BC\x77BD\x77BB\x77C7\x77CD\x77D7\x77DA" ++ {-0xE0-} chars "\x77DC\x77E3\x77EE\x77FC\x780C\x7812\x7926\x7820" ++ {-0xE8-} chars "\x792A\x7845\x788E\x7874\x7886\x787C\x789A\x788C" ++ {-0xF0-} chars "\x78A3\x78B5\x78AA\x78AF\x78D1\x78C6\x78CB\x78D4" ++ {-0xF8-} chars "\x78BE\x78BC\x78C5\x78CA\x78EC" -- | The multibyte characters with a lead byte of @0xE2@. secondE2 :: SecondByteTable secondE2 = V.fromList $ {-0x40-} chars "\x78E7\x78DA\x78FD\x78F4\x7907\x7912\x7911\x7919" ++ {-0x48-} chars "\x792C\x792B\x7940\x7960\x7957\x795F\x795A\x7955" ++ {-0x50-} chars "\x7953\x797A\x797F\x798A\x799D\x79A7\x9F4B\x79AA" ++ {-0x58-} chars "\x79AE\x79B3\x79B9\x79BA\x79C9\x79D5\x79E7\x79EC" ++ {-0x60-} chars "\x79E1\x79E3\x7A08\x7A0D\x7A18\x7A19\x7A20\x7A1F" ++ {-0x68-} chars "\x7980\x7A31\x7A3B\x7A3E\x7A37\x7A43\x7A57\x7A49" ++ {-0x70-} chars "\x7A61\x7A62\x7A69\x9F9D\x7A70\x7A79\x7A7D\x7A88" ++ {-0x78-} chars "\x7A97\x7A95\x7A98\x7A96\x7AA9\x7AC8\x7AB0" ++ Nothing : {-0x80-} chars "\x7AB6\x7AC5\x7AC4\x7ABF\x9083\x7AC7\x7ACA\x7ACD" ++ {-0x88-} chars "\x7ACF\x7AD5\x7AD3\x7AD9\x7ADA\x7ADD\x7AE1\x7AE2" ++ {-0x90-} chars "\x7AE6\x7AED\x7AF0\x7B02\x7B0F\x7B0A\x7B06\x7B33" ++ {-0x98-} chars "\x7B18\x7B19\x7B1E\x7B35\x7B28\x7B36\x7B50\x7B7A" ++ {-0xA0-} chars "\x7B04\x7B4D\x7B0B\x7B4C\x7B45\x7B75\x7B65\x7B74" ++ {-0xA8-} chars "\x7B67\x7B70\x7B71\x7B6C\x7B6E\x7B9D\x7B98\x7B9F" ++ {-0xB0-} chars "\x7B8D\x7B9C\x7B9A\x7B8B\x7B92\x7B8F\x7B5D\x7B99" ++ {-0xB8-} chars "\x7BCB\x7BC1\x7BCC\x7BCF\x7BB4\x7BC6\x7BDD\x7BE9" ++ {-0xC0-} chars "\x7C11\x7C14\x7BE6\x7BE5\x7C60\x7C00\x7C07\x7C13" ++ {-0xC8-} chars "\x7BF3\x7BF7\x7C17\x7C0D\x7BF6\x7C23\x7C27\x7C2A" ++ {-0xD0-} chars "\x7C1F\x7C37\x7C2B\x7C3D\x7C4C\x7C43\x7C54\x7C4F" ++ {-0xD8-} chars "\x7C40\x7C50\x7C58\x7C5F\x7C64\x7C56\x7C65\x7C6C" ++ {-0xE0-} chars "\x7C75\x7C83\x7C90\x7CA4\x7CAD\x7CA2\x7CAB\x7CA1" ++ {-0xE8-} chars "\x7CA8\x7CB3\x7CB2\x7CB1\x7CAE\x7CB9\x7CBD\x7CC0" ++ {-0xF0-} chars "\x7CC5\x7CC2\x7CD8\x7CD2\x7CDC\x7CE2\x9B3B\x7CEF" ++ {-0xF8-} chars "\x7CF2\x7CF4\x7CF6\x7CFA\x7D06" -- | The multibyte characters with a lead byte of @0xE3@. secondE3 :: SecondByteTable secondE3 = V.fromList $ {-0x40-} chars "\x7D02\x7D1C\x7D15\x7D0A\x7D45\x7D4B\x7D2E\x7D32" ++ {-0x48-} chars "\x7D3F\x7D35\x7D46\x7D73\x7D56\x7D4E\x7D72\x7D68" ++ {-0x50-} chars "\x7D6E\x7D4F\x7D63\x7D93\x7D89\x7D5B\x7D8F\x7D7D" ++ {-0x58-} chars "\x7D9B\x7DBA\x7DAE\x7DA3\x7DB5\x7DC7\x7DBD\x7DAB" ++ {-0x60-} chars "\x7E3D\x7DA2\x7DAF\x7DDC\x7DB8\x7D9F\x7DB0\x7DD8" ++ {-0x68-} chars "\x7DDD\x7DE4\x7DDE\x7DFB\x7DF2\x7DE1\x7E05\x7E0A" ++ {-0x70-} chars "\x7E23\x7E21\x7E12\x7E31\x7E1F\x7E09\x7E0B\x7E22" ++ {-0x78-} chars "\x7E46\x7E66\x7E3B\x7E35\x7E39\x7E43\x7E37" ++ Nothing : {-0x80-} chars "\x7E32\x7E3A\x7E67\x7E5D\x7E56\x7E5E\x7E59\x7E5A" ++ {-0x88-} chars "\x7E79\x7E6A\x7E69\x7E7C\x7E7B\x7E83\x7DD5\x7E7D" ++ {-0x90-} chars "\x8FAE\x7E7F\x7E88\x7E89\x7E8C\x7E92\x7E90\x7E93" ++ {-0x98-} chars "\x7E94\x7E96\x7E8E\x7E9B\x7E9C\x7F38\x7F3A\x7F45" ++ {-0xA0-} chars "\x7F4C\x7F4D\x7F4E\x7F50\x7F51\x7F55\x7F54\x7F58" ++ {-0xA8-} chars "\x7F5F\x7F60\x7F68\x7F69\x7F67\x7F78\x7F82\x7F86" ++ {-0xB0-} chars "\x7F83\x7F88\x7F87\x7F8C\x7F94\x7F9E\x7F9D\x7F9A" ++ {-0xB8-} chars "\x7FA3\x7FAF\x7FB2\x7FB9\x7FAE\x7FB6\x7FB8\x8B71" ++ {-0xC0-} chars "\x7FC5\x7FC6\x7FCA\x7FD5\x7FD4\x7FE1\x7FE6\x7FE9" ++ {-0xC8-} chars "\x7FF3\x7FF9\x98DC\x8006\x8004\x800B\x8012\x8018" ++ {-0xD0-} chars "\x8019\x801C\x8021\x8028\x803F\x803B\x804A\x8046" ++ {-0xD8-} chars "\x8052\x8058\x805A\x805F\x8062\x8068\x8073\x8072" ++ {-0xE0-} chars "\x8070\x8076\x8079\x807D\x807F\x8084\x8086\x8085" ++ {-0xE8-} chars "\x809B\x8093\x809A\x80AD\x5190\x80AC\x80DB\x80E5" ++ {-0xF0-} chars "\x80D9\x80DD\x80C4\x80DA\x80D6\x8109\x80EF\x80F1" ++ {-0xF8-} chars "\x811B\x8129\x8123\x812F\x814B" -- | The multibyte characters with a lead byte of @0xE4@. secondE4 :: SecondByteTable secondE4 = V.fromList $ {-0x40-} chars "\x968B\x8146\x813E\x8153\x8151\x80FC\x8171\x816E" ++ {-0x48-} chars "\x8165\x8166\x8174\x8183\x8188\x818A\x8180\x8182" ++ {-0x50-} chars "\x81A0\x8195\x81A4\x81A3\x815F\x8193\x81A9\x81B0" ++ {-0x58-} chars "\x81B5\x81BE\x81B8\x81BD\x81C0\x81C2\x81BA\x81C9" ++ {-0x60-} chars "\x81CD\x81D1\x81D9\x81D8\x81C8\x81DA\x81DF\x81E0" ++ {-0x68-} chars "\x81E7\x81FA\x81FB\x81FE\x8201\x8202\x8205\x8207" ++ {-0x70-} chars "\x820A\x820D\x8210\x8216\x8229\x822B\x8238\x8233" ++ {-0x78-} chars "\x8240\x8259\x8258\x825D\x825A\x825F\x8264" ++ Nothing : {-0x80-} chars "\x8262\x8268\x826A\x826B\x822E\x8271\x8277\x8278" ++ {-0x88-} chars "\x827E\x828D\x8292\x82AB\x829F\x82BB\x82AC\x82E1" ++ {-0x90-} chars "\x82E3\x82DF\x82D2\x82F4\x82F3\x82FA\x8393\x8303" ++ {-0x98-} chars "\x82FB\x82F9\x82DE\x8306\x82DC\x8309\x82D9\x8335" ++ {-0xA0-} chars "\x8334\x8316\x8332\x8331\x8340\x8339\x8350\x8345" ++ {-0xA8-} chars "\x832F\x832B\x8317\x8318\x8385\x839A\x83AA\x839F" ++ {-0xB0-} chars "\x83A2\x8396\x8323\x838E\x8387\x838A\x837C\x83B5" ++ {-0xB8-} chars "\x8373\x8375\x83A0\x8389\x83A8\x83F4\x8413\x83EB" ++ {-0xC0-} chars "\x83CE\x83FD\x8403\x83D8\x840B\x83C1\x83F7\x8407" ++ {-0xC8-} chars "\x83E0\x83F2\x840D\x8422\x8420\x83BD\x8438\x8506" ++ {-0xD0-} chars "\x83FB\x846D\x842A\x843C\x855A\x8484\x8477\x846B" ++ {-0xD8-} chars "\x84AD\x846E\x8482\x8469\x8446\x842C\x846F\x8479" ++ {-0xE0-} chars "\x8435\x84CA\x8462\x84B9\x84BF\x849F\x84D9\x84CD" ++ {-0xE8-} chars "\x84BB\x84DA\x84D0\x84C1\x84C6\x84D6\x84A1\x8521" ++ {-0xF0-} chars "\x84FF\x84F4\x8517\x8518\x852C\x851F\x8515\x8514" ++ {-0xF8-} chars "\x84FC\x8540\x8563\x8558\x8548" -- | The multibyte characters with a lead byte of @0xE5@. secondE5 :: SecondByteTable secondE5 = V.fromList $ {-0x40-} chars "\x8541\x8602\x854B\x8555\x8580\x85A4\x8588\x8591" ++ {-0x48-} chars "\x858A\x85A8\x856D\x8594\x859B\x85EA\x8587\x859C" ++ {-0x50-} chars "\x8577\x857E\x8590\x85C9\x85BA\x85CF\x85B9\x85D0" ++ {-0x58-} chars "\x85D5\x85DD\x85E5\x85DC\x85F9\x860A\x8613\x860B" ++ {-0x60-} chars "\x85FE\x85FA\x8606\x8622\x861A\x8630\x863F\x864D" ++ {-0x68-} chars "\x4E55\x8654\x865F\x8667\x8671\x8693\x86A3\x86A9" ++ {-0x70-} chars "\x86AA\x868B\x868C\x86B6\x86AF\x86C4\x86C6\x86B0" ++ {-0x78-} chars "\x86C9\x8823\x86AB\x86D4\x86DE\x86E9\x86EC" ++ Nothing : {-0x80-} chars "\x86DF\x86DB\x86EF\x8712\x8706\x8708\x8700\x8703" ++ {-0x88-} chars "\x86FB\x8711\x8709\x870D\x86F9\x870A\x8734\x873F" ++ {-0x90-} chars "\x8737\x873B\x8725\x8729\x871A\x8760\x875F\x8778" ++ {-0x98-} chars "\x874C\x874E\x8774\x8757\x8768\x876E\x8759\x8753" ++ {-0xA0-} chars "\x8763\x876A\x8805\x87A2\x879F\x8782\x87AF\x87CB" ++ {-0xA8-} chars "\x87BD\x87C0\x87D0\x96D6\x87AB\x87C4\x87B3\x87C7" ++ {-0xB0-} chars "\x87C6\x87BB\x87EF\x87F2\x87E0\x880F\x880D\x87FE" ++ {-0xB8-} chars "\x87F6\x87F7\x880E\x87D2\x8811\x8816\x8815\x8822" ++ {-0xC0-} chars "\x8821\x8831\x8836\x8839\x8827\x883B\x8844\x8842" ++ {-0xC8-} chars "\x8852\x8859\x885E\x8862\x886B\x8881\x887E\x889E" ++ {-0xD0-} chars "\x8875\x887D\x88B5\x8872\x8882\x8897\x8892\x88AE" ++ {-0xD8-} chars "\x8899\x88A2\x888D\x88A4\x88B0\x88BF\x88B1\x88C3" ++ {-0xE0-} chars "\x88C4\x88D4\x88D8\x88D9\x88DD\x88F9\x8902\x88FC" ++ {-0xE8-} chars "\x88F4\x88E8\x88F2\x8904\x890C\x890A\x8913\x8943" ++ {-0xF0-} chars "\x891E\x8925\x892A\x892B\x8941\x8944\x893B\x8936" ++ {-0xF8-} chars "\x8938\x894C\x891D\x8960\x895E" -- | The multibyte characters with a lead byte of @0xE6@. secondE6 :: SecondByteTable secondE6 = V.fromList $ {-0x40-} chars "\x8966\x8964\x896D\x896A\x896F\x8974\x8977\x897E" ++ {-0x48-} chars "\x8983\x8988\x898A\x8993\x8998\x89A1\x89A9\x89A6" ++ {-0x50-} chars "\x89AC\x89AF\x89B2\x89BA\x89BD\x89BF\x89C0\x89DA" ++ {-0x58-} chars "\x89DC\x89DD\x89E7\x89F4\x89F8\x8A03\x8A16\x8A10" ++ {-0x60-} chars "\x8A0C\x8A1B\x8A1D\x8A25\x8A36\x8A41\x8A5B\x8A52" ++ {-0x68-} chars "\x8A46\x8A48\x8A7C\x8A6D\x8A6C\x8A62\x8A85\x8A82" ++ {-0x70-} chars "\x8A84\x8AA8\x8AA1\x8A91\x8AA5\x8AA6\x8A9A\x8AA3" ++ {-0x78-} chars "\x8AC4\x8ACD\x8AC2\x8ADA\x8AEB\x8AF3\x8AE7" ++ Nothing : {-0x80-} chars "\x8AE4\x8AF1\x8B14\x8AE0\x8AE2\x8AF7\x8ADE\x8ADB" ++ {-0x88-} chars "\x8B0C\x8B07\x8B1A\x8AE1\x8B16\x8B10\x8B17\x8B20" ++ {-0x90-} chars "\x8B33\x97AB\x8B26\x8B2B\x8B3E\x8B28\x8B41\x8B4C" ++ {-0x98-} chars "\x8B4F\x8B4E\x8B49\x8B56\x8B5B\x8B5A\x8B6B\x8B5F" ++ {-0xA0-} chars "\x8B6C\x8B6F\x8B74\x8B7D\x8B80\x8B8C\x8B8E\x8B92" ++ {-0xA8-} chars "\x8B93\x8B96\x8B99\x8B9A\x8C3A\x8C41\x8C3F\x8C48" ++ {-0xB0-} chars "\x8C4C\x8C4E\x8C50\x8C55\x8C62\x8C6C\x8C78\x8C7A" ++ {-0xB8-} chars "\x8C82\x8C89\x8C85\x8C8A\x8C8D\x8C8E\x8C94\x8C7C" ++ {-0xC0-} chars "\x8C98\x621D\x8CAD\x8CAA\x8CBD\x8CB2\x8CB3\x8CAE" ++ {-0xC8-} chars "\x8CB6\x8CC8\x8CC1\x8CE4\x8CE3\x8CDA\x8CFD\x8CFA" ++ {-0xD0-} chars "\x8CFB\x8D04\x8D05\x8D0A\x8D07\x8D0F\x8D0D\x8D10" ++ {-0xD8-} chars "\x9F4E\x8D13\x8CCD\x8D14\x8D16\x8D67\x8D6D\x8D71" ++ {-0xE0-} chars "\x8D73\x8D81\x8D99\x8DC2\x8DBE\x8DBA\x8DCF\x8DDA" ++ {-0xE8-} chars "\x8DD6\x8DCC\x8DDB\x8DCB\x8DEA\x8DEB\x8DDF\x8DE3" ++ {-0xF0-} chars "\x8DFC\x8E08\x8E09\x8DFF\x8E1D\x8E1E\x8E10\x8E1F" ++ {-0xF8-} chars "\x8E42\x8E35\x8E30\x8E34\x8E4A" -- | The multibyte characters with a lead byte of @0xE7@. secondE7 :: SecondByteTable secondE7 = V.fromList $ {-0x40-} chars "\x8E47\x8E49\x8E4C\x8E50\x8E48\x8E59\x8E64\x8E60" ++ {-0x48-} chars "\x8E2A\x8E63\x8E55\x8E76\x8E72\x8E7C\x8E81\x8E87" ++ {-0x50-} chars "\x8E85\x8E84\x8E8B\x8E8A\x8E93\x8E91\x8E94\x8E99" ++ {-0x58-} chars "\x8EAA\x8EA1\x8EAC\x8EB0\x8EC6\x8EB1\x8EBE\x8EC5" ++ {-0x60-} chars "\x8EC8\x8ECB\x8EDB\x8EE3\x8EFC\x8EFB\x8EEB\x8EFE" ++ {-0x68-} chars "\x8F0A\x8F05\x8F15\x8F12\x8F19\x8F13\x8F1C\x8F1F" ++ {-0x70-} chars "\x8F1B\x8F0C\x8F26\x8F33\x8F3B\x8F39\x8F45\x8F42" ++ {-0x78-} chars "\x8F3E\x8F4C\x8F49\x8F46\x8F4E\x8F57\x8F5C" ++ Nothing : {-0x80-} chars "\x8F62\x8F63\x8F64\x8F9C\x8F9F\x8FA3\x8FAD\x8FAF" ++ {-0x88-} chars "\x8FB7\x8FDA\x8FE5\x8FE2\x8FEA\x8FEF\x9087\x8FF4" ++ {-0x90-} chars "\x9005\x8FF9\x8FFA\x9011\x9015\x9021\x900D\x901E" ++ {-0x98-} chars "\x9016\x900B\x9027\x9036\x9035\x9039\x8FF8\x904F" ++ {-0xA0-} chars "\x9050\x9051\x9052\x900E\x9049\x903E\x9056\x9058" ++ {-0xA8-} chars "\x905E\x9068\x906F\x9076\x96A8\x9072\x9082\x907D" ++ {-0xB0-} chars "\x9081\x9080\x908A\x9089\x908F\x90A8\x90AF\x90B1" ++ {-0xB8-} chars "\x90B5\x90E2\x90E4\x6248\x90DB\x9102\x9112\x9119" ++ {-0xC0-} chars "\x9132\x9130\x914A\x9156\x9158\x9163\x9165\x9169" ++ {-0xC8-} chars "\x9173\x9172\x918B\x9189\x9182\x91A2\x91AB\x91AF" ++ {-0xD0-} chars "\x91AA\x91B5\x91B4\x91BA\x91C0\x91C1\x91C9\x91CB" ++ {-0xD8-} chars "\x91D0\x91D6\x91DF\x91E1\x91DB\x91FC\x91F5\x91F6" ++ {-0xE0-} chars "\x921E\x91FF\x9214\x922C\x9215\x9211\x925E\x9257" ++ {-0xE8-} chars "\x9245\x9249\x9264\x9248\x9295\x923F\x924B\x9250" ++ {-0xF0-} chars "\x929C\x9296\x9293\x929B\x925A\x92CF\x92B9\x92B7" ++ {-0xF8-} chars "\x92E9\x930F\x92FA\x9344\x932E" -- | The multibyte characters with a lead byte of @0xE8@. secondE8 :: SecondByteTable secondE8 = V.fromList $ {-0x40-} chars "\x9319\x9322\x931A\x9323\x933A\x9335\x933B\x935C" ++ {-0x48-} chars "\x9360\x937C\x936E\x9356\x93B0\x93AC\x93AD\x9394" ++ {-0x50-} chars "\x93B9\x93D6\x93D7\x93E8\x93E5\x93D8\x93C3\x93DD" ++ {-0x58-} chars "\x93D0\x93C8\x93E4\x941A\x9414\x9413\x9403\x9407" ++ {-0x60-} chars "\x9410\x9436\x942B\x9435\x9421\x943A\x9441\x9452" ++ {-0x68-} chars "\x9444\x945B\x9460\x9462\x945E\x946A\x9229\x9470" ++ {-0x70-} chars "\x9475\x9477\x947D\x945A\x947C\x947E\x9481\x947F" ++ {-0x78-} chars "\x9582\x9587\x958A\x9594\x9596\x9598\x9599" ++ Nothing : {-0x80-} chars "\x95A0\x95A8\x95A7\x95AD\x95BC\x95BB\x95B9\x95BE" ++ {-0x88-} chars "\x95CA\x6FF6\x95C3\x95CD\x95CC\x95D5\x95D4\x95D6" ++ {-0x90-} chars "\x95DC\x95E1\x95E5\x95E2\x9621\x9628\x962E\x962F" ++ {-0x98-} chars "\x9642\x964C\x964F\x964B\x9677\x965C\x965E\x965D" ++ {-0xA0-} chars "\x965F\x9666\x9672\x966C\x968D\x9698\x9695\x9697" ++ {-0xA8-} chars "\x96AA\x96A7\x96B1\x96B2\x96B0\x96B4\x96B6\x96B8" ++ {-0xB0-} chars "\x96B9\x96CE\x96CB\x96C9\x96CD\x894D\x96DC\x970D" ++ {-0xB8-} chars "\x96D5\x96F9\x9704\x9706\x9708\x9713\x970E\x9711" ++ {-0xC0-} chars "\x970F\x9716\x9719\x9724\x972A\x9730\x9739\x973D" ++ {-0xC8-} chars "\x973E\x9744\x9746\x9748\x9742\x9749\x975C\x9760" ++ {-0xD0-} chars "\x9764\x9766\x9768\x52D2\x976B\x9771\x9779\x9785" ++ {-0xD8-} chars "\x977C\x9781\x977A\x9786\x978B\x978F\x9790\x979C" ++ {-0xE0-} chars "\x97A8\x97A6\x97A3\x97B3\x97B4\x97C3\x97C6\x97C8" ++ {-0xE8-} chars "\x97CB\x97DC\x97ED\x9F4F\x97F2\x7ADF\x97F6\x97F5" ++ {-0xF0-} chars "\x980F\x980C\x9838\x9824\x9821\x9837\x983D\x9846" ++ {-0xF8-} chars "\x984F\x984B\x986B\x986F\x9870" -- | The multibyte characters with a lead byte of @0xE9@. secondE9 :: SecondByteTable secondE9 = V.fromList $ {-0x40-} chars "\x9871\x9874\x9873\x98AA\x98AF\x98B1\x98B6\x98C4" ++ {-0x48-} chars "\x98C3\x98C6\x98E9\x98EB\x9903\x9909\x9912\x9914" ++ {-0x50-} chars "\x9918\x9921\x991D\x991E\x9924\x9920\x992C\x992E" ++ {-0x58-} chars "\x993D\x993E\x9942\x9949\x9945\x9950\x994B\x9951" ++ {-0x60-} chars "\x9952\x994C\x9955\x9997\x9998\x99A5\x99AD\x99AE" ++ {-0x68-} chars "\x99BC\x99DF\x99DB\x99DD\x99D8\x99D1\x99ED\x99EE" ++ {-0x70-} chars "\x99F1\x99F2\x99FB\x99F8\x9A01\x9A0F\x9A05\x99E2" ++ {-0x78-} chars "\x9A19\x9A2B\x9A37\x9A45\x9A42\x9A40\x9A43" ++ Nothing : {-0x80-} chars "\x9A3E\x9A55\x9A4D\x9A5B\x9A57\x9A5F\x9A62\x9A65" ++ {-0x88-} chars "\x9A64\x9A69\x9A6B\x9A6A\x9AAD\x9AB0\x9ABC\x9AC0" ++ {-0x90-} chars "\x9ACF\x9AD1\x9AD3\x9AD4\x9ADE\x9ADF\x9AE2\x9AE3" ++ {-0x98-} chars "\x9AE6\x9AEF\x9AEB\x9AEE\x9AF4\x9AF1\x9AF7\x9AFB" ++ {-0xA0-} chars "\x9B06\x9B18\x9B1A\x9B1F\x9B22\x9B23\x9B25\x9B27" ++ {-0xA8-} chars "\x9B28\x9B29\x9B2A\x9B2E\x9B2F\x9B32\x9B44\x9B43" ++ {-0xB0-} chars "\x9B4F\x9B4D\x9B4E\x9B51\x9B58\x9B74\x9B93\x9B83" ++ {-0xB8-} chars "\x9B91\x9B96\x9B97\x9B9F\x9BA0\x9BA8\x9BB4\x9BC0" ++ {-0xC0-} chars "\x9BCA\x9BB9\x9BC6\x9BCF\x9BD1\x9BD2\x9BE3\x9BE2" ++ {-0xC8-} chars "\x9BE4\x9BD4\x9BE1\x9C3A\x9BF2\x9BF1\x9BF0\x9C15" ++ {-0xD0-} chars "\x9C14\x9C09\x9C13\x9C0C\x9C06\x9C08\x9C12\x9C0A" ++ {-0xD8-} chars "\x9C04\x9C2E\x9C1B\x9C25\x9C24\x9C21\x9C30\x9C47" ++ {-0xE0-} chars "\x9C32\x9C46\x9C3E\x9C5A\x9C60\x9C67\x9C76\x9C78" ++ {-0xE8-} chars "\x9CE7\x9CEC\x9CF0\x9D09\x9D08\x9CEB\x9D03\x9D06" ++ {-0xF0-} chars "\x9D2A\x9D26\x9DAF\x9D23\x9D1F\x9D44\x9D15\x9D12" ++ {-0xF8-} chars "\x9D41\x9D3F\x9D3E\x9D46\x9D48" -- | The multibyte characters with a lead byte of @0xEA@. secondEA :: SecondByteTable secondEA = V.fromList $ {-0x40-} chars "\x9D5D\x9D5E\x9D64\x9D51\x9D50\x9D59\x9D72\x9D89" ++ {-0x48-} chars "\x9D87\x9DAB\x9D6F\x9D7A\x9D9A\x9DA4\x9DA9\x9DB2" ++ {-0x50-} chars "\x9DC4\x9DC1\x9DBB\x9DB8\x9DBA\x9DC6\x9DCF\x9DC2" ++ {-0x58-} chars "\x9DD9\x9DD3\x9DF8\x9DE6\x9DED\x9DEF\x9DFD\x9E1A" ++ {-0x60-} chars "\x9E1B\x9E1E\x9E75\x9E79\x9E7D\x9E81\x9E88\x9E8B" ++ {-0x68-} chars "\x9E8C\x9E92\x9E95\x9E91\x9E9D\x9EA5\x9EA9\x9EB8" ++ {-0x70-} chars "\x9EAA\x9EAD\x9761\x9ECC\x9ECE\x9ECF\x9ED0\x9ED4" ++ {-0x78-} chars "\x9EDC\x9EDE\x9EDD\x9EE0\x9EE5\x9EE8\x9EEF" ++ Nothing : {-0x80-} chars "\x9EF4\x9EF6\x9EF7\x9EF9\x9EFB\x9EFC\x9EFD\x9F07" ++ {-0x88-} chars "\x9F08\x76B7\x9F15\x9F21\x9F2C\x9F3E\x9F4A\x9F52" ++ {-0x90-} chars "\x9F54\x9F63\x9F5F\x9F60\x9F61\x9F66\x9F67\x9F6C" ++ {-0x98-} chars "\x9F6A\x9F77\x9F72\x9F76\x9F95\x9F9C\x9FA0\x582F" ++ {-0xA0-} chars "\x69C7\x9059\x7464\x51DC\x7199" ++ {-0xA5..0xFC-} nothings 0x58 -- | The multibyte characters with a lead byte of @0xEB@. secondEB :: SecondByteTable secondEB = nothingSecond -- | The multibyte characters with a lead byte of @0xEC@. secondEC :: SecondByteTable secondEC = nothingSecond -- | The multibyte characters with a lead byte of @0xED@. secondED :: SecondByteTable secondED = V.fromList $ {-0x40-} chars "\x7E8A\x891C\x9348\x9288\x84DC\x4FC9\x70BB\x6631" ++ {-0x48-} chars "\x68C8\x92F9\x66FB\x5F45\x4E28\x4EE1\x4EFC\x4F00" ++ {-0x50-} chars "\x4F03\x4F39\x4F56\x4F92\x4F8A\x4F9A\x4F94\x4FCD" ++ {-0x58-} chars "\x5040\x5022\x4FFF\x501E\x5046\x5070\x5042\x5094" ++ {-0x60-} chars "\x50F4\x50D8\x514A\x5164\x519D\x51BE\x51EC\x5215" ++ {-0x68-} chars "\x529C\x52A6\x52C0\x52DB\x5300\x5307\x5324\x5372" ++ {-0x70-} chars "\x5393\x53B2\x53DD\xFA0E\x549C\x548A\x54A9\x54FF" ++ {-0x78-} chars "\x5586\x5759\x5765\x57AC\x57C8\x57C7\xFA0F" ++ Nothing : {-0x80-} chars "\xFA10\x589E\x58B2\x590B\x5953\x595B\x595D\x5963" ++ {-0x88-} chars "\x59A4\x59BA\x5B56\x5BC0\x752F\x5BD8\x5BEC\x5C1E" ++ {-0x90-} chars "\x5CA6\x5CBA\x5CF5\x5D27\x5D53\xFA11\x5D42\x5D6D" ++ {-0x98-} chars "\x5DB8\x5DB9\x5DD0\x5F21\x5F34\x5F67\x5FB7\x5FDE" ++ {-0xA0-} chars "\x605D\x6085\x608A\x60DE\x60D5\x6120\x60F2\x6111" ++ {-0xA8-} chars "\x6137\x6130\x6198\x6213\x62A6\x63F5\x6460\x649D" ++ {-0xB0-} chars "\x64CE\x654E\x6600\x6615\x663B\x6609\x662E\x661E" ++ {-0xB8-} chars "\x6624\x6665\x6657\x6659\xFA12\x6673\x6699\x66A0" ++ {-0xC0-} chars "\x66B2\x66BF\x66FA\x670E\xF929\x6766\x67BB\x6852" ++ {-0xC8-} chars "\x67C0\x6801\x6844\x68CF\xFA13\x6968\xFA14\x6998" ++ {-0xD0-} chars "\x69E2\x6A30\x6A6B\x6A46\x6A73\x6A7E\x6AE2\x6AE4" ++ {-0xD8-} chars "\x6BD6\x6C3F\x6C5C\x6C86\x6C6F\x6CDA\x6D04\x6D87" ++ {-0xE0-} chars "\x6D6F\x6D96\x6DAC\x6DCF\x6DF8\x6DF2\x6DFC\x6E39" ++ {-0xE8-} chars "\x6E5C\x6E27\x6E3C\x6EBF\x6F88\x6FB5\x6FF5\x7005" ++ {-0xF0-} chars "\x7007\x7028\x7085\x70AB\x710F\x7104\x715C\x7146" ++ {-0xF8-} chars "\x7147\xFA15\x71C1\x71FE\x72B1" -- | The multibyte characters with a lead byte of @0xEE@. secondEE :: SecondByteTable secondEE = V.fromList $ {-0x40-} chars "\x72BE\x7324\xFA16\x7377\x73BD\x73C9\x73D6\x73E3" ++ {-0x48-} chars "\x73D2\x7407\x73F5\x7426\x742A\x7429\x742E\x7462" ++ {-0x50-} chars "\x7489\x749F\x7501\x756F\x7682\x769C\x769E\x769B" ++ {-0x58-} chars "\x76A6\xFA17\x7746\x52AF\x7821\x784E\x7864\x787A" ++ {-0x40-} chars "\x7930\xFA18\xFA19\xFA1A\x7994\xFA1B\x799B\x7AD1" ++ {-0x68-} chars "\x7AE7\xFA1C\x7AEB\x7B9E\xFA1D\x7D48\x7D5C\x7DB7" ++ {-0x70-} chars "\x7DA0\x7DD6\x7E52\x7F47\x7FA1\xFA1E\x8301\x8362" ++ {-0x78-} chars "\x837F\x83C7\x83F6\x8448\x84B4\x8553\x8559" ++ Nothing : {-0x80-} chars "\x856B\xFA1F\x85B0\xFA20\xFA21\x8807\x88F5\x8A12" ++ {-0x88-} chars "\x8A37\x8A79\x8AA7\x8ABE\x8ADF\xFA22\x8AF6\x8B53" ++ {-0x90-} chars "\x8B7F\x8CF0\x8CF4\x8D12\x8D76\xFA23\x8ECF\xFA24" ++ {-0x98-} chars "\xFA25\x9067\x90DE\xFA26\x9115\x9127\x91DA\x91D7" ++ {-0xA0-} chars "\x91DE\x91ED\x91EE\x91E4\x91E5\x9206\x9210\x920A" ++ {-0xA8-} chars "\x923A\x9240\x923C\x924E\x9259\x9251\x9239\x9267" ++ {-0xB0-} chars "\x92A7\x9277\x9278\x92E7\x92D7\x92D9\x92D0\xFA27" ++ {-0xB8-} chars "\x92D5\x92E0\x92D3\x9325\x9321\x92FB\xFA28\x931E" ++ {-0xC0-} chars "\x92FF\x931D\x9302\x9370\x9357\x93A4\x93C6\x93DE" ++ {-0xC8-} chars "\x93F8\x9431\x9445\x9448\x9592\xF9DC\xFA29\x969D" ++ {-0xD0-} chars "\x96AF\x9733\x973B\x9743\x974D\x974F\x9751\x9755" ++ {-0xD8-} chars "\x9857\x9865\xFA2A\xFA2B\x9927\xFA2C\x999E\x9A4E" ++ {-0xE0-} chars "\x9AD9\x9ADC\x9B75\x9B72\x9B8F\x9BB1\x9BBB\x9C00" ++ {-0xE8-} chars "\x9D70\x9D6B\xFA2D\x9E19\x9ED1" ++ nothings 2 ++ {-0xEF..0xF8-} chars ['\x2170'..'\x2179'] ++ {-0xF9-} chars "\xFFE2\xFFE4\xFF07\xFF02" -- | The multibyte characters with a lead byte of @0xEF@. secondEF :: SecondByteTable secondEF = nothingSecond -- | The multibyte characters with a lead byte of @0xF0@. secondF0 :: SecondByteTable secondF0 = privateUseSecond 0xE000 -- | The multibyte characters with a lead byte of @0xF1@. secondF1 :: SecondByteTable secondF1 = privateUseSecond 0xE0BC -- | The multibyte characters with a lead byte of @0xF2@. secondF2 :: SecondByteTable secondF2 = privateUseSecond 0xE178 -- | The multibyte characters with a lead byte of @0xF3@. secondF3 :: SecondByteTable secondF3 = privateUseSecond 0xE234 -- | The multibyte characters with a lead byte of @0xF4@. secondF4 :: SecondByteTable secondF4 = privateUseSecond 0xE2F0 -- | The multibyte characters with a lead byte of @0xF5@. secondF5 :: SecondByteTable secondF5 = privateUseSecond 0xE3AC -- | The multibyte characters with a lead byte of @0xF6@. secondF6 :: SecondByteTable secondF6 = privateUseSecond 0xE468 -- | The multibyte characters with a lead byte of @0xF7@. secondF7 :: SecondByteTable secondF7 = privateUseSecond 0xE524 -- | The multibyte characters with a lead byte of @0xF8@. secondF8 :: SecondByteTable secondF8 = privateUseSecond 0xE5E0 -- | The multibyte characters with a lead byte of @0xF9@. secondF9 :: SecondByteTable secondF9 = privateUseSecond 0xE69C -- | The multibyte characters with a lead byte of @0xFA@. secondFA :: SecondByteTable secondFA = V.fromList $ {-0x40..0x49-} chars ['\x2170'..'\x2179'] ++ {-0x4A..0x53-} chars ['\x2160'..'\x2169'] ++ {-0x54-} chars "\xFFE2\xFFE4\xFF07\xFF02" ++ {-0x58-} chars "\x3231\x2116\x2121\x2235\x7E8A\x891C\x9348\x9288" ++ {-0x60-} chars "\x84DC\x4FC9\x70BB\x6631\x68C8\x92F9\x66FB\x5F45" ++ {-0x68-} chars "\x4E28\x4EE1\x4EFC\x4F00\x4F03\x4F39\x4F56\x4F92" ++ {-0x70-} chars "\x4F8A\x4F9A\x4F94\x4FCD\x5040\x5022\x4FFF\x501E" ++ {-0x78-} chars "\x5046\x5070\x5042\x5094\x50F4\x50D8\x514A" ++ Nothing : {-0x80-} chars "\x5164\x519D\x51BE\x51EC\x5215\x529C\x52A6\x52C0" ++ {-0x88-} chars "\x52DB\x5300\x5307\x5324\x5372\x5393\x53B2\x53DD" ++ {-0x90-} chars "\xFA0E\x549C\x548A\x54A9\x54FF\x5586\x5759\x5765" ++ {-0x98-} chars "\x57AC\x57C8\x57C7\xFA0F\xFA10\x589E\x58B2\x590B" ++ {-0xA0-} chars "\x5953\x595B\x595D\x5963\x59A4\x59BA\x5B56\x5BC0" ++ {-0xA8-} chars "\x752F\x5BD8\x5BEC\x5C1E\x5CA6\x5CBA\x5CF5\x5D27" ++ {-0xB0-} chars "\x5D53\xFA11\x5D42\x5D6D\x5DB8\x5DB9\x5DD0\x5F21" ++ {-0xB8-} chars "\x5F34\x5F67\x5FB7\x5FDE\x605D\x6085\x608A\x60DE" ++ {-0xC0-} chars "\x60D5\x6120\x60F2\x6111\x6137\x6130\x6198\x6213" ++ {-0xC8-} chars "\x62A6\x63F5\x6460\x649D\x64CE\x654E\x6600\x6615" ++ {-0xD0-} chars "\x663B\x6609\x662E\x661E\x6624\x6665\x6657\x6659" ++ {-0xD8-} chars "\xFA12\x6673\x6699\x66A0\x66B2\x66BF\x66FA\x670E" ++ {-0xE0-} chars "\xF929\x6766\x67BB\x6852\x67C0\x6801\x6844\x68CF" ++ {-0xE8-} chars "\xFA13\x6968\xFA14\x6998\x69E2\x6A30\x6A6B\x6A46" ++ {-0xF0-} chars "\x6A73\x6A7E\x6AE2\x6AE4\x6BD6\x6C3F\x6C5C\x6C86" ++ {-0xF8-} chars "\x6C6F\x6CDA\x6D04\x6D87\x6D6F" -- | The multibyte characters with a lead byte of @0xFB@. secondFB :: SecondByteTable secondFB = V.fromList $ {-0x40-} chars "\x6D96\x6DAC\x6DCF\x6DF8\x6DF2\x6DFC\x6E39\x6E5C" ++ {-0x48-} chars "\x6E27\x6E3C\x6EBF\x6F88\x6FB5\x6FF5\x7005\x7007" ++ {-0x50-} chars "\x7028\x7085\x70AB\x710F\x7104\x715C\x7146\x7147" ++ {-0x58-} chars "\xFA15\x71C1\x71FE\x72B1\x72BE\x7324\xFA16\x7377" ++ {-0x60-} chars "\x73BD\x73C9\x73D6\x73E3\x73D2\x7407\x73F5\x7426" ++ {-0x68-} chars "\x742A\x7429\x742E\x7462\x7489\x749F\x7501\x756F" ++ {-0x70-} chars "\x7682\x769C\x769E\x769B\x76A6\xFA17\x7746\x52AF" ++ {-0x78-} chars "\x7821\x784E\x7864\x787A\x7930\xFA18\xFA19" ++ Nothing : {-0x80-} chars "\xFA1A\x7994\xFA1B\x799B\x7AD1\x7AE7\xFA1C\x7AEB" ++ {-0x88-} chars "\x7B9E\xFA1D\x7D48\x7D5C\x7DB7\x7DA0\x7DD6\x7E52" ++ {-0x90-} chars "\x7F47\x7FA1\xFA1E\x8301\x8362\x837F\x83C7\x83F6" ++ {-0x98-} chars "\x8448\x84B4\x8553\x8559\x856B\xFA1F\x85B0\xFA20" ++ {-0xA0-} chars "\xFA21\x8807\x88F5\x8A12\x8A37\x8A79\x8AA7\x8ABE" ++ {-0xA8-} chars "\x8ADF\xFA22\x8AF6\x8B53\x8B7F\x8CF0\x8CF4\x8D12" ++ {-0xB0-} chars "\x8D76\xFA23\x8ECF\xFA24\xFA25\x9067\x90DE\xFA26" ++ {-0xB8-} chars "\x9115\x9127\x91DA\x91D7\x91DE\x91ED\x91EE\x91E4" ++ {-0xC0-} chars "\x91E5\x9206\x9210\x920A\x923A\x9240\x923C\x924E" ++ {-0xC8-} chars "\x9259\x9251\x9239\x9267\x92A7\x9277\x9278\x92E7" ++ {-0xD0-} chars "\x92D7\x92D9\x92D0\xFA27\x92D5\x92E0\x92D3\x9325" ++ {-0xD8-} chars "\x9321\x92FB\xFA28\x931E\x92FF\x931D\x9302\x9370" ++ {-0xE0-} chars "\x9357\x93A4\x93C6\x93DE\x93F8\x9431\x9445\x9448" ++ {-0xE8-} chars "\x9592\xF9DC\xFA29\x969D\x96AF\x9733\x973B\x9743" ++ {-0xF0-} chars "\x974D\x974F\x9751\x9755\x9857\x9865\xFA2A\xFA2B" ++ {-0xF8-} chars "\x9927\xFA2C\x999E\x9A4E\x9AD9" -- | The multibyte characters with a lead byte of @0xFC@. secondFC :: SecondByteTable secondFC = V.fromList $ {-0x40-} chars "\x9ADC\x9B75\x9B72\x9B8F\x9BB1\x9BBB\x9C00\x9D70" ++ {-0x48-} chars "\x9D6B\xFA2D\x9E19\x9ED1" ++ {-0x4C..0xFC-} nothings 0xB1