diff --git a/OpenAFP.cabal b/OpenAFP.cabal
--- a/OpenAFP.cabal
+++ b/OpenAFP.cabal
@@ -1,16 +1,18 @@
-name: OpenAFP
-version: 1.0
-license: BSD3
+Name: OpenAFP
+Version: 1.1
+License: BSD3
License-file: LICENSE
-author: Audrey Tang
-maintainer: audreyt@audreyt.org
-synopsis: IBM AFP document format parser and generator
-description: IBM AFP document format parser and generator
-exposed-modules: OpenAFP.Internals.Binary OpenAFP.Internals.Ebc2Asc
- OpenAFP.Internals.UConv
+Author: Audrey Tang
+Maintainer: audreyt@audreyt.org
+Synopsis: IBM AFP document format parser and generator
+Description: IBM AFP document format parser and generator
+Category: Data
+Build-type: Simple
+
+Exposed-modules: OpenAFP.Internals.Binary OpenAFP.Internals.Ebc2Asc
OpenAFP.Prelude.Utils OpenAFP.Prelude.Instances OpenAFP.Prelude.InstanceT
OpenAFP.Prelude.Lookups
- OpenAFP.Prelude.InstanceAFP OpenAFP.Prelude.InstancePTX OpenAFP.Prelude.Exts
+ OpenAFP.Prelude.InstanceAFP OpenAFP.Prelude.InstancePTX
OpenAFP.Records.T.LDOPM OpenAFP.Records.T.OSFO OpenAFP.Records.T.FRMT
OpenAFP.Records.T.OCH OpenAFP.Records.T.MO OpenAFP.Records.T.T2FRMT
OpenAFP.Records.T.FDS OpenAFP.Records.T.OCL OpenAFP.Records.T.OO
@@ -81,12 +83,19 @@
OpenAFP.Records.AFP OpenAFP.Records.PTX OpenAFP.Records.T OpenAFP.Records.MCF
OpenAFP.Types.Chunk OpenAFP.Types.Buffer OpenAFP.Types.View
OpenAFP.Types.Record OpenAFP.Internals OpenAFP.Records OpenAFP.Types OpenAFP
-category: Data
-includes: unicode/ucnv.h
-extensions: CPP, ForeignFunctionInterface
-build-depends: base, mtl, haskell98, regex-compat
-include-dirs: /usr/include /usr/local/include /opt/local/include
-extra-lib-dirs: /usr/lib /usr/local/lib /opt/local/lib
-ld-options: -licuuc
-ghc-options: -fglasgow-exts -funbox-strict-fields -fno-warn-missing-signatures
-hs-source-dirs: src
+ OpenAFP.Prelude.InstanceAFP.B
+ OpenAFP.Prelude.InstanceAFP.C
+ OpenAFP.Prelude.InstanceAFP.D
+ OpenAFP.Prelude.InstanceAFP.E
+ OpenAFP.Prelude.InstanceAFP.F
+ OpenAFP.Prelude.InstanceAFP.G
+ OpenAFP.Prelude.InstanceAFP.I
+ OpenAFP.Prelude.InstanceAFP.L
+ OpenAFP.Prelude.InstanceAFP.M
+Extensions: MagicHash, DeriveDataTypeable, GeneralizedNewtypeDeriving,
+ RankNTypes, TypeFamilies, FlexibleContexts, TypeSynonymInstances,
+ ScopedTypeVariables, MultiParamTypeClasses
+Build-depends: base, mtl, haskell98, regex-compat, directory, process,
+ array, containers, binary, bytestring
+Ghc-options: -funbox-strict-fields -fno-warn-missing-signatures
+Hs-source-dirs: src
diff --git a/src/OpenAFP.hs b/src/OpenAFP.hs
--- a/src/OpenAFP.hs
+++ b/src/OpenAFP.hs
@@ -1,5 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
-
-----------------------------------------------------------------------------
-- |
-- Module : OpenAFP
@@ -19,35 +17,31 @@
module OpenAFP.Types,
module OpenAFP.Records,
module OpenAFP.Internals,
- module OpenAFP.Prelude.Exts,
module OpenAFP.Prelude.Utils,
module OpenAFP.Prelude.Lookups,
module OpenAFP.Prelude.Instances,
- module OpenAFP.Internals.UConv,
- readAFP, writeAFP, filterAFP,
- readArgs, afp_Chunks,
+ readAFP, writeAFP,
+ readArgs, afp_Chunks
) where
import OpenAFP.Types
import OpenAFP.Records
import OpenAFP.Internals
-import OpenAFP.Internals.UConv
import OpenAFP.Prelude.Utils
import OpenAFP.Prelude.Lookups
import OpenAFP.Prelude.Instances
-import OpenAFP.Prelude.Exts
+import qualified Data.ByteString.Lazy as L
afp_Chunks :: FilePath -> [AFP_]
afp_Chunks filename = unsafePerformIO $ readAFP filename
writeAFP :: (Binary a) => FilePath -> [a] -> IO ()
-writeAFP filename c = do
- fh <- openBinaryFile filename WriteMode
- bh <- openBinIO_ fh
- put bh $ c
- hClose fh
- return ()
+writeAFP "-" c = do
+ hSetBinaryMode stdout True
+ L.hPut stdout (encodeList c)
+writeAFP filename c = encodeListFile filename c
+{-
filterAFP :: FilePath -> FilePath -> [(ChunkType, AFP_ -> IO [AFP_])] -> IO ()
filterAFP input output filters = do
ifh <- openBinaryFile input ReadMode
@@ -74,20 +68,21 @@
where
filters = filter (\(t, _) -> (t == chunkType c)) possibleFilters
-instance RecChunk FilePath AFP_ N3 Buffer2 where
+-}
+instance RecChunk FilePath where
+ type ChunkOf FilePath = AFP_
readChunks = afp_Chunks
instance Rec Char
readAFP :: (MonadIO m) => FilePath -> m [AFP_]
-readAFP filename = liftIO $ do
- fh <- openBinaryFile filename ReadMode
- bh <- openBinIO_ fh
- cs <- get bh
- return cs
+readAFP "-" = io $ do
+ hSetBinaryMode stdin True
+ fmap decodeList (L.hGetContents stdin)
+readAFP filename = io $ decodeListFile filename
readArgs :: (MonadIO m) => Int -> m [String]
-readArgs n = liftIO $ do
+readArgs n = io $ do
args <- getArgs
when ((length args) < n) $ do
pgm <- getProgName
diff --git a/src/OpenAFP/Internals.hs b/src/OpenAFP/Internals.hs
--- a/src/OpenAFP/Internals.hs
+++ b/src/OpenAFP/Internals.hs
@@ -1,5 +1,3 @@
-{-# OPTIONS -fglasgow-exts #-}
-
-----------------------------------------------------------------------------
-- |
-- Module : OpenAFP.Internals
@@ -16,94 +14,71 @@
-----------------------------------------------------------------------------
module OpenAFP.Internals (
- module OpenAFP.Internals.Binary,
- module OpenAFP.Internals.Ebc2Asc,
-
- module Control.Exception,
- module Control.Monad.RWS,
- module Control.Monad.Error,
- module Data.Array.Unboxed,
- module Data.Bits,
- module Data.Char,
- module Data.List,
- module Data.HashTable,
- module Data.Word,
- module Data.Typeable,
- module Data.IORef,
- module Data.Maybe,
- module Debug.Trace,
- module Foreign.C.String,
- module Foreign.C.Types,
- module Foreign.Marshal.Alloc,
- module Foreign.Marshal.Array,
- module Foreign.Marshal.Utils,
- module Foreign.Ptr,
- module Foreign.ForeignPtr,
- module Foreign.Storable,
- module System.Mem.Weak,
- module System.Console.GetOpt,
- module System.IO,
- module System.Cmd,
- module System.Environment,
- module System.Exit,
- module System.IO.Unsafe,
- module System.IO.Error,
- module System.Directory,
- module Text.Regex,
- module GHC.IOBase,
+ module X,
- IOm, StateIO,
+ IOm, StateIO, BS,
hashNew, hashLookup, hashInsert, hashDelete,
stateGet, statePut
) where
-import OpenAFP.Internals.Binary
-import OpenAFP.Internals.Ebc2Asc
+import OpenAFP.Internals.Binary as X
+import OpenAFP.Internals.Ebc2Asc as X
-import Control.Exception hiding (try, catch, ioError)
-import Control.Monad.Error (throwError, catchError, MonadError(..), Error(..))
-import Control.Monad.RWS hiding (get, put)
+import Control.Exception as X hiding (try, catch, ioError)
+import Control.Monad as X
+import Control.Monad.Trans as X
+import Control.Monad.Error as X (throwError, catchError, MonadError(..), Error(..))
+import Control.Monad.Writer as X
+import Control.Monad.Reader as X
+import Control.Monad.RWS as X hiding (get, put)
+import Data.Array.Unboxed as X
+import Data.Bits as X
+import Data.Char as X
+import Data.List as X
+import Data.HashTable as X hiding (lookup, insert, delete, new)
+import Data.Word as X
+import Data.Typeable as X
+import Data.IORef as X
+import Data.Maybe as X
+import Data.Monoid as X
+import Debug.Trace as X
+import Foreign.C.String as X
+import Foreign.C.Types as X
+import Foreign.Marshal.Alloc as X
+import Foreign.Marshal.Array as X
+import Foreign.Marshal.Utils as X
+import Foreign.Ptr as X
+import Foreign.ForeignPtr as X
+import Foreign.Storable as X
+import Numeric as X
+import System.Cmd as X
+import System.Console.GetOpt as X
+import System.IO as X
+import System.Environment as X
+import System.Exit as X
+import System.Mem.Weak as X
+import System.IO.Unsafe as X
+import System.IO.Error as X
+import System.Directory as X
+import Text.Regex as X
+import GHC.IOBase as X (IOArray, newIOArray, readIOArray, writeIOArray)
import qualified Control.Monad.RWS (get, put)
-import Data.Array.Unboxed
-import Data.Bits
-import Data.Char
-import Data.List
-import Data.HashTable hiding (lookup, insert, delete, new)
+import qualified Control.Monad.State (MonadState)
import qualified Data.HashTable (lookup, insert, delete, new)
-import Data.Word
-import Data.Typeable
-import Data.IORef
-import Data.Maybe
-import Debug.Trace
-import Foreign.C.String
-import Foreign.C.Types
-import Foreign.Marshal.Alloc
-import Foreign.Marshal.Array
-import Foreign.Marshal.Utils
-import Foreign.Ptr
-import Foreign.ForeignPtr
-import Foreign.Storable
-import Numeric
-import System.Cmd
-import System.Console.GetOpt
-import System.IO
-import System.Environment
-import System.Exit
-import System.Mem.Weak
-import System.IO.Unsafe
-import System.IO.Error
-import System.Directory
-import Text.Regex
-import GHC.IOBase (IOArray, newIOArray, readIOArray, writeIOArray)
+import qualified Data.ByteString as S
+import qualified Data.ByteString.Lazy as L
hashNew = Data.HashTable.new
hashLookup = Data.HashTable.lookup
hashInsert = Data.HashTable.insert
hashDelete = Data.HashTable.delete
-stateGet :: (Control.Monad.RWS.MonadState s m) => m s
+type BS = S.ByteString
+type BL = L.ByteString
+
+stateGet :: (Control.Monad.State.MonadState s m) => m s
stateGet = Control.Monad.RWS.get
-statePut :: (Control.Monad.RWS.MonadState s m) => s -> m ()
+statePut :: (Control.Monad.State.MonadState s m) => s -> m ()
statePut = Control.Monad.RWS.put
type IOm a = (MonadPlus m, MonadIO m, MonadError e m, Show e, Typeable e) => m a
diff --git a/src/OpenAFP/Internals/Binary.hs b/src/OpenAFP/Internals/Binary.hs
--- a/src/OpenAFP/Internals/Binary.hs
+++ b/src/OpenAFP/Internals/Binary.hs
@@ -1,54 +1,22 @@
-{-# OPTIONS -fglasgow-exts -O -funbox-strict-fields #-}
-
------------------------------------------------------------------------------
--- |
--- Module : OpenAFP.Internals.Binary
--- Copyright : (c) Audrey Tang 2004, 2006
--- License : BSD-style
---
--- Maintainer : audreyt@audreyt.org
--- Stability : experimental
--- Portability : non-portable (GHC-only)
---
--- Binary IO library for buffers and file handles.
---
--- Based on Binary.hs from GHC source tree, (c) The University of Glasgow 2002.
---
--- Based on the nhc98 Binary library, which is copyright
--- (c) Malcolm Wallace and Colin Runciman, University of York, 1998.
--- Under the terms of the license for that software, we must tell you
--- where you can obtain the original version of the Binary library, namely
---
---
------------------------------------------------------------------------------
-
module OpenAFP.Internals.Binary (
- {-class-} Binary(..),
- {-type-} BinHandle,
-
- openBinIO, openBinIO_,
- openBinBuf, newBinBuf,
-
- seekBin, tellBin, closeBin, isEOFBin, sizeBin,
-
- putByte, getByte,
-
- getBuf, putBuf, bufOf,
-
N0(..),
N1(..), N2(..), N3(..), N4(..),
I1(..), I2(..), I4(..), I8(..),
A1(..), A2(..), A3(..), A4(..), A6(..), A8(..), A12(..),
- PStringLen,
+ PStringLen, getList, putList, encodeList, decodeList, encodeListFile, decodeListFile,
+
+ module Data.Binary,
+ module Data.ByteString.Internal
) where
+import Data.Binary
import Data.Array.Unboxed
import Data.Bits
import Data.Int
import Data.Word
import Data.Typeable
-import Control.Monad ( when )
+import Control.Monad ( when, liftM )
import System.IO as IO
import System.IO.Error ( mkIOError, eofErrorType )
import GHC.Exts
@@ -66,204 +34,59 @@
import GHC.Base
import GHC.IOBase
----------------------------------------------------------------
--- BinHandle
----------------------------------------------------------------
-
-data BinHandle =
- BinIO { -- binary data stored in a file
- off_r :: !IntM, -- the current offset (cached)
- hdl :: !IO.Handle -- the file handle (must be seekable)
- }
- |
- BinBuf { -- PStringLen based buffers
- off_r :: !IntM, -- the current offset (cached)
- buf :: !PStringLen -- the memory buffer
- }
- deriving (Show, Typeable)
-
-type PStringLen = (ForeignPtr CChar, Int)
-
----------------------------------------------------------------
--- Accessors
----------------------------------------------------------------
-
-bufOf :: BinHandle -> PStringLen
-bufOf (BinIO _ _) = error "bufOf not defined"
-bufOf (BinBuf _ buf) = buf
-
-instance Show IntM where
- show i = (show $ unsafePerformIO $ readIntM i)
-
----------------------------------------------------------------
--- class Binary
----------------------------------------------------------------
-
-class Binary a where
- put :: BinHandle -> a -> IO ()
- get :: BinHandle -> IO a
-
-openBinIO_ :: IO.Handle -> IO BinHandle
-openBinIO_ h = openBinIO h
-
-openBinIO :: IO.Handle -> IO BinHandle
-openBinIO h = do
- r <- newIntM
- writeIntM r 0
- return (BinIO r h)
-
-openBinBuf :: PStringLen -> IO BinHandle
-openBinBuf pstrlen = do
- ix_r <- newIntM
- writeIntM ix_r 0
- return $ BinBuf ix_r pstrlen
-
-newBinBuf :: Int -> IO BinHandle
-newBinBuf size
- | size <= 0 = error "newBinBuf: size must be >= 0"
- | otherwise = do
- pstr <- mallocForeignPtrBytes size
- openBinBuf (pstr, size)
-
-tellBin :: BinHandle -> IO Int
-tellBin (BinIO r _) = readIntM r
-tellBin (BinBuf r _) = readIntM r
-
-seekBin :: BinHandle -> Int -> IO ()
-seekBin (BinIO ix_r h) p = do
- writeIntM ix_r p
- hSeek h AbsoluteSeek (fromIntegral p)
-seekBin (BinBuf ix_r _) p = do
- writeIntM ix_r p
-
-closeBin :: BinHandle -> IO ()
-closeBin (BinIO _ h) = hClose h
-closeBin (BinBuf _ _) = return ()
-
-isEOFBin :: BinHandle -> IO Bool
-isEOFBin (BinIO _ h) = hIsEOF h
-isEOFBin (BinBuf ix_r (_, len)) = do
- ix <- readIntM ix_r
- return (ix >= len)
-
-sizeBin :: BinHandle -> IO Int
-sizeBin (BinIO _ h) = do
- size <- hFileSize h
- return $ fromEnum size
-sizeBin (BinBuf _ (_, len)) = return len
-
--- -----------------------------------------------------------------------------
--- Low-level reading/writing of bytes
-
-putWord8 :: BinHandle -> Word8 -> IO ()
-putWord8 (BinIO ix_r h) w = do
- -- ix <- readIntM ix_r
- hPutChar h $ chr $ fromEnum w -- XXX not really correct
- -- writeIntM ix_r (ix+1)
- return ()
-putWord8 (BinBuf ix_r (pstr, len)) w = do
- ix <- readIntM ix_r
- when (ix >= len) $
- ioError (mkIOError eofErrorType "putWord8" Nothing Nothing)
- writeIntM ix_r (ix+1)
- withForeignPtr pstr $ \cstr ->
- pokeByteOff cstr ix w
- return ()
-
-getWord8 :: BinHandle -> IO Word8
-getWord8 (BinIO ix_r h) = do
- ix <- readIntM ix_r
- c <- hGetChar h
- writeIntM ix_r (ix+1)
- return $! (fromIntegral (ord c)) -- XXX not really correct
-getWord8 (BinBuf ix_r (pstr, len)) = do
- ix <- readIntM ix_r
--- when (ix >= len) $
--- ioError (mkIOError eofErrorType "getWord8" Nothing Nothing)
- writeIntM ix_r (ix+1)
- withForeignPtr pstr $ \cstr ->
- peekByteOff cstr ix
-
-getBuf :: BinHandle -> Int -> IO PStringLen
-getBuf (BinIO ix_r h) size = do
- pstr <- mallocForeignPtrBytes size
- withForeignPtr pstr $ \cstr -> do
- len <- hGetBuf h cstr size
- ix <- readIntM ix_r
- writeIntM ix_r (ix + len)
- return (pstr, len)
-getBuf (BinBuf ix_r (pstr, len)) size = do
- ix <- readIntM ix_r
- let len' = min (len - ix) size
- writeIntM ix_r (ix + len')
- withForeignPtr pstr $ \cstr -> do
- pstr' <- newForeignPtr_ (plusPtr cstr ix)
- addFinalizer pstr' $ touchForeignPtr pstr -- ???
- return (pstr', len')
-
-putBuf :: BinHandle -> PStringLen -> IO ()
-putBuf (BinIO ix_r h) (pstr, len) = do
- ix <- readIntM ix_r
- writeIntM ix_r (ix + len)
- withForeignPtr pstr $ \cstr ->
- hPutBuf h cstr len
-putBuf (BinBuf ix_r (pstr, len)) (pstr', len') = do
- ix <- readIntM ix_r
- when ((ix + len') > len) $
- ioError (mkIOError eofErrorType "putBuf" Nothing Nothing)
- writeIntM ix_r (ix+len')
- withForeignPtr pstr $ \cstr ->
- withForeignPtr pstr' $ \cstr' ->
- copyBytes (plusPtr cstr ix) cstr' len'
+import Data.Binary.Get
+import Data.Binary.Put
+import Data.ByteString.Internal (ByteString(..))
+import qualified Data.ByteString as S
+import GHC.Word (Word32(..),Word16(..),Word64(..))
+import qualified Data.ByteString.Lazy as L
-putByte :: BinHandle -> Word8 -> IO ()
-putByte bh w = put bh w
+newtype A1 = A1 Word8 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Bounded)
+newtype A2 = A2 Word16 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Bounded)
+newtype A3 = A3 Word32 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable)
+newtype A4 = A4 Word32 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Bounded)
+newtype A6 = A6 Word64 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable)
+newtype A8 = A8 Word64 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Bounded)
+newtype A12 = A12 Integer deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable)
-getByte :: BinHandle -> IO Word8
-getByte = getWord8
+newtype I1 = I1 Int8 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Ix, IArray UArray, Show)
+newtype I2 = I2 Int16 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Ix, IArray UArray, Show)
+newtype I4 = I4 Int32 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Ix, IArray UArray, Show)
+newtype I8 = I8 Int64 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Ix, IArray UArray, Show)
--- -----------------------------------------------------------------------------
--- Primitve Word writes
+newtype N1 = N1 { fromN1 :: Word8 } deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary, Ix, IArray UArray, Bounded)
+newtype N2 = N2 { fromN2 :: Word16 } deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary, Bounded)
+newtype N3 = N3 { fromN3 :: Word32 } deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable)
+newtype N4 = N4 { fromN4 :: Word32 } deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary, Bounded)
-instance Binary Word8 where
- put = putWord8
- get = getWord8
+data N0 = N0 deriving (Show, Ord, Enum, Eq, Typeable, Ix, Bounded)
-instance Binary Word16 where
- put h w = do -- XXX too slow.. inline putWord8?
- putByte h (fromIntegral (w `shiftR` 8))
- putByte h (fromIntegral (w .&. 0xff))
- get h = do
- w1 <- getWord8 h
- w2 <- getWord8 h
- return $! ((fromIntegral w1 `shiftL` 8) .|. fromIntegral w2)
+instance Bounded A3 where
+ minBound = A3 0
+ maxBound = A3 (2 ^ (8 * 3))
-newtype A1 = A1 Word8 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary)
-newtype A2 = A2 Word16 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary)
-newtype A3 = A3 Word32 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable)
-newtype A4 = A4 Word32 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary)
-newtype A6 = A6 Word64 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable)
-newtype A8 = A8 Word64 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary)
-newtype A12 = A12 Integer deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable)
+instance Bounded A6 where
+ minBound = A6 0
+ maxBound = A6 (2 ^ (8 * 6))
-newtype I1 = I1 Int8 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary, Ix, IArray UArray, Show)
-newtype I2 = I2 Int16 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary, Ix, IArray UArray, Show)
-newtype I4 = I4 Int32 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary, Ix, IArray UArray, Show)
-newtype I8 = I8 Int64 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary, Ix, IArray UArray, Show)
+instance Bounded A12 where
+ minBound = A12 0
+ maxBound = A12 (2 ^ (8 * 12))
-newtype N1 = N1 Word8 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary, Ix, IArray UArray)
-newtype N2 = N2 Word16 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary)
-newtype N3 = N3 Word32 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable)
-newtype N4 = N4 Word32 deriving (Ord, Enum, Real, Integral, Eq, Num, Bits, Typeable, Storable, Binary)
+instance Bounded N3 where
+ minBound = N3 0
+ maxBound = N3 (2 ^ (8 * 3))
-newtype N0 = N0 () deriving (Show, Ord, Enum, Eq, Typeable, Binary, Ix)
+instance Binary N0 where
+ get = return N0
+ put _ = return ()
instance Num N0 where
x + _ = x
x * _ = x
abs x = x
signum x = x
- fromInteger _ = N0 ()
+ fromInteger _ = N0
instance Show N1 where show = zeropad 1
instance Show N2 where show = zeropad 2
@@ -302,230 +125,138 @@
instance (Storable a, Storable b) => Storable (a, b) where
alignment _ = error "alignment not defined"
- sizeOf (x, y) = (sizeOf x) + (sizeOf y)
+ sizeOf (x, y) = sizeOf x + sizeOf y
-instance Binary N3 where
- put h w = do
- putByte h (fromIntegral (w `shiftR` 16))
- putByte h (fromIntegral ((w `shiftR` 8) .&. 0xff))
- putByte h (fromIntegral (w .&. 0xff))
- get h = do
- w1 <- getWord8 h
- w2 <- getWord8 h
- w3 <- getWord8 h
- return $! ((fromIntegral w1 `shiftL` 16) .|.
- (fromIntegral w2 `shiftL` 8) .|.
- (fromIntegral w3))
+-- type PStringLen = (ForeignPtr CChar, Int)
+type PStringLen = S.ByteString
-instance Binary A3 where
- put h w = do
- putByte h (fromIntegral (w `shiftR` 16))
- putByte h (fromIntegral ((w `shiftR` 8) .&. 0xff))
- putByte h (fromIntegral (w .&. 0xff))
- get h = do
- w1 <- getWord8 h
- w2 <- getWord8 h
- w3 <- getWord8 h
- return $! ((fromIntegral w1 `shiftL` 16) .|.
- (fromIntegral w2 `shiftL` 8) .|.
- (fromIntegral w3))
+instance Binary A1 where
+ put (A1 w) = putWord8 w
+ get = fmap A1 getWord8
-instance Binary A6 where
- put h w = do
- putByte h (fromIntegral (w `shiftR` 40))
- putByte h (fromIntegral ((w `shiftR` 32) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 24) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 16) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 8) .&. 0xff))
- putByte h (fromIntegral (w .&. 0xff))
- get h = do
- w1 <- getWord8 h
- w2 <- getWord8 h
- w3 <- getWord8 h
- w4 <- getWord8 h
- w5 <- getWord8 h
- w6 <- getWord8 h
- return $! ((fromIntegral w1 `shiftL` 40) .|.
- (fromIntegral w2 `shiftL` 32) .|.
- (fromIntegral w3 `shiftL` 24) .|.
- (fromIntegral w4 `shiftL` 16) .|.
- (fromIntegral w5 `shiftL` 8) .|.
- (fromIntegral w6))
+instance Binary A2 where
+ put (A2 w) = putWord16be w
+ get = fmap A2 getWord16be
-instance Binary A12 where
- put h w = do
- putByte h (fromIntegral (w `shiftR` 88))
- putByte h (fromIntegral ((w `shiftR` 80) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 72) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 64) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 56) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 48) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 40) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 32) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 24) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 16) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 8) .&. 0xff))
- putByte h (fromIntegral (w .&. 0xff))
- get h = do
- w1 <- getWord8 h
- w2 <- getWord8 h
- w3 <- getWord8 h
- w4 <- getWord8 h
- w5 <- getWord8 h
- w6 <- getWord8 h
- return $! ((fromIntegral w1 `shiftL` 88) .|.
- (fromIntegral w2 `shiftL` 80) .|.
- (fromIntegral w3 `shiftL` 72) .|.
- (fromIntegral w4 `shiftL` 64) .|.
- (fromIntegral w5 `shiftL` 56) .|.
- (fromIntegral w2 `shiftL` 48) .|.
- (fromIntegral w3 `shiftL` 40) .|.
- (fromIntegral w2 `shiftL` 32) .|.
- (fromIntegral w3 `shiftL` 24) .|.
- (fromIntegral w4 `shiftL` 16) .|.
- (fromIntegral w5 `shiftL` 8) .|.
- (fromIntegral w6))
+instance Binary A4 where
+ put (A4 w) = putWord32be w
+ get = fmap A4 getWord32be
-instance Binary Word32 where
- put h w = do
- putByte h (fromIntegral (w `shiftR` 24))
- putByte h (fromIntegral ((w `shiftR` 16) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 8) .&. 0xff))
- putByte h (fromIntegral (w .&. 0xff))
- get h = do
- w1 <- getWord8 h
- w2 <- getWord8 h
- w3 <- getWord8 h
- w4 <- getWord8 h
- return $! ((fromIntegral w1 `shiftL` 24) .|.
- (fromIntegral w2 `shiftL` 16) .|.
- (fromIntegral w3 `shiftL` 8) .|.
- (fromIntegral w4))
+instance Binary A8 where
+ put (A8 w) = putWord64be w
+ get = fmap A8 getWord64be
+instance Binary A3 where
+ put (A3 w) = do
+ putWord8 $ fromIntegral (shiftr_w32 w 16)
+ putWord16be $ fromIntegral w
+ get = do
+ s <- readN 3 id
+ return $! A3 ((fromIntegral (s `S.index` 0) `shiftl_w32` 16) .|.
+ (fromIntegral (s `S.index` 1) `shiftl_w32` 8) .|.
+ (fromIntegral (s `S.index` 2)))
-instance Binary Word64 where
- put h w = do
- putByte h (fromIntegral (w `shiftR` 56))
- putByte h (fromIntegral ((w `shiftR` 48) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 40) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 32) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 24) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 16) .&. 0xff))
- putByte h (fromIntegral ((w `shiftR` 8) .&. 0xff))
- putByte h (fromIntegral (w .&. 0xff))
- get h = do
- w1 <- getWord8 h
- w2 <- getWord8 h
- w3 <- getWord8 h
- w4 <- getWord8 h
- w5 <- getWord8 h
- w6 <- getWord8 h
- w7 <- getWord8 h
- w8 <- getWord8 h
- return $! ((fromIntegral w1 `shiftL` 56) .|.
- (fromIntegral w2 `shiftL` 48) .|.
- (fromIntegral w3 `shiftL` 40) .|.
- (fromIntegral w4 `shiftL` 32) .|.
- (fromIntegral w5 `shiftL` 24) .|.
- (fromIntegral w6 `shiftL` 16) .|.
- (fromIntegral w7 `shiftL` 8) .|.
- (fromIntegral w8))
+instance Binary A6 where
+ put (A6 w) = do
+ putWord16be $ fromIntegral (shiftr_w64 w 32)
+ putWord32be $ fromIntegral w
+ get = do
+ s <- readN 6 id
+ return $! A6 ((fromIntegral (s `S.index` 0) `shiftl_w64` 40) .|.
+ (fromIntegral (s `S.index` 1) `shiftl_w64` 32) .|.
+ (fromIntegral (s `S.index` 2) `shiftl_w64` 24) .|.
+ (fromIntegral (s `S.index` 3) `shiftl_w64` 16) .|.
+ (fromIntegral (s `S.index` 4) `shiftl_w64` 8) .|.
+ (fromIntegral (s `S.index` 5)))
--- -----------------------------------------------------------------------------
--- Primitve Int writes
+instance Binary A12 where
+ put (A12 w) = do
+ putWord32be $ fromIntegral (shiftR w 64)
+ putWord64be $ fromIntegral w
+ get = do
+ s <- readN 12 id
+ return $! A12 ((fromIntegral (s `S.index` 0) `shiftL` 88) .|.
+ (fromIntegral (s `S.index` 1) `shiftL` 80) .|.
+ (fromIntegral (s `S.index` 2) `shiftL` 72) .|.
+ (fromIntegral (s `S.index` 3) `shiftL` 64) .|.
+ (fromIntegral (s `S.index` 4) `shiftL` 56) .|.
+ (fromIntegral (s `S.index` 5) `shiftL` 48) .|.
+ (fromIntegral (s `S.index` 6) `shiftL` 40) .|.
+ (fromIntegral (s `S.index` 7) `shiftL` 32) .|.
+ (fromIntegral (s `S.index` 8) `shiftL` 24) .|.
+ (fromIntegral (s `S.index` 9) `shiftL` 16) .|.
+ (fromIntegral (s `S.index` 10) `shiftL` 8) .|.
+ (fromIntegral (s `S.index` 11)))
-instance Binary Int8 where
- put h w = put h (fromIntegral w :: Word8)
- get h = do w <- get h; return $! (fromIntegral (w::Word8))
+instance Binary I1 where
+ put (I1 w) = putWord8 $ fromIntegral w
+ get = fmap (I1 . fromIntegral) getWord8
-instance Binary Int16 where
- put h w = put h (fromIntegral w :: Word16)
- get h = do w <- get h; return $! (fromIntegral (w::Word16))
+instance Binary I2 where
+ put (I2 w) = putWord16be $ fromIntegral w
+ get = fmap (I2 . fromIntegral) getWord16be
-instance Binary Int32 where
- put h w = put h (fromIntegral w :: Word32)
- get h = do w <- get h; return $! (fromIntegral (w::Word32))
+instance Binary I4 where
+ put (I4 w) = putWord32be $ fromIntegral w
+ get = fmap (I4 . fromIntegral) getWord32be
-instance Binary Int64 where
- put h w = put h (fromIntegral w :: Word64)
- get h = do w <- get h; return $! (fromIntegral (w::Word64))
+instance Binary I8 where
+ put (I8 w) = putWord64be $ fromIntegral w
+ get = fmap (I8 . fromIntegral) getWord64be
--- -----------------------------------------------------------------------------
--- Instances for standard types
+instance Binary N3 where
+ put (N3 w) = do
+ putWord8 $ fromIntegral (shiftr_w32 w 16)
+ putWord16be $ fromIntegral w
+ get = do
+ s <- readN 3 id
+ return $! N3 ((fromIntegral (s `S.index` 0) `shiftl_w32` 16) .|.
+ (fromIntegral (s `S.index` 1) `shiftl_w32` 8) .|.
+ (fromIntegral (s `S.index` 2)))
-instance Binary () where
- put bh () = return ()
- get _ = return ()
+------------------------------------------------------------------------
+-- Unchecked shifts
-instance Binary Bool where
- put bh b = putByte bh (fromIntegral (fromEnum b))
- get bh = do x <- getWord8 bh; return $! (toEnum (fromEnum x))
+shiftr_w16 :: Word16 -> Int -> Word16
+shiftr_w16 (W16# w) (I# i) = W16# (w `uncheckedShiftRL#` i)
+shiftr_w32 :: Word32 -> Int -> Word32
+shiftr_w32 (W32# w) (I# i) = W32# (w `uncheckedShiftRL#` i)
-instance Binary Char where
- put bh c = put bh (fromIntegral (ord c) :: Word8)
- get bh = do x <- get bh; return $! (chr (fromEnum (x :: Word8)))
+readN :: Int -> (S.ByteString -> a) -> Get a
+readN n f = fmap f $ getBytes n
+{-# INLINE readN #-}
+-- ^ important
--- XXX - 32-bitism
-instance Binary Int where
- put bh i = put bh (fromIntegral i :: Int32)
- get bh = do
- x <- get bh
- return $! (fromIntegral (x :: Int32))
+shiftl_w16 :: Word16 -> Int -> Word16
+shiftl_w32 :: Word32 -> Int -> Word32
-instance Binary a => Binary [a] where
- put bh list = do mapM_ (put bh) list
- get bh@(BinBuf ix_r (_, len)) = do
- ix <- readIntM ix_r
- if (ix >= len) then
- return []
- else do
- x <- get bh
- xs <- get bh
- return (x:xs)
- get bh@(BinIO _ _) = (do
- x <- get bh
- xs <- unsafeInterleaveIO $ get bh
- return (x:xs)) `catch` \e -> return []
+shiftl_w16 (W16# w) (I# i) = W16# (w `uncheckedShiftL#` i)
+shiftl_w32 (W32# w) (I# i) = W32# (w `uncheckedShiftL#` i)
-instance (Binary a, Binary b) => Binary (a,b) where
- put bh (a,b) = do put bh a; put bh b
- get bh = do a <- get bh
- b <- get bh
- return (a,b)
-instance (Binary a, Binary b, Binary c) => Binary (a,b,c) where
- put bh (a,b,c) = do put bh a; put bh b; put bh c
- get bh = do a <- get bh
- b <- get bh
- c <- get bh
- return (a,b,c)
+shiftr_w64 = shiftR
+shiftl_w64 = shiftL
-instance (Binary a, Binary b, Binary c, Binary d) => Binary (a,b,c,d) where
- put bh (a,b,c,d)= do put bh a; put bh b; put bh c; put bh d
- get bh = do a <- get bh
- b <- get bh
- c <- get bh
- d <- get bh
- return (a,b,c,d)
+getList :: Binary a => Get [a]
+getList = do
+ rv <- isEmpty
+ if rv then return [] else do
+ x <- get
+ xs <- getList
+ return (x:xs)
----------------------------------------------------------------
--- Support code: IntM
----------------------------------------------------------------
+putList :: Binary a => [a] -> Put
+putList = mapM_ put
-data IntM = IntM (MutableByteArray# RealWorld)
+encodeList :: Binary a => [a] -> L.ByteString
+encodeList = runPut . putList
+{-# INLINE encodeList #-}
-newIntM :: IO IntM
-newIntM = IO $ \s ->
- case newByteArray# size s of { (# s, arr #) ->
- (# s, IntM arr #) }
- where I# size = 4 -- XXX - 32-bitism
+decodeList :: Binary a => L.ByteString -> [a]
+decodeList = runGet getList
-readIntM :: IntM -> IO Int
-readIntM (IntM arr) = IO $ \s ->
- case readIntArray# arr 0# s of { (# s, i #) ->
- (# s, I# i #) }
-writeIntM :: IntM -> Int -> IO ()
-writeIntM (IntM arr) (I# i) = IO $ \s ->
- case writeIntArray# arr 0# i s of { s ->
- (# s, () #) }
+encodeListFile :: Binary a => FilePath -> [a] -> IO ()
+encodeListFile f v = L.writeFile f (encodeList v)
+decodeListFile :: Binary a => FilePath -> IO [a]
+decodeListFile f = liftM decodeList (L.readFile f)
diff --git a/src/OpenAFP/Internals/Ebc2Asc.hs b/src/OpenAFP/Internals/Ebc2Asc.hs
--- a/src/OpenAFP/Internals/Ebc2Asc.hs
+++ b/src/OpenAFP/Internals/Ebc2Asc.hs
@@ -1,76 +1,32137 @@
-{-# OPTIONS -O -fglasgow-exts #-}
-
-module OpenAFP.Internals.Ebc2Asc where
-import Data.Word
-import Data.Array.Unboxed
-import OpenAFP.Internals.Binary
-
-ebc2asc :: UArray N1 Char
-ebc2asc = listArray (0, 255) [
- '\x00', '\x01', '\x02', '\x03', '\x00', '\x09', '\x00', '\x00',
- '\x00', '\x00', '\x00', '\x0B', '\x0C', '\x0D', '\x20', '\x20',
- '\x10', '\x11', '\x12', '\x13', '\x00', '\x00', '\x08', '\x00',
- '\x18', '\x19', '\x00', '\x00', '\x1C', '\x1D', '\x1E', '\x1F',
- '\x00', '\x00', '\x00', '\x00', '\x00', '\x0A', '\x17', '\x1B',
- '\x00', '\x00', '\x00', '\x00', '\x00', '\x05', '\x06', '\x07',
- '\x00', '\x00', '\x16', '\x00', '\x00', '\x00', '\x00', '\x04',
- '\x00', '\x00', '\x00', '\x00', '\x14', '\x15', '\x00', '\x00',
- '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
- '\x20', '\x20', '\x5B', '\x2E', '\x3C', '\x28', '\x2B', '\x21',
- '\x26', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
- '\x20', '\x20', '\x5D', '\x24', '\x2A', '\x29', '\x3B', '\x5E',
- '\x2D', '\x2F', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
- '\x20', '\x20', '\x7C', '\x2C', '\x25', '\x5F', '\x3E', '\x3F',
- '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
- '\x20', '\x60', '\x3A', '\x23', '\x40', '\x27', '\x3D', '\x22',
- '\x20', '\x61', '\x62', '\x63', '\x64', '\x65', '\x66', '\x67',
- '\x68', '\x69', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
- '\x20', '\x6A', '\x6B', '\x6C', '\x6D', '\x6E', '\x6F', '\x70',
- '\x71', '\x72', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
- '\x20', '\x7E', '\x73', '\x74', '\x75', '\x76', '\x77', '\x78',
- '\x79', '\x7A', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
- '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
- '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
- '\x7B', '\x41', '\x42', '\x43', '\x44', '\x45', '\x46', '\x47',
- '\x48', '\x49', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
- '\x7D', '\x4A', '\x4B', '\x4C', '\x4D', '\x4E', '\x4F', '\x50',
- '\x51', '\x52', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
- '\x5C', '\x20', '\x53', '\x54', '\x55', '\x56', '\x57', '\x58',
- '\x59', '\x5A', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
- '\x30', '\x31', '\x32', '\x33', '\x34', '\x35', '\x36', '\x37',
- '\x38', '\x39', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20' ]
-
-asc2ebc :: UArray Int N1
-asc2ebc = listArray (0, 255) [
- 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F,
- 0x16, 0x05, 0x25, 0x0B, 0x0C, 0x0D, 0x3F, 0x3F,
- 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26,
- 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F,
- 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D,
- 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61,
- 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
- 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F,
- 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
- 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
- 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,
- 0xE7, 0xE8, 0xE9, 0x4A, 0xE0, 0x6A, 0x5F, 0x6D,
- 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
- 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
- 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
- 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
- 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 ]
+module OpenAFP.Internals.Ebc2Asc
+ ( Encoding(..), Size
+ , convert835to950, convert939to932, fontInfoOf
+ , ebc2asc, asc2ebc
+ , ebc2ascW8, asc2ebcW8
+ , ebc2ascIsPrintW8
+ ) where
+import Data.Word
+import Data.Array.Unboxed
+import OpenAFP.Internals.Binary
+import Data.Char
+import qualified Data.IntMap as IM
+import qualified Data.ByteString as B
+import qualified Data.ByteString.Char8 as C
+
+ebc2ascW8 :: UArray Word8 Word8
+ebc2ascW8 = listArray (0x00, 0xff) [
+ 0x00, 0x01, 0x02, 0x03, 0x20, 0x09, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x0B, 0x0C, 0x0D, 0x20, 0x20,
+ 0x10, 0x11, 0x12, 0x13, 0x20, 0x20, 0x08, 0x20,
+ 0x18, 0x19, 0x20, 0x20, 0x1C, 0x1D, 0x1E, 0x1F,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x17, 0x1B,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x05, 0x06, 0x07,
+ 0x20, 0x20, 0x16, 0x20, 0x20, 0x20, 0x20, 0x04,
+ 0x20, 0x20, 0x20, 0x20, 0x14, 0x15, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x5B, 0x2E, 0x3C, 0x28, 0x2B, 0x21,
+ 0x26, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x5D, 0x24, 0x2A, 0x29, 0x3B, 0x5E,
+ 0x2D, 0x2F, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x7C, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x60, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22,
+ 0x20, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+ 0x68, 0x69, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
+ 0x71, 0x72, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+ 0x79, 0x7A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+ 0x48, 0x49, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
+ 0x51, 0x52, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x5C, 0x20, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+ 0x59, 0x5A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+ 0x38, 0x39, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 ]
+
+ebc2ascIsPrintW8 :: UArray Word8 Word8
+ebc2ascIsPrintW8 = listArray (0x00, 0xFF) [
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x09, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x0D, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x0A, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x5B, 0x2E, 0x3C, 0x28, 0x2B, 0x21,
+ 0x26, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x5D, 0x24, 0x2A, 0x29, 0x3B, 0x5E,
+ 0x2D, 0x2F, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x7C, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x60, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22,
+ 0x20, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+ 0x68, 0x69, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
+ 0x71, 0x72, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+ 0x79, 0x7A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+ 0x48, 0x49, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
+ 0x51, 0x52, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x5C, 0x20, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+ 0x59, 0x5A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+ 0x38, 0x39, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 ]
+
+ebc2asc :: UArray N1 Char
+ebc2asc = listArray (0, 255) [
+ '\x00', '\x01', '\x02', '\x03', '\x20', '\x09', '\x20', '\x20',
+ '\x20', '\x20', '\x20', '\x0B', '\x0C', '\x0D', '\x20', '\x20',
+ '\x10', '\x11', '\x12', '\x13', '\x20', '\x20', '\x08', '\x20',
+ '\x18', '\x19', '\x20', '\x20', '\x1C', '\x1D', '\x1E', '\x1F',
+ '\x20', '\x20', '\x20', '\x20', '\x20', '\x0A', '\x17', '\x1B',
+ '\x20', '\x20', '\x20', '\x20', '\x20', '\x05', '\x06', '\x07',
+ '\x20', '\x20', '\x16', '\x20', '\x20', '\x20', '\x20', '\x04',
+ '\x20', '\x20', '\x20', '\x20', '\x14', '\x15', '\x20', '\x20',
+ '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
+ '\x20', '\x20', '\x5B', '\x2E', '\x3C', '\x28', '\x2B', '\x21',
+ '\x26', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
+ '\x20', '\x20', '\x5D', '\x24', '\x2A', '\x29', '\x3B', '\x5E',
+ '\x2D', '\x2F', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
+ '\x20', '\x20', '\x7C', '\x2C', '\x25', '\x5F', '\x3E', '\x3F',
+ '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
+ '\x20', '\x60', '\x3A', '\x23', '\x40', '\x27', '\x3D', '\x22',
+ '\x20', '\x61', '\x62', '\x63', '\x64', '\x65', '\x66', '\x67',
+ '\x68', '\x69', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
+ '\x20', '\x6A', '\x6B', '\x6C', '\x6D', '\x6E', '\x6F', '\x70',
+ '\x71', '\x72', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
+ '\x20', '\x7E', '\x73', '\x74', '\x75', '\x76', '\x77', '\x78',
+ '\x79', '\x7A', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
+ '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
+ '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
+ '\x7B', '\x41', '\x42', '\x43', '\x44', '\x45', '\x46', '\x47',
+ '\x48', '\x49', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
+ '\x7D', '\x4A', '\x4B', '\x4C', '\x4D', '\x4E', '\x4F', '\x50',
+ '\x51', '\x52', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
+ '\x5C', '\x20', '\x53', '\x54', '\x55', '\x56', '\x57', '\x58',
+ '\x59', '\x5A', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20',
+ '\x30', '\x31', '\x32', '\x33', '\x34', '\x35', '\x36', '\x37',
+ '\x38', '\x39', '\x20', '\x20', '\x20', '\x20', '\x20', '\x20' ]
+
+asc2ebcW8 :: UArray Char Word8
+asc2ebcW8 = listArray ('\x00', '\xFF') [
+ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F,
+ 0x16, 0x05, 0x25, 0x0B, 0x0C, 0x0D, 0x3F, 0x3F,
+ 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26,
+ 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F,
+ 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D,
+ 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61,
+ 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
+ 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F,
+ 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
+ 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
+ 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,
+ 0xE7, 0xE8, 0xE9, 0x4A, 0xE0, 0x6A, 0x5F, 0x6D,
+ 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+ 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
+ 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
+ 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 ]
+
+asc2ebc :: UArray Int N1
+asc2ebc = listArray (0, 255) [
+ 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F,
+ 0x16, 0x05, 0x25, 0x0B, 0x0C, 0x0D, 0x3F, 0x3F,
+ 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26,
+ 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F,
+ 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D,
+ 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61,
+ 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
+ 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F,
+ 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
+ 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
+ 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,
+ 0xE7, 0xE8, 0xE9, 0x4A, 0xE0, 0x6A, 0x5F, 0x6D,
+ 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+ 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
+ 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
+ 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 ]
+
+type Size = Int
+
+fontInfoOf :: ByteString -> (Encoding, Size)
+fontInfoOf f
+ | (C.length font == 8) && (C.head font == 'X')
+ = (CP950, 10) -- X08PD0SB etc. (TBB)
+ | C.pack "T0XXXX" `C.isPrefixOf` font
+ = (CP939, 10) -- T0XXXX means Japanese. (CHB)
+ | (not (C.null font) && C.last font == 'T')
+ || (not (C.null namePart) && C.last namePart == 'S')
+ = (CP835, sz `div` 2) -- M40T, NS32
+ | otherwise
+ = (CP37, sz)
+ where
+ (font, _) = C.spanEnd isSpace f
+ (namePart, sizePart) = C.spanEnd isDigit . fst $ C.breakEnd isDigit font
+ sz = case C.readInt sizePart of
+ Just (0, _) -> 10
+ Just (x, _) -> x
+ _ -> error $ "Cannot parse font for size: " ++ show f
+
+data Encoding = CP37 | CP835 | CP950 | CP939 deriving (Show)
+
+convert835to950 :: Int -> Int
+convert835to950 i = case IM.lookup i _map835to950 of
+ Just rv -> rv
+ _ -> _default
+
+convert939to932 :: Int -> Int
+convert939to932 i = case IM.lookup i _map939to932 of
+ Just rv -> rv
+ _ -> _default
+
+_map835to950 :: IM.IntMap Int
+_map835to950 = IM.fromDistinctAscList (build _str835to950)
+
+_map939to932 :: IM.IntMap Int
+_map939to932 = IM.fromDistinctAscList (build _str939to932)
+
+_default :: Int
+_default = 0x20 * 256 + 0x20
+
+build [] = []
+build (x:y:rest) = (ord x, ord y):build rest
+
+_str939to932 :: String
+_str939to932 = "\x4040\x8140\
+\\x4141\x83BF\
+\\x4142\x83C0\
+\\x4143\x83C1\
+\\x4144\x83C2\
+\\x4145\x83C3\
+\\x4146\x83C4\
+\\x4147\x83C5\
+\\x4148\x83C6\
+\\x4149\x83C7\
+\\x414A\x83C8\
+\\x414B\x83C9\
+\\x414C\x83CA\
+\\x414D\x83CB\
+\\x414E\x83CC\
+\\x414F\x83CD\
+\\x4150\x83CE\
+\\x4151\x83CF\
+\\x4152\x83D0\
+\\x4153\x83D1\
+\\x4154\x83D2\
+\\x4155\x83D3\
+\\x4156\x83D4\
+\\x4157\x83D5\
+\\x4158\x83D6\
+\\x4161\x839F\
+\\x4162\x83A0\
+\\x4163\x83A1\
+\\x4164\x83A2\
+\\x4165\x83A3\
+\\x4166\x83A4\
+\\x4167\x83A5\
+\\x4168\x83A6\
+\\x4169\x83A7\
+\\x416A\x83A8\
+\\x416B\x83A9\
+\\x416C\x83AA\
+\\x416D\x83AB\
+\\x416E\x83AC\
+\\x416F\x83AD\
+\\x4170\x83AE\
+\\x4171\x83AF\
+\\x4172\x83B0\
+\\x4173\x83B1\
+\\x4174\x83B2\
+\\x4175\x83B3\
+\\x4176\x83B4\
+\\x4177\x83B5\
+\\x4178\x83B6\
+\\x4180\x8470\
+\\x4181\x8471\
+\\x4182\x8472\
+\\x4183\x8473\
+\\x4184\x8474\
+\\x4185\x8475\
+\\x4186\x8476\
+\\x4187\x8477\
+\\x4188\x8478\
+\\x4189\x8479\
+\\x418A\x847A\
+\\x418B\x847B\
+\\x418C\x847C\
+\\x418D\x847D\
+\\x418E\x847E\
+\\x418F\x8480\
+\\x4190\x8481\
+\\x4191\x8482\
+\\x4192\x8483\
+\\x4193\x8484\
+\\x4194\x8485\
+\\x4195\x8486\
+\\x4196\x8487\
+\\x4197\x8488\
+\\x4198\x8489\
+\\x4199\x848A\
+\\x419A\x848B\
+\\x419B\x848C\
+\\x419C\x848D\
+\\x419D\x848E\
+\\x419E\x848F\
+\\x419F\x8490\
+\\x41A0\x8491\
+\\x41B1\xFA40\
+\\x41B2\xFA41\
+\\x41B3\xFA42\
+\\x41B4\xFA43\
+\\x41B5\xFA44\
+\\x41B6\xFA45\
+\\x41B7\xFA46\
+\\x41B8\xFA47\
+\\x41B9\xFA48\
+\\x41BA\xFA49\
+\\x41C0\x8440\
+\\x41C1\x8441\
+\\x41C2\x8442\
+\\x41C3\x8443\
+\\x41C4\x8444\
+\\x41C5\x8445\
+\\x41C6\x8446\
+\\x41C7\x8447\
+\\x41C8\x8448\
+\\x41C9\x8449\
+\\x41CA\x844A\
+\\x41CB\x844B\
+\\x41CC\x844C\
+\\x41CD\x844D\
+\\x41CE\x844E\
+\\x41CF\x844F\
+\\x41D0\x8450\
+\\x41D1\x8451\
+\\x41D2\x8452\
+\\x41D3\x8453\
+\\x41D4\x8454\
+\\x41D5\x8455\
+\\x41D6\x8456\
+\\x41D7\x8457\
+\\x41D8\x8458\
+\\x41D9\x8459\
+\\x41DA\x845A\
+\\x41DB\x845B\
+\\x41DC\x845C\
+\\x41DD\x845D\
+\\x41DE\x845E\
+\\x41DF\x845F\
+\\x41E0\x8460\
+\\x41F1\x8754\
+\\x41F2\x8755\
+\\x41F3\x8756\
+\\x41F4\x8757\
+\\x41F5\x8758\
+\\x41F6\x8759\
+\\x41F7\x875A\
+\\x41F8\x875B\
+\\x41F9\x875C\
+\\x41FA\x875D\
+\\x424A\x8192\
+\\x424B\x8144\
+\\x424C\x8183\
+\\x424D\x8169\
+\\x424E\x817B\
+\\x424F\x8162\
+\\x4250\x8195\
+\\x425A\x8149\
+\\x425B\x818F\
+\\x425C\x8196\
+\\x425D\x816A\
+\\x425E\x8147\
+\\x425F\x81CA\
+\\x4260\x817C\
+\\x4261\x815E\
+\\x426A\xFA55\
+\\x426B\x8143\
+\\x426C\x8193\
+\\x426D\x8151\
+\\x426E\x8184\
+\\x426F\x8148\
+\\x4279\x814D\
+\\x427A\x8146\
+\\x427B\x8194\
+\\x427C\x8197\
+\\x427D\xFA56\
+\\x427E\x8181\
+\\x427F\xFA57\
+\\x4281\x8281\
+\\x4282\x8282\
+\\x4283\x8283\
+\\x4284\x8284\
+\\x4285\x8285\
+\\x4286\x8286\
+\\x4287\x8287\
+\\x4288\x8288\
+\\x4289\x8289\
+\\x4291\x828A\
+\\x4292\x828B\
+\\x4293\x828C\
+\\x4294\x828D\
+\\x4295\x828E\
+\\x4296\x828F\
+\\x4297\x8290\
+\\x4298\x8291\
+\\x4299\x8292\
+\\x42A1\x8150\
+\\x42A2\x8293\
+\\x42A3\x8294\
+\\x42A4\x8295\
+\\x42A5\x8296\
+\\x42A6\x8297\
+\\x42A7\x8298\
+\\x42A8\x8299\
+\\x42A9\x829A\
+\\x42C0\x816F\
+\\x42C1\x8260\
+\\x42C2\x8261\
+\\x42C3\x8262\
+\\x42C4\x8263\
+\\x42C5\x8264\
+\\x42C6\x8265\
+\\x42C7\x8266\
+\\x42C8\x8267\
+\\x42C9\x8268\
+\\x42D0\x8170\
+\\x42D1\x8269\
+\\x42D2\x826A\
+\\x42D3\x826B\
+\\x42D4\x826C\
+\\x42D5\x826D\
+\\x42D6\x826E\
+\\x42D7\x826F\
+\\x42D8\x8270\
+\\x42D9\x8271\
+\\x42E0\x8190\
+\\x42E2\x8272\
+\\x42E3\x8273\
+\\x42E4\x8274\
+\\x42E5\x8275\
+\\x42E6\x8276\
+\\x42E7\x8277\
+\\x42E8\x8278\
+\\x42E9\x8279\
+\\x42F0\x824F\
+\\x42F1\x8250\
+\\x42F2\x8251\
+\\x42F3\x8252\
+\\x42F4\x8253\
+\\x42F5\x8254\
+\\x42F6\x8255\
+\\x42F7\x8256\
+\\x42F8\x8257\
+\\x42F9\x8258\
+\\x4341\x8142\
+\\x4342\x8175\
+\\x4343\x8176\
+\\x4344\x8141\
+\\x4345\x8145\
+\\x4346\x8392\
+\\x4347\x8340\
+\\x4348\x8342\
+\\x4349\x8344\
+\\x434A\x8191\
+\\x434B\x81DA\
+\\x434C\x81DB\
+\\x434D\x81DC\
+\\x434E\x81DD\
+\\x434F\x81DE\
+\\x4351\x8346\
+\\x4352\x8348\
+\\x4353\x8383\
+\\x4354\x8385\
+\\x4355\x8387\
+\\x4356\x8362\
+\\x4357\x838E\
+\\x4358\x815B\
+\\x4359\x8395\
+\\x435A\x8396\
+\\x435B\x81DF\
+\\x435C\x81E0\
+\\x435D\x81E1\
+\\x435E\x81E2\
+\\x435F\x81E3\
+\\x4360\x81E4\
+\\x4361\x81E5\
+\\x4362\x81E7\
+\\x4363\x81E8\
+\\x4364\x81B8\
+\\x4365\x81B9\
+\\x4366\x81BA\
+\\x4367\x81BB\
+\\x4368\x81BC\
+\\x4369\x81BD\
+\\x436A\x81BE\
+\\x436B\x81BF\
+\\x436C\x81C8\
+\\x436D\x81C9\
+\\x436E\x81CB\
+\\x436F\x81CC\
+\\x4370\x81CD\
+\\x4371\x81CE\
+\\x4372\x81F0\
+\\x4373\x81F1\
+\\x4374\x81F2\
+\\x4375\x81F3\
+\\x4376\x81F4\
+\\x4377\x81F5\
+\\x4378\x81F6\
+\\x4379\x81F7\
+\\x437A\x81FC\
+\\x437C\x849F\
+\\x437D\x84A0\
+\\x437E\x84A1\
+\\x437F\x84A2\
+\\x4381\x8341\
+\\x4382\x8343\
+\\x4383\x8345\
+\\x4384\x8347\
+\\x4385\x8349\
+\\x4386\x834A\
+\\x4387\x834C\
+\\x4388\x834E\
+\\x4389\x8350\
+\\x438A\x8352\
+\\x438C\x8354\
+\\x438D\x8356\
+\\x438E\x8358\
+\\x438F\x835A\
+\\x4390\x835C\
+\\x4391\x835E\
+\\x4392\x8360\
+\\x4393\x8363\
+\\x4394\x8365\
+\\x4395\x8367\
+\\x4396\x8369\
+\\x4397\x836A\
+\\x4398\x836B\
+\\x4399\x836C\
+\\x439A\x836D\
+\\x439D\x836E\
+\\x439E\x8371\
+\\x439F\x8374\
+\\x43A1\x8160\
+\\x43A2\x8377\
+\\x43A3\x837A\
+\\x43A4\x837D\
+\\x43A5\x837E\
+\\x43A6\x8380\
+\\x43A7\x8381\
+\\x43A8\x8382\
+\\x43A9\x8384\
+\\x43AA\x8386\
+\\x43AC\x8388\
+\\x43AD\x8389\
+\\x43AE\x838A\
+\\x43AF\x838B\
+\\x43B0\x84A3\
+\\x43B1\x84A4\
+\\x43B2\x84A5\
+\\x43B3\x84A6\
+\\x43B4\x84A7\
+\\x43B5\x84A8\
+\\x43B6\x84A9\
+\\x43B7\x84AA\
+\\x43B8\x84AB\
+\\x43B9\x84AC\
+\\x43BA\x838C\
+\\x43BB\x838D\
+\\x43BC\x838F\
+\\x43BD\x8393\
+\\x43BE\x814A\
+\\x43BF\x814B\
+\\x43C0\x834B\
+\\x43C1\x834D\
+\\x43C2\x834F\
+\\x43C3\x8351\
+\\x43C4\x8353\
+\\x43C5\x8355\
+\\x43C6\x8357\
+\\x43C7\x8359\
+\\x43C8\x835B\
+\\x43C9\x835D\
+\\x43CA\x835F\
+\\x43CB\x8361\
+\\x43CC\x8364\
+\\x43CD\x8366\
+\\x43CE\x8368\
+\\x43CF\x836F\
+\\x43D0\x8372\
+\\x43D1\x8375\
+\\x43D2\x8378\
+\\x43D3\x837B\
+\\x43D4\x8394\
+\\x43D5\x8370\
+\\x43D6\x8373\
+\\x43D7\x8376\
+\\x43D8\x8379\
+\\x43D9\x837C\
+\\x43DA\x8390\
+\\x43DB\x8391\
+\\x43DC\x8152\
+\\x43DD\x8153\
+\\x43E0\x815F\
+\\x43E1\x84AD\
+\\x43E2\x84AE\
+\\x43E3\x84AF\
+\\x43E4\x84B0\
+\\x43E5\x84B1\
+\\x43E6\x84B2\
+\\x43E7\x84B3\
+\\x43E8\x84B4\
+\\x43E9\x84B5\
+\\x43EA\x84B6\
+\\x43EB\x84B7\
+\\x43EC\x84B8\
+\\x43ED\x84B9\
+\\x43EE\x84BA\
+\\x43EF\x84BB\
+\\x43F0\x84BC\
+\\x43F1\x84BD\
+\\x43F2\x84BE\
+\\x4442\x8177\
+\\x4443\x8178\
+\\x4444\x816D\
+\\x4445\x816E\
+\\x4446\x82F0\
+\\x4447\x829F\
+\\x4448\x82A1\
+\\x4449\x82A3\
+\\x444A\x815C\
+\\x444B\x817D\
+\\x444C\x8182\
+\\x444D\x8187\
+\\x444E\x818E\
+\\x4450\x814C\
+\\x4451\x82A5\
+\\x4452\x82A7\
+\\x4453\x82E1\
+\\x4454\x82E3\
+\\x4455\x82E5\
+\\x4456\x82C1\
+\\x4457\x82EC\
+\\x445A\x815D\
+\\x445B\x8156\
+\\x445C\x8157\
+\\x445D\x8158\
+\\x445E\x8159\
+\\x445F\x815A\
+\\x4460\x814E\
+\\x4461\x8165\
+\\x4462\x8167\
+\\x4463\x816B\
+\\x4464\x8171\
+\\x4465\x8173\
+\\x4466\x8179\
+\\x4467\x8185\
+\\x4468\x8188\
+\\x4469\x8189\
+\\x446A\x8198\
+\\x446B\x81A6\
+\\x446C\x81A7\
+\\x446D\x878A\
+\\x446E\x8782\
+\\x446F\x8784\
+\\x4470\x814F\
+\\x4471\x8166\
+\\x4472\x8168\
+\\x4473\x816C\
+\\x4474\x8172\
+\\x4475\x8174\
+\\x4476\x817A\
+\\x4477\x8186\
+\\x4478\x81E6\
+\\x4479\x818A\
+\\x447A\x817E\
+\\x447B\x8180\
+\\x447C\x8161\
+\\x447D\x81AC\
+\\x447E\x8164\
+\\x447F\x8163\
+\\x4481\x82A0\
+\\x4482\x82A2\
+\\x4483\x82A4\
+\\x4484\x82A6\
+\\x4485\x82A8\
+\\x4486\x82A9\
+\\x4487\x82AB\
+\\x4488\x82AD\
+\\x4489\x82AF\
+\\x448A\x82B1\
+\\x448C\x82B3\
+\\x448D\x82B5\
+\\x448E\x82B7\
+\\x448F\x82B9\
+\\x4490\x82BB\
+\\x4491\x82BD\
+\\x4492\x82BF\
+\\x4493\x82C2\
+\\x4494\x82C4\
+\\x4495\x82C6\
+\\x4496\x82C8\
+\\x4497\x82C9\
+\\x4498\x82CA\
+\\x4499\x82CB\
+\\x449A\x82CC\
+\\x449D\x82CD\
+\\x449E\x82D0\
+\\x449F\x82D3\
+\\x44A2\x82D6\
+\\x44A3\x82D9\
+\\x44A4\x82DC\
+\\x44A5\x82DD\
+\\x44A6\x82DE\
+\\x44A7\x82DF\
+\\x44A8\x82E0\
+\\x44A9\x82E2\
+\\x44AA\x82E4\
+\\x44AC\x82E6\
+\\x44AD\x82E7\
+\\x44AE\x82E8\
+\\x44AF\x82E9\
+\\x44BA\x82EA\
+\\x44BB\x82EB\
+\\x44BC\x82ED\
+\\x44BD\x82F1\
+\\x44C0\x82AA\
+\\x44C1\x82AC\
+\\x44C2\x82AE\
+\\x44C3\x82B0\
+\\x44C4\x82B2\
+\\x44C5\x82B4\
+\\x44C6\x82B6\
+\\x44C7\x82B8\
+\\x44C8\x82BA\
+\\x44C9\x82BC\
+\\x44CA\x82BE\
+\\x44CB\x82C0\
+\\x44CC\x82C3\
+\\x44CD\x82C5\
+\\x44CE\x82C7\
+\\x44CF\x82CE\
+\\x44D0\x82D1\
+\\x44D1\x82D4\
+\\x44D2\x82D7\
+\\x44D3\x82DA\
+\\x44D5\x82CF\
+\\x44D6\x82D2\
+\\x44D7\x82D5\
+\\x44D8\x82D8\
+\\x44D9\x82DB\
+\\x44DA\x82EE\
+\\x44DB\x82EF\
+\\x44DC\x8154\
+\\x44DD\x8155\
+\\x44E0\x819B\
+\\x44E1\x819C\
+\\x44E2\x81A2\
+\\x44E3\x81A3\
+\\x44E4\x819D\
+\\x44E5\x8199\
+\\x44E6\x819A\
+\\x44E7\x819E\
+\\x44E8\x819F\
+\\x44E9\x81A0\
+\\x44EA\x81A1\
+\\x44EB\x81A4\
+\\x44EC\x81A5\
+\\x44ED\x818B\
+\\x44EE\x818C\
+\\x44EF\x818D\
+\\x44F0\x81A8\
+\\x44F1\x81A9\
+\\x44F2\x81AA\
+\\x44F3\x81AB\
+\\x4541\x88EA\
+\\x4542\x93F1\
+\\x4543\x8E4F\
+\\x4544\x8E6C\
+\\x4545\x8CDC\
+\\x4546\x985A\
+\\x4547\x8EB5\
+\\x4548\x94AA\
+\\x4549\x8BE3\
+\\x454A\x8F5C\
+\\x454B\x9553\
+\\x454C\x90E7\
+\\x454D\x969C\
+\\x454E\x89AD\
+\\x454F\x9373\
+\\x4550\x93B9\
+\\x4551\x957B\
+\\x4552\x8CA7\
+\\x4553\x8E73\
+\\x4554\x8BE6\
+\\x4555\x92AC\
+\\x4556\x91BA\
+\\x4557\x938C\
+\\x4558\x90BC\
+\\x4559\x93EC\
+\\x455A\x966B\
+\\x455B\x91E5\
+\\x455C\x9286\
+\\x455D\x8FAC\
+\\x455E\x8FE3\
+\\x455F\x89BA\
+\\x4560\x944E\
+\\x4561\x8C8E\
+\\x4562\x93FA\
+\\x4563\x9363\
+\\x4564\x8E71\
+\\x4565\x8E52\
+\\x4566\x967B\
+\\x4567\x90EC\
+\\x4568\x93A1\
+\\x4569\x96EC\
+\\x456A\x8D48\
+\\x456B\x8BC6\
+\\x456C\x96D8\
+\\x456D\x88E4\
+\\x456E\x9859\
+\\x456F\x9387\
+\\x4570\x9759\
+\\x4571\x8D82\
+\\x4572\x89AA\
+\\x4573\x9576\
+\\x4574\x8CB4\
+\\x4575\x8B9E\
+\\x4576\x8DB2\
+\\x4577\x90B3\
+\\x4578\x8FBC\
+\\x4579\x8B40\
+\\x457A\x9861\
+\\x457B\x90BB\
+\\x457C\x926A\
+\\x457D\x94FC\
+\\x457E\x8B67\
+\\x457F\x8DE8\
+\\x4580\x90CE\
+\\x4581\x924A\
+\\x4582\x9364\
+\\x4583\x92B7\
+\\x4584\x8EA1\
+\\x4585\x91F2\
+\\x4586\x8BE0\
+\\x4587\x9056\
+\\x4588\x8CFB\
+\\x4589\x8BB4\
+\\x458A\x8B76\
+\\x458B\x959F\
+\\x458C\x8F8A\
+\\x458D\x95BD\
+\\x458E\x93E0\
+\\x458F\x8D91\
+\\x4590\x89BB\
+\\x4591\x8DE3\
+\\x4592\x8B7B\
+\\x4593\x906C\
+\\x4594\x8DEC\
+\\x4595\x9594\
+\\x4596\x90B4\
+\\x4597\x8E9F\
+\\x4598\x8B60\
+\\x4599\x90B6\
+\\x459A\x91E3\
+\\x459B\x8F6F\
+\\x459C\x9085\
+\\x459D\x9058\
+\\x459E\x8CF5\
+\\x459F\x89C1\
+\\x45A0\x8D87\
+\\x45A1\x905F\
+\\x45A2\x97D1\
+\\x45A3\x8F64\
+\\x45A4\x8D73\
+\\x45A5\x904D\
+\\x45A6\x96BE\
+\\x45A7\x8A43\
+\\x45A8\x88C0\
+\\x45A9\x8D4B\
+\\x45AA\x95DB\
+\\x45AB\x91BE\
+\\x45AC\x9578\
+\\x45AD\x8D5D\
+\\x45AE\x97E9\
+\\x45AF\x914F\
+\\x45B0\x926D\
+\\x45B1\x9590\
+\\x45B2\x88C9\
+\\x45B3\x8FBA\
+\\x45B4\x95AA\
+\\x45B5\x8F9F\
+\\x45B6\x9770\
+\\x45B7\x8D4C\
+\\x45B8\x91A2\
+\\x45B9\x8B43\
+\\x45BA\x90AC\
+\\x45BB\x8CA9\
+\\x45BC\x9798\
+\\x45BD\x89EF\
+\\x45BE\x8A77\
+\\x45BF\x8AE2\
+\\x45C0\x8E59\
+\\x45C1\x8AD4\
+\\x45C2\x926E\
+\\x45C3\x8EA9\
+\\x45C4\x97C7\
+\\x45C5\x8AD6\
+\\x45C6\x88A4\
+\\x45C7\x90AD\
+\\x45C8\x94F6\
+\\x45C9\x8C76\
+\\x45CA\x95B6\
+\\x45CB\x8EE8\
+\\x45CC\x9583\
+\\x45CD\x95FB\
+\\x45CE\x8E96\
+\\x45CF\x8CCB\
+\\x45D0\x9569\
+\\x45D1\x8AEC\
+\\x45D2\x936E\
+\\x45D3\x8D4F\
+\\x45D4\x8CC3\
+\\x45D5\x95D3\
+\\x45D6\x9171\
+\\x45D7\x9353\
+\\x45D8\x9456\
+\\x45D9\x8FEA\
+\\x45DA\x976D\
+\\x45DB\x8FE9\
+\\x45DC\x92C3\
+\\x45DD\x97A7\
+\\x45DE\x9378\
+\\x45DF\x8CDF\
+\\x45E0\x8DA1\
+\\x45E1\x9546\
+\\x45E2\x90DD\
+\\x45E3\x92CA\
+\\x45E4\x93AE\
+\\x45E5\x8CE3\
+\\x45E6\x93DE\
+\\x45E7\x92E8\
+\\x45E8\x9272\
+\\x45E9\x89AE\
+\\x45EA\x956C\
+\\x45EB\x979D\
+\\x45EC\x8DE2\
+\\x45ED\x8EC0\
+\\x45EE\x8970\
+\\x45EF\x9349\
+\\x45F0\x8E69\
+\\x45F1\x8F47\
+\\x45F2\x89A1\
+\\x45F3\x96BC\
+\\x45F4\x8D46\
+\\x45F5\x927C\
+\\x45F6\x948E\
+\\x45F7\x97CD\
+\\x45F8\x8CC9\
+\\x45F9\x9774\
+\\x45FA\x8968\
+\\x45FB\x8969\
+\\x45FC\x8AED\
+\\x45FD\x8BCA\
+\\x45FE\x91BD\
+\\x4641\x89EA\
+\\x4642\x905E\
+\\x4643\x8C62\
+\\x4644\x90C3\
+\\x4645\x897E\
+\\x4646\x96CE\
+\\x4647\x9571\
+\\x4648\x964C\
+\\x4649\x95BA\
+\\x464A\x9640\
+\\x464B\x94AD\
+\\x464C\x90C2\
+\\x464D\x919D\
+\\x464E\x97BF\
+\\x464F\x9289\
+\\x4650\x8E91\
+\\x4651\x8E9E\
+\\x4652\x95A8\
+\\x4653\x8ED4\
+\\x4654\x93BF\
+\\x4655\x9776\
+\\x4656\x91CE\
+\\x4657\x92CB\
+\\x4658\x8F48\
+\\x4659\x9492\
+\\x465A\x89CD\
+\\x465B\x90A3\
+\\x465C\x96FB\
+\\x465D\x97B2\
+\\x465E\x91A0\
+\\x465F\x9396\
+\\x4660\x8F72\
+\\x4661\x8E75\
+\\x4662\x8F74\
+\\x4663\x8ED0\
+\\x4664\x946E\
+\\x4665\x93FC\
+\\x4666\x8C9A\
+\\x4667\x8DAA\
+\\x4668\x9099\
+\\x4669\x9069\
+\\x466A\x8BBB\
+\\x466B\x8959\
+\\x466C\x90B8\
+\\x466D\x93AF\
+\\x466E\x90AB\
+\\x466F\x95C4\
+\\x4670\x8ED2\
+\\x4671\x8F95\
+\\x4672\x8E7D\
+\\x4673\x8BDF\
+\\x4674\x92BC\
+\\x4675\x96DA\
+\\x4676\x9788\
+\\x4677\x89E6\
+\\x4678\x918A\
+\\x4679\x8D95\
+\\x467A\x8ADB\
+\\x467B\x9144\
+\\x467C\x9752\
+\\x467D\x8E6D\
+\\x467E\x91E6\
+\\x467F\x8C46\
+\\x4680\x8E86\
+\\x4681\x8C92\
+\\x4682\x8A42\
+\\x4683\x9646\
+\\x4684\x9379\
+\\x4685\x974C\
+\\x4686\x89C6\
+\\x4687\x90FC\
+\\x4688\x8C6F\
+\\x4689\x92B2\
+\\x468A\x9356\
+\\x468B\x8AFA\
+\\x468C\x9275\
+\\x468D\x90F3\
+\\x468E\x90C4\
+\\x468F\x8EAE\
+\\x4690\x8C60\
+\\x4691\x96CA\
+\\x4692\x8EED\
+\\x4693\x9741\
+\\x4694\x8A4F\
+\\x4695\x8CB3\
+\\x4696\x91CC\
+\\x4697\x8EAD\
+\\x4698\x8CE4\
+\\x4699\x8F97\
+\\x469A\x8D4E\
+\\x469B\x90A2\
+\\x469C\x9745\
+\\x469D\x9678\
+\\x469E\x8D44\
+\\x469F\x8E99\
+\\x46A0\x8E9B\
+\\x46A1\x8D7C\
+\\x46A2\x93C1\
+\\x46A3\x8DE9\
+\\x46A4\x9242\
+\\x46A5\x8CFC\
+\\x46A6\x8EE6\
+\\x46A7\x9399\
+\\x46A8\x9271\
+\\x46A9\x89F1\
+\\x46AA\x96E5\
+\\x46AB\x895E\
+\\x46AC\x94F5\
+\\x46AD\x8E76\
+\\x46AE\x88A2\
+\\x46AF\x9573\
+\\x46B0\x907B\
+\\x46B1\x9153\
+\\x46B2\x8EF5\
+\\x46B3\x9150\
+\\x46B4\x94C2\
+\\x46B5\x94D1\
+\\x46B6\x92E5\
+\\x46B7\x8CBB\
+\\x46B8\x9048\
+\\x46B9\x9167\
+\\x46BA\x97DE\
+\\x46BB\x8CF6\
+\\x46BC\x8DDE\
+\\x46BD\x8D81\
+\\x46BE\x8FA4\
+\\x46BF\x8C8B\
+\\x46C0\x955C\
+\\x46C1\x96EE\
+\\x46C2\x8A83\
+\\x46C3\x8E84\
+\\x46C4\x90A7\
+\\x46C5\x964D\
+\\x46C6\x8FC0\
+\\x46C7\x8E85\
+\\x46C8\x8D47\
+\\x46C9\x8DF4\
+\\x46CA\x9467\
+\\x46CB\x88F5\
+\\x46CC\x9094\
+\\x46CD\x8A4A\
+\\x46CE\x8F80\
+\\x46CF\x8EF7\
+\\x46D0\x94EF\
+\\x46D1\x8FB9\
+\\x46D2\x8BAD\
+\\x46D3\x8CA4\
+\\x46D4\x9746\
+\\x46D5\x8946\
+\\x46D6\x8EE1\
+\\x46D7\x8B65\
+\\x46D8\x8E9D\
+\\x46D9\x89D4\
+\\x46DA\x88F8\
+\\x46DB\x8B49\
+\\x46DC\x8D72\
+\\x46DD\x95CA\
+\\x46DE\x8F43\
+\\x46DF\x897A\
+\\x46E0\x8F5A\
+\\x46E1\x96F2\
+\\x46E2\x96D1\
+\\x46E3\x8993\
+\\x46E4\x96E2\
+\\x46E5\x899C\
+\\x46E6\x8C5E\
+\\x46E7\x9053\
+\\x46E8\x936F\
+\\x46E9\x9181\
+\\x46EA\x96F6\
+\\x46EB\x8D5F\
+\\x46EC\x8EBF\
+\\x46ED\x96B1\
+\\x46EE\x90F2\
+\\x46EF\x8FED\
+\\x46F0\x8EE7\
+\\x46F1\x8AEE\
+\\x46F2\x8AC7\
+\\x46F3\x91D7\
+\\x46F4\x904C\
+\\x46F5\x8DC5\
+\\x46F6\x88C8\
+\\x46F7\x89CC\
+\\x46F8\x9754\
+\\x46F9\x90D4\
+\\x46FA\x91AB\
+\\x46FB\x8B4B\
+\\x46FC\x97AC\
+\\x46FD\x90BD\
+\\x46FE\x8FB8\
+\\x4741\x8F42\
+\\x4742\x8FC6\
+\\x4743\x8996\
+\\x4744\x9197\
+\\x4745\x89EB\
+\\x4746\x9696\
+\\x4747\x934E\
+\\x4748\x8ADD\
+\\x4749\x96E7\
+\\x474A\x8AF2\
+\\x474B\x8F89\
+\\x474C\x88EF\
+\\x474D\x91A5\
+\\x474E\x94E4\
+\\x474F\x945C\
+\\x4750\x9862\
+\\x4751\x938A\
+\\x4752\x935D\
+\\x4753\x909B\
+\\x4754\x9841\
+\\x4755\x91BC\
+\\x4756\x96AF\
+\\x4757\x8B8B\
+\\x4758\x8EF0\
+\\x4759\x94C9\
+\\x475A\x89BF\
+\\x475B\x969E\
+\\x475C\x92A9\
+\\x475D\x9574\
+\\x475E\x8FF0\
+\\x475F\x96B3\
+\\x4760\x8D6C\
+\\x4761\x8A79\
+\\x4762\x8EE5\
+\\x4763\x88D3\
+\\x4764\x90ED\
+\\x4765\x90D8\
+\\x4766\x8DDC\
+\\x4767\x95D0\
+\\x4768\x8DD7\
+\\x4769\x8DCF\
+\\x476A\x88EE\
+\\x476B\x957A\
+\\x476C\x97A2\
+\\x476D\x91AE\
+\\x476E\x8FCD\
+\\x476F\x95CF\
+\\x4770\x89BD\
+\\x4771\x8DF7\
+\\x4772\x94DE\
+\\x4773\x8DB8\
+\\x4774\x8976\
+\\x4775\x9484\
+\\x4776\x906D\
+\\x4777\x905B\
+\\x4778\x91E4\
+\\x4779\x92B9\
+\\x477A\x92DF\
+\\x477B\x8E78\
+\\x477C\x90AE\
+\\x477D\x8A70\
+\\x477E\x89C3\
+\\x477F\x96A1\
+\\x4780\x8971\
+\\x4781\x8B63\
+\\x4782\x88B3\
+\\x4783\x97A6\
+\\x4784\x9848\
+\\x4785\x89CE\
+\\x4786\x958C\
+\\x4787\x8B50\
+\\x4788\x935F\
+\\x4789\x975E\
+\\x478A\x8CB8\
+\\x478B\x94A8\
+\\x478C\x8BE2\
+\\x478D\x8BF3\
+\\x478E\x8CF0\
+\\x478F\x8948\
+\\x4790\x94BC\
+\\x4791\x8EFB\
+\\x4792\x899B\
+\\x4793\x918D\
+\\x4794\x8B4C\
+\\x4795\x90B0\
+\\x4796\x8D5C\
+\\x4797\x8DDB\
+\\x4798\x947E\
+\\x4799\x88F3\
+\\x479A\x8CBE\
+\\x479B\x8C49\
+\\x479C\x9067\
+\\x479D\x8F91\
+\\x479E\x8D8E\
+\\x479F\x9166\
+\\x47A0\x8F57\
+\\x47A1\x90DF\
+\\x47A2\x90E6\
+\\x47A3\x91EA\
+\\x47A4\x8C88\
+\\x47A5\x8BB3\
+\\x47A6\x8F83\
+\\x47A7\x8EC4\
+\\x47A8\x90DA\
+\\x47A9\x90AF\
+\\x47AA\x9285\
+\\x47AB\x97AF\
+\\x47AC\x8966\
+\\x47AD\x8CC8\
+\\x47AE\x8A45\
+\\x47AF\x8BEF\
+\\x47B0\x8C68\
+\\x47B1\x8C51\
+\\x47B2\x8F87\
+\\x47B3\x8BA4\
+\\x47B4\x8A88\
+\\x47B5\x97CA\
+\\x47B6\x8E77\
+\\x47B7\x89F0\
+\\x47B8\x8EBA\
+\\x47B9\x89CA\
+\\x47BA\x8A65\
+\\x47BB\x965D\
+\\x47BC\x9668\
+\\x47BD\x96F1\
+\\x47BE\x8C9B\
+\\x47BF\x977A\
+\\x47C0\x8B54\
+\\x47C1\x907D\
+\\x47C2\x975C\
+\\x47C3\x9046\
+\\x47C4\x90C5\
+\\x47C5\x9041\
+\\x47C6\x89C2\
+\\x47C7\x8D50\
+\\x47C8\x88CA\
+\\x47C9\x9354\
+\\x47CA\x954B\
+\\x47CB\x91B1\
+\\x47CC\x8B7D\
+\\x47CD\x8DDD\
+\\x47CE\x8A5F\
+\\x47CF\x8C4E\
+\\x47D0\x8984\
+\\x47D1\x9388\
+\\x47D2\x8AE9\
+\\x47D3\x93C8\
+\\x47D4\x959E\
+\\x47D5\x944D\
+\\x47D6\x8A84\
+\\x47D7\x8BA6\
+\\x47D8\x95E0\
+\\x47D9\x8E6A\
+\\x47DA\x9744\
+\\x47DB\x8DD6\
+\\x47DC\x965B\
+\\x47DD\x8F40\
+\\x47DE\x8A69\
+\\x47DF\x9243\
+\\x47E0\x8A7D\
+\\x47E1\x8980\
+\\x47E2\x8F94\
+\\x47E3\x9865\
+\\x47E4\x8C5B\
+\\x47E5\x8CAB\
+\\x47E6\x96ED\
+\\x47E7\x9597\
+\\x47E8\x93BE\
+\\x47E9\x88D5\
+\\x47EA\x91C5\
+\\x47EB\x93AA\
+\\x47EC\x88AE\
+\\x47ED\x9269\
+\\x47EE\x90A8\
+\\x47EF\x9152\
+\\x47F0\x9263\
+\\x47F1\x8A7A\
+\\x47F2\x978E\
+\\x47F3\x947A\
+\\x47F4\x92F6\
+\\x47F5\x92D2\
+\\x47F6\x8CE1\
+\\x47F7\x8AB4\
+\\x47F8\x8AB0\
+\\x47F9\x94BD\
+\\x47FA\x96AB\
+\\x47FB\x8EF9\
+\\x47FC\x8CB9\
+\\x47FD\x89AB\
+\\x47FE\x91E8\
+\\x4841\x8D9E\
+\\x4842\x9190\
+\\x4843\x8E5A\
+\\x4844\x90B7\
+\\x4845\x945F\
+\\x4846\x93DF\
+\\x4847\x8FC8\
+\\x4848\x976C\
+\\x4849\x9361\
+\\x484A\x8FAD\
+\\x484B\x89EE\
+\\x484C\x8EF3\
+\\x484D\x89B9\
+\\x484E\x95D2\
+\\x484F\x88CF\
+\\x4850\x8FAF\
+\\x4851\x8C57\
+\\x4852\x8FF3\
+\\x4853\x8EA6\
+\\x4854\x9358\
+\\x4855\x9551\
+\\x4856\x8A94\
+\\x4857\x8EA0\
+\\x4858\x979C\
+\\x4859\x93EA\
+\\x485A\x8945\
+\\x485B\x8DB6\
+\\x485C\x8B79\
+\\x485D\x9149\
+\\x485E\x8B8F\
+\\x485F\x8FEE\
+\\x4860\x97FB\
+\\x4861\x9259\
+\\x4862\x8AD9\
+\\x4863\x8D7A\
+\\x4864\x96CD\
+\\x4865\x8EEA\
+\\x4866\x90D1\
+\\x4867\x889F\
+\\x4868\x9140\
+\\x4869\x9287\
+\\x486A\x9368\
+\\x486B\x8FC1\
+\\x486C\x8F70\
+\\x486D\x8C9F\
+\\x486E\x984E\
+\\x486F\x91EE\
+\\x4870\x8CF7\
+\\x4871\x8FAE\
+\\x4872\x9666\
+\\x4873\x8978\
+\\x4874\x8E89\
+\\x4875\x8EC2\
+\\x4876\x89C0\
+\\x4877\x9661\
+\\x4878\x9579\
+\\x4879\x8C4B\
+\\x487A\x8A6D\
+\\x487B\x9671\
+\\x487C\x95C0\
+\\x487D\x926C\
+\\x487E\x8ACF\
+\\x487F\x8B4D\
+\\x4880\x88DB\
+\\x4881\x939D\
+\\x4882\x8F68\
+\\x4883\x97BC\
+\\x4884\x939C\
+\\x4885\x9065\
+\\x4886\x985E\
+\\x4887\x909F\
+\\x4888\x8E7B\
+\\x4889\x9765\
+\\x488A\x94F2\
+\\x488B\x8BC7\
+\\x488C\x9753\
+\\x488D\x89DF\
+\\x488E\x8E81\
+\\x488F\x89FC\
+\\x4890\x94D5\
+\\x4891\x90CF\
+\\x4892\x8F61\
+\\x4893\x8AAA\
+\\x4894\x8F7E\
+\\x4895\x899E\
+\\x4896\x9188\
+\\x4897\x8C52\
+\\x4898\x9195\
+\\x4899\x8E5F\
+\\x489A\x9044\
+\\x489B\x90F5\
+\\x489C\x92E9\
+\\x489D\x96C8\
+\\x489E\x95B2\
+\\x489F\x8D71\
+\\x48A0\x8D62\
+\\x48A1\x8EFC\
+\\x48A2\x90E5\
+\\x48A3\x91D2\
+\\x48A4\x92E1\
+\\x48A5\x97CE\
+\\x48A6\x8C79\
+\\x48A7\x9683\
+\\x48A8\x8C63\
+\\x48A9\x984A\
+\\x48AA\x88E9\
+\\x48AB\x924F\
+\\x48AC\x88E7\
+\\x48AD\x8CC0\
+\\x48AE\x93B1\
+\\x48AF\x95FA\
+\\x48B0\x8D57\
+\\x48B1\x8DC0\
+\\x48B2\x8C8F\
+\\x48B3\x917A\
+\\x48B4\x8CB1\
+\\x48B5\x8E64\
+\\x48B6\x8E67\
+\\x48B7\x97D6\
+\\x48B8\x8AE7\
+\\x48B9\x94D4\
+\\x48BA\x92A3\
+\\x48BB\x95B7\
+\\x48BC\x8B9F\
+\\x48BD\x9392\
+\\x48BE\x976E\
+\\x48BF\x8D5A\
+\\x48C0\x93BA\
+\\x48C1\x9292\
+\\x48C2\x975A\
+\\x48C3\x96F5\
+\\x48C4\x8ECA\
+\\x48C5\x8AAE\
+\\x48C6\x8D60\
+\\x48C7\x9262\
+\\x48C8\x96E9\
+\\x48C9\x8F5B\
+\\x48CA\x97B4\
+\\x48CB\x8D6A\
+\\x48CC\x9548\
+\\x48CD\x91AC\
+\\x48CE\x95D7\
+\\x48CF\x8DFC\
+\\x48D0\x8B4E\
+\\x48D1\x9680\
+\\x48D2\x8E51\
+\\x48D3\x8963\
+\\x48D4\x95E4\
+\\x48D5\x9084\
+\\x48D6\x95D4\
+\\x48D7\x9045\
+\\x48D8\x8E7E\
+\\x48D9\x9360\
+\\x48DA\x8AB2\
+\\x48DB\x8B85\
+\\x48DC\x8CA0\
+\\x48DD\x9357\
+\\x48DE\x94A6\
+\\x48DF\x8A8B\
+\\x48E0\x92EB\
+\\x48E1\x94F1\
+\\x48E2\x8D86\
+\\x48E3\x9250\
+\\x48E4\x8DCE\
+\\x48E5\x8A67\
+\\x48E6\x8F88\
+\\x48E7\x8CEA\
+\\x48E8\x8DF0\
+\\x48E9\x88E6\
+\\x48EA\x95A3\
+\\x48EB\x8DC4\
+\\x48EC\x93AD\
+\\x48ED\x89C8\
+\\x48EE\x8B9B\
+\\x48EF\x925B\
+\\x48F0\x9372\
+\\x48F1\x88C4\
+\\x48F2\x8E9A\
+\\x48F3\x985F\
+\\x48F4\x8C93\
+\\x48F5\x9694\
+\\x48F6\x9055\
+\\x48F7\x8B5A\
+\\x48F8\x934F\
+\\x48F9\x8E44\
+\\x48FA\x8C6E\
+\\x48FB\x8F5D\
+\\x48FC\x97E2\
+\\x48FD\x91D4\
+\\x48FE\x95F4\
+\\x4941\x8EB8\
+\\x4942\x8CFA\
+\\x4943\x91A4\
+\\x4944\x928D\
+\\x4945\x91AA\
+\\x4946\x8DA0\
+\\x4947\x8FE6\
+\\x4948\x8E8E\
+\\x4949\x92D8\
+\\x494A\x948B\
+\\x494B\x937D\
+\\x494C\x8B44\
+\\x494D\x95F3\
+\\x494E\x8BB1\
+\\x494F\x94F3\
+\\x4950\x89B7\
+\\x4951\x957E\
+\\x4952\x90E0\
+\\x4953\x8C7C\
+\\x4954\x8D90\
+\\x4955\x97F0\
+\\x4956\x94CA\
+\\x4957\x8FFC\
+\\x4958\x97E7\
+\\x4959\x8FAB\
+\\x495A\x93EF\
+\\x495B\x8DBB\
+\\x495C\x94BB\
+\\x495D\x96F0\
+\\x495E\x8965\
+\\x495F\x915D\
+\\x4960\x91D1\
+\\x4961\x97A4\
+\\x4962\x8A99\
+\\x4963\x926B\
+\\x4964\x8FB2\
+\\x4965\x88AB\
+\\x4966\x9557\
+\\x4967\x905C\
+\\x4968\x8A51\
+\\x4969\x95EA\
+\\x496A\x95E2\
+\\x496B\x9679\
+\\x496C\x90BA\
+\\x496D\x8F9C\
+\\x496E\x8DF9\
+\\x496F\x9577\
+\\x4970\x8AA3\
+\\x4971\x8BA3\
+\\x4972\x8EC5\
+\\x4973\x8B8D\
+\\x4974\x9483\
+\\x4975\x88DA\
+\\x4976\x8FC9\
+\\x4977\x9283\
+\\x4978\x8CF8\
+\\x4979\x977B\
+\\x497A\x8C4D\
+\\x497B\x94EC\
+\\x497C\x8CAA\
+\\x497D\x9846\
+\\x497E\x89C4\
+\\x497F\x93B0\
+\\x4980\x9490\
+\\x4981\x95A5\
+\\x4982\x8B41\
+\\x4983\x8FC4\
+\\x4984\x97B0\
+\\x4985\x9856\
+\\x4986\x8B86\
+\\x4987\x9052\
+\\x4988\x906A\
+\\x4989\x9266\
+\\x498A\x8ECB\
+\\x498B\x8DB7\
+\\x498C\x9792\
+\\x498D\x90DC\
+\\x498E\x91CF\
+\\x498F\x90E9\
+\\x4990\x8E6E\
+\\x4991\x97A5\
+\\x4992\x8E63\
+\\x4993\x8C69\
+\\x4994\x8FDB\
+\\x4995\x8BBD\
+\\x4996\x91EC\
+\\x4997\x97A3\
+\\x4998\x8C4F\
+\\x4999\x8E80\
+\\x499A\x8D6B\
+\\x499B\x9180\
+\\x499C\x97BA\
+\\x499D\x895D\
+\\x499E\x8C53\
+\\x499F\x8BCE\
+\\x49A0\x8B81\
+\\x49A1\x8AD1\
+\\x49A2\x8AAF\
+\\x49A3\x8DC8\
+\\x49A4\x97A0\
+\\x49A5\x8AE1\
+\\x49A6\x948C\
+\\x49A7\x9771\
+\\x49A8\x927A\
+\\x49A9\x8A4B\
+\\x49AA\x8AB7\
+\\x49AB\x8C6A\
+\\x49AC\x8977\
+\\x49AD\x8A81\
+\\x49AE\x8BCF\
+\\x49AF\x8DE0\
+\\x49B0\x96BD\
+\\x49B1\x89A4\
+\\x49B2\x8A97\
+\\x49B3\x88E8\
+\\x49B4\x9681\
+\\x49B5\x8FCE\
+\\x49B6\x8BC8\
+\\x49B7\x8BC9\
+\\x49B8\x95F1\
+\\x49B9\x92F1\
+\\x49BA\x8FD8\
+\\x49BB\x90E1\
+\\x49BC\x88E1\
+\\x49BD\x8DD9\
+\\x49BE\x8EF1\
+\\x49BF\x9561\
+\\x49C0\x8BCB\
+\\x49C1\x975D\
+\\x49C2\x8AA2\
+\\x49C3\x97DF\
+\\x49C4\x9081\
+\\x49C5\x9296\
+\\x49C6\x96A2\
+\\x49C7\x8D84\
+\\x49C8\x9589\
+\\x49C9\x94BA\
+\\x49CA\x8B56\
+\\x49CB\x8ADC\
+\\x49CC\x934B\
+\\x49CD\x9698\
+\\x49CE\x904B\
+\\x49CF\x8ADE\
+\\x49D0\x939A\
+\\x49D1\x92C7\
+\\x49D2\x93A2\
+\\x49D3\x8FE4\
+\\x49D4\x8994\
+\\x49D5\x9452\
+\\x49D6\x89DB\
+\\x49D7\x88D7\
+\\x49D8\x8940\
+\\x49D9\x9687\
+\\x49DA\x94E7\
+\\x49DB\x8CEC\
+\\x49DC\x88BB\
+\\x49DD\x894A\
+\\x49DE\x89E4\
+\\x49DF\x8AF1\
+\\x49E0\x89AC\
+\\x49E1\x899F\
+\\x49E2\x945B\
+\\x49E3\x8AC4\
+\\x49E4\x9644\
+\\x49E5\x8D7E\
+\\x49E6\x8C5C\
+\\x49E7\x97B3\
+\\x49E8\x94CD\
+\\x49E9\x8E45\
+\\x49EA\x8A4C\
+\\x49EB\x897C\
+\\x49EC\x8BF6\
+\\x49ED\x8989\
+\\x49EE\x90E8\
+\\x49EF\x9497\
+\\x49F0\x8C80\
+\\x49F1\x8DCB\
+\\x49F2\x93D6\
+\\x49F3\x8B89\
+\\x49F4\x8F49\
+\\x49F5\x9688\
+\\x49F6\x8CA6\
+\\x49F7\x8F6B\
+\\x49F8\x9581\
+\\x49F9\x8FCB\
+\\x49FA\x8CC2\
+\\x49FB\x90EA\
+\\x49FC\x8BEE\
+\\x49FD\x955D\
+\\x49FE\x94A9\
+\\x4A41\x91B6\
+\\x4A42\x93F7\
+\\x4A43\x8C58\
+\\x4A44\x8E74\
+\\x4A45\x8974\
+\\x4A46\x97E1\
+\\x4A47\x9062\
+\\x4A48\x8E8A\
+\\x4A49\x88F6\
+\\x4A4A\x8C70\
+\\x4A4B\x9BDF\
+\\x4A4C\x8A6F\
+\\x4A4D\x8D61\
+\\x4A4E\x90F4\
+\\x4A4F\x93C7\
+\\x4A50\x8E8B\
+\\x4A51\x96D2\
+\\x4A52\x8B90\
+\\x4A53\x96D4\
+\\x4A54\x91DC\
+\\x4A55\x9443\
+\\x4A56\x96A7\
+\\x4A57\x91B3\
+\\x4A58\x8BB5\
+\\x4A59\x9298\
+\\x4A5A\x8A72\
+\\x4A5B\x8B42\
+\\x4A5C\x8BBF\
+\\x4A5D\x94CC\
+\\x4A5E\x959D\
+\\x4A5F\x8BEA\
+\\x4A60\x915B\
+\\x4A61\x90AA\
+\\x4A62\x8EA5\
+\\x4A63\x9591\
+\\x4A64\x9377\
+\\x4A65\x8C45\
+\\x4A66\x96AD\
+\\x4A67\x8D52\
+\\x4A68\x95E3\
+\\x4A69\x8F4B\
+\\x4A6A\x91A3\
+\\x4A6B\x8DC6\
+\\x4A6C\x8CAF\
+\\x4A6D\x8D58\
+\\x4A6E\x8D75\
+\\x4A6F\x8AB1\
+\\x4A70\x959C\
+\\x4A71\x964B\
+\\x4A72\x9468\
+\\x4A73\x93C2\
+\\x4A74\x8C82\
+\\x4A75\x8EAF\
+\\x4A76\x9054\
+\\x4A77\x8DA5\
+\\x4A78\x92B4\
+\\x4A79\x97D3\
+\\x4A7A\x978A\
+\\x4A7B\x8EEB\
+\\x4A7C\x8DE4\
+\\x4A7D\x8BD0\
+\\x4A7E\x9446\
+\\x4A7F\x95BF\
+\\x4A80\x92F7\
+\\x4A81\x8B78\
+\\x4A82\x925A\
+\\x4A83\x959A\
+\\x4A84\x93D0\
+\\x4A85\x94B2\
+\\x4A86\x93F2\
+\\x4A87\x88E3\
+\\x4A88\x9784\
+\\x4A89\x8950\
+\\x4A8A\x8E47\
+\\x4A8B\x9756\
+\\x4A8C\x9582\
+\\x4A8D\x8BBE\
+\\x4A8E\x9177\
+\\x4A8F\x8E94\
+\\x4A90\x8DED\
+\\x4A91\x9359\
+\\x4A92\x9496\
+\\x4A93\x91E0\
+\\x4A94\x8CC5\
+\\x4A95\x8BAB\
+\\x4A96\x9672\
+\\x4A97\x8D80\
+\\x4A98\x93FB\
+\\x4A99\x93A4\
+\\x4A9A\x8B96\
+\\x4A9B\x8F8F\
+\\x4A9C\x8F71\
+\\x4A9D\x9851\
+\\x4A9E\x88CB\
+\\x4A9F\x8E95\
+\\x4AA0\x89A2\
+\\x4AA1\x9253\
+\\x4AA2\x8F9E\
+\\x4AA3\x8A76\
+\\x4AA4\x8B70\
+\\x4AA5\x8D9C\
+\\x4AA6\x8B6E\
+\\x4AA7\x8BDC\
+\\x4AA8\x95EF\
+\\x4AA9\x88D9\
+\\x4AAA\x9196\
+\\x4AAB\x8CD5\
+\\x4AAC\x95F5\
+\\x4AAD\x8FDC\
+\\x4AAE\x944F\
+\\x4AAF\x96B4\
+\\x4AB0\x8A46\
+\\x4AB1\x8CE5\
+\\x4AB2\x9477\
+\\x4AB3\x9550\
+\\x4AB4\x9245\
+\\x4AB5\x8AF3\
+\\x4AB6\x91F5\
+\\x4AB7\x93A9\
+\\x4AB8\x9563\
+\\x4AB9\x8AC2\
+\\x4ABA\x8FF6\
+\\x4ABB\x966C\
+\\x4ABC\x895F\
+\\x4ABD\x94C5\
+\\x4ABE\x946A\
+\\x4ABF\x8F69\
+\\x4AC0\x8FC2\
+\\x4AC1\x8A60\
+\\x4AC2\x8C89\
+\\x4AC3\x975B\
+\\x4AC4\x947B\
+\\x4AC5\x8CA2\
+\\x4AC6\x89A9\
+\\x4AC7\x954D\
+\\x4AC8\x8B53\
+\\x4AC9\x8E55\
+\\x4ACA\x8B8E\
+\\x4ACB\x9755\
+\\x4ACC\x8A98\
+\\x4ACD\x97CC\
+\\x4ACE\x945A\
+\\x4ACF\x97B7\
+\\x4AD0\x8ED8\
+\\x4AD1\x9772\
+\\x4AD2\x8F81\
+\\x4AD3\x8F54\
+\\x4AD4\x9265\
+\\x4AD5\x8987\
+\\x4AD6\x88ED\
+\\x4AD7\x8C78\
+\\x4AD8\x93C4\
+\\x4AD9\x949A\
+\\x4ADA\x938D\
+\\x4ADB\x93C6\
+\\x4ADC\x91B0\
+\\x4ADD\x88B0\
+\\x4ADE\x8B71\
+\\x4ADF\x93ED\
+\\x4AE0\x949E\
+\\x4AE1\x95E5\
+\\x4AE2\x90CD\
+\\x4AE3\x8A7C\
+\\x4AE4\x8A47\
+\\x4AE5\x8CB0\
+\\x4AE6\x96A4\
+\\x4AE7\x8C98\
+\\x4AE8\x90BF\
+\\x4AE9\x8A74\
+\\x4AEA\x88DF\
+\\x4AEB\x89DD\
+\\x4AEC\x8B47\
+\\x4AED\x8FB0\
+\\x4AEE\x8CE0\
+\\x4AEF\x8D64\
+\\x4AF0\x8E87\
+\\x4AF1\x8D76\
+\\x4AF2\x91B2\
+\\x4AF3\x90E2\
+\\x4AF4\x91DD\
+\\x4AF5\x8A44\
+\\x4AF6\x8CC4\
+\\x4AF7\x8CCC\
+\\x4AF8\x8FBB\
+\\x4AF9\x97E6\
+\\x4AFA\x88CD\
+\\x4AFB\x94A0\
+\\x4AFC\x966E\
+\\x4AFD\x93CB\
+\\x4AFE\x95E9\
+\\x4B41\x94A3\
+\\x4B42\x8E70\
+\\x4B43\x8C8C\
+\\x4B44\x8DA2\
+\\x4B45\x927D\
+\\x4B46\x8DAC\
+\\x4B47\x95D9\
+\\x4B48\x93E7\
+\\x4B49\x91DE\
+\\x4B4A\x9693\
+\\x4B4B\x91A9\
+\\x4B4C\x95D6\
+\\x4B4D\x92C0\
+\\x4B4E\x959B\
+\\x4B4F\x8DCC\
+\\x4B50\x9843\
+\\x4B51\x95A1\
+\\x4B52\x8DE5\
+\\x4B53\x90C8\
+\\x4B54\x96BA\
+\\x4B55\x8AC3\
+\\x4B56\x96C6\
+\\x4B57\x8AF4\
+\\x4B58\x8DC2\
+\\x4B59\x9051\
+\\x4B5A\x965F\
+\\x4B5B\x9090\
+\\x4B5C\x92CE\
+\\x4B5D\x94F7\
+\\x4B5E\x8E6B\
+\\x4B5F\x8B6C\
+\\x4B60\x90A1\
+\\x4B61\x92E7\
+\\x4B62\x9191\
+\\x4B63\x8B7C\
+\\x4B64\x92EA\
+\\x4B65\x9394\
+\\x4B66\x9072\
+\\x4B67\x8D67\
+\\x4B68\x9179\
+\\x4B69\x8C4A\
+\\x4B6A\x937C\
+\\x4B6B\x8C94\
+\\x4B6C\x89D8\
+\\x4B6D\x91A6\
+\\x4B6E\x8EE3\
+\\x4B6F\x8A7E\
+\\x4B70\x96C2\
+\\x4B71\x916F\
+\\x4B72\x8F46\
+\\x4B73\x8B9D\
+\\x4B74\x8CDD\
+\\x4B75\xE4DD\
+\\x4B76\x8E8F\
+\\x4B77\x8AF9\
+\\x4B78\x8B99\
+\\x4B79\x8CA8\
+\\x4B7A\x91E9\
+\\x4B7B\x8FF7\
+\\x4B7C\x939B\
+\\x4B7D\x95C2\
+\\x4B7E\x9781\
+\\x4B7F\x9254\
+\\x4B80\x94E3\
+\\x4B81\x8AA6\
+\\x4B82\x8B93\
+\\x4B83\x924E\
+\\x4B84\x96BF\
+\\x4B85\x8A5D\
+\\x4B86\x8C8A\
+\\x4B87\x9495\
+\\x4B88\x8F4F\
+\\x4B89\x918F\
+\\x4B8A\x9473\
+\\x4B8B\x96B2\
+\\x4B8C\x958D\
+\\x4B8D\x94ED\
+\\x4B8E\x8BD1\
+\\x4B8F\x8BD8\
+\\x4B90\x92EF\
+\\x4B91\x8AEB\
+\\x4B92\x92A1\
+\\x4B93\x8E40\
+\\x4B94\x95B9\
+\\x4B95\x95C7\
+\\x4B96\x93E5\
+\\x4B97\x8BD9\
+\\x4B98\x8B7A\
+\\x4B99\x8EEC\
+\\x4B9A\x8AA8\
+\\x4B9B\x8AA0\
+\\x4B9C\x94D6\
+\\x4B9D\x8BD3\
+\\x4B9E\x8A6A\
+\\x4B9F\x9454\
+\\x4BA0\x92C5\
+\\x4BA1\x89D7\
+\\x4BA2\x8A8A\
+\\x4BA3\x88F9\
+\\x4BA4\x8D98\
+\\x4BA5\x8A58\
+\\x4BA6\x8EB2\
+\\x4BA7\x92F5\
+\\x4BA8\x8DD8\
+\\x4BA9\x8C7D\
+\\x4BAA\x898F\
+\\x4BAB\x9382\
+\\x4BAC\x8B9C\
+\\x4BAD\x96F3\
+\\x4BAE\x907C\
+\\x4BAF\x89F4\
+\\x4BB0\x91A7\
+\\x4BB1\x97B9\
+\\x4BB2\x9057\
+\\x4BB3\x8ECC\
+\\x4BB4\x97F1\
+\\x4BB5\x90B9\
+\\x4BB6\x949F\
+\\x4BB7\x97C3\
+\\x4BB8\x8F4D\
+\\x4BB9\x8BF7\
+\\x4BBA\x919C\
+\\x4BBB\x90A5\
+\\x4BBC\x8E97\
+\\x4BBD\x89B3\
+\\x4BBE\x924D\
+\\x4BBF\x9790\
+\\x4BC0\x8E68\
+\\x4BC1\x907A\
+\\x4BC2\x8B6B\
+\\x4BC3\x91D6\
+\\x4BC4\x95FC\
+\\x4BC5\x8D55\
+\\x4BC6\x9849\
+\\x4BC7\x9470\
+\\x4BC8\x8C50\
+\\x4BC9\x9082\
+\\x4BCA\x97F6\
+\\x4BCB\x928E\
+\\x4BCC\x93AC\
+\\x4BCD\x9459\
+\\x4BCE\x929A\
+\\x4BCF\x9560\
+\\x4BD0\x8C83\
+\\x4BD1\x8ECE\
+\\x4BD2\x90D3\
+\\x4BD3\x8A9D\
+\\x4BD4\x8FCF\
+\\x4BD5\x8BB0\
+\\x4BD6\x978B\
+\\x4BD7\x9445\
+\\x4BD8\x91B9\
+\\x4BD9\x8D45\
+\\x4BDA\x93A7\
+\\x4BDB\x91F1\
+\\x4BDC\x9685\
+\\x4BDD\x898C\
+\\x4BDE\x937E\
+\\x4BDF\x8FCC\
+\\x4BE0\x9742\
+\\x4BE1\x916E\
+\\x4BE2\x88C3\
+\\x4BE3\x8BB9\
+\\x4BE4\x986A\
+\\x4BE5\x95A7\
+\\x4BE6\x9380\
+\\x4BE7\x894C\
+\\x4BE8\x8C5A\
+\\x4BE9\x918B\
+\\x4BEA\x928C\
+\\x4BEB\x97DB\
+\\x4BEC\x8AC8\
+\\x4BED\x8D74\
+\\x4BEE\x8F41\
+\\x4BEF\x9249\
+\\x4BF0\x8BFA\
+\\x4BF1\x9868\
+\\x4BF2\x8AF6\
+\\x4BF3\x9347\
+\\x4BF4\x9840\
+\\x4BF5\x8D8F\
+\\x4BF6\x977E\
+\\x4BF7\x9453\
+\\x4BF8\x9440\
+\\x4BF9\x8FE1\
+\\x4BFA\x9465\
+\\x4BFB\x88BE\
+\\x4BFC\x8B74\
+\\x4BFD\x8FB5\
+\\x4BFE\x976A\
+\\x4C41\x95DF\
+\\x4C42\x8A54\
+\\x4C43\x8DC3\
+\\x4C44\x96DF\
+\\x4C45\x9659\
+\\x4C46\x9767\
+\\x4C47\x92C9\
+\\x4C48\x8FB3\
+\\x4C49\x97B6\
+\\x4C4A\x8ACD\
+\\x4C4B\x9494\
+\\x4C4C\x8ECF\
+\\x4C4D\x8CD9\
+\\x4C4E\x8DDF\
+\\x4C4F\x94DB\
+\\x4C50\x9381\
+\\x4C51\x89D9\
+\\x4C52\x8C59\
+\\x4C53\x9174\
+\\x4C54\x8A9B\
+\\x4C55\x9656\
+\\x4C56\x93DC\
+\\x4C57\x8AE8\
+\\x4C58\x8EC9\
+\\x4C59\x90CC\
+\\x4C5A\x898E\
+\\x4C5B\x8F9D\
+\\x4C5C\x8B7E\
+\\x4C5D\x9766\
+\\x4C5E\x91B7\
+\\x4C5F\x8BAA\
+\\x4C60\x89F5\
+\\x4C61\x8EF6\
+\\x4C62\x9299\
+\\x4C63\x9474\
+\\x4C64\x8C5F\
+\\x4C65\x88D0\
+\\x4C66\x9187\
+\\x4C67\x9183\
+\\x4C68\x8D8B\
+\\x4C69\x88B5\
+\\x4C6A\x9276\
+\\x4C6B\x8EDA\
+\\x4C6C\x936B\
+\\x4C6D\x9278\
+\\x4C6E\x8CBA\
+\\x4C6F\x97F9\
+\\x4C70\x94E9\
+\\x4C71\x8DD5\
+\\x4C72\x93A6\
+\\x4C73\x8BDB\
+\\x4C74\x92A5\
+\\x4C75\x8EB3\
+\\x4C76\x94E1\
+\\x4C77\x8E42\
+\\x4C78\x8D68\
+\\x4C79\x8EA2\
+\\x4C7A\x97BE\
+\\x4C7B\x8B8C\
+\\x4C7C\x91A1\
+\\x4C7D\x8CB2\
+\\x4C7E\x8AA9\
+\\x4C7F\x9092\
+\\x4C80\x97EE\
+\\x4C81\x89B6\
+\\x4C82\x894B\
+\\x4C83\x8BC5\
+\\x4C84\x9077\
+\\x4C85\x9658\
+\\x4C86\x95F8\
+\\x4C87\x92DC\
+\\x4C88\x96A9\
+\\x4C89\x92C1\
+\\x4C8A\x9060\
+\\x4C8B\x8BE5\
+\\x4C8C\x8ACC\
+\\x4C8D\x909E\
+\\x4C8E\x8CB5\
+\\x4C8F\x92BE\
+\\x4C90\x8EBC\
+\\x4C91\x88F2\
+\\x4C92\x9757\
+\\x4C93\x92AA\
+\\x4C94\x927E\
+\\x4C95\xE54D\
+\\x4C96\xE3F9\
+\\x4C97\x93C5\
+\\x4C98\x928B\
+\\x4C99\x8F90\
+\\x4C9A\x89CF\
+\\x4C9B\x92ED\
+\\x4C9C\x9162\
+\\x4C9D\x94DF\
+\\x4C9E\x8BB7\
+\\x4C9F\x9173\
+\\x4CA0\x95A0\
+\\x4CA1\x96F4\
+\\x4CA2\x979A\
+\\x4CA3\x8D49\
+\\x4CA4\x9558\
+\\x4CA5\x9257\
+\\x4CA6\x9796\
+\\x4CA7\x94C6\
+\\x4CA8\x9778\
+\\x4CA9\x97B1\
+\\x4CAA\x8ADA\
+\\x4CAB\x8EA8\
+\\x4CAC\x8D54\
+\\x4CAD\x914C\
+\\x4CAE\x8CF3\
+\\x4CAF\x9872\
+\\x4CB0\x8E8D\
+\\x4CB1\x93EE\
+\\x4CB2\x965C\
+\\x4CB3\x945D\
+\\x4CB4\x8B5E\
+\\x4CB5\x8C87\
+\\x4CB6\x94D3\
+\\x4CB7\x9758\
+\\x4CB8\x8BF8\
+\\x4CB9\x8C5D\
+\\x4CBA\x92D6\
+\\x4CBB\x8D63\
+\\x4CBC\x8DD0\
+\\x4CBD\x8DAE\
+\\x4CBE\x8E9C\
+\\x4CBF\x9168\
+\\x4CC0\x8F78\
+\\x4CC1\x8E6F\
+\\x4CC2\x9643\
+\\x4CC3\x8DD3\
+\\x4CC4\x94F0\
+\\x4CC5\x8CD2\
+\\x4CC6\x9441\
+\\x4CC7\x92A8\
+\\x4CC8\x8FE0\
+\\x4CC9\x8FF2\
+\\x4CCA\x968B\
+\\x4CCB\x9383\
+\\x4CCC\x96A5\
+\\x4CCD\x90D5\
+\\x4CCE\x9653\
+\\x4CCF\x93D8\
+\\x4CD0\x97D5\
+\\x4CD1\x9047\
+\\x4CD2\x8941\
+\\x4CD3\x8C95\
+\\x4CD4\x9572\
+\\x4CD5\x8BC1\
+\\x4CD6\x937B\
+\\x4CD7\x8AA7\
+\\x4CD8\x8BD5\
+\\x4CD9\x95C5\
+\\x4CDA\x88E2\
+\\x4CDB\x8953\
+\\x4CDC\x9163\
+\\x4CDD\x939E\
+\\x4CDE\x8DE7\
+\\x4CDF\x9169\
+\\x4CE0\x97D7\
+\\x4CE1\x946F\
+\\x4CE2\x8F65\
+\\x4CE3\x92DE\
+\\x4CE4\x8FD0\
+\\x4CE5\x8C47\
+\\x4CE6\x9743\
+\\x4CE7\x978D\
+\\x4CE8\x97E4\
+\\x4CE9\x914E\
+\\x4CEA\x899D\
+\\x4CEB\x8F6A\
+\\x4CEC\x8992\
+\\x4CED\x8EEF\
+\\x4CEE\xE2C4\
+\\x4CEF\x91B8\
+\\x4CF0\x97AA\
+\\x4CF1\x8E46\
+\\x4CF2\x974B\
+\\x4CF3\x97ED\
+\\x4CF4\x8DF5\
+\\x4CF5\x9791\
+\\x4CF6\x94AF\
+\\x4CF7\x908B\
+\\x4CF8\x8BD4\
+\\x4CF9\x96E4\
+\\x4CFA\x9472\
+\\x4CFB\x9662\
+\\x4CFC\x8AC9\
+\\x4CFD\x9540\
+\\x4CFE\x8BEC\
+\\x4D41\x905A\
+\\x4D42\x8EE9\
+\\x4D43\x8FA5\
+\\x4D44\x8C40\
+\\x4D45\x9375\
+\\x4D46\x8A78\
+\\x4D47\x8F84\
+\\x4D48\x914B\
+\\x4D49\x964F\
+\\x4D4A\x9761\
+\\x4D4B\x8B83\
+\\x4D4C\x8D9F\
+\\x4D4D\x8BA7\
+\\x4D4E\x8ABD\
+\\x4D4F\x8F98\
+\\x4D50\x93B6\
+\\x4D51\x97CF\
+\\x4D52\x8CCE\
+\\x4D53\x928A\
+\\x4D54\x8990\
+\\x4D55\x9E77\
+\\x4D56\x8B75\
+\\x4D57\x8EB7\
+\\x4D58\x95E1\
+\\x4D59\x9165\
+\\x4D5A\x93CF\
+\\x4D5B\x92B8\
+\\x4D5C\x8B72\
+\\x4D5D\x92BF\
+\\x4D5E\x9068\
+\\x4D5F\x9071\
+\\x4D60\x88AC\
+\\x4D61\x8A6C\
+\\x4D62\x9585\
+\\x4D63\x8CD3\
+\\x4D64\x9288\
+\\x4D65\x9390\
+\\x4D66\x977D\
+\\x4D67\x8F7B\
+\\x4D68\x9066\
+\\x4D69\x8AEF\
+\\x4D6A\x8E7C\
+\\x4D6B\x9870\
+\\x4D6C\x9267\
+\\x4D6D\x8B69\
+\\x4D6E\x8DDA\
+\\x4D6F\x8973\
+\\x4D70\x8DBD\
+\\x4D71\x89BC\
+\\x4D72\x927B\
+\\x4D73\x9151\
+\\x4D74\x8EAB\
+\\x4D75\x8BD6\
+\\x4D76\x9595\
+\\x4D77\x8B92\
+\\x4D78\x8C7E\
+\\x4D79\x8EDF\
+\\x4D7A\x957D\
+\\x4D7B\x90F9\
+\\x4D7C\x93A5\
+\\x4D7D\x9777\
+\\x4D7E\x9059\
+\\x4D7F\x88BD\
+\\x4D80\x947D\
+\\x4D81\x9340\
+\\x4D82\x97BB\
+\\x4D83\x9164\
+\\x4D84\x8F60\
+\\x4D85\x8FE8\
+\\x4D86\x8D79\
+\\x4D87\x8BDE\
+\\x4D88\x9691\
+\\x4D89\x906F\
+\\x4D8A\x968C\
+\\x4D8B\x8B58\
+\\x4D8C\x975F\
+\\x4D8D\x8A59\
+\\x4D8E\x8C7B\
+\\x4D8F\x8FB7\
+\\x4D90\x937A\
+\\x4D91\x8CEB\
+\\x4D92\x97E3\
+\\x4D93\x93E8\
+\\x4D94\x8BFC\
+\\x4D95\x94B5\
+\\x4D96\x8AF7\
+\\x4D97\x94E6\
+\\x4D98\x93B4\
+\\x4D99\x8CDE\
+\\x4D9A\x969A\
+\\x4D9B\x94A4\
+\\x4D9C\x9782\
+\\x4D9D\x9255\
+\\x4D9E\x91C3\
+\\x4D9F\x9281\
+\\x4DA0\x89FA\
+\\x4DA1\x91D8\
+\\x4DA2\x8AC5\
+\\x4DA3\x956E\
+\\x4DA4\x8997\
+\\x4DA5\x8FD5\
+\\x4DA6\x8BF9\
+\\x4DA7\x93CD\
+\\x4DA8\x92AE\
+\\x4DA9\x8AD2\
+\\x4DAA\x8B4F\
+\\x4DAB\x8AF8\
+\\x4DAC\x947C\
+\\x4DAD\x898A\
+\\x4DAE\x8EBD\
+\\x4DAF\x9763\
+\\x4DB0\x8F75\
+\\x4DB1\x9555\
+\\x4DB2\x95F2\
+\\x4DB3\x8F4C\
+\\x4DB4\x96A3\
+\\x4DB5\x9783\
+\\x4DB6\x92B0\
+\\x4DB7\x9185\
+\\x4DB8\x9491\
+\\x4DB9\xEAA0\
+\\x4DBA\x9562\
+\\x4DBB\x8ED3\
+\\x4DBC\x96D9\
+\\x4DBD\x919F\
+\\x4DBE\x89D2\
+\\x4DBF\x955B\
+\\x4DC0\x90F6\
+\\x4DC1\x8C66\
+\\x4DC2\x8B97\
+\\x4DC3\x917C\
+\\x4DC4\x97AD\
+\\x4DC5\x92A0\
+\\x4DC6\x8C9C\
+\\x4DC7\x8E4D\
+\\x4DC8\x94C0\
+\\x4DC9\x92D4\
+\\x4DCA\x90EE\
+\\x4DCB\x9345\
+\\x4DCC\x90B2\
+\\x4DCD\x8DCA\
+\\x4DCE\x88A7\
+\\x4DCF\x9274\
+\\x4DD0\x8BDA\
+\\x4DD1\x97F3\
+\\x4DD2\x919B\
+\\x4DD3\x8AB5\
+\\x4DD4\x91F3\
+\\x4DD5\x8BA9\
+\\x4DD6\x8D83\
+\\x4DD7\x8F45\
+\\x4DD8\x9749\
+\\x4DD9\x8AD5\
+\\x4DDA\x97DC\
+\\x4DDB\x969D\
+\\x4DDC\x96C1\
+\\x4DDD\x917B\
+\\x4DDE\x906B\
+\\x4DDF\x8F50\
+\\x4DE0\x8DCD\
+\\x4DE1\x967D\
+\\x4DE2\x9682\
+\\x4DE3\x92EE\
+\\x4DE4\x8FEC\
+\\x4DE5\x91CA\
+\\x4DE6\x8FC5\
+\\x4DE7\x8FDA\
+\\x4DE8\x919A\
+\\x4DE9\x8BE8\
+\\x4DEA\x8F5F\
+\\x4DEB\x8AB3\
+\\x4DEC\x894E\
+\\x4DED\x8BC2\
+\\x4DEE\x8E5E\
+\\x4DEF\x96E1\
+\\x4DF0\xE245\
+\\x4DF1\x8C43\
+\\x4DF2\x95A2\
+\\x4DF3\x929B\
+\\x4DF4\x9457\
+\\x4DF5\x9293\
+\\x4DF6\x88DD\
+\\x4DF7\x91F9\
+\\x4DF8\x95C9\
+\\x4DF9\x8C75\
+\\x4DFA\x9785\
+\\x4DFB\x88CC\
+\\x4DFC\x92F8\
+\\x4DFD\x96B8\
+\\x4DFE\x90D0\
+\\x4E41\x91FC\
+\\x4E42\x8CB7\
+\\x4E43\x88AD\
+\\x4E44\x97C0\
+\\x4E45\x8CAE\
+\\x4E46\x9246\
+\\x4E47\x8FA1\
+\\x4E48\x96B6\
+\\x4E49\x8C67\
+\\x4E4A\x8FC7\
+\\x4E4B\xE056\
+\\x4E4C\x8ADF\
+\\x4E4D\x8BE9\
+\\x4E4E\x8AD3\
+\\x4E4F\x9588\
+\\x4E50\x94A7\
+\\x4E51\x979B\
+\\x4E52\x92E0\
+\\x4E53\xEA9F\
+\\x4E54\x8FF4\
+\\x4E55\x8CAC\
+\\x4E56\x9344\
+\\x4E57\x8FF9\
+\\x4E58\x96C0\
+\\x4E59\x9061\
+\\x4E5A\x8BB6\
+\\x4E5B\x95DC\
+\\x4E5C\x91F4\
+\\x4E5D\x8AA1\
+\\x4E5E\x93AB\
+\\x4E5F\x92AD\
+\\x4E60\x8C61\
+\\x4E61\x92C2\
+\\x4E62\x9464\
+\\x4E63\x93DD\
+\\x4E64\x895A\
+\\x4E65\x93D5\
+\\x4E66\x9567\
+\\x4E67\x89B4\
+\\x4E68\x97F2\
+\\x4E69\x8A92\
+\\x4E6A\x96B0\
+\\x4E6B\x8FA0\
+\\x4E6C\x89AF\
+\\x4E6D\x95AC\
+\\x4E6E\x92B1\
+\\x4E6F\x8988\
+\\x4E70\x92E2\
+\\x4E71\x89F6\
+\\x4E72\x88AF\
+\\x4E73\x9042\
+\\x4E74\x97C1\
+\\x4E75\x8AD8\
+\\x4E76\x908F\
+\\x4E77\x89B1\
+\\x4E78\x9866\
+\\x4E79\x89B5\
+\\x4E7A\x9350\
+\\x4E7B\x8AA5\
+\\x4E7C\x908C\
+\\x4E7D\x9462\
+\\x4E7E\x91F0\
+\\x4E7F\x95BC\
+\\x4E80\x92B6\
+\\x4E81\xE1A9\
+\\x4E82\x8998\
+\\x4E83\x936C\
+\\x4E84\x916D\
+\\x4E85\x8C48\
+\\x4E86\x92A4\
+\\x4E87\x9641\
+\\x4E88\x956A\
+\\x4E89\x89C5\
+\\x4E8A\x92D0\
+\\x4E8B\x88FC\
+\\x4E8C\x90DB\
+\\x4E8D\x8DBF\
+\\x4E8E\x9264\
+\\x4E8F\x8D77\
+\\x4E90\x8E8C\
+\\x4E91\x90FA\
+\\x4E92\x9E8A\
+\\x4E93\x8F63\
+\\x4E94\x8D92\
+\\x4E95\x8D96\
+\\x4E96\xE67C\
+\\x4E97\x91AD\
+\\x4E98\x8FF5\
+\\x4E99\x96EB\
+\\x4E9A\x88DC\
+\\x4E9B\x925F\
+\\x4E9C\x9740\
+\\x4E9D\x97C2\
+\\x4E9E\xE78C\
+\\x4E9F\x8AEA\
+\\x4EA0\x9544\
+\\x4EA1\x8DFB\
+\\x4EA2\x9670\
+\\x4EA3\x965A\
+\\x4EA4\x8DA7\
+\\x4EA5\x8E7A\
+\\x4EA6\x9650\
+\\x4EA7\x984C\
+\\x4EA8\x94AB\
+\\x4EA9\x938F\
+\\x4EAA\x95A6\
+\\x4EAB\x93B7\
+\\x4EAC\x9684\
+\\x4EAD\x8DB9\
+\\x4EAE\x8942\
+\\x4EAF\x8CC7\
+\\x4EB0\x88EB\
+\\x4EB1\x8AFC\
+\\x4EB2\x9366\
+\\x4EB3\x966A\
+\\x4EB4\x8CD6\
+\\x4EB5\x8CEE\
+\\x4EB6\x8C64\
+\\x4EB7\x8E4C\
+\\x4EB8\x8ED7\
+\\x4EB9\x8BF2\
+\\x4EBA\x89E8\
+\\x4EBB\x9244\
+\\x4EBC\x8967\
+\\x4EBD\x9587\
+\\x4EBE\x95E6\
+\\x4EBF\x8F6E\
+\\x4EC0\x8FB4\
+\\x4EC1\x8AB9\
+\\x4EC2\x8CAD\
+\\x4EC3\x8C99\
+\\x4EC4\x8ABE\
+\\x4EC5\x97C6\
+\\x4EC6\x9159\
+\\x4EC7\x966F\
+\\x4EC8\x89F3\
+\\x4EC9\x8C73\
+\\x4ECA\x8FA7\
+\\x4ECB\x93F5\
+\\x4ECC\x946B\
+\\x4ECD\x9649\
+\\x4ECE\x9270\
+\\x4ECF\x915F\
+\\x4ED0\x9797\
+\\x4ED1\x9DF4\
+\\x4ED2\x9182\
+\\x4ED3\x8DB5\
+\\x4ED4\x8DC9\
+\\x4ED5\x94B9\
+\\x4ED6\x9098\
+\\x4ED7\x90C9\
+\\x4ED8\x8B46\
+\\x4ED9\x8BC3\
+\\x4EDA\xE562\
+\\x4EDB\x97F5\
+\\x4EDC\x94C8\
+\\x4EDD\x95B1\
+\\x4EDE\x9793\
+\\x4EDF\x92CF\
+\\x4EE0\x9493\
+\\x4EE1\x974D\
+\\x4EE2\x9471\
+\\x4EE3\x9463\
+\\x4EE4\x89E0\
+\\x4EE5\x9040\
+\\x4EE6\x96C5\
+\\x4EE7\x9654\
+\\x4EE8\x89CB\
+\\x4EE9\x88FB\
+\\x4EEA\x969B\
+\\x4EEB\x88C1\
+\\x4EEC\x8FB6\
+\\x4EED\x9795\
+\\x4EEE\x8CDA\
+\\x4EEF\x92BA\
+\\x4EF0\x957C\
+\\x4EF1\x8AFB\
+\\x4EF2\x89F9\
+\\x4EF3\x8D42\
+\\x4EF4\x9479\
+\\x4EF5\x8F7A\
+\\x4EF6\x9663\
+\\x4EF7\x88BA\
+\\x4EF8\x9395\
+\\x4EF9\x88A3\
+\\x4EFA\x92C6\
+\\x4EFB\x8ABC\
+\\x4EFC\x8E61\
+\\x4EFD\x91B5\
+\\x4EFE\x9241\
+\\x4F41\x934A\
+\\x4F42\x9677\
+\\x4F43\x9787\
+\\x4F44\x906E\
+\\x4F45\x8CA3\
+\\x4F46\x89C9\
+\\x4F47\x8ED1\
+\\x4F48\x8FFB\
+\\x4F49\x8C97\
+\\x4F4A\x919E\
+\\x4F4B\x97EC\
+\\x4F4C\x95EB\
+\\x4F4D\x9664\
+\\x4F4E\x8CE9\
+\\x4F4F\x9485\
+\\x4F50\x8DEE\
+\\x4F51\x89D3\
+\\x4F52\x896C\
+\\x4F53\xE2C0\
+\\x4F54\x908A\
+\\x4F55\x97D0\
+\\x4F56\x92E6\
+\\x4F57\x896A\
+\\x4F58\x8ABF\
+\\x4F59\x8A90\
+\\x4F5A\x8CD1\
+\\x4F5B\x96E6\
+\\x4F5C\x8A6E\
+\\x4F5D\x8E5C\
+\\x4F5E\x9355\
+\\x4F5F\x95F6\
+\\x4F60\x97F4\
+\\x4F61\x8B91\
+\\x4F62\x8FE5\
+\\x4F63\x8BE4\
+\\x4F64\x909D\
+\\x4F65\x8F62\
+\\x4F66\x9290\
+\\x4F67\x91B4\
+\\x4F68\xEAA4\
+\\x4F69\x9089\
+\\x4F6A\x8C55\
+\\x4F6B\x8EC8\
+\\x4F6C\x9652\
+\\x4F6D\x8A57\
+\\x4F6E\x969F\
+\\x4F6F\x94B7\
+\\x4F70\x8C4C\
+\\x4F71\x9240\
+\\x4F72\x8B95\
+\\x4F73\x93D1\
+\\x4F74\xE582\
+\\x4F75\x94BF\
+\\x4F76\x904F\
+\\x4F77\x91DF\
+\\x4F78\x968D\
+\\x4F79\x9192\
+\\x4F7A\x9747\
+\\x4F7B\x8A48\
+\\x4F7C\x8A9E\
+\\x4F7D\x974F\
+\\x4F7E\x9768\
+\\x4F7F\x88E5\
+\\x4F80\x8F79\
+\\x4F81\x88A5\
+\\x4F82\x94B1\
+\\x4F83\x96D0\
+\\x4F84\x9BD4\
+\\x4F85\x8BED\
+\\x4F86\x8FA2\
+\\x4F87\x9154\
+\\x4F88\x8FD9\
+\\x4F89\x9449\
+\\x4F8A\x8DBE\
+\\x4F8B\x8AF0\
+\\x4F8C\x904E\
+\\x4F8D\x98D0\
+\\x4F8E\x88BC\
+\\x4F8F\x9660\
+\\x4F90\x95B5\
+\\x4F91\x8A55\
+\\x4F92\x8B59\
+\\x4F93\x8F4E\
+\\x4F94\x8E92\
+\\x4F95\x92E3\
+\\x4F96\x93BB\
+\\x4F97\x8A8E\
+\\x4F98\x8AA4\
+\\x4F99\xE2D6\
+\\x4F9A\x96AA\
+\\x4F9B\x93B5\
+\\x4F9C\x8E90\
+\\x4F9D\x89E3\
+\\x4F9E\x8E41\
+\\x4F9F\xFAD0\
+\\x4FA0\x90BE\
+\\x4FA1\x92D3\
+\\x4FA2\x9261\
+\\x4FA3\x89A0\
+\\x4FA4\x8DF1\
+\\x4FA5\x8F66\
+\\x4FA6\x94E2\
+\\x4FA7\x958A\
+\\x4FA8\x8FD6\
+\\x4FA9\x944A\
+\\x4FAA\x89E1\
+\\x4FAB\x9DF3\
+\\x4FAC\x8AAC\
+\\x4FAD\x88D4\
+\\x4FAE\x8F7C\
+\\x4FAF\x8CDB\
+\\x4FB0\x9282\
+\\x4FB1\x894F\
+\\x4FB2\x8A80\
+\\x4FB3\x9080\
+\\x4FB4\x8FDE\
+\\x4FB5\x9552\
+\\x4FB6\x95D1\
+\\x4FB7\x9348\
+\\x4FB8\x8F77\
+\\x4FB9\x9073\
+\\x4FBA\x948F\
+\\x4FBB\x986D\
+\\x4FBC\x9559\
+\\x4FBD\x974E\
+\\x4FBE\x8F8B\
+\\x4FBF\x9145\
+\\x4FC0\x93E6\
+\\x4FC1\x9143\
+\\x4FC2\x8E98\
+\\x4FC3\x8C86\
+\\x4FC4\x92F9\
+\\x4FC5\x8A87\
+\\x4FC6\x8CEF\
+\\x4FC7\x8C6D\
+\\x4FC8\x8F6C\
+\\x4FC9\x8BCD\
+\\x4FCA\x9487\
+\\x4FCB\x9086\
+\\x4FCC\x9088\
+\\x4FCD\x8B5B\
+\\x4FCE\x9DEE\
+\\x4FCF\x8AB8\
+\\x4FD0\x944C\
+\\x4FD1\x9543\
+\\x4FD2\x9867\
+\\x4FD3\x8C96\
+\\x4FD4\x8D5E\
+\\x4FD5\x8D65\
+\\x4FD6\x8E43\
+\\x4FD7\xE255\
+\\x4FD8\x92D1\
+\\x4FD9\x9584\
+\\x4FDA\x90C7\
+\\x4FDB\x92A7\
+\\x4FDC\x8B5D\
+\\x4FDD\x93D4\
+\\x4FDE\x9295\
+\\x4FDF\x9442\
+\\x4FE0\x88D2\
+\\x4FE1\x91F8\
+\\x4FE2\x93A3\
+\\x4FE3\x8EAA\
+\\x4FE4\x8E49\
+\\x4FE5\x9063\
+\\x4FE6\x9842\
+\\x4FE7\x8DA9\
+\\x4FE8\x91C9\
+\\x4FE9\x8EE2\
+\\x4FEA\x8ED6\
+\\x4FEB\x8E83\
+\\x4FEC\x96D5\
+\\x4FED\x909A\
+\\x4FEE\xE075\
+\\x4FEF\x916A\
+\\x4FF0\x96E0\
+\\x4FF1\x90A9\
+\\x4FF2\x8E79\
+\\x4FF3\x95B4\
+\\x4FF4\x9342\
+\\x4FF5\x9268\
+\\x4FF6\x94CB\
+\\x4FF7\x88D6\
+\\x4FF8\x8C42\
+\\x4FF9\x9860\
+\\x4FFA\x9692\
+\\x4FFB\x89A5\
+\\x4FFC\x95AE\
+\\x4FFD\x91AF\
+\\x4FFE\x8AD7\
+\\x5041\x934C\
+\\x5042\x8EB6\
+\\x5043\x9444\
+\\x5044\xE75A\
+\\x5045\x8D53\
+\\x5046\x954F\
+\\x5047\x898D\
+\\x5048\xE2A8\
+\\x5049\x95CE\
+\\x504A\x965E\
+\\x504B\x8991\
+\\x504C\x88C6\
+\\x504D\xE0F6\
+\\x504E\x9478\
+\\x504F\x9750\
+\\x5050\x9365\
+\\x5051\x8BBA\
+\\x5052\x8D78\
+\\x5053\x89F2\
+\\x5054\x968F\
+\\x5055\xE05F\
+\\x5056\x8D9A\
+\\x5057\x967E\
+\\x5058\x8B52\
+\\x5059\x8B55\
+\\x505A\x8A75\
+\\x505B\x92EC\
+\\x505C\x94A2\
+\\x505D\x95D5\
+\\x505E\x94C4\
+\\x505F\x9194\
+\\x5060\x9547\
+\\x5061\x8CCD\
+\\x5062\x9158\
+\\x5063\x9251\
+\\x5064\x9665\
+\\x5065\x8EFA\
+\\x5066\x94C7\
+\\x5067\x9864\
+\\x5068\x9076\
+\\x5069\x97EB\
+\\x506A\x8EAC\
+\\x506B\xE5F5\
+\\x506C\x9760\
+\\x506D\x8D69\
+\\x506E\x8E53\
+\\x506F\x9854\
+\\x5070\x918E\
+\\x5071\x939F\
+\\x5072\x8F73\
+\\x5073\x95F0\
+\\x5074\x8A52\
+\\x5075\x9676\
+\\x5076\x9156\
+\\x5077\x9AE2\
+\\x5078\x8983\
+\\x5079\x96AC\
+\\x507A\x8BE1\
+\\x507B\x935C\
+\\x507C\x974A\
+\\x507D\x90D7\
+\\x507E\x9447\
+\\x507F\x8FDD\
+\\x5080\x96D3\
+\\x5081\x91D3\
+\\x5082\x8F82\
+\\x5083\x9775\
+\\x5084\x8ACA\
+\\x5085\x8B77\
+\\x5086\x90A4\
+\\x5087\x9542\
+\\x5088\x9648\
+\\x5089\x9273\
+\\x508A\x8E66\
+\\x508B\x8D59\
+\\x508C\x97DA\
+\\x508D\x8C9D\
+\\x508E\x9499\
+\\x508F\x9489\
+\\x5090\x8A49\
+\\x5091\x89F7\
+\\x5092\x91D5\
+\\x5093\x8E62\
+\\x5094\x90E3\
+\\x5095\x96D6\
+\\x5096\x96EA\
+\\x5097\x8AF5\
+\\x5098\x96F9\
+\\x5099\x8947\
+\\x509A\x89B2\
+\\x509B\x88AA\
+\\x509C\x8E50\
+\\x509D\x9545\
+\\x509E\x9093\
+\\x509F\x97E5\
+\\x50A0\x9DEC\
+\\x50A1\x93E9\
+\\x50A2\x8CB6\
+\\x50A3\x8DEF\
+\\x50A4\x8981\
+\\x50A5\x8DB3\
+\\x50A6\x8C41\
+\\x50A7\x8961\
+\\x50A8\x8DB0\
+\\x50A9\x8D8C\
+\\x50AA\x8B87\
+\\x50AB\x88B6\
+\\x50AC\x8FBD\
+\\x50AD\x94E0\
+\\x50AE\x985C\
+\\x50AF\x8DEB\
+\\x50B0\x93DB\
+\\x50B1\x8DF6\
+\\x50B2\xE678\
+\\x50B3\x8F99\
+\\x50B4\x92B5\
+\\x50B5\x8CE2\
+\\x50B6\x9645\
+\\x50B7\x896B\
+\\x50B8\x89B8\
+\\x50B9\x9193\
+\\x50BA\x8EB0\
+\\x50BB\x9280\
+\\x50BC\x9FA9\
+\\x50BD\x978F\
+\\x50BE\x91F7\
+\\x50BF\x96DD\
+\\x50C0\x8A6B\
+\\x50C1\x8F8E\
+\\x50C2\x8FF8\
+\\x50C3\x8BF4\
+\\x50C4\x9852\
+\\x50C5\x95B8\
+\\x50C6\x9799\
+\\x50C7\x97CB\
+\\x50C8\x8B82\
+\\x50C9\x8DE1\
+\\x50CA\x8FFA\
+\\x50CB\x916C\
+\\x50CC\x97EF\
+\\x50CD\x95BE\
+\\x50CE\x8975\
+\\x50CF\x93CA\
+\\x50D0\x88C7\
+\\x50D1\x9148\
+\\x50D2\x91BF\
+\\x50D3\x986C\
+\\x50D4\x8B45\
+\\x50D5\x96A6\
+\\x50D6\x8C85\
+\\x50D7\x956F\
+\\x50D8\x91E2\
+\\x50D9\x88A8\
+\\x50DA\x88B2\
+\\x50DB\x9647\
+\\x50DC\x8D9D\
+\\x50DD\x93EB\
+\\x50DE\x986E\
+\\x50DF\x9376\
+\\x50E0\x9598\
+\\x50E1\x93F3\
+\\x50E2\x88A9\
+\\x50E3\x90F0\
+\\x50E4\x8F8D\
+\\x50E5\xE9F2\
+\\x50E6\x899A\
+\\x50E7\xE268\
+\\x50E8\x9869\
+\\x50E9\x9C41\
+\\x50EA\xE7B2\
+\\x50EB\x8D6D\
+\\x50EC\x9657\
+\\x50ED\x96B5\
+\\x50EE\x958B\
+\\x50EF\x8FD7\
+\\x50F0\x8B80\
+\\x50F1\x93BD\
+\\x50F2\x9075\
+\\x50F3\x8952\
+\\x50F4\x8FF1\
+\\x50F5\x8F96\
+\\x50F6\x94B0\
+\\x50F7\x97AE\
+\\x50F8\x984B\
+\\x50F9\x95EE\
+\\x50FA\x9448\
+\\x50FB\xE8F2\
+\\x50FC\xE748\
+\\x50FD\x8D94\
+\\x50FE\x8A8D\
+\\x5141\x90CB\
+\\x5142\x8EBE\
+\\x5143\x9198\
+\\x5144\x88B8\
+\\x5145\x9389\
+\\x5146\x96E8\
+\\x5147\x88CE\
+\\x5148\x97DD\
+\\x5149\x8F56\
+\\x514A\x9EC4\
+\\x514B\x8D66\
+\\x514C\xE1E8\
+\\x514D\x9BC1\
+\\x514E\x9769\
+\\x514F\x9070\
+\\x5150\x92C4\
+\\x5151\x8ECD\
+\\x5152\x8F8C\
+\\x5153\x92A6\
+\\x5154\x9341\
+\\x5155\x8FC3\
+\\x5156\xE863\
+\\x5157\x95C3\
+\\x5158\x90B5\
+\\x5159\x9556\
+\\x515A\x8D4D\
+\\x515B\xE770\
+\\x515C\x9386\
+\\x515D\x9B9A\
+\\x515E\x92FC\
+\\x515F\x8960\
+\\x5160\x9157\
+\\x5161\x95E8\
+\\x5162\x8A73\
+\\x5163\x8A91\
+\\x5164\x9FBA\
+\\x5165\x9DD7\
+\\x5166\x915C\
+\\x5167\x98B2\
+\\x5168\x9172\
+\\x5169\x90DE\
+\\x516A\x95EC\
+\\x516B\x8E5D\
+\\x516C\xE4D1\
+\\x516D\x8CD4\
+\\x516E\xE3A3\
+\\x516F\x91E7\
+\\x5170\x8CED\
+\\x5171\x9161\
+\\x5172\x94B4\
+\\x5173\xE468\
+\\x5174\x979F\
+\\x5175\x8C65\
+\\x5176\x8DBC\
+\\x5177\x897B\
+\\x5178\x907E\
+\\x5179\x88A6\
+\\x517A\x93DA\
+\\x517B\x94E8\
+\\x517C\xE2CA\
+\\x517D\x8B5C\
+\\x517E\x9575\
+\\x517F\x8F5E\
+\\x5180\x8FD2\
+\\x5181\x97C8\
+\\x5182\x8EA4\
+\\x5183\x9667\
+\\x5184\x9B49\
+\\x5185\x97AB\
+\\x5186\xE78E\
+\\x5187\xE068\
+\\x5188\x8DBA\
+\\x5189\x88D1\
+\\x518A\x9651\
+\\x518B\xE4F8\
+\\x518C\x918C\
+\\x518D\x90FB\
+\\x518E\x9146\
+\\x518F\x9AF5\
+\\x5190\x9458\
+\\x5191\x9586\
+\\x5192\x8B5F\
+\\x5193\x9DE2\
+\\x5194\x8962\
+\\x5195\x92F4\
+\\x5196\x8FEB\
+\\x5197\x9199\
+\\x5198\x8C6B\
+\\x5199\x9655\
+\\x519A\x88F0\
+\\x519B\x97D9\
+\\x519C\x914D\
+\\x519D\x956B\
+\\x519E\x985B\
+\\x519F\x8E82\
+\\x51A0\x8951\
+\\x51A1\x93BC\
+\\x51A2\x94DC\
+\\x51A3\x8EF8\
+\\x51A4\x8AE5\
+\\x51A5\x8AB6\
+\\x51A6\x96DB\
+\\x51A7\xEA74\
+\\x51A8\xE7B5\
+\\x51A9\x8F86\
+\\x51AA\x9343\
+\\x51AB\x94F4\
+\\x51AC\x8A4D\
+\\x51AD\x93E3\
+\\x51AE\x998F\
+\\x51AF\x8D40\
+\\x51B0\x8FCA\
+\\x51B1\x9DC6\
+\\x51B2\x9DED\
+\\x51B3\x8BAC\
+\\x51B4\x8C6C\
+\\x51B5\x896D\
+\\x51B6\x93F8\
+\\x51B7\x9178\
+\\x51B8\x8DB4\
+\\x51B9\xE1E6\
+\\x51BA\x964A\
+\\x51BB\x8BB8\
+\\x51BC\xE2EF\
+\\x51BD\x9AA0\
+\\x51BE\x8A95\
+\\x51BF\xFA5C\
+\\x51C0\x966D\
+\\x51C1\x8972\
+\\x51C2\x9580\
+\\x51C3\x89DA\
+\\x51C4\x9252\
+\\x51C5\x94A5\
+\\x51C6\x8B61\
+\\x51C7\x929F\
+\\x51C8\x9247\
+\\x51C9\xE6E0\
+\\x51CA\xE1C1\
+\\x51CB\xE0DA\
+\\x51CC\x9E44\
+\\x51CD\xE860\
+\\x51CE\x8EEE\
+\\x51CF\x8B88\
+\\x51D0\xE7DD\
+\\x51D1\x9AA8\
+\\x51D2\x9FB7\
+\\x51D3\x9593\
+\\x51D4\x9155\
+\\x51D5\x8BC0\
+\\x51D6\x9786\
+\\x51D7\x976B\
+\\x51D8\x8D70\
+\\x51D9\x93F9\
+\\x51DA\xFA5D\
+\\x51DB\x8CCF\
+\\x51DC\xE8F7\
+\\x51DD\x91E1\
+\\x51DE\xE6E2\
+\\x51DF\x9BDC\
+\\x51E0\x9695\
+\\x51E1\x958F\
+\\x51E2\x98C9\
+\\x51E3\x9CC3\
+\\x51E4\x92F2\
+\\x51E5\x92A2\
+\\x51E6\x8EA7\
+\\x51E7\x8B98\
+\\x51E8\xE2B9\
+\\x51E9\x8CF9\
+\\x51EA\x9DE5\
+\\x51EB\x8D93\
+\\x51EC\x8BA5\
+\\x51ED\x8B66\
+\\x51EE\x8ACE\
+\\x51EF\x90A0\
+\\x51F0\xE9CB\
+\\x51F1\x8DF2\
+\\x51F2\xE2D7\
+\\x51F3\x8E56\
+\\x51F4\x9844\
+\\x51F5\xE256\
+\\x51F6\x967C\
+\\x51F7\xFA5E\
+\\x51F8\x98E6\
+\\x51F9\xEA69\
+\\x51FA\x94AE\
+\\x51FB\x9097\
+\\x51FC\x9B89\
+\\x51FD\x94E5\
+\\x51FE\x8B8A\
+\\x5241\x96F8\
+\\x5242\x8A9C\
+\\x5243\x9DF9\
+\\x5244\x9B86\
+\\x5245\x88B9\
+\\x5246\x92FA\
+\\x5247\x8D6F\
+\\x5248\x8B6D\
+\\x5249\x8EA3\
+\\x524A\x9FE6\
+\\x524B\xFA5F\
+\\x524C\x9050\
+\\x524D\x9176\
+\\x524E\x91FB\
+\\x524F\xE187\
+\\x5250\x97B8\
+\\x5251\x9DE8\
+\\x5252\xE7D6\
+\\x5253\x8D41\
+\\x5254\x896E\
+\\x5255\x8957\
+\\x5256\x9C96\
+\\x5257\x8EE0\
+\\x5258\x9B74\
+\\x5259\x9566\
+\\x525A\x9BA8\
+\\x525B\xE8B4\
+\\x525C\x90D9\
+\\x525D\x936D\
+\\x525E\x94F8\
+\\x525F\x9748\
+\\x5260\x8B73\
+\\x5261\x8D8D\
+\\x5262\x91D0\
+\\x5263\x91D9\
+\\x5264\x8B48\
+\\x5265\x8B62\
+\\x5266\x9A9B\
+\\x5267\x8FD1\
+\\x5268\xE34E\
+\\x5269\xE7E5\
+\\x526A\x9549\
+\\x526B\x97C9\
+\\x526C\x9087\
+\\x526D\xE590\
+\\x526E\x8F85\
+\\x526F\x9142\
+\\x5270\x97FA\
+\\x5271\x88EC\
+\\x5272\xE89E\
+\\x5273\xE396\
+\\x5274\x8BE7\
+\\x5275\x9AE6\
+\\x5276\x9C7B\
+\\x5277\xE8DB\
+\\x5278\xE392\
+\\x5279\x8F6D\
+\\x527A\x8B94\
+\\x527B\xFA60\
+\\x527C\x9EBE\
+\\x527D\x97C4\
+\\x527E\x8FE7\
+\\x527F\x9D98\
+\\x5280\x9466\
+\\x5281\x9BD9\
+\\x5282\x8F44\
+\\x5283\xE7FC\
+\\x5284\x967A\
+\\x5285\x95F9\
+\\x5286\x89D0\
+\\x5287\x8AC6\
+\\x5288\xE3F4\
+\\x5289\x95AD\
+\\x528A\x8A53\
+\\x528B\x9F43\
+\\x528C\x979E\
+\\x528D\x95A9\
+\\x528E\x9DDD\
+\\x528F\x938B\
+\\x5290\x98D4\
+\\x5291\x9E5B\
+\\x5292\xE3E8\
+\\x5293\x986B\
+\\x5294\xFA61\
+\\x5295\x9596\
+\\x5296\x97C5\
+\\x5297\x96DC\
+\\x5298\x8F9A\
+\\x5299\xE1A7\
+\\x529A\x91DA\
+\\x529B\x895C\
+\\x529C\x9C64\
+\\x529D\x976F\
+\\x529E\xFA62\
+\\x529F\x9469\
+\\x52A0\x9773\
+\\x52A1\x9858\
+\\x52A2\x9A6A\
+\\x52A3\x94FA\
+\\x52A4\x8E48\
+\\x52A5\x8EB4\
+\\x52A6\x9498\
+\\x52A7\x935B\
+\\x52A8\x94D2\
+\\x52A9\x9FE4\
+\\x52AA\xE2DC\
+\\x52AB\x8A9F\
+\\x52AC\x9FAB\
+\\x52AD\xE847\
+\\x52AE\x91EB\
+\\x52AF\x9083\
+\\x52B0\xE06C\
+\\x52B1\x88F4\
+\\x52B2\x8BF0\
+\\x52B3\x9480\
+\\x52B4\x9F8A\
+\\x52B5\x8AAB\
+\\x52B6\x9FAA\
+\\x52B7\x8E93\
+\\x52B8\x89C7\
+\\x52B9\x88F7\
+\\x52BA\x984F\
+\\x52BB\x8EDE\
+\\x52BC\x94FB\
+\\x52BD\x8EC1\
+\\x52BE\x9673\
+\\x52BF\x94A1\
+\\x52C0\x8F9B\
+\\x52C1\x9371\
+\\x52C2\xE2FB\
+\\x52C3\x8995\
+\\x52C4\x9074\
+\\x52C5\x9091\
+\\x52C6\x9E91\
+\\x52C7\x97D2\
+\\x52C8\x99C7\
+\\x52C9\x9789\
+\\x52CA\x89DC\
+\\x52CB\x8A40\
+\\x52CC\x8D5B\
+\\x52CD\xE07A\
+\\x52CE\xE8D5\
+\\x52CF\x93A8\
+\\x52D0\x9095\
+\\x52D1\x92CC\
+\\x52D2\x8DEA\
+\\x52D3\x8CE6\
+\\x52D4\x9944\
+\\x52D5\x8D6E\
+\\x52D6\x9C4E\
+\\x52D7\x91DB\
+\\x52D8\xE251\
+\\x52D9\x9541\
+\\x52DA\x8F4A\
+\\x52DB\x9184\
+\\x52DC\x90A6\
+\\x52DD\x9175\
+\\x52DE\x9E7A\
+\\x52DF\x9279\
+\\x52E0\x954A\
+\\x52E1\x8C44\
+\\x52E2\x9E81\
+\\x52E3\x95E7\
+\\x52E4\x94C1\
+\\x52E5\x904A\
+\\x52E6\x949B\
+\\x52E7\x8FE2\
+\\x52E8\xE960\
+\\x52E9\x928F\
+\\x52EA\x92DA\
+\\x52EB\xFA63\
+\\x52EC\x8BA0\
+\\x52ED\x9EB9\
+\\x52EE\x9F4E\
+\\x52EF\x8FAA\
+\\x52F0\xE27D\
+\\x52F1\x8C91\
+\\x52F2\x8982\
+\\x52F3\xEAA1\
+\\x52F4\x9079\
+\\x52F5\x94B3\
+\\x52F6\x8F52\
+\\x52F7\x94D7\
+\\x52F8\x9384\
+\\x52F9\x93E4\
+\\x52FA\x8C90\
+\\x52FB\xE569\
+\\x52FC\xE8EE\
+\\x52FD\xE15D\
+\\x52FE\x924B\
+\\x5341\x98C1\
+\\x5342\xEA47\
+\\x5343\x8CF4\
+\\x5344\x97BD\
+\\x5345\x9D61\
+\\x5346\x94CE\
+\\x5347\x9049\
+\\x5348\x9451\
+\\x5349\xE5E8\
+\\x534A\x9674\
+\\x534B\x8B6A\
+\\x534C\x915E\
+\\x534D\x92F3\
+\\x534E\xE2AB\
+\\x534F\x9E54\
+\\x5350\xE1DE\
+\\x5351\xE579\
+\\x5352\x96EF\
+\\x5353\x8BEB\
+\\x5354\x8DD2\
+\\x5355\x98AC\
+\\x5356\x8A56\
+\\x5357\xE085\
+\\x5358\xE46F\
+\\x5359\x8DAB\
+\\x535A\xE6D1\
+\\x535B\x914A\
+\\x535C\x93D2\
+\\x535D\x89DE\
+\\x535E\x90D2\
+\\x535F\x945E\
+\\x5360\xE658\
+\\x5361\x9E80\
+\\x5362\x9F4A\
+\\x5363\x95DD\
+\\x5364\x88C5\
+\\x5365\xE24C\
+\\x5366\xE266\
+\\x5367\x8958\
+\\x5368\x90D6\
+\\x5369\x8CA5\
+\\x536A\xE25A\
+\\x536B\x8CCA\
+\\x536C\x9C40\
+\\x536D\x8ABA\
+\\x536E\xE84D\
+\\x536F\x8F58\
+\\x5370\x9EAD\
+\\x5371\x91CD\
+\\x5372\x90EF\
+\\x5373\x8C71\
+\\x5374\xE356\
+\\x5375\x90B1\
+\\x5376\x9FEE\
+\\x5377\x89D5\
+\\x5378\x90C1\
+\\x5379\x92E4\
+\\x537A\xE75B\
+\\x537B\xE7B0\
+\\x537C\xE0A3\
+\\x537D\x94EA\
+\\x537E\x95C8\
+\\x537F\x9369\
+\\x5380\x8D8A\
+\\x5381\xE695\
+\\x5382\x8E88\
+\\x5383\x91ED\
+\\x5384\x8A86\
+\\x5385\x8BAE\
+\\x5386\xFA64\
+\\x5387\x92F0\
+\\x5388\x91F6\
+\\x5389\xE9B0\
+\\x538A\x89E7\
+\\x538B\x9294\
+\\x538C\xE07E\
+\\x538D\x9ED0\
+\\x538E\x8D51\
+\\x538F\x8A62\
+\\x5390\x908D\
+\\x5391\x8DF8\
+\\x5392\x99A6\
+\\x5393\xE7E6\
+\\x5394\xFA65\
+\\x5395\x8B57\
+\\x5396\xE1A8\
+\\x5397\xFA66\
+\\x5398\x9AAE\
+\\x5399\x8E58\
+\\x539A\xE1A1\
+\\x539B\x8FBE\
+\\x539C\xE39C\
+\\x539D\x8AE6\
+\\x539E\x93F6\
+\\x539F\x95BB\
+\\x53A0\x91A8\
+\\x53A1\x96A8\
+\\x53A2\x89FB\
+\\x53A3\x9CAA\
+\\x53A4\x8F7D\
+\\x53A5\x94D8\
+\\x53A6\x8DA3\
+\\x53A7\x9AC4\
+\\x53A8\x8FD4\
+\\x53A9\x8EDD\
+\\x53AA\x96FC\
+\\x53AB\x9570\
+\\x53AC\x8CBD\
+\\x53AD\x94DA\
+\\x53AE\x96DE\
+\\x53AF\x8FA8\
+\\x53B0\x91C2\
+\\x53B1\x90C0\
+\\x53B2\x9ED6\
+\\x53B3\x8C74\
+\\x53B4\xEA6E\
+\\x53B5\xE8D4\
+\\x53B6\xE3E6\
+\\x53B7\x897D\
+\\x53B8\x8DA6\
+\\x53B9\x958E\
+\\x53BA\x9475\
+\\x53BB\x9EE0\
+\\x53BC\x9E8B\
+\\x53BD\x8FDF\
+\\x53BE\x89ED\
+\\x53BF\x8DD1\
+\\x53C0\x90EB\
+\\x53C1\x8DC7\
+\\x53C2\x93B2\
+\\x53C3\x8C84\
+\\x53C4\x98D6\
+\\x53C5\xE487\
+\\x53C6\x9690\
+\\x53C7\xFA67\
+\\x53C8\x96FA\
+\\x53C9\x96AE\
+\\x53CA\x97FC\
+\\x53CB\x8D4A\
+\\x53CC\x8A71\
+\\x53CD\x9AB9\
+\\x53CE\x8B51\
+\\x53CF\x95DE\
+\\x53D0\x93C3\
+\\x53D1\x9764\
+\\x53D2\x8C56\
+\\x53D3\x92DD\
+\\x53D4\x9370\
+\\x53D5\x8A8F\
+\\x53D6\xE8D3\
+\\x53D7\x94F9\
+\\x53D8\x9260\
+\\x53D9\x8F59\
+\\x53DA\x91CB\
+\\x53DB\x8C54\
+\\x53DC\xE3CB\
+\\x53DD\x9751\
+\\x53DE\x8E54\
+\\x53DF\x9352\
+\\x53E0\x8EB9\
+\\x53E1\x9669\
+\\x53E2\x8BA8\
+\\x53E3\x8CF2\
+\\x53E4\x9857\
+\\x53E5\x95AB\
+\\x53E6\xE150\
+\\x53E7\xE298\
+\\x53E8\x90E4\
+\\x53E9\x8A50\
+\\x53EA\x9FF3\
+\\x53EB\x9460\
+\\x53EC\x9697\
+\\x53ED\xE561\
+\\x53EE\x898B\
+\\x53EF\x9EB8\
+\\x53F0\x9564\
+\\x53F1\x8CE8\
+\\x53F2\x8CC6\
+\\x53F3\x9258\
+\\x53F4\x977C\
+\\x53F5\x9170\
+\\x53F6\xE4AA\
+\\x53F7\xE1B8\
+\\x53F8\x8FD3\
+\\x53F9\x8F92\
+\\x53FA\x9EA7\
+\\x53FB\x936A\
+\\x53FC\x89E5\
+\\x53FD\x8DAD\
+\\x53FE\x8F51\
+\\x5441\x8A89\
+\\x5442\x946D\
+\\x5443\x9BA0\
+\\x5444\x9855\
+\\x5445\x8A93\
+\\x5446\x92D7\
+\\x5447\x8AE0\
+\\x5448\x88BF\
+\\x5449\x964E\
+\\x544A\x97E0\
+\\x544B\x9C4F\
+\\x544C\x916B\
+\\x544D\x97A1\
+\\x544E\x944B\
+\\x544F\x95B0\
+\\x5450\x978C\
+\\x5451\x8DE6\
+\\x5452\x955A\
+\\x5453\x97D4\
+\\x5454\x96B9\
+\\x5455\x91BB\
+\\x5456\xE8F1\
+\\x5457\x8DFA\
+\\x5458\x8ED5\
+\\x5459\x89A3\
+\\x545A\x9064\
+\\x545B\x9871\
+\\x545C\x8EB1\
+\\x545D\x9E8D\
+\\x545E\x8A8C\
+\\x545F\x895B\
+\\x5460\x9CFA\
+\\x5461\x89BE\
+\\x5462\x8CF1\
+\\x5463\x89D1\
+\\x5464\x89A8\
+\\x5465\x8E65\
+\\x5466\x8D43\
+\\x5467\x96BB\
+\\x5468\x986F\
+\\x5469\x8EBB\
+\\x546A\x8EDC\
+\\x546B\x8F76\
+\\x546C\x89A6\
+\\x546D\x8A5A\
+\\x546E\x9568\
+\\x546F\x8EF2\
+\\x5470\x8ED9\
+\\x5471\x8CD0\
+\\x5472\x8EE4\
+\\x5473\x8B84\
+\\x5474\x89B0\
+\\x5475\x8A85\
+\\x5476\x9ED2\
+\\x5477\xE8B3\
+\\x5478\x91C1\
+\\x5479\xE3DA\
+\\x547A\x89D6\
+\\x547B\xE4A2\
+\\x547C\x9A4D\
+\\x547D\x8A9A\
+\\x547E\x9248\
+\\x547F\x9A7B\
+\\x5480\x9E59\
+\\x5481\x948D\
+\\x5482\x88DE\
+\\x5483\x9BEE\
+\\x5484\xE2A6\
+\\x5485\xE79C\
+\\x5486\xE4B4\
+\\x5487\x9256\
+\\x5488\x8DA4\
+\\x5489\x88C2\
+\\x548A\x8CA1\
+\\x548B\x95DA\
+\\x548C\x9EC5\
+\\x548D\x8EF4\
+\\x548E\x8A7B\
+\\x548F\x8DC1\
+\\x5490\x90F7\
+\\x5491\x9599\
+\\x5492\x95B3\
+\\x5493\x8C9E\
+\\x5494\x9EA8\
+\\x5495\x8D99\
+\\x5496\xE541\
+\\x5497\x934D\
+\\x5498\x8FA9\
+\\x5499\x8DF3\
+\\x549A\x8955\
+\\x549B\x8D7D\
+\\x549C\x88B7\
+\\x549D\x8D9B\
+\\x549E\x93E2\
+\\x549F\x95D8\
+\\x54A0\x94CF\
+\\x54A1\x9186\
+\\x54A2\x9EB5\
+\\x54A3\x917E\
+\\x54A4\x9189\
+\\x54A5\x8CC1\
+\\x54A6\x925D\
+\\x54A7\x93CC\
+\\x54A8\xE4EF\
+\\x54A9\xE792\
+\\x54AA\x92D5\
+\\x54AB\x8956\
+\\x54AC\x95A4\
+\\x54AD\x8A66\
+\\x54AE\xE47A\
+\\x54AF\x8BDD\
+\\x54B0\x9297\
+\\x54B1\x9675\
+\\x54B2\x8BFB\
+\\x54B3\x949C\
+\\x54B4\x8DD4\
+\\x54B5\xE260\
+\\x54B6\x8ACB\
+\\x54B7\x95AF\
+\\x54B8\x91C4\
+\\x54B9\x915A\
+\\x54BA\x8AC0\
+\\x54BB\xE091\
+\\x54BC\xE94D\
+\\x54BD\x96D7\
+\\x54BE\x9BE7\
+\\x54BF\x984D\
+\\x54C0\x9450\
+\\x54C1\x8EDB\
+\\x54C2\x9EA5\
+\\x54C3\x8E4E\
+\\x54C4\x93CE\
+\\x54C5\xE5DC\
+\\x54C6\x8D85\
+\\x54C7\x89E2\
+\\x54C8\x98A5\
+\\x54C9\x9E6B\
+\\x54CA\x925C\
+\\x54CB\xE3A1\
+\\x54CC\x8C8D\
+\\x54CD\x92CD\
+\\x54CE\x8E57\
+\\x54CF\x8BD2\
+\\x54D0\x8D97\
+\\x54D1\x95C1\
+\\x54D2\x8EC3\
+\\x54D3\xE359\
+\\x54D4\x88A0\
+\\x54D5\xE2A0\
+\\x54D6\x9482\
+\\x54D7\x9F97\
+\\x54D8\xE4CB\
+\\x54D9\x8C81\
+\\x54DA\x9762\
+\\x54DB\x91C7\
+\\x54DC\x9277\
+\\x54DD\x8F67\
+\\x54DE\x8985\
+\\x54DF\x9E60\
+\\x54E0\x97F8\
+\\x54E1\x905D\
+\\x54E2\x9EB3\
+\\x54E3\x9986\
+\\x54E4\xE3CF\
+\\x54E5\x8979\
+\\x54E6\x9043\
+\\x54E7\x9AA2\
+\\x54E8\x8DA8\
+\\x54E9\xE4BF\
+\\x54EA\x9481\
+\\x54EB\xE358\
+\\x54EC\x8FA6\
+\\x54ED\xE357\
+\\x54EE\x9351\
+\\x54EF\x908E\
+\\x54F0\x93A0\
+\\x54F1\x9BBC\
+\\x54F2\x9E62\
+\\x54F3\x9E6F\
+\\x54F4\xE5AF\
+\\x54F5\xE258\
+\\x54F6\x9367\
+\\x54F7\x93B8\
+\\x54F8\x93D9\
+\\x54F9\xE3C4\
+\\x54FA\x94AC\
+\\x54FB\x8C77\
+\\x54FC\xE9EC\
+\\x54FD\x9E4B\
+\\x54FE\x92C8\
+\\x5541\x8B64\
+\\x5542\x8BAF\
+\\x5543\x9346\
+\\x5544\x9C9B\
+\\x5545\x97EA\
+\\x5546\x92BB\
+\\x5547\x9592\
+\\x5548\x8F55\
+\\x5549\x9397\
+\\x554A\x9C9C\
+\\x554B\x89EC\
+\\x554C\x97D8\
+\\x554D\x96CF\
+\\x554E\x88FA\
+\\x554F\x95F7\
+\\x5550\x93C0\
+\\x5551\xE9CE\
+\\x5552\x9AD4\
+\\x5553\x9398\
+\\x5554\x96E3\
+\\x5555\x917D\
+\\x5556\x929E\
+\\x5557\x94D0\
+\\x5558\x929D\
+\\x5559\x97E8\
+\\x555A\x8BA2\
+\\x555B\x97F7\
+\\x555C\xE250\
+\\x555D\x8BD7\
+\\x555E\x93F0\
+\\x555F\x96CB\
+\\x5560\x924C\
+\\x5561\x9096\
+\\x5562\x8FB1\
+\\x5563\x8CBC\
+\\x5564\x9455\
+\\x5565\x8BBC\
+\\x5566\xE6CB\
+\\x5567\x9284\
+\\x5568\x8FA3\
+\\x5569\x95ED\
+\\x556A\x8A4E\
+\\x556B\x96C9\
+\\x556C\x95CC\
+\\x556D\x8A41\
+\\x556E\x94C3\
+\\x556F\x9476\
+\\x5570\x92B3\
+\\x5571\x8A82\
+\\x5572\x95CB\
+\\x5573\x88E0\
+\\x5574\xE6D2\
+\\x5575\x9FF2\
+\\x5576\x896F\
+\\x5577\x8943\
+\\x5578\x95C6\
+\\x5579\x946C\
+\\x557A\x88A1\
+\\x557B\x96A0\
+\\x557C\x97B5\
+\\x557D\x8E4A\
+\\x557E\x96B7\
+\\x557F\x985D\
+\\x5580\x9999\
+\\x5581\x88B4\
+\\x5582\x94B6\
+\\x5583\x9385\
+\\x5584\x8AE4\
+\\x5585\x8FBF\
+\\x5586\x9845\
+\\x5587\x9642\
+\\x5588\x8BF1\
+\\x5589\x9362\
+\\x558A\x91FA\
+\\x558B\x8AE3\
+\\x558C\x96C3\
+\\x558D\x94DD\
+\\x558E\x9863\
+\\x558F\x88D8\
+\\x5590\x90F8\
+\\x5591\x9291\
+\\x5592\x92DB\
+\\x5593\x955E\
+\\x5594\x89F8\
+\\x5595\x90CA\
+\\x5596\x9141\
+\\x5597\x926F\
+\\x5598\x93D7\
+\\x5599\x89E9\
+\\x559A\x954C\
+\\x559B\x95CD\
+\\x559C\x8A5B\
+\\x559D\x9686\
+\\x559E\x894D\
+\\x559F\x97A8\
+\\x55A0\xE046\
+\\x55A1\x9554\
+\\x55A2\x9461\
+\\x55A3\x9794\
+\\x55A4\xE2B3\
+\\x55A5\x94EB\
+\\x55A6\x8F53\
+\\x55A7\x92FB\
+\\x55A8\xE370\
+\\x55A9\x93E1\
+\\x55AA\x8B9A\
+\\x55AB\x8CBF\
+\\x55AC\x954E\
+\\x55AD\x8BA1\
+\\x55AE\x8B6F\
+\\x55AF\x955F\
+\\x55B0\x9160\
+\\x55B1\x8BB2\
+\\x55B2\x94BE\
+\\x55B3\x8E60\
+\\x55B4\x8DAF\
+\\x55B5\x8D89\
+\\x55B6\x8ABB\
+\\x55B7\x96C4\
+\\x55B8\x925E\
+\\x55B9\x8D88\
+\\x55BA\x8E72\
+\\x55BB\x8A5E\
+\\x55BC\x8944\
+\\x55BD\xE5A2\
+\\x55BE\x9565\
+\\x55BF\x8CD8\
+\\x55C0\x8EC6\
+\\x55C1\x935E\
+\\x55C2\x94B8\
+\\x55C3\x9486\
+\\x55C4\x9853\
+\\x55C5\x91C8\
+\\x55C6\x9F99\
+\\x55C7\x9850\
+\\x55C8\x88F1\
+\\x55C9\x948A\
+\\x55CA\x96C7\
+\\x55CB\x8CD7\
+\\x55CC\x8A5C\
+\\x55CD\x91C6\
+\\x55CE\x968E\
+\\x55CF\x9CDD\
+\\x55D0\x8986\
+\\x55D1\x956D\
+\\x55D2\x8E4B\
+\\x55D3\x9374\
+\\x55D4\x93C9\
+\\x55D5\x91EF\
+\\x55D6\x8A63\
+\\x55D7\x8999\
+\\x55D8\x8A64\
+\\x55D9\x9780\
+\\x55DA\x90F1\
+\\x55DB\x93B3\
+\\x55DC\x8DB1\
+\\x55DD\x92AB\
+\\x55DE\x8AAD\
+\\x55DF\x8949\
+\\x55E0\x8B4A\
+\\x55E1\x9391\
+\\x55E2\x8F93\
+\\x55E3\x91C0\
+\\x55E4\x909C\
+\\x55E5\x949D\
+\\x55E6\x97A9\
+\\x55E7\x8BCC\
+\\x55E8\x8964\
+\\x55E9\x92AF\
+\\x55EA\x8B68\
+\\x55EB\x8E5B\
+\\x55EC\x90C6\
+\\x55ED\x94D9\
+\\x55EE\x8CE7\
+\\x55EF\x8C72\
+\\x55F0\x9689\
+\\x55F1\x93D3\
+\\x55F2\x94EE\
+\\x55F3\x92BD\
+\\x55F4\x8BF5\
+\\x55F5\x96CC\
+\\x55F6\x8FEF\
+\\x55F7\x8954\
+\\x55F8\x9847\
+\\x55F9\x929C\
+\\x55FA\x935A\
+\\x5641\x989F\
+\\x5642\x98A0\
+\\x5643\x98A1\
+\\x5644\xFA68\
+\\x5645\x98A2\
+\\x5646\x98A3\
+\\x5647\x98A4\
+\\x5648\x98A6\
+\\x5649\x98A7\
+\\x564A\x98A8\
+\\x564B\x98A9\
+\\x564C\x9BA4\
+\\x564D\x98AA\
+\\x564E\x98AB\
+\\x564F\x98AD\
+\\x5650\x98B0\
+\\x5651\x98AF\
+\\x5652\x98B1\
+\\x5653\x98B3\
+\\x5654\x98B4\
+\\x5655\x98B5\
+\\x5656\x98B6\
+\\x5657\x98B7\
+\\x5658\x98B8\
+\\x5659\x98B9\
+\\x565A\x98BA\
+\\x565B\x98BB\
+\\x565C\x98BC\
+\\x565D\xFA69\
+\\x565E\x98BD\
+\\x565F\x98BE\
+\\x5660\x98BF\
+\\x5661\x98C0\
+\\x5662\xFA6A\
+\\x5663\x98C2\
+\\x5664\x98E5\
+\\x5665\xFA6B\
+\\x5666\xFA6C\
+\\x5667\x98C3\
+\\x5668\x98C4\
+\\x5669\x98C6\
+\\x566A\xFA6D\
+\\x566B\x98C7\
+\\x566C\x98C8\
+\\x566D\x9B43\
+\\x566E\xFA6E\
+\\x566F\x98C5\
+\\x5670\xFA6F\
+\\x5671\xFA70\
+\\x5672\x98CA\
+\\x5673\x98CB\
+\\x5674\xFA71\
+\\x5675\x9699\
+\\x5676\x98CC\
+\\x5677\x98CD\
+\\x5678\x9B44\
+\\x5679\x98CE\
+\\x567A\x98CF\
+\\x567B\xFA72\
+\\x567C\x98D1\
+\\x567D\x98D2\
+\\x567E\x98D3\
+\\x567F\x98D5\
+\\x5680\x98D7\
+\\x5681\x98D8\
+\\x5682\x98D9\
+\\x5683\x98DA\
+\\x5684\x98DB\
+\\x5685\x98DC\
+\\x5686\xFA73\
+\\x5687\x98DD\
+\\x5688\x98DE\
+\\x5689\x98DF\
+\\x568A\xFA74\
+\\x568B\x98E0\
+\\x568C\x98E1\
+\\x568D\x98E2\
+\\x568E\x98E3\
+\\x568F\x98E4\
+\\x5690\x98E7\
+\\x5691\xFA75\
+\\x5692\x98E8\
+\\x5693\x98E9\
+\\x5694\xFA76\
+\\x5695\x98EA\
+\\x5696\x98EB\
+\\x5697\x98EC\
+\\x5698\xFA77\
+\\x5699\x98ED\
+\\x569A\x98EE\
+\\x569B\x98EF\
+\\x569C\x98F1\
+\\x569D\x98F2\
+\\x569E\x98F3\
+\\x569F\x98F4\
+\\x56A0\x98F5\
+\\x56A1\xE0C5\
+\\x56A2\xFA78\
+\\x56A3\xFA79\
+\\x56A4\xFA7A\
+\\x56A5\x98F6\
+\\x56A6\x98F7\
+\\x56A7\x98F8\
+\\x56A8\xFA7B\
+\\x56A9\x98F9\
+\\x56AA\x98FA\
+\\x56AB\x98FB\
+\\x56AC\x98F0\
+\\x56AD\x98FC\
+\\x56AE\x9940\
+\\x56AF\x9941\
+\\x56B0\x9942\
+\\x56B1\x9943\
+\\x56B2\xFA7C\
+\\x56B3\x9945\
+\\x56B4\x9946\
+\\x56B5\xFA7D\
+\\x56B6\x9947\
+\\x56B7\x9948\
+\\x56B8\x9949\
+\\x56B9\x994A\
+\\x56BA\x994B\
+\\x56BB\x994C\
+\\x56BC\x994D\
+\\x56BD\x994E\
+\\x56BE\x9952\
+\\x56BF\x9950\
+\\x56C0\x9951\
+\\x56C1\x994F\
+\\x56C2\x9953\
+\\x56C3\x9954\
+\\x56C4\x9955\
+\\x56C5\x9956\
+\\x56C6\x9957\
+\\x56C7\x9958\
+\\x56C8\x9959\
+\\x56C9\xFA7E\
+\\x56CA\x995B\
+\\x56CB\x995A\
+\\x56CC\x995C\
+\\x56CD\x995D\
+\\x56CE\xFA80\
+\\x56CF\x995F\
+\\x56D0\x9960\
+\\x56D1\x9961\
+\\x56D2\x9962\
+\\x56D3\x9963\
+\\x56D4\x9964\
+\\x56D5\x9965\
+\\x56D6\x9966\
+\\x56D7\x9967\
+\\x56D8\x9968\
+\\x56D9\x9969\
+\\x56DA\x996A\
+\\x56DB\x996B\
+\\x56DC\xFA81\
+\\x56DD\x996C\
+\\x56DE\x996D\
+\\x56DF\x996E\
+\\x56E0\x996F\
+\\x56E1\x9970\
+\\x56E2\x9971\
+\\x56E3\x9972\
+\\x56E4\x9973\
+\\x56E5\x9974\
+\\x56E6\x9975\
+\\x56E7\x9976\
+\\x56E8\xFA82\
+\\x56E9\x9977\
+\\x56EA\x9978\
+\\x56EB\x9979\
+\\x56EC\x997A\
+\\x56ED\x997B\
+\\x56EE\x997D\
+\\x56EF\xFA83\
+\\x56F0\x997E\
+\\x56F1\x9980\
+\\x56F2\x9981\
+\\x56F3\x9982\
+\\x56F4\x9983\
+\\x56F5\x9984\
+\\x56F6\x9985\
+\\x56F7\xFA84\
+\\x56F8\x9987\
+\\x56F9\x9988\
+\\x56FA\x9989\
+\\x56FB\x998A\
+\\x56FC\x998B\
+\\x56FD\x998D\
+\\x56FE\x998E\
+\\x5741\x998C\
+\\x5742\x9990\
+\\x5743\x9991\
+\\x5744\x999B\
+\\x5745\x9992\
+\\x5746\x9995\
+\\x5747\x9993\
+\\x5748\x9994\
+\\x5749\x9996\
+\\x574A\x9997\
+\\x574B\x9998\
+\\x574C\x999C\
+\\x574D\x999A\
+\\x574E\x999D\
+\\x574F\xFA85\
+\\x5750\xFA86\
+\\x5751\x99A0\
+\\x5752\x99A1\
+\\x5753\x99A2\
+\\x5754\x99A3\
+\\x5755\x99A4\
+\\x5756\xFA87\
+\\x5757\x99A5\
+\\x5758\xFA88\
+\\x5759\x99A7\
+\\x575A\x99A8\
+\\x575B\x99A9\
+\\x575C\x99AB\
+\\x575D\x99AC\
+\\x575E\x99AD\
+\\x575F\x99AE\
+\\x5760\x99AF\
+\\x5761\xFA89\
+\\x5762\x99B0\
+\\x5763\xFA8A\
+\\x5764\x99B1\
+\\x5765\x99B2\
+\\x5766\x99B3\
+\\x5767\x99B4\
+\\x5768\x99B5\
+\\x5769\x99B6\
+\\x576A\x99B7\
+\\x576B\xFA8B\
+\\x576C\x99B8\
+\\x576D\x99B9\
+\\x576E\x99BA\
+\\x576F\x99BB\
+\\x5770\x99BC\
+\\x5771\x99BD\
+\\x5772\x99BF\
+\\x5773\x99BE\
+\\x5774\x99C1\
+\\x5775\x99C0\
+\\x5776\x99C2\
+\\x5777\x99C3\
+\\x5778\x9DA8\
+\\x5779\x99C4\
+\\x577A\x99C5\
+\\x577B\x99C6\
+\\x577C\xFA8C\
+\\x577D\x99C9\
+\\x577E\x99C8\
+\\x577F\x99CA\
+\\x5780\xFA8D\
+\\x5781\x99CB\
+\\x5782\x99CC\
+\\x5783\x99CD\
+\\x5784\x99CE\
+\\x5785\x99CF\
+\\x5786\x99D0\
+\\x5787\xFA8E\
+\\x5788\x99D1\
+\\x5789\x99D2\
+\\x578A\x99D3\
+\\x578B\xFA8F\
+\\x578C\x99D5\
+\\x578D\x99D6\
+\\x578E\xFA90\
+\\x578F\x99D7\
+\\x5790\x99D8\
+\\x5791\x99D9\
+\\x5792\x99DA\
+\\x5793\x99DB\
+\\x5794\x99DC\
+\\x5795\x99DD\
+\\x5796\x99DE\
+\\x5797\x99DF\
+\\x5798\x99E0\
+\\x5799\x99E1\
+\\x579A\x99E2\
+\\x579B\x99E3\
+\\x579C\x99E4\
+\\x579D\x99E5\
+\\x579E\x99E6\
+\\x579F\x99E7\
+\\x57A0\x99E8\
+\\x57A1\x99E9\
+\\x57A2\x99EA\
+\\x57A3\x99EB\
+\\x57A4\x99EC\
+\\x57A5\x99ED\
+\\x57A6\x99EE\
+\\x57A7\x99EF\
+\\x57A8\x99F0\
+\\x57A9\xFA91\
+\\x57AA\x99F1\
+\\x57AB\x99F2\
+\\x57AC\x99F3\
+\\x57AD\x99F4\
+\\x57AE\xFA92\
+\\x57AF\x99F5\
+\\x57B0\x9A44\
+\\x57B1\x9A5D\
+\\x57B2\x99F6\
+\\x57B3\x99F7\
+\\x57B4\x99F8\
+\\x57B5\x99F9\
+\\x57B6\x99FA\
+\\x57B7\x9A45\
+\\x57B8\x99FB\
+\\x57B9\x99FC\
+\\x57BA\x9A40\
+\\x57BB\x9A41\
+\\x57BC\x9A42\
+\\x57BD\xFA93\
+\\x57BE\x9A43\
+\\x57BF\x9A46\
+\\x57C0\xFA94\
+\\x57C1\x9A47\
+\\x57C2\x9A48\
+\\x57C3\x9A49\
+\\x57C4\x9A4A\
+\\x57C5\x9A4B\
+\\x57C6\x9A4C\
+\\x57C7\x9A4E\
+\\x57C8\x9A4F\
+\\x57C9\x9A50\
+\\x57CA\x9A51\
+\\x57CB\x9A52\
+\\x57CC\x9A53\
+\\x57CD\x9A54\
+\\x57CE\x9A55\
+\\x57CF\x9A56\
+\\x57D0\x9A57\
+\\x57D1\x9A58\
+\\x57D2\x9A59\
+\\x57D3\x9A5A\
+\\x57D4\x9A5B\
+\\x57D5\x9A5C\
+\\x57D6\x9A5E\
+\\x57D7\x9A5F\
+\\x57D8\x9A60\
+\\x57D9\x9A61\
+\\x57DA\x9A62\
+\\x57DB\x9A63\
+\\x57DC\x9A64\
+\\x57DD\x9A65\
+\\x57DE\xFA95\
+\\x57DF\x9A66\
+\\x57E0\x9A67\
+\\x57E1\x9A68\
+\\x57E2\x9A69\
+\\x57E3\x9A6B\
+\\x57E4\x9A6C\
+\\x57E5\x9A6D\
+\\x57E6\x9A6E\
+\\x57E7\x9A6F\
+\\x57E8\x9A70\
+\\x57E9\x9A77\
+\\x57EA\x9A71\
+\\x57EB\x9A72\
+\\x57EC\x9A73\
+\\x57ED\x9A74\
+\\x57EE\x9A75\
+\\x57EF\x9A76\
+\\x57F0\x9A78\
+\\x57F1\x9A79\
+\\x57F2\x9A7C\
+\\x57F3\x9A7D\
+\\x57F4\x9A7E\
+\\x57F5\x9A80\
+\\x57F6\x9A81\
+\\x57F7\x9A85\
+\\x57F8\x9A82\
+\\x57F9\x9A83\
+\\x57FA\x9A84\
+\\x57FB\x9A7A\
+\\x57FC\x9A89\
+\\x57FD\x9A8A\
+\\x57FE\x9A86\
+\\x5841\x9A87\
+\\x5842\x9A88\
+\\x5843\x9A8B\
+\\x5844\x9A8C\
+\\x5845\x9A8D\
+\\x5846\x9A8E\
+\\x5847\x9A94\
+\\x5848\x9A8F\
+\\x5849\x9A90\
+\\x584A\x9A91\
+\\x584B\x9A92\
+\\x584C\x9A93\
+\\x584D\x9A95\
+\\x584E\x9A97\
+\\x584F\x9A96\
+\\x5850\x9A98\
+\\x5851\x9A99\
+\\x5852\x9A9A\
+\\x5853\x9A9C\
+\\x5854\x9A9D\
+\\x5855\x9A9E\
+\\x5856\x9A9F\
+\\x5857\x9AA1\
+\\x5858\x9AA5\
+\\x5859\x9AA3\
+\\x585A\x9AA4\
+\\x585B\x9AA6\
+\\x585C\x9AA7\
+\\x585D\x9AA9\
+\\x585E\x9AAA\
+\\x585F\x9AAB\
+\\x5860\xFA96\
+\\x5861\x9AAC\
+\\x5862\x9AAD\
+\\x5863\xFA97\
+\\x5864\x9AB0\
+\\x5865\x9AB1\
+\\x5866\x9AB2\
+\\x5867\x9AB3\
+\\x5868\x9AB4\
+\\x5869\x9AB5\
+\\x586A\x9AB7\
+\\x586B\x9AB6\
+\\x586C\xFA98\
+\\x586D\x9AB8\
+\\x586E\x9ABA\
+\\x586F\x9ABB\
+\\x5870\xFA99\
+\\x5871\x9AAF\
+\\x5872\x9ABC\
+\\x5873\xFA9A\
+\\x5874\x9ABD\
+\\x5875\x9ABE\
+\\x5876\x9AC0\
+\\x5877\xFA9B\
+\\x5878\x9ABF\
+\\x5879\x9AC1\
+\\x587A\x9AC2\
+\\x587B\x9AC3\
+\\x587C\x9AC6\
+\\x587D\x9AC8\
+\\x587E\x9AC7\
+\\x587F\x9ACA\
+\\x5880\x9ACC\
+\\x5881\x9ACB\
+\\x5882\xFA9C\
+\\x5883\x9AC9\
+\\x5884\x9ACD\
+\\x5885\x9ACE\
+\\x5886\x9AC5\
+\\x5887\x9AD0\
+\\x5888\x9AD1\
+\\x5889\x9AD5\
+\\x588A\xFA9D\
+\\x588B\x9AD6\
+\\x588C\xFA9E\
+\\x588D\x9ACF\
+\\x588E\x9AD2\
+\\x588F\x9AD7\
+\\x5890\x9AD8\
+\\x5891\x9AD9\
+\\x5892\x9ADA\
+\\x5893\x9ADB\
+\\x5894\x9ADC\
+\\x5895\x9AD3\
+\\x5896\x9ADE\
+\\x5897\x9AE0\
+\\x5898\x9ADF\
+\\x5899\x9ADD\
+\\x589A\x9AE1\
+\\x589B\x92D9\
+\\x589C\x9AE3\
+\\x589D\x9AE4\
+\\x589E\x9AE5\
+\\x589F\x9AE7\
+\\x58A0\x9AE8\
+\\x58A1\xFA9F\
+\\x58A2\x9AE9\
+\\x58A3\x9AEA\
+\\x58A4\x9AEB\
+\\x58A5\x9AEC\
+\\x58A6\x9AED\
+\\x58A7\x9AEE\
+\\x58A8\x9AEF\
+\\x58A9\x9AF0\
+\\x58AA\x9AF1\
+\\x58AB\x9AF3\
+\\x58AC\x9AF4\
+\\x58AD\xFAA0\
+\\x58AE\x9AF6\
+\\x58AF\x9AF7\
+\\x58B0\xFAA1\
+\\x58B1\xFAA2\
+\\x58B2\xFAA3\
+\\x58B3\x9AF8\
+\\x58B4\x9AF9\
+\\x58B5\x9AFA\
+\\x58B6\x9AFB\
+\\x58B7\x9AFC\
+\\x58B8\x9B40\
+\\x58B9\x9B41\
+\\x58BA\x9B4A\
+\\x58BB\x9BAA\
+\\x58BC\x9B42\
+\\x58BD\x9B45\
+\\x58BE\xFAA4\
+\\x58BF\x9B46\
+\\x58C0\xFAA5\
+\\x58C1\x9B47\
+\\x58C2\x9B48\
+\\x58C3\x9B4B\
+\\x58C4\x9B4C\
+\\x58C5\x9B4D\
+\\x58C6\x9B4E\
+\\x58C7\x9B4F\
+\\x58C8\x9B50\
+\\x58C9\x9B52\
+\\x58CA\x9B51\
+\\x58CB\x9B53\
+\\x58CC\x9B54\
+\\x58CD\x9B55\
+\\x58CE\x9B56\
+\\x58CF\x9B57\
+\\x58D0\x9B58\
+\\x58D1\x9B59\
+\\x58D2\x9B5A\
+\\x58D3\x9B5B\
+\\x58D4\x9B5C\
+\\x58D5\x9B6B\
+\\x58D6\x9B5D\
+\\x58D7\x9B5E\
+\\x58D8\x9B5F\
+\\x58D9\x9B60\
+\\x58DA\x9B61\
+\\x58DB\x9B62\
+\\x58DC\x9B63\
+\\x58DD\x9B64\
+\\x58DE\x9B65\
+\\x58DF\x9B66\
+\\x58E0\x9B67\
+\\x58E1\x9B68\
+\\x58E2\x9B69\
+\\x58E3\x9B6A\
+\\x58E4\x9B6C\
+\\x58E5\x9B6D\
+\\x58E6\x9B6E\
+\\x58E7\x9B6F\
+\\x58E8\x9B70\
+\\x58E9\x9B71\
+\\x58EA\x9B72\
+\\x58EB\x9B73\
+\\x58EC\xFAA6\
+\\x58ED\x9B7C\
+\\x58EE\x9B75\
+\\x58EF\x9B76\
+\\x58F0\x9B77\
+\\x58F1\x9B78\
+\\x58F2\x9B79\
+\\x58F3\x9B7A\
+\\x58F4\x9B7B\
+\\x58F5\x9B7D\
+\\x58F6\x9B7E\
+\\x58F7\x9B80\
+\\x58F8\x9B81\
+\\x58F9\x9B82\
+\\x58FA\x9B83\
+\\x58FB\x9B84\
+\\x58FC\xFAA7\
+\\x58FD\x9B85\
+\\x58FE\xFAA8\
+\\x5941\x9B87\
+\\x5942\xFAA9\
+\\x5943\x9B8B\
+\\x5944\xFAAA\
+\\x5945\x9B88\
+\\x5946\x9B8A\
+\\x5947\x9B8C\
+\\x5948\x9B8D\
+\\x5949\x9B8E\
+\\x594A\x9B90\
+\\x594B\x9B8F\
+\\x594C\x9B91\
+\\x594D\x9B92\
+\\x594E\x9B93\
+\\x594F\x9B94\
+\\x5950\x9B95\
+\\x5951\xFAAB\
+\\x5952\x9B96\
+\\x5953\x9B97\
+\\x5954\x9B98\
+\\x5955\x9B99\
+\\x5956\x9B9B\
+\\x5957\x9B9C\
+\\x5958\x9B9D\
+\\x5959\x9B9E\
+\\x595A\x9B9F\
+\\x595B\x9BA1\
+\\x595C\x9BA2\
+\\x595D\x9BA3\
+\\x595E\x9BA5\
+\\x595F\x9BA6\
+\\x5960\x9BA7\
+\\x5961\x9BA9\
+\\x5962\x9BB1\
+\\x5963\x9BAB\
+\\x5964\x9BAC\
+\\x5965\x9BAD\
+\\x5966\x9BAF\
+\\x5967\xFAAC\
+\\x5968\xFAAD\
+\\x5969\x9BB0\
+\\x596A\x9BAE\
+\\x596B\x9BB2\
+\\x596C\x9BB3\
+\\x596D\x9BB4\
+\\x596E\x9BB5\
+\\x596F\x9BB6\
+\\x5970\xFAAE\
+\\x5971\x9BB7\
+\\x5972\x9BB9\
+\\x5973\x9BBA\
+\\x5974\x9BBB\
+\\x5975\x9BBE\
+\\x5976\x9BBF\
+\\x5977\x9BC0\
+\\x5978\xFAAF\
+\\x5979\x9BC2\
+\\x597A\x9BC3\
+\\x597B\x9BC4\
+\\x597C\x9BC5\
+\\x597D\x9BC6\
+\\x597E\x9BC7\
+\\x597F\xFAB0\
+\\x5980\xFAB1\
+\\x5981\x9BBD\
+\\x5982\x9BC8\
+\\x5983\x9BC9\
+\\x5984\xFAB2\
+\\x5985\x9BCA\
+\\x5986\x9BCB\
+\\x5987\xFAB3\
+\\x5988\x9BCC\
+\\x5989\x9BCD\
+\\x598A\x9BCE\
+\\x598B\x9BCF\
+\\x598C\x9BB8\
+\\x598D\x9BD0\
+\\x598E\x9BD1\
+\\x598F\x9BD5\
+\\x5990\x9BD2\
+\\x5991\x9BD3\
+\\x5992\x9BD6\
+\\x5993\xFAB4\
+\\x5994\x9BD7\
+\\x5995\xFAB5\
+\\x5996\x9BD8\
+\\x5997\xFAB6\
+\\x5998\x9BDA\
+\\x5999\x9BDB\
+\\x599A\x9BDD\
+\\x599B\x9BDE\
+\\x599C\x9BE0\
+\\x599D\x9BE1\
+\\x599E\x9BE2\
+\\x599F\x9BE3\
+\\x59A0\x9BE4\
+\\x59A1\x9BE5\
+\\x59A2\x9BE6\
+\\x59A3\x9BE8\
+\\x59A4\x9BE9\
+\\x59A5\x9BEA\
+\\x59A6\x9BF1\
+\\x59A7\x9BEB\
+\\x59A8\x9BEC\
+\\x59A9\x9BED\
+\\x59AA\x9BEF\
+\\x59AB\x9BF0\
+\\x59AC\x9BF2\
+\\x59AD\x9BF3\
+\\x59AE\x9BF4\
+\\x59AF\x9BF6\
+\\x59B0\x9BF7\
+\\x59B1\x9BF8\
+\\x59B2\x9BF9\
+\\x59B3\x9BFA\
+\\x59B4\x9BFB\
+\\x59B5\x9BFC\
+\\x59B6\x9C42\
+\\x59B7\x9C43\
+\\x59B8\x9C44\
+\\x59B9\x9C45\
+\\x59BA\x9C46\
+\\x59BB\x9C47\
+\\x59BC\x9C48\
+\\x59BD\x9C49\
+\\x59BE\x9C4C\
+\\x59BF\x9C4A\
+\\x59C0\x9C4B\
+\\x59C1\x9C4D\
+\\x59C2\x9C50\
+\\x59C3\x9C51\
+\\x59C4\x9C54\
+\\x59C5\x9C55\
+\\x59C6\x9C56\
+\\x59C7\xFAB7\
+\\x59C8\x9C57\
+\\x59C9\x9C58\
+\\x59CA\x9C5E\
+\\x59CB\xFAB8\
+\\x59CC\x9C59\
+\\x59CD\x9C5A\
+\\x59CE\x9C5B\
+\\x59CF\x9C5C\
+\\x59D0\x9C5D\
+\\x59D1\x9C5F\
+\\x59D2\x9C60\
+\\x59D3\x9C61\
+\\x59D4\x9C62\
+\\x59D5\x9C53\
+\\x59D6\x9C52\
+\\x59D7\x9C63\
+\\x59D8\xFAB9\
+\\x59D9\x9C65\
+\\x59DA\x9C66\
+\\x59DB\x9C67\
+\\x59DC\x9C68\
+\\x59DD\x9C69\
+\\x59DE\x9C6A\
+\\x59DF\x9C6B\
+\\x59E0\x9C6D\
+\\x59E1\x9C6C\
+\\x59E2\x9C6F\
+\\x59E3\x9C6E\
+\\x59E4\x9C70\
+\\x59E5\x9C71\
+\\x59E6\x9C72\
+\\x59E7\x9C73\
+\\x59E8\xFABA\
+\\x59E9\x9C74\
+\\x59EA\x9C75\
+\\x59EB\x9C76\
+\\x59EC\x9C77\
+\\x59ED\x9C78\
+\\x59EE\x9C79\
+\\x59EF\x9CAB\
+\\x59F0\x9C7A\
+\\x59F1\xFABB\
+\\x59F2\x9C7C\
+\\x59F3\x9C7D\
+\\x59F4\x9C80\
+\\x59F5\x9C81\
+\\x59F6\x9C82\
+\\x59F7\x9C83\
+\\x59F8\x9C84\
+\\x59F9\x9C85\
+\\x59FA\x9C86\
+\\x59FB\x9C87\
+\\x59FC\x9C88\
+\\x59FD\x9C89\
+\\x59FE\x9C8A\
+\\x5A41\x9C8B\
+\\x5A42\x9C8C\
+\\x5A43\x9C7E\
+\\x5A44\xFABC\
+\\x5A45\x9C8D\
+\\x5A46\x9C8E\
+\\x5A47\x9C8F\
+\\x5A48\x9C90\
+\\x5A49\x9C91\
+\\x5A4A\x9C92\
+\\x5A4B\x9C93\
+\\x5A4C\x9C94\
+\\x5A4D\x9C95\
+\\x5A4E\x9C97\
+\\x5A4F\x9C98\
+\\x5A50\x9C99\
+\\x5A51\xFABD\
+\\x5A52\x9C9A\
+\\x5A53\x9C9D\
+\\x5A54\x9C9E\
+\\x5A55\x9C9F\
+\\x5A56\x9CA0\
+\\x5A57\xFABE\
+\\x5A58\x9CA1\
+\\x5A59\x9CA2\
+\\x5A5A\x9CA3\
+\\x5A5B\x9CA4\
+\\x5A5C\x9CA5\
+\\x5A5D\x9CA6\
+\\x5A5E\x9CA7\
+\\x5A5F\xFABF\
+\\x5A60\x9CA8\
+\\x5A61\x9CA9\
+\\x5A62\x9CAC\
+\\x5A63\x9CAD\
+\\x5A64\x9CAE\
+\\x5A65\xFAC0\
+\\x5A66\x9CAF\
+\\x5A67\xFAC1\
+\\x5A68\xFAC2\
+\\x5A69\x9CB1\
+\\x5A6A\x9CB2\
+\\x5A6B\x9CB3\
+\\x5A6C\x9CB4\
+\\x5A6D\x9CB5\
+\\x5A6E\x9CB6\
+\\x5A6F\x9CB7\
+\\x5A70\x9CB8\
+\\x5A71\x9CB9\
+\\x5A72\x9CBA\
+\\x5A73\x9CBB\
+\\x5A74\x9CBC\
+\\x5A75\x9CBD\
+\\x5A76\xFAC3\
+\\x5A77\x9CBE\
+\\x5A78\x9CB0\
+\\x5A79\xFAC4\
+\\x5A7A\x9CC0\
+\\x5A7B\x9CC1\
+\\x5A7C\x9CBF\
+\\x5A7D\x9CC2\
+\\x5A7E\xFAC5\
+\\x5A7F\x9CC4\
+\\x5A80\x9CC5\
+\\x5A81\x9CC6\
+\\x5A82\x9CD2\
+\\x5A83\x9CD5\
+\\x5A84\x9CC7\
+\\x5A85\x9CC8\
+\\x5A86\x9CC9\
+\\x5A87\x9CCA\
+\\x5A88\x9CDA\
+\\x5A89\x9CCB\
+\\x5A8A\x9CCC\
+\\x5A8B\x9CCD\
+\\x5A8C\x9CCE\
+\\x5A8D\x9CCF\
+\\x5A8E\x9CD0\
+\\x5A8F\x9CD1\
+\\x5A90\x9CD3\
+\\x5A91\x9CD4\
+\\x5A92\x9CD6\
+\\x5A93\x9CD7\
+\\x5A94\xFAC6\
+\\x5A95\x9CD8\
+\\x5A96\x9CD9\
+\\x5A97\x9CDB\
+\\x5A98\x9CDC\
+\\x5A99\x9CDE\
+\\x5A9A\x9CDF\
+\\x5A9B\x9CE0\
+\\x5A9C\x9CE1\
+\\x5A9D\x9CE2\
+\\x5A9E\x9CE3\
+\\x5A9F\x9CE4\
+\\x5AA0\x9CE6\
+\\x5AA1\x9CE7\
+\\x5AA2\x9CE8\
+\\x5AA3\x9CE9\
+\\x5AA4\x9CEA\
+\\x5AA5\x9CEB\
+\\x5AA6\x9CEC\
+\\x5AA7\x9CED\
+\\x5AA8\x9CEE\
+\\x5AA9\x9CF1\
+\\x5AAA\x9CE5\
+\\x5AAB\x9CEF\
+\\x5AAC\x9CF3\
+\\x5AAD\x9CF0\
+\\x5AAE\x9CF2\
+\\x5AAF\x9CF4\
+\\x5AB0\x9CF5\
+\\x5AB1\x9CF6\
+\\x5AB2\x9CF7\
+\\x5AB3\x9CF8\
+\\x5AB4\x9CF9\
+\\x5AB5\xFAC7\
+\\x5AB6\x9CFB\
+\\x5AB7\x9CFC\
+\\x5AB8\x9D40\
+\\x5AB9\x9D41\
+\\x5ABA\x9D42\
+\\x5ABB\x9D43\
+\\x5ABC\x9D44\
+\\x5ABD\x9D45\
+\\x5ABE\x9D46\
+\\x5ABF\x9D47\
+\\x5AC0\x9D48\
+\\x5AC1\x9D49\
+\\x5AC2\x9D4A\
+\\x5AC3\x9D4B\
+\\x5AC4\x9D4C\
+\\x5AC5\x9D4D\
+\\x5AC6\x9D4E\
+\\x5AC7\x9D4F\
+\\x5AC8\x9D50\
+\\x5AC9\x9D52\
+\\x5ACA\x9D51\
+\\x5ACB\x9D53\
+\\x5ACC\x9D54\
+\\x5ACD\x9D56\
+\\x5ACE\x9D57\
+\\x5ACF\x9D58\
+\\x5AD0\x9D59\
+\\x5AD1\x9D5A\
+\\x5AD2\x9D5B\
+\\x5AD3\x9DAB\
+\\x5AD4\x9D5D\
+\\x5AD5\x9D5F\
+\\x5AD6\x9D60\
+\\x5AD7\x9D55\
+\\x5AD8\x9D62\
+\\x5AD9\x9D63\
+\\x5ADA\xFAC8\
+\\x5ADB\x9D64\
+\\x5ADC\x9D65\
+\\x5ADD\x9D66\
+\\x5ADE\x9D67\
+\\x5ADF\x9D68\
+\\x5AE0\x9D69\
+\\x5AE1\x9D6A\
+\\x5AE2\x9D6B\
+\\x5AE3\x9D6C\
+\\x5AE4\x9D6D\
+\\x5AE5\x9D6E\
+\\x5AE6\x9D5C\
+\\x5AE7\x9D6F\
+\\x5AE8\x9D71\
+\\x5AE9\x9D70\
+\\x5AEA\x9D73\
+\\x5AEB\x9D74\
+\\x5AEC\x9D75\
+\\x5AED\x9D76\
+\\x5AEE\x9D77\
+\\x5AEF\x9D78\
+\\x5AF0\x9D79\
+\\x5AF1\x9D7A\
+\\x5AF2\x9D7B\
+\\x5AF3\x9D7C\
+\\x5AF4\x9D7E\
+\\x5AF5\x9D80\
+\\x5AF6\x9D7D\
+\\x5AF7\x9D81\
+\\x5AF8\x9D82\
+\\x5AF9\x9D83\
+\\x5AFA\x9D84\
+\\x5AFB\xFAC9\
+\\x5AFC\x9D85\
+\\x5AFD\x9D86\
+\\x5AFE\x9D87\
+\\x5B41\x9D88\
+\\x5B42\x9D89\
+\\x5B43\x9D8B\
+\\x5B44\x9D8C\
+\\x5B45\x9D8D\
+\\x5B46\x9D8E\
+\\x5B47\x9D8F\
+\\x5B48\x9D72\
+\\x5B49\x9D91\
+\\x5B4A\x9D92\
+\\x5B4B\x9D93\
+\\x5B4C\x9D8A\
+\\x5B4D\x9D97\
+\\x5B4E\x9D94\
+\\x5B4F\x9D95\
+\\x5B50\xFACA\
+\\x5B51\x9D96\
+\\x5B52\x8A68\
+\\x5B53\xFACB\
+\\x5B54\xFACC\
+\\x5B55\x9D99\
+\\x5B56\x9DA3\
+\\x5B57\x9D9A\
+\\x5B58\x9D9B\
+\\x5B59\x9D9C\
+\\x5B5A\x9D9D\
+\\x5B5B\x9D9E\
+\\x5B5C\x9D9F\
+\\x5B5D\x9DA0\
+\\x5B5E\x9DA1\
+\\x5B5F\x9DA2\
+\\x5B60\x9D5E\
+\\x5B61\x9DA4\
+\\x5B62\x9DA5\
+\\x5B63\x9DA6\
+\\x5B64\x9DA7\
+\\x5B65\x9DA9\
+\\x5B66\x9DAA\
+\\x5B67\x9DAC\
+\\x5B68\x9DAD\
+\\x5B69\x9DB0\
+\\x5B6A\x9DAF\
+\\x5B6B\x9DB1\
+\\x5B6C\x9DB2\
+\\x5B6D\x9DB3\
+\\x5B6E\x9DB4\
+\\x5B6F\x9DB5\
+\\x5B70\x9DB6\
+\\x5B71\x9D90\
+\\x5B72\x9DB7\
+\\x5B73\x9DB8\
+\\x5B74\x9DB9\
+\\x5B75\x9DBA\
+\\x5B76\x9DAE\
+\\x5B77\x9DBB\
+\\x5B78\x9DBC\
+\\x5B79\x9DBD\
+\\x5B7A\x9DBE\
+\\x5B7B\x9DBF\
+\\x5B7C\x9DC0\
+\\x5B7D\x9DC1\
+\\x5B7E\xFACD\
+\\x5B7F\x9DC2\
+\\x5B80\x9DC4\
+\\x5B81\x9DC5\
+\\x5B82\x9DC3\
+\\x5B83\x9DC7\
+\\x5B84\x9DC8\
+\\x5B85\x9DC9\
+\\x5B86\x9DCA\
+\\x5B87\x9DCB\
+\\x5B88\x9DCC\
+\\x5B89\x9DCD\
+\\x5B8A\x9DCE\
+\\x5B8B\x9DCF\
+\\x5B8C\x9DD0\
+\\x5B8D\x9DD1\
+\\x5B8E\x9DD2\
+\\x5B8F\x9DD3\
+\\x5B90\x9DD4\
+\\x5B91\x9DD5\
+\\x5B92\x9DD6\
+\\x5B93\x9DD8\
+\\x5B94\x9DDA\
+\\x5B95\x9DD9\
+\\x5B96\x9DDB\
+\\x5B97\xFACE\
+\\x5B98\xFACF\
+\\x5B99\x8D56\
+\\x5B9A\x9DDC\
+\\x5B9B\x9DDE\
+\\x5B9C\x9DDF\
+\\x5B9D\xFAD1\
+\\x5B9E\x9E45\
+\\x5B9F\x9DE1\
+\\x5BA0\xFAD2\
+\\x5BA1\xFAD3\
+\\x5BA2\x9DE3\
+\\x5BA3\x9DE4\
+\\x5BA4\xFAD4\
+\\x5BA5\x9DE6\
+\\x5BA6\x9DE7\
+\\x5BA7\xFAD5\
+\\x5BA8\xFAD6\
+\\x5BA9\x9DE9\
+\\x5BAA\x9DEB\
+\\x5BAB\xFAD7\
+\\x5BAC\x9DEF\
+\\x5BAD\x9DEA\
+\\x5BAE\xFAD8\
+\\x5BAF\xFAD9\
+\\x5BB0\x9DF0\
+\\x5BB1\x9DF1\
+\\x5BB2\x9DF2\
+\\x5BB3\x9DF5\
+\\x5BB4\xFADA\
+\\x5BB5\x9DF6\
+\\x5BB6\xFADB\
+\\x5BB7\x9DF7\
+\\x5BB8\xFADC\
+\\x5BB9\x9E40\
+\\x5BBA\x9DF8\
+\\x5BBB\xFADD\
+\\x5BBC\x9DFA\
+\\x5BBD\x9DFB\
+\\x5BBE\x9DFC\
+\\x5BBF\x9E41\
+\\x5BC0\x9E42\
+\\x5BC1\x9E43\
+\\x5BC2\x9E46\
+\\x5BC3\x9E47\
+\\x5BC4\x9E48\
+\\x5BC5\x9E49\
+\\x5BC6\x9E4A\
+\\x5BC7\xFADE\
+\\x5BC8\xFADF\
+\\x5BC9\xFAE0\
+\\x5BCA\x9E4C\
+\\x5BCB\x9E4D\
+\\x5BCC\xE377\
+\\x5BCD\x9E4E\
+\\x5BCE\x9E4F\
+\\x5BCF\x9E50\
+\\x5BD0\x9E51\
+\\x5BD1\x9E52\
+\\x5BD2\x9E53\
+\\x5BD3\x9E56\
+\\x5BD4\x9E55\
+\\x5BD5\x9E57\
+\\x5BD6\x9E58\
+\\x5BD7\x9E5A\
+\\x5BD8\xFAE1\
+\\x5BD9\x9E5C\
+\\x5BDA\x9E5D\
+\\x5BDB\x9E66\
+\\x5BDC\x9E5E\
+\\x5BDD\x9E5F\
+\\x5BDE\x9E61\
+\\x5BDF\x9E63\
+\\x5BE0\x9DE0\
+\\x5BE1\x9E64\
+\\x5BE2\x9E65\
+\\x5BE3\xFAE2\
+\\x5BE4\x9E67\
+\\x5BE5\x9E68\
+\\x5BE6\x9E69\
+\\x5BE7\x9E6A\
+\\x5BE8\x9E6C\
+\\x5BE9\x9E6D\
+\\x5BEA\x9E76\
+\\x5BEB\x9E6E\
+\\x5BEC\xFAE3\
+\\x5BED\x9E70\
+\\x5BEE\x9E71\
+\\x5BEF\x9E72\
+\\x5BF0\xFAE4\
+\\x5BF1\x9E74\
+\\x5BF2\x9E73\
+\\x5BF3\xFAE5\
+\\x5BF4\x9E75\
+\\x5BF5\x9E78\
+\\x5BF6\x9E79\
+\\x5BF7\x9E7C\
+\\x5BF8\x9E7B\
+\\x5BF9\xFAE6\
+\\x5BFA\x9E7D\
+\\x5BFB\x9E7E\
+\\x5BFC\x9E83\
+\\x5BFD\x9E82\
+\\x5BFE\x9E94\
+\\x5C41\x9E84\
+\\x5C42\x9E85\
+\\x5C43\x9E86\
+\\x5C44\x9E95\
+\\x5C45\x9E87\
+\\x5C46\x9E88\
+\\x5C47\x9E89\
+\\x5C48\x9E8C\
+\\x5C49\x938E\
+\\x5C4A\x9E8E\
+\\x5C4B\x9E8F\
+\\x5C4C\x9E90\
+\\x5C4D\x9E92\
+\\x5C4E\x9E93\
+\\x5C4F\x9E96\
+\\x5C50\x9E97\
+\\x5C51\x9E98\
+\\x5C52\x9E99\
+\\x5C53\x9E9B\
+\\x5C54\x9E9C\
+\\x5C55\x9E9D\
+\\x5C56\x9E9E\
+\\x5C57\x9E9F\
+\\x5C58\x9EA0\
+\\x5C59\x9EA1\
+\\x5C5A\x9EA3\
+\\x5C5B\x9EAA\
+\\x5C5C\x9EA4\
+\\x5C5D\x9EA6\
+\\x5C5E\x9EA9\
+\\x5C5F\xFAE7\
+\\x5C60\x9EB0\
+\\x5C61\x9E9A\
+\\x5C62\x9EAC\
+\\x5C63\x9EAF\
+\\x5C64\x9EAE\
+\\x5C65\x9EAB\
+\\x5C66\xFAE8\
+\\x5C67\x9EB1\
+\\x5C68\x9EB2\
+\\x5C69\x9EA2\
+\\x5C6A\x9EB4\
+\\x5C6B\x9EB6\
+\\x5C6C\x9EC2\
+\\x5C6D\x9EBA\
+\\x5C6E\xFAE9\
+\\x5C6F\x9EBB\
+\\x5C70\x9EBC\
+\\x5C71\x9EBD\
+\\x5C72\x9EBF\
+\\x5C73\x9EC0\
+\\x5C74\x9EB7\
+\\x5C75\x9EC1\
+\\x5C76\x9EC3\
+\\x5C77\x9EC6\
+\\x5C78\xFAEA\
+\\x5C79\xFAEB\
+\\x5C7A\x9EC7\
+\\x5C7B\x9EC8\
+\\x5C7C\x9EC9\
+\\x5C7D\x9ECA\
+\\x5C7E\x9ECB\
+\\x5C7F\x9ECC\
+\\x5C80\x9EE1\
+\\x5C81\x9ECD\
+\\x5C82\x9ECE\
+\\x5C83\x9ECF\
+\\x5C84\x9ED3\
+\\x5C85\x9ED4\
+\\x5C86\x9ED5\
+\\x5C87\x9ED7\
+\\x5C88\x9ED1\
+\\x5C89\x9ED8\
+\\x5C8A\x9ED9\
+\\x5C8B\x9EDA\
+\\x5C8C\x9EDB\
+\\x5C8D\x9EDD\
+\\x5C8E\x9EDE\
+\\x5C8F\x9EDF\
+\\x5C90\xFAEC\
+\\x5C91\x9EE2\
+\\x5C92\x9EE3\
+\\x5C93\x9EE4\
+\\x5C94\x9EE5\
+\\x5C95\x9EE6\
+\\x5C96\x9EF6\
+\\x5C97\x9EE7\
+\\x5C98\x9EE9\
+\\x5C99\x9EEA\
+\\x5C9A\xFAED\
+\\x5C9B\xFAEE\
+\\x5C9C\x9EEB\
+\\x5C9D\x9EEC\
+\\x5C9E\x9EF9\
+\\x5C9F\x9EEE\
+\\x5CA0\x9EEF\
+\\x5CA1\x9EF0\
+\\x5CA2\x9EF1\
+\\x5CA3\x9EF2\
+\\x5CA4\x9EF3\
+\\x5CA5\x9EF4\
+\\x5CA6\xFAEF\
+\\x5CA7\x9EF5\
+\\x5CA8\x9EED\
+\\x5CA9\xFAF0\
+\\x5CAA\x9EF7\
+\\x5CAB\x9EF8\
+\\x5CAC\x9EFA\
+\\x5CAD\x9EFB\
+\\x5CAE\x9EFC\
+\\x5CAF\xFAF1\
+\\x5CB0\x9F40\
+\\x5CB1\x9F47\
+\\x5CB2\x9F4B\
+\\x5CB3\x9F42\
+\\x5CB4\x9F44\
+\\x5CB5\x9F45\
+\\x5CB6\x9F46\
+\\x5CB7\x9EE8\
+\\x5CB8\x9F48\
+\\x5CB9\xFAF2\
+\\x5CBA\x9F49\
+\\x5CBB\x9F4C\
+\\x5CBC\xFAF3\
+\\x5CBD\x9F50\
+\\x5CBE\x9F41\
+\\x5CBF\x9F4D\
+\\x5CC0\x9F4F\
+\\x5CC1\x9EDC\
+\\x5CC2\x9F51\
+\\x5CC3\x9F52\
+\\x5CC4\x9F53\
+\\x5CC5\x9F55\
+\\x5CC6\x9F56\
+\\x5CC7\x9F57\
+\\x5CC8\x9F59\
+\\x5CC9\x9F58\
+\\x5CCA\x9F5A\
+\\x5CCB\x9F5B\
+\\x5CCC\x9F5C\
+\\x5CCD\x9F5D\
+\\x5CCE\x9F5E\
+\\x5CCF\x9F5F\
+\\x5CD0\x9F60\
+\\x5CD1\x9F61\
+\\x5CD2\x9F62\
+\\x5CD3\x9F63\
+\\x5CD4\x9F64\
+\\x5CD5\x9F65\
+\\x5CD6\x9F66\
+\\x5CD7\x9F67\
+\\x5CD8\x9F68\
+\\x5CD9\x9F69\
+\\x5CDA\x9F6A\
+\\x5CDB\x9F6B\
+\\x5CDC\x9F6C\
+\\x5CDD\x9F6D\
+\\x5CDE\x9F6E\
+\\x5CDF\x9F6F\
+\\x5CE0\x9F70\
+\\x5CE1\x9F71\
+\\x5CE2\x9F73\
+\\x5CE3\x9F72\
+\\x5CE4\x9F74\
+\\x5CE5\x9F75\
+\\x5CE6\x9F76\
+\\x5CE7\x9F77\
+\\x5CE8\x9F78\
+\\x5CE9\x9F79\
+\\x5CEA\xFAF4\
+\\x5CEB\x9F7A\
+\\x5CEC\x9F7B\
+\\x5CED\x9F7C\
+\\x5CEE\x9F7D\
+\\x5CEF\x9F7E\
+\\x5CF0\x9F81\
+\\x5CF1\x9F82\
+\\x5CF2\x9F83\
+\\x5CF3\x9F84\
+\\x5CF4\x9F85\
+\\x5CF5\x9F86\
+\\x5CF6\xFAF5\
+\\x5CF7\x9F87\
+\\x5CF8\x9F88\
+\\x5CF9\xFAF6\
+\\x5CFA\x9F89\
+\\x5CFB\x9F8B\
+\\x5CFC\x9F8C\
+\\x5CFD\xFAF7\
+\\x5CFE\xFAF8\
+\\x5D41\x9F8D\
+\\x5D42\x9F8E\
+\\x5D43\x9F8F\
+\\x5D44\x9F90\
+\\x5D45\x9F91\
+\\x5D46\x9F92\
+\\x5D47\x9F93\
+\\x5D48\x9F94\
+\\x5D49\x9F95\
+\\x5D4A\x9F96\
+\\x5D4B\x9F98\
+\\x5D4C\x9F9A\
+\\x5D4D\x9F9C\
+\\x5D4E\xFAF9\
+\\x5D4F\x9F9B\
+\\x5D50\x9F9D\
+\\x5D51\x9F9E\
+\\x5D52\x9F9F\
+\\x5D53\x9FA0\
+\\x5D54\x9FA1\
+\\x5D55\x9FA2\
+\\x5D56\x9FA3\
+\\x5D57\x9FA4\
+\\x5D58\xFAFA\
+\\x5D59\x9FA6\
+\\x5D5A\x9FA7\
+\\x5D5B\x9FA8\
+\\x5D5C\x9FAC\
+\\x5D5D\x9FAD\
+\\x5D5E\x9FAE\
+\\x5D5F\x9FAF\
+\\x5D60\xFAFB\
+\\x5D61\x9FB0\
+\\x5D62\xFAFC\
+\\x5D63\x9FB1\
+\\x5D64\x9FB2\
+\\x5D65\x9FB3\
+\\x5D66\x9FB4\
+\\x5D67\x9FB5\
+\\x5D68\x9FB6\
+\\x5D69\x9393\
+\\x5D6A\x9FB8\
+\\x5D6B\xFB40\
+\\x5D6C\x9FB9\
+\\x5D6D\x9FBB\
+\\x5D6E\x9FCF\
+\\x5D6F\x9FBC\
+\\x5D70\x9FBE\
+\\x5D71\x9FBD\
+\\x5D72\xFB41\
+\\x5D73\x9FBF\
+\\x5D74\xFB42\
+\\x5D75\x9FC0\
+\\x5D76\x9FC1\
+\\x5D77\x9FC2\
+\\x5D78\x9FC3\
+\\x5D79\x9FC4\
+\\x5D7A\xFB43\
+\\x5D7B\x9FC5\
+\\x5D7C\x9FC6\
+\\x5D7D\x9FC7\
+\\x5D7E\x9FC8\
+\\x5D7F\xFB44\
+\\x5D80\xFB45\
+\\x5D81\x9FC9\
+\\x5D82\x9FCA\
+\\x5D83\x9FCB\
+\\x5D84\x9FCC\
+\\x5D85\x9FCD\
+\\x5D86\x9FCE\
+\\x5D87\x9FD0\
+\\x5D88\x9FD1\
+\\x5D89\x9FD2\
+\\x5D8A\xFB46\
+\\x5D8B\x9FD3\
+\\x5D8C\x9FD4\
+\\x5D8D\x9FD5\
+\\x5D8E\xFB47\
+\\x5D8F\x9FD6\
+\\x5D90\x9FD7\
+\\x5D91\x9FD8\
+\\x5D92\x9FD9\
+\\x5D93\xFB48\
+\\x5D94\x9FDA\
+\\x5D95\xFB49\
+\\x5D96\x9FDB\
+\\x5D97\x9FDC\
+\\x5D98\x9FDD\
+\\x5D99\x9FDF\
+\\x5D9A\x9FE0\
+\\x5D9B\x9FE1\
+\\x5D9C\x9FE2\
+\\x5D9D\x9FE3\
+\\x5D9E\x9FE5\
+\\x5D9F\x9FE7\
+\\x5DA0\x9FE8\
+\\x5DA1\x9FE9\
+\\x5DA2\x9FEA\
+\\x5DA3\x9FEB\
+\\x5DA4\x9FEC\
+\\x5DA5\x9FED\
+\\x5DA6\xFB4A\
+\\x5DA7\x9FEF\
+\\x5DA8\x9FF0\
+\\x5DA9\x9FF1\
+\\x5DAA\x8AC1\
+\\x5DAB\x9FF4\
+\\x5DAC\x9FF5\
+\\x5DAD\x9FF6\
+\\x5DAE\x9FF7\
+\\x5DAF\x9FF8\
+\\x5DB0\x9FF9\
+\\x5DB1\x9FFA\
+\\x5DB2\x9FFB\
+\\x5DB3\x9FFC\
+\\x5DB4\x9FDE\
+\\x5DB5\xE040\
+\\x5DB6\xE041\
+\\x5DB7\xE042\
+\\x5DB8\xE043\
+\\x5DB9\xE044\
+\\x5DBA\xE045\
+\\x5DBB\xE047\
+\\x5DBC\xE048\
+\\x5DBD\xE049\
+\\x5DBE\xE04B\
+\\x5DBF\xE06B\
+\\x5DC0\xE04C\
+\\x5DC1\xFB4B\
+\\x5DC2\xE04D\
+\\x5DC3\xE04E\
+\\x5DC4\xE058\
+\\x5DC5\xE04F\
+\\x5DC6\xE050\
+\\x5DC7\xE052\
+\\x5DC8\xE053\
+\\x5DC9\xE054\
+\\x5DCA\xFB4C\
+\\x5DCB\xE055\
+\\x5DCC\xE057\
+\\x5DCD\xE061\
+\\x5DCE\xE059\
+\\x5DCF\xE051\
+\\x5DD0\xE05A\
+\\x5DD1\xE05B\
+\\x5DD2\xE05C\
+\\x5DD3\xE05E\
+\\x5DD4\xE05D\
+\\x5DD5\xFB4D\
+\\x5DD6\xE060\
+\\x5DD7\xFB4E\
+\\x5DD8\xFB4F\
+\\x5DD9\xE062\
+\\x5DDA\xE063\
+\\x5DDB\xE064\
+\\x5DDC\xE065\
+\\x5DDD\xE066\
+\\x5DDE\xE067\
+\\x5DDF\xE069\
+\\x5DE0\xE06A\
+\\x5DE1\xE06E\
+\\x5DE2\xE04A\
+\\x5DE3\xFB50\
+\\x5DE4\xE06D\
+\\x5DE5\xE06F\
+\\x5DE6\xE070\
+\\x5DE7\xE071\
+\\x5DE8\xE072\
+\\x5DE9\xE073\
+\\x5DEA\xFB51\
+\\x5DEB\xE074\
+\\x5DEC\xE076\
+\\x5DED\xFB52\
+\\x5DEE\xE078\
+\\x5DEF\xE079\
+\\x5DF0\xE07B\
+\\x5DF1\xE07C\
+\\x5DF2\xE07D\
+\\x5DF3\xE080\
+\\x5DF4\xE081\
+\\x5DF5\xFB53\
+\\x5DF6\xFB54\
+\\x5DF7\xE077\
+\\x5DF8\xE082\
+\\x5DF9\xE083\
+\\x5DFA\xE084\
+\\x5DFB\xFB55\
+\\x5DFC\xFB56\
+\\x5DFD\xFB57\
+\\x5DFE\xE088\
+\\x5E41\xE089\
+\\x5E42\xE08A\
+\\x5E43\xE08B\
+\\x5E44\xE08C\
+\\x5E45\xE087\
+\\x5E46\xE08D\
+\\x5E47\xE08F\
+\\x5E48\xE090\
+\\x5E49\xFB58\
+\\x5E4A\xE092\
+\\x5E4B\xFB59\
+\\x5E4C\xE094\
+\\x5E4D\xE095\
+\\x5E4E\xE096\
+\\x5E4F\xE09C\
+\\x5E50\xE097\
+\\x5E51\xE098\
+\\x5E52\xE093\
+\\x5E53\xE099\
+\\x5E54\xE09D\
+\\x5E55\xE09A\
+\\x5E56\xE09B\
+\\x5E57\xE08E\
+\\x5E58\xE09E\
+\\x5E59\xE09F\
+\\x5E5A\xFB5A\
+\\x5E5B\xE0A0\
+\\x5E5C\xE0A1\
+\\x5E5D\xE0A2\
+\\x5E5E\xE0A4\
+\\x5E5F\xE0A5\
+\\x5E60\xE0A6\
+\\x5E61\xE0A7\
+\\x5E62\xE0A8\
+\\x5E63\xE0A9\
+\\x5E64\xE0AA\
+\\x5E65\xE0AB\
+\\x5E66\xE0AC\
+\\x5E67\xE0AD\
+\\x5E68\xE0AE\
+\\x5E69\xE0AF\
+\\x5E6A\xE0B0\
+\\x5E6B\xE0B1\
+\\x5E6C\xE0B3\
+\\x5E6D\xE0B4\
+\\x5E6E\xE0B2\
+\\x5E6F\xE0B5\
+\\x5E70\xE0B6\
+\\x5E71\xE0B7\
+\\x5E72\xE0B8\
+\\x5E73\xFB5B\
+\\x5E74\xE0BA\
+\\x5E75\xFB5C\
+\\x5E76\xE0BB\
+\\x5E77\xE0BC\
+\\x5E78\xE0BD\
+\\x5E79\xE0B9\
+\\x5E7A\xE0BE\
+\\x5E7B\xE0BF\
+\\x5E7C\xE0C0\
+\\x5E7D\xE0C1\
+\\x5E7E\xE0C2\
+\\x5E7F\xE0C3\
+\\x5E80\xE0C4\
+\\x5E81\xE0C6\
+\\x5E82\xE0C7\
+\\x5E83\xE0C8\
+\\x5E84\xE0C9\
+\\x5E85\xE0CA\
+\\x5E86\xFB5D\
+\\x5E87\xE0CB\
+\\x5E88\xE0CD\
+\\x5E89\xE0CC\
+\\x5E8A\xFB5E\
+\\x5E8B\xE0CE\
+\\x5E8C\xE0CF\
+\\x5E8D\xE0D1\
+\\x5E8E\xE0D0\
+\\x5E8F\xE0D3\
+\\x5E90\xE0D2\
+\\x5E91\xE0D4\
+\\x5E92\xE0D5\
+\\x5E93\xE0D6\
+\\x5E94\xFB5F\
+\\x5E95\xE0D7\
+\\x5E96\xE0D8\
+\\x5E97\xE0D9\
+\\x5E98\xE0DB\
+\\x5E99\xFB60\
+\\x5E9A\xE0DC\
+\\x5E9B\xE0DD\
+\\x5E9C\xE0DE\
+\\x5E9D\xE0DF\
+\\x5E9E\xFB61\
+\\x5E9F\xFB62\
+\\x5EA0\xE0E0\
+\\x5EA1\xFB63\
+\\x5EA2\xFB64\
+\\x5EA3\xE0E1\
+\\x5EA4\xE0FC\
+\\x5EA5\xE0E2\
+\\x5EA6\xE0E7\
+\\x5EA7\xFB65\
+\\x5EA8\xFB66\
+\\x5EA9\xE0E4\
+\\x5EAA\xFB67\
+\\x5EAB\xFB68\
+\\x5EAC\xE0E6\
+\\x5EAD\xFB69\
+\\x5EAE\xFB6A\
+\\x5EAF\xE0E8\
+\\x5EB0\xE0E9\
+\\x5EB1\xE0EA\
+\\x5EB2\xE0EB\
+\\x5EB3\xE0EC\
+\\x5EB4\xE0ED\
+\\x5EB5\xE0EE\
+\\x5EB6\xE0EF\
+\\x5EB7\xE0F0\
+\\x5EB8\xE0F1\
+\\x5EB9\xE0F2\
+\\x5EBA\xE0F3\
+\\x5EBB\xEAA2\
+\\x5EBC\xFB6B\
+\\x5EBD\xFB6C\
+\\x5EBE\xE0E5\
+\\x5EBF\xE0F5\
+\\x5EC0\xFB6D\
+\\x5EC1\xE0F7\
+\\x5EC2\xE0E3\
+\\x5EC3\xE0F8\
+\\x5EC4\xE0F9\
+\\x5EC5\xE0FA\
+\\x5EC6\xE0FB\
+\\x5EC7\xE140\
+\\x5EC8\xE141\
+\\x5EC9\xE142\
+\\x5ECA\xE143\
+\\x5ECB\xE144\
+\\x5ECC\xE146\
+\\x5ECD\xE145\
+\\x5ECE\xE147\
+\\x5ECF\xE149\
+\\x5ED0\xE148\
+\\x5ED1\xFB6E\
+\\x5ED2\xE14A\
+\\x5ED3\xE14B\
+\\x5ED4\xE14C\
+\\x5ED5\xE14F\
+\\x5ED6\xE14D\
+\\x5ED7\xE14E\
+\\x5ED8\xE151\
+\\x5ED9\xE152\
+\\x5EDA\xE153\
+\\x5EDB\xE154\
+\\x5EDC\xE155\
+\\x5EDD\xE156\
+\\x5EDE\xE157\
+\\x5EDF\xE158\
+\\x5EE0\xE159\
+\\x5EE1\xE15B\
+\\x5EE2\xE15A\
+\\x5EE3\xE15C\
+\\x5EE4\xE15E\
+\\x5EE5\xE15F\
+\\x5EE6\xE160\
+\\x5EE7\xFB6F\
+\\x5EE8\xE166\
+\\x5EE9\xE161\
+\\x5EEA\xE162\
+\\x5EEB\xE163\
+\\x5EEC\xE169\
+\\x5EED\xE164\
+\\x5EEE\xE165\
+\\x5EEF\xE167\
+\\x5EF0\xE168\
+\\x5EF1\xE16A\
+\\x5EF2\xE16B\
+\\x5EF3\xE16C\
+\\x5EF4\xE16D\
+\\x5EF5\xE16E\
+\\x5EF6\xE16F\
+\\x5EF7\xE170\
+\\x5EF8\xE171\
+\\x5EF9\xE172\
+\\x5EFA\xE173\
+\\x5EFB\xE174\
+\\x5EFC\xE175\
+\\x5EFD\xE176\
+\\x5EFE\xE177\
+\\x5F41\xE178\
+\\x5F42\xE179\
+\\x5F43\xE17A\
+\\x5F44\xE17B\
+\\x5F45\xE17C\
+\\x5F46\xE17D\
+\\x5F47\xE17E\
+\\x5F48\xE180\
+\\x5F49\xE181\
+\\x5F4A\xE182\
+\\x5F4B\xE183\
+\\x5F4C\xE184\
+\\x5F4D\xE185\
+\\x5F4E\xE186\
+\\x5F4F\xE188\
+\\x5F50\xE189\
+\\x5F51\xE18A\
+\\x5F52\xE18B\
+\\x5F53\xE18C\
+\\x5F54\xE18D\
+\\x5F55\xE18E\
+\\x5F56\xE18F\
+\\x5F57\xE190\
+\\x5F58\xE191\
+\\x5F59\xE192\
+\\x5F5A\xE193\
+\\x5F5B\xE196\
+\\x5F5C\xE194\
+\\x5F5D\xE195\
+\\x5F5E\xE197\
+\\x5F5F\xE198\
+\\x5F60\xE199\
+\\x5F61\xE19A\
+\\x5F62\xE19C\
+\\x5F63\xE19B\
+\\x5F64\xE19D\
+\\x5F65\xE19E\
+\\x5F66\xE19F\
+\\x5F67\xE1A0\
+\\x5F68\xE1A2\
+\\x5F69\xFB70\
+\\x5F6A\xE1A3\
+\\x5F6B\xE1A4\
+\\x5F6C\xE1A5\
+\\x5F6D\xE1A6\
+\\x5F6E\xE1AA\
+\\x5F6F\xE1AB\
+\\x5F70\xFB71\
+\\x5F71\xFB72\
+\\x5F72\xFB73\
+\\x5F73\xFB74\
+\\x5F74\xE1AC\
+\\x5F75\xE1AD\
+\\x5F76\xE1AE\
+\\x5F77\xE1AF\
+\\x5F78\xE1B0\
+\\x5F79\xE1B1\
+\\x5F7A\xFB75\
+\\x5F7B\xE1B2\
+\\x5F7C\xE1B3\
+\\x5F7D\xE1B4\
+\\x5F7E\xE1B5\
+\\x5F7F\xE1B6\
+\\x5F80\xE1B7\
+\\x5F81\xE1B9\
+\\x5F82\xE1BA\
+\\x5F83\xE1BB\
+\\x5F84\xE1BC\
+\\x5F85\xE1BD\
+\\x5F86\xE1BE\
+\\x5F87\xE1C0\
+\\x5F88\xE1BF\
+\\x5F89\xE1C2\
+\\x5F8A\xE1C3\
+\\x5F8B\xE1C4\
+\\x5F8C\xE1C5\
+\\x5F8D\xE1C6\
+\\x5F8E\xFB76\
+\\x5F8F\xE1C7\
+\\x5F90\xE1C8\
+\\x5F91\xE1C9\
+\\x5F92\xE1CA\
+\\x5F93\xE1CB\
+\\x5F94\xE1CC\
+\\x5F95\xE1CD\
+\\x5F96\xE1CE\
+\\x5F97\xE1CF\
+\\x5F98\xE1D0\
+\\x5F99\xE1D1\
+\\x5F9A\xE1D2\
+\\x5F9B\xE1D3\
+\\x5F9C\xE1D4\
+\\x5F9D\xE1D5\
+\\x5F9E\xE1D6\
+\\x5F9F\xE1D7\
+\\x5FA0\xE1D8\
+\\x5FA1\xE1D9\
+\\x5FA2\xE1DA\
+\\x5FA3\xE1DB\
+\\x5FA4\xE1DC\
+\\x5FA5\xE1DD\
+\\x5FA6\xE1DF\
+\\x5FA7\xE1E0\
+\\x5FA8\xE1E1\
+\\x5FA9\xE1E2\
+\\x5FAA\xFB77\
+\\x5FAB\xE1E3\
+\\x5FAC\xE1E4\
+\\x5FAD\xE1E5\
+\\x5FAE\xFB78\
+\\x5FAF\x8D7B\
+\\x5FB0\xE1E7\
+\\x5FB1\xE1E9\
+\\x5FB2\xFB79\
+\\x5FB3\xFB7A\
+\\x5FB4\xE1EB\
+\\x5FB5\xE1EA\
+\\x5FB6\xFB7B\
+\\x5FB7\xE1EC\
+\\x5FB8\xE1EE\
+\\x5FB9\xE1ED\
+\\x5FBA\xE1EF\
+\\x5FBB\xE1F0\
+\\x5FBC\xE1F1\
+\\x5FBD\xE1F2\
+\\x5FBE\xE1F3\
+\\x5FBF\xE1F4\
+\\x5FC0\xE1F5\
+\\x5FC1\xE1F6\
+\\x5FC2\xE1F7\
+\\x5FC3\xE1F8\
+\\x5FC4\xE1F9\
+\\x5FC5\xE1FA\
+\\x5FC6\xE1FB\
+\\x5FC7\xE1FC\
+\\x5FC8\xE240\
+\\x5FC9\xE241\
+\\x5FCA\xE242\
+\\x5FCB\xE243\
+\\x5FCC\xE244\
+\\x5FCD\xE246\
+\\x5FCE\xE247\
+\\x5FCF\xE248\
+\\x5FD0\xE249\
+\\x5FD1\xFB7C\
+\\x5FD2\xFB7D\
+\\x5FD3\xE24A\
+\\x5FD4\xE24B\
+\\x5FD5\xFB7E\
+\\x5FD6\xE24D\
+\\x5FD7\xE24E\
+\\x5FD8\xE24F\
+\\x5FD9\xFB80\
+\\x5FDA\xE252\
+\\x5FDB\xE253\
+\\x5FDC\xFB81\
+\\x5FDD\xFB82\
+\\x5FDE\xE254\
+\\x5FDF\xFB83\
+\\x5FE0\xE257\
+\\x5FE1\xE259\
+\\x5FE2\xE25B\
+\\x5FE3\xE25C\
+\\x5FE4\xE25D\
+\\x5FE5\xE25E\
+\\x5FE6\xE25F\
+\\x5FE7\xE261\
+\\x5FE8\xE262\
+\\x5FE9\xE263\
+\\x5FEA\xE264\
+\\x5FEB\xE265\
+\\x5FEC\xE267\
+\\x5FED\xE269\
+\\x5FEE\xE26B\
+\\x5FEF\xE26C\
+\\x5FF0\xE26A\
+\\x5FF1\xE26D\
+\\x5FF2\xE26E\
+\\x5FF3\xE26F\
+\\x5FF4\xE271\
+\\x5FF5\xE270\
+\\x5FF6\xE272\
+\\x5FF7\xE273\
+\\x5FF8\xE274\
+\\x5FF9\xE275\
+\\x5FFA\xE276\
+\\x5FFB\xE277\
+\\x5FFC\xE279\
+\\x5FFD\xE27A\
+\\x5FFE\xE27B\
+\\x6041\xE278\
+\\x6042\xE27C\
+\\x6043\xE27E\
+\\x6044\xE280\
+\\x6045\xE284\
+\\x6046\x8A96\
+\\x6047\xE283\
+\\x6048\xE281\
+\\x6049\xE282\
+\\x604A\xE285\
+\\x604B\xE286\
+\\x604C\xE287\
+\\x604D\xE288\
+\\x604E\x9AF2\
+\\x604F\xFB84\
+\\x6050\xE289\
+\\x6051\xE28A\
+\\x6052\xE28B\
+\\x6053\xE28C\
+\\x6054\xE28D\
+\\x6055\xE28E\
+\\x6056\xE28F\
+\\x6057\xE290\
+\\x6058\xFB85\
+\\x6059\xFB86\
+\\x605A\xFB87\
+\\x605B\xE291\
+\\x605C\xE292\
+\\x605D\x995E\
+\\x605E\xE293\
+\\x605F\xE294\
+\\x6060\xE2A2\
+\\x6061\xE295\
+\\x6062\xE296\
+\\x6063\xE297\
+\\x6064\xE29D\
+\\x6065\xE299\
+\\x6066\xE29A\
+\\x6067\xE29B\
+\\x6068\xE29C\
+\\x6069\xE29E\
+\\x606A\xE2A1\
+\\x606B\xE2A3\
+\\x606C\xE2A4\
+\\x606D\xE2B6\
+\\x606E\xE2A5\
+\\x606F\xE29F\
+\\x6070\xE2A7\
+\\x6071\xE2A9\
+\\x6072\xE2AA\
+\\x6073\xE2AC\
+\\x6074\xE2AD\
+\\x6075\xE2AE\
+\\x6076\xE2AF\
+\\x6077\xE2B0\
+\\x6078\xE2B1\
+\\x6079\xE2B2\
+\\x607A\xE2B4\
+\\x607B\xE2B5\
+\\x607C\xE2B7\
+\\x607D\xE2BB\
+\\x607E\xE2B8\
+\\x607F\xE2BA\
+\\x6080\xE2BC\
+\\x6081\xE2BD\
+\\x6082\xFB88\
+\\x6083\xE2BE\
+\\x6084\xE2BF\
+\\x6085\xE2C2\
+\\x6086\xE2C9\
+\\x6087\xE2C3\
+\\x6088\xE2C1\
+\\x6089\xE2C5\
+\\x608A\xE2C7\
+\\x608B\xE2C6\
+\\x608C\xE2C8\
+\\x608D\xE2CB\
+\\x608E\xE2CC\
+\\x608F\xE2CD\
+\\x6090\xE2CE\
+\\x6091\xE2CF\
+\\x6092\xE2D0\
+\\x6093\xE2D1\
+\\x6094\xE2D2\
+\\x6095\xE2D3\
+\\x6096\xE2D8\
+\\x6097\xE2D4\
+\\x6098\xE2D5\
+\\x6099\xE2DD\
+\\x609A\xE2D9\
+\\x609B\xE2DA\
+\\x609C\xE2DB\
+\\x609D\xE2DE\
+\\x609E\xE2DF\
+\\x609F\xE2E0\
+\\x60A0\xE2E1\
+\\x60A1\xE2E2\
+\\x60A2\xE2E3\
+\\x60A3\xE2E5\
+\\x60A4\xE2E6\
+\\x60A5\xE2E7\
+\\x60A6\xE2E4\
+\\x60A7\xE2E8\
+\\x60A8\xE2E9\
+\\x60A9\xE2EA\
+\\x60AA\xE2EB\
+\\x60AB\xE2EC\
+\\x60AC\xE2ED\
+\\x60AD\xFB89\
+\\x60AE\xE2EE\
+\\x60AF\xE2F0\
+\\x60B0\xE2F1\
+\\x60B1\xE2F3\
+\\x60B2\xE2F5\
+\\x60B3\xE2F2\
+\\x60B4\xE2F4\
+\\x60B5\xE2F7\
+\\x60B6\xE2F8\
+\\x60B7\xE2F9\
+\\x60B8\xE2FA\
+\\x60B9\xE2FC\
+\\x60BA\xE340\
+\\x60BB\xE341\
+\\x60BC\xE342\
+\\x60BD\xE343\
+\\x60BE\xE344\
+\\x60BF\xE345\
+\\x60C0\xE346\
+\\x60C1\xE347\
+\\x60C2\xE348\
+\\x60C3\xE349\
+\\x60C4\xFB8A\
+\\x60C5\xE34A\
+\\x60C6\xFB8B\
+\\x60C7\xE34B\
+\\x60C8\xE34C\
+\\x60C9\xE34D\
+\\x60CA\xE34F\
+\\x60CB\xE350\
+\\x60CC\xE351\
+\\x60CD\xE352\
+\\x60CE\xE353\
+\\x60CF\xE354\
+\\x60D0\xE355\
+\\x60D1\xE35A\
+\\x60D2\xE35B\
+\\x60D3\xE35C\
+\\x60D4\xFB8C\
+\\x60D5\xE35D\
+\\x60D6\xE35E\
+\\x60D7\xE35F\
+\\x60D8\xE361\
+\\x60D9\xE362\
+\\x60DA\xFB8D\
+\\x60DB\xE364\
+\\x60DC\xE365\
+\\x60DD\xE366\
+\\x60DE\xE38E\
+\\x60DF\xE367\
+\\x60E0\xE368\
+\\x60E1\xFB8E\
+\\x60E2\xE369\
+\\x60E3\xE36A\
+\\x60E4\xE36B\
+\\x60E5\xE376\
+\\x60E6\xE36C\
+\\x60E7\xE36D\
+\\x60E8\xE363\
+\\x60E9\xE36E\
+\\x60EA\xE36F\
+\\x60EB\xE371\
+\\x60EC\xE372\
+\\x60ED\xE374\
+\\x60EE\xE375\
+\\x60EF\xE381\
+\\x60F0\xE378\
+\\x60F1\xE379\
+\\x60F2\xE373\
+\\x60F3\xE360\
+\\x60F4\xE37B\
+\\x60F5\xE37A\
+\\x60F6\xE37C\
+\\x60F7\xE37D\
+\\x60F8\xE37E\
+\\x60F9\xE380\
+\\x60FA\xE383\
+\\x60FB\xE384\
+\\x60FC\xE385\
+\\x60FD\xFB8F\
+\\x60FE\xE386\
+\\x6141\xE387\
+\\x6142\xE382\
+\\x6143\xE388\
+\\x6144\xE389\
+\\x6145\xE38A\
+\\x6146\xE38B\
+\\x6147\xE38C\
+\\x6148\xE38F\
+\\x6149\xE390\
+\\x614A\xE391\
+\\x614B\xE38D\
+\\x614C\xE393\
+\\x614D\xE39A\
+\\x614E\xE394\
+\\x614F\xE395\
+\\x6150\xE397\
+\\x6151\xE398\
+\\x6152\xE399\
+\\x6153\xE39B\
+\\x6154\xE39D\
+\\x6155\xE39E\
+\\x6156\xE39F\
+\\x6157\xFB90\
+\\x6158\xE3A0\
+\\x6159\xE3A2\
+\\x615A\xE3A4\
+\\x615B\xE3A5\
+\\x615C\xE3A6\
+\\x615D\xE3A7\
+\\x615E\xE3A8\
+\\x615F\xE3A9\
+\\x6160\xE3AA\
+\\x6161\xE3AC\
+\\x6162\xE3AB\
+\\x6163\xE3AD\
+\\x6164\xE3AE\
+\\x6165\xE3AF\
+\\x6166\xE3B0\
+\\x6167\xE3B2\
+\\x6168\xE3B1\
+\\x6169\xE3B3\
+\\x616A\xE3B4\
+\\x616B\xE3B5\
+\\x616C\xE3B6\
+\\x616D\xE3B7\
+\\x616E\xFB91\
+\\x616F\xE3B8\
+\\x6170\xE3B9\
+\\x6171\xE3BC\
+\\x6172\xE3BA\
+\\x6173\xE3BB\
+\\x6174\xE3BD\
+\\x6175\xE3BE\
+\\x6176\xE3BF\
+\\x6177\xFB92\
+\\x6178\xE3C0\
+\\x6179\xE3C1\
+\\x617A\xE3C2\
+\\x617B\xE3C3\
+\\x617C\xE3C5\
+\\x617D\xE3C6\
+\\x617E\xE3C7\
+\\x617F\xE3C8\
+\\x6180\xE3C9\
+\\x6181\xE3CC\
+\\x6182\xE3CD\
+\\x6183\xE3CE\
+\\x6184\xE3D0\
+\\x6185\xE3D1\
+\\x6186\xE3D2\
+\\x6187\xE3D3\
+\\x6188\xE3D4\
+\\x6189\xE3D5\
+\\x618A\xE3D6\
+\\x618B\xE3D7\
+\\x618C\xE3D8\
+\\x618D\xE3D9\
+\\x618E\xE3DB\
+\\x618F\xE3DC\
+\\x6190\xE3DD\
+\\x6191\xE3DE\
+\\x6192\xE3DF\
+\\x6193\xE3E0\
+\\x6194\xE3E1\
+\\x6195\xE3E2\
+\\x6196\xE3E3\
+\\x6197\xE3E4\
+\\x6198\xE3E5\
+\\x6199\xE3E7\
+\\x619A\xE3E9\
+\\x619B\xE3EA\
+\\x619C\xE3EB\
+\\x619D\xE3EC\
+\\x619E\xE3ED\
+\\x619F\xE3EE\
+\\x61A0\xE3EF\
+\\x61A1\xE3F0\
+\\x61A2\xE3F1\
+\\x61A3\xE3F2\
+\\x61A4\xE3F3\
+\\x61A5\xE3F5\
+\\x61A6\xE3F6\
+\\x61A7\xE3F7\
+\\x61A8\xE3F8\
+\\x61A9\xE3FA\
+\\x61AA\xE3FB\
+\\x61AB\xE3FC\
+\\x61AC\xE441\
+\\x61AD\xE442\
+\\x61AE\xE443\
+\\x61AF\xE444\
+\\x61B0\xE445\
+\\x61B1\xE446\
+\\x61B2\xE447\
+\\x61B3\xE448\
+\\x61B4\xE454\
+\\x61B5\xE449\
+\\x61B6\xE44A\
+\\x61B7\xE44B\
+\\x61B8\xE44C\
+\\x61B9\xE44D\
+\\x61BA\xE44E\
+\\x61BB\xE44F\
+\\x61BC\xE450\
+\\x61BD\xE451\
+\\x61BE\xE453\
+\\x61BF\xE455\
+\\x61C0\xE458\
+\\x61C1\xE452\
+\\x61C2\xE456\
+\\x61C3\xE45A\
+\\x61C4\xE457\
+\\x61C5\xE464\
+\\x61C6\xE459\
+\\x61C7\xE45B\
+\\x61C8\xE45C\
+\\x61C9\xE45D\
+\\x61CA\xE45E\
+\\x61CB\xE45F\
+\\x61CC\xE460\
+\\x61CD\xE461\
+\\x61CE\xE463\
+\\x61CF\xE462\
+\\x61D0\xE465\
+\\x61D1\xE466\
+\\x61D2\xE467\
+\\x61D3\xE469\
+\\x61D4\xE46A\
+\\x61D5\xE46B\
+\\x61D6\xE46C\
+\\x61D7\xE46D\
+\\x61D8\xE46E\
+\\x61D9\xE471\
+\\x61DA\xE472\
+\\x61DB\x98AE\
+\\x61DC\xE473\
+\\x61DD\xE474\
+\\x61DE\xE475\
+\\x61DF\xE484\
+\\x61E0\xE476\
+\\x61E1\xE477\
+\\x61E2\xE478\
+\\x61E3\xE479\
+\\x61E4\xE47C\
+\\x61E5\xE47B\
+\\x61E6\xE47D\
+\\x61E7\xE47E\
+\\x61E8\xE480\
+\\x61E9\xE481\
+\\x61EA\xE482\
+\\x61EB\xE483\
+\\x61EC\xE485\
+\\x61ED\xE486\
+\\x61EE\xE488\
+\\x61EF\xE489\
+\\x61F0\xE48A\
+\\x61F1\xE48B\
+\\x61F2\xE48C\
+\\x61F3\xE48D\
+\\x61F4\xE48E\
+\\x61F5\xE48F\
+\\x61F6\xE490\
+\\x61F7\xE491\
+\\x61F8\xFB93\
+\\x61F9\xE492\
+\\x61FA\xE493\
+\\x61FB\xE494\
+\\x61FC\xE497\
+\\x61FD\xE498\
+\\x61FE\xE499\
+\\x6241\xE49A\
+\\x6242\xE49B\
+\\x6243\xE49C\
+\\x6244\xE495\
+\\x6245\xE49D\
+\\x6246\xE49E\
+\\x6247\xE49F\
+\\x6248\xFB94\
+\\x6249\xE4A0\
+\\x624A\xE4A1\
+\\x624B\xE4A3\
+\\x624C\xE4A4\
+\\x624D\xE4A5\
+\\x624E\xE4A6\
+\\x624F\xE4A7\
+\\x6250\xE4A8\
+\\x6251\xE4A9\
+\\x6252\xE4AB\
+\\x6253\xE4AD\
+\\x6254\xE4AE\
+\\x6255\xE4AF\
+\\x6256\xE4B0\
+\\x6257\xE4B1\
+\\x6258\xE4B2\
+\\x6259\xE4B3\
+\\x625A\xE4B9\
+\\x625B\xFB95\
+\\x625C\xE4B5\
+\\x625D\xE4B6\
+\\x625E\xE4B7\
+\\x625F\xE4B8\
+\\x6260\xE496\
+\\x6261\xE4BA\
+\\x6262\xE4AC\
+\\x6263\xE4BB\
+\\x6264\xE4BC\
+\\x6265\xE4BD\
+\\x6266\xE4BE\
+\\x6267\xFB96\
+\\x6268\xE4C0\
+\\x6269\xE4C6\
+\\x626A\xE4C1\
+\\x626B\xE4C2\
+\\x626C\xE4C3\
+\\x626D\xE4C4\
+\\x626E\xE4C5\
+\\x626F\xE4C7\
+\\x6270\xE4C8\
+\\x6271\xE4C9\
+\\x6272\xE4CA\
+\\x6273\xE4CC\
+\\x6274\xFB97\
+\\x6275\xE4CD\
+\\x6276\xE4D0\
+\\x6277\xE4D2\
+\\x6278\xE4E2\
+\\x6279\xE4D3\
+\\x627A\xE4D5\
+\\x627B\xE4D6\
+\\x627C\xE4D7\
+\\x627D\xE4DF\
+\\x627E\xFB98\
+\\x627F\xE4D9\
+\\x6280\xE4DA\
+\\x6281\xE4DB\
+\\x6282\xE4DC\
+\\x6283\xE4DE\
+\\x6284\xE4CE\
+\\x6285\xE4E0\
+\\x6286\xE4E1\
+\\x6287\xE4E3\
+\\x6288\xE4E4\
+\\x6289\xE4E5\
+\\x628A\xFB99\
+\\x628B\xE4E7\
+\\x628C\xE4E8\
+\\x628D\xE4E9\
+\\x628E\xE4EA\
+\\x628F\xE4EB\
+\\x6290\xE4D8\
+\\x6291\xE4EC\
+\\x6292\xE4ED\
+\\x6293\xE4EE\
+\\x6294\xE4E6\
+\\x6295\xE4F0\
+\\x6296\xE4F1\
+\\x6297\xE4F2\
+\\x6298\xE4F3\
+\\x6299\xE4F4\
+\\x629A\xE4F5\
+\\x629B\xE4F6\
+\\x629C\xE4F7\
+\\x629D\xE4CF\
+\\x629E\xFB9A\
+\\x629F\xE4D4\
+\\x62A0\xE4F9\
+\\x62A1\xFB9B\
+\\x62A2\xE4FA\
+\\x62A3\xE4FB\
+\\x62A4\xE4FC\
+\\x62A5\xE540\
+\\x62A6\x8EC7\
+\\x62A7\xE542\
+\\x62A8\xFB9C\
+\\x62A9\xE543\
+\\x62AA\xE544\
+\\x62AB\xE545\
+\\x62AC\xE546\
+\\x62AD\xE547\
+\\x62AE\xE548\
+\\x62AF\xE549\
+\\x62B0\xE54A\
+\\x62B1\xE54B\
+\\x62B2\xE54C\
+\\x62B3\x96F7\
+\\x62B4\xE54E\
+\\x62B5\xE54F\
+\\x62B6\xE550\
+\\x62B7\xE551\
+\\x62B8\xE552\
+\\x62B9\xFB9D\
+\\x62BA\xE470\
+\\x62BB\xFB9E\
+\\x62BC\xE553\
+\\x62BD\xE554\
+\\x62BE\xE555\
+\\x62BF\xE556\
+\\x62C0\xE557\
+\\x62C1\xE558\
+\\x62C2\xE559\
+\\x62C3\xE55A\
+\\x62C4\xE55B\
+\\x62C5\xE55C\
+\\x62C6\xE55D\
+\\x62C7\xE55E\
+\\x62C8\xE55F\
+\\x62C9\xE560\
+\\x62CA\xE563\
+\\x62CB\xE564\
+\\x62CC\xE565\
+\\x62CD\xE566\
+\\x62CE\xFB9F\
+\\x62CF\xE567\
+\\x62D0\xE568\
+\\x62D1\x997C\
+\\x62D2\xE56A\
+\\x62D3\xE56B\
+\\x62D4\xE56C\
+\\x62D5\xE56D\
+\\x62D6\xE56E\
+\\x62D7\xE56F\
+\\x62D8\xE571\
+\\x62D9\xE570\
+\\x62DA\xE572\
+\\x62DB\xE573\
+\\x62DC\xE574\
+\\x62DD\xE575\
+\\x62DE\xE576\
+\\x62DF\xE577\
+\\x62E0\xE578\
+\\x62E1\x8A61\
+\\x62E2\xFBA0\
+\\x62E3\xE57A\
+\\x62E4\xE57B\
+\\x62E5\xE57C\
+\\x62E6\xE57D\
+\\x62E7\xE57E\
+\\x62E8\xE580\
+\\x62E9\xE581\
+\\x62EA\xE583\
+\\x62EB\xE584\
+\\x62EC\xE585\
+\\x62ED\xE586\
+\\x62EE\xE587\
+\\x62EF\xE588\
+\\x62F0\xE589\
+\\x62F1\xE58A\
+\\x62F2\xE58B\
+\\x62F3\xE58C\
+\\x62F4\xE58D\
+\\x62F5\xE58E\
+\\x62F6\xE58F\
+\\x62F7\xE591\
+\\x62F8\xE592\
+\\x62F9\xE593\
+\\x62FA\xE594\
+\\x62FB\xE596\
+\\x62FC\xE597\
+\\x62FD\xE598\
+\\x62FE\xE599\
+\\x6341\xE59A\
+\\x6342\xE59B\
+\\x6343\xE59C\
+\\x6344\xE5A5\
+\\x6345\xE5A1\
+\\x6346\xE595\
+\\x6347\xE59D\
+\\x6348\xE59E\
+\\x6349\xE59F\
+\\x634A\xE5A0\
+\\x634B\x9488\
+\\x634C\xE5A3\
+\\x634D\xE5B0\
+\\x634E\xE5A4\
+\\x634F\xE5A6\
+\\x6350\xE5A7\
+\\x6351\xE5A8\
+\\x6352\xE5A9\
+\\x6353\xE5AA\
+\\x6354\xE5AB\
+\\x6355\xE5AC\
+\\x6356\xE5AD\
+\\x6357\xE5AE\
+\\x6358\xE5BB\
+\\x6359\xE5B1\
+\\x635A\xE5B2\
+\\x635B\xE5B3\
+\\x635C\xE5B4\
+\\x635D\xE5BA\
+\\x635E\xFBA1\
+\\x635F\xE5B5\
+\\x6360\xE5BD\
+\\x6361\xE5B6\
+\\x6362\xE5B7\
+\\x6363\xE5B8\
+\\x6364\xE5B9\
+\\x6365\xE5BC\
+\\x6366\xE5BE\
+\\x6367\xE5BF\
+\\x6368\xE5C0\
+\\x6369\xE5C4\
+\\x636A\xE5C1\
+\\x636B\xE5C2\
+\\x636C\xE5C3\
+\\x636D\xE5C5\
+\\x636E\xE5C7\
+\\x636F\xE5C6\
+\\x6370\x9FA5\
+\\x6371\xE5C8\
+\\x6372\xE5C9\
+\\x6373\xE5CA\
+\\x6374\xE5CB\
+\\x6375\xE5CC\
+\\x6376\xE5CD\
+\\x6377\xE5CE\
+\\x6378\xE5D0\
+\\x6379\xE5D1\
+\\x637A\xE5D3\
+\\x637B\xE5D4\
+\\x637C\xE5CF\
+\\x637D\xE5D5\
+\\x637E\xE5D6\
+\\x637F\xE5D7\
+\\x6380\xE5D8\
+\\x6381\xE5D9\
+\\x6382\xE5DA\
+\\x6383\xE5DB\
+\\x6384\xE5DD\
+\\x6385\xE5D2\
+\\x6386\xE5DE\
+\\x6387\xE5DF\
+\\x6388\xE5E0\
+\\x6389\xE5E1\
+\\x638A\xE5E2\
+\\x638B\xE5E3\
+\\x638C\xE5E4\
+\\x638D\xE5E5\
+\\x638E\xE5E6\
+\\x638F\xE5E7\
+\\x6390\xFBA2\
+\\x6391\xE5E9\
+\\x6392\xE5EA\
+\\x6393\xE5EB\
+\\x6394\xE5EC\
+\\x6395\xE5F2\
+\\x6396\xE5FA\
+\\x6397\xE5ED\
+\\x6398\xE5EE\
+\\x6399\xE5F0\
+\\x639A\xE5F1\
+\\x639B\xE5F3\
+\\x639C\xE5F4\
+\\x639D\xE5F6\
+\\x639E\xE5F7\
+\\x639F\xE5EF\
+\\x63A0\xE5F8\
+\\x63A1\xE8B5\
+\\x63A2\xE5F9\
+\\x63A3\xE5FB\
+\\x63A4\xE5FC\
+\\x63A5\xE640\
+\\x63A6\xE643\
+\\x63A7\xE641\
+\\x63A8\xE642\
+\\x63A9\xE644\
+\\x63AA\xE645\
+\\x63AB\xE646\
+\\x63AC\xE647\
+\\x63AD\xE648\
+\\x63AE\xE649\
+\\x63AF\xE64A\
+\\x63B0\xE64B\
+\\x63B1\xE64C\
+\\x63B2\xE64D\
+\\x63B3\xE64E\
+\\x63B4\xE64F\
+\\x63B5\xE650\
+\\x63B6\xE651\
+\\x63B7\xE652\
+\\x63B8\xE653\
+\\x63B9\xE655\
+\\x63BA\xE654\
+\\x63BB\xE656\
+\\x63BC\xE657\
+\\x63BD\xE659\
+\\x63BE\xE65A\
+\\x63BF\xE65B\
+\\x63C0\xE65C\
+\\x63C1\xE65D\
+\\x63C2\xE65E\
+\\x63C3\xE65F\
+\\x63C4\xE660\
+\\x63C5\xFBA3\
+\\x63C6\xE661\
+\\x63C7\xE662\
+\\x63C8\xE663\
+\\x63C9\xE664\
+\\x63CA\xE665\
+\\x63CB\xFBA4\
+\\x63CC\xE666\
+\\x63CD\xE667\
+\\x63CE\xE668\
+\\x63CF\xE669\
+\\x63D0\xE66A\
+\\x63D1\xE66B\
+\\x63D2\xE66C\
+\\x63D3\xE66D\
+\\x63D4\xFBA5\
+\\x63D5\xE66E\
+\\x63D6\xE66F\
+\\x63D7\xE670\
+\\x63D8\xE671\
+\\x63D9\xE672\
+\\x63DA\xE673\
+\\x63DB\xE674\
+\\x63DC\xE675\
+\\x63DD\xE676\
+\\x63DE\xE677\
+\\x63DF\xFBA6\
+\\x63E0\x8AD0\
+\\x63E1\xFBA7\
+\\x63E2\xE679\
+\\x63E3\xE67A\
+\\x63E4\xE67B\
+\\x63E5\xE67D\
+\\x63E6\xE67E\
+\\x63E7\xE680\
+\\x63E8\xE681\
+\\x63E9\xE682\
+\\x63EA\xE683\
+\\x63EB\xE684\
+\\x63EC\xE68B\
+\\x63ED\xFBA8\
+\\x63EE\xFBA9\
+\\x63EF\xFBAA\
+\\x63F0\xE685\
+\\x63F1\xE686\
+\\x63F2\xE687\
+\\x63F3\xE688\
+\\x63F4\xE689\
+\\x63F5\xE68A\
+\\x63F6\xE68C\
+\\x63F7\xE68D\
+\\x63F8\xE68E\
+\\x63F9\xE68F\
+\\x63FA\xE690\
+\\x63FB\xE696\
+\\x63FC\xE691\
+\\x63FD\xE692\
+\\x63FE\xE693\
+\\x6441\xE694\
+\\x6442\xE697\
+\\x6443\xE698\
+\\x6444\xE699\
+\\x6445\xFBAB\
+\\x6446\xE69A\
+\\x6447\xE69B\
+\\x6448\xE69C\
+\\x6449\xE69D\
+\\x644A\xE6A2\
+\\x644B\xE69E\
+\\x644C\xE69F\
+\\x644D\xE6A0\
+\\x644E\xE6A1\
+\\x644F\xE6A3\
+\\x6450\xFBAC\
+\\x6451\xE6A4\
+\\x6452\xE6A5\
+\\x6453\xE6A6\
+\\x6454\xE6AA\
+\\x6455\xE6A7\
+\\x6456\xE6A8\
+\\x6457\xE6A9\
+\\x6458\xE6AB\
+\\x6459\xE6AC\
+\\x645A\xE6AD\
+\\x645B\xE6AE\
+\\x645C\xE6AF\
+\\x645D\xE6B0\
+\\x645E\xE6B1\
+\\x645F\xE6B2\
+\\x6460\xE6B3\
+\\x6461\xE6B4\
+\\x6462\xE6B5\
+\\x6463\xE6B6\
+\\x6464\xE6B7\
+\\x6465\xE6BF\
+\\x6466\xE6B8\
+\\x6467\xE6B9\
+\\x6468\xE6BA\
+\\x6469\xE6BB\
+\\x646A\xE6BC\
+\\x646B\xE6BD\
+\\x646C\xE6C0\
+\\x646D\xE6BE\
+\\x646E\xE6C1\
+\\x646F\xE6C2\
+\\x6470\xE6C3\
+\\x6471\xE6C7\
+\\x6472\xE6C4\
+\\x6473\xE6C5\
+\\x6474\xE6C6\
+\\x6475\xE6CA\
+\\x6476\xE6C8\
+\\x6477\xE6C9\
+\\x6478\x9147\
+\\x6479\xE6DA\
+\\x647A\xE6CC\
+\\x647B\xE6CD\
+\\x647C\xFBAD\
+\\x647D\xFBAE\
+\\x647E\xE6CE\
+\\x647F\xE6CF\
+\\x6480\xE6D0\
+\\x6481\xE6D4\
+\\x6482\xE6D3\
+\\x6483\xE6D5\
+\\x6484\xE6D6\
+\\x6485\xFBAF\
+\\x6486\xE6D7\
+\\x6487\xE6D9\
+\\x6488\xE6DB\
+\\x6489\xE6DC\
+\\x648A\xE6DD\
+\\x648B\xE6DE\
+\\x648C\xE6DF\
+\\x648D\xFBB0\
+\\x648E\xFBB1\
+\\x648F\xE6E1\
+\\x6490\xE6E3\
+\\x6491\xE6E4\
+\\x6492\xE6E5\
+\\x6493\xE6E6\
+\\x6494\xE6E7\
+\\x6495\xE6E8\
+\\x6496\xE6E9\
+\\x6497\xE6EA\
+\\x6498\xE6EB\
+\\x6499\xE6EC\
+\\x649A\xE6ED\
+\\x649B\xE6EE\
+\\x649C\xE6EF\
+\\x649D\xE6F0\
+\\x649E\xE6F1\
+\\x649F\xE6F3\
+\\x64A0\xE6F2\
+\\x64A1\xE6F4\
+\\x64A2\xE6F5\
+\\x64A3\xE6F6\
+\\x64A4\xE6F7\
+\\x64A5\xE6F8\
+\\x64A6\xE6F9\
+\\x64A7\xE6FA\
+\\x64A8\xE6FB\
+\\x64A9\xE6FC\
+\\x64AA\xE740\
+\\x64AB\xE741\
+\\x64AC\xE742\
+\\x64AD\xE743\
+\\x64AE\xE744\
+\\x64AF\xE745\
+\\x64B0\xE746\
+\\x64B1\xE747\
+\\x64B2\xE74A\
+\\x64B3\xE749\
+\\x64B4\xE74B\
+\\x64B5\xE74C\
+\\x64B6\xE74F\
+\\x64B7\xE74D\
+\\x64B8\xE74E\
+\\x64B9\xE750\
+\\x64BA\xE751\
+\\x64BB\xE752\
+\\x64BC\xE753\
+\\x64BD\xE754\
+\\x64BE\xE755\
+\\x64BF\xE756\
+\\x64C0\xE757\
+\\x64C1\xE759\
+\\x64C2\xE758\
+\\x64C3\xE75D\
+\\x64C4\xE75E\
+\\x64C5\xE75C\
+\\x64C6\xE75F\
+\\x64C7\xE760\
+\\x64C8\xE761\
+\\x64C9\xFBB2\
+\\x64CA\xE762\
+\\x64CB\xE763\
+\\x64CC\xE764\
+\\x64CD\xE765\
+\\x64CE\xE766\
+\\x64CF\xE767\
+\\x64D0\xE768\
+\\x64D1\xE771\
+\\x64D2\xE769\
+\\x64D3\xE76A\
+\\x64D4\xE76B\
+\\x64D5\xE76D\
+\\x64D6\xE76E\
+\\x64D7\xE76C\
+\\x64D8\xE76F\
+\\x64D9\xE772\
+\\x64DA\xE773\
+\\x64DB\xE774\
+\\x64DC\xE775\
+\\x64DD\xE776\
+\\x64DE\xE777\
+\\x64DF\xE778\
+\\x64E0\xE77A\
+\\x64E1\xE77B\
+\\x64E2\xE779\
+\\x64E3\xE77C\
+\\x64E4\xE77D\
+\\x64E5\xE77E\
+\\x64E6\xE780\
+\\x64E7\xE781\
+\\x64E8\xE782\
+\\x64E9\xE783\
+\\x64EA\xE784\
+\\x64EB\xE785\
+\\x64EC\x999E\
+\\x64ED\x999F\
+\\x64EE\xE786\
+\\x64EF\xE787\
+\\x64F0\xE788\
+\\x64F1\xFBB3\
+\\x64F2\xE789\
+\\x64F3\xE78A\
+\\x64F4\xE78B\
+\\x64F5\xE78D\
+\\x64F6\x93F4\
+\\x64F7\xE78F\
+\\x64F8\xE790\
+\\x64F9\xE791\
+\\x64FA\xE79E\
+\\x64FB\xE793\
+\\x64FC\xE794\
+\\x64FD\xE7A3\
+\\x64FE\xE795\
+\\x6541\xE796\
+\\x6542\xE797\
+\\x6543\xE798\
+\\x6544\xE799\
+\\x6545\xE79A\
+\\x6546\xE79B\
+\\x6547\xE79D\
+\\x6548\xE79F\
+\\x6549\xFBB4\
+\\x654A\xE7A0\
+\\x654B\xE7A1\
+\\x654C\xE7A2\
+\\x654D\xE7A4\
+\\x654E\xE7A5\
+\\x654F\xE7A6\
+\\x6550\xE7A7\
+\\x6551\xE7A8\
+\\x6552\xE7A9\
+\\x6553\xFBB5\
+\\x6554\xE7AA\
+\\x6555\xE7AB\
+\\x6556\xE7AC\
+\\x6557\xE7AD\
+\\x6558\xE7AE\
+\\x6559\xE7AF\
+\\x655A\xE7B3\
+\\x655B\xE7B1\
+\\x655C\xE7B4\
+\\x655D\xE7BB\
+\\x655E\xE7B6\
+\\x655F\xE7B7\
+\\x6560\xE7B8\
+\\x6561\xE7B9\
+\\x6562\xE7BA\
+\\x6563\xE7BC\
+\\x6564\xFBB6\
+\\x6565\xE7BD\
+\\x6566\xFBB7\
+\\x6567\xFBB8\
+\\x6568\xE7BE\
+\\x6569\xE7BF\
+\\x656A\xE7C0\
+\\x656B\xFBB9\
+\\x656C\xE7C1\
+\\x656D\xE7C2\
+\\x656E\xE7C3\
+\\x656F\xE7C4\
+\\x6570\xE7C5\
+\\x6571\xE7C6\
+\\x6572\xE7C7\
+\\x6573\xE7C8\
+\\x6574\xE7C9\
+\\x6575\xE7CA\
+\\x6576\xE7CB\
+\\x6577\xE7CC\
+\\x6578\xE7CD\
+\\x6579\xE7CE\
+\\x657A\xE7CF\
+\\x657B\xE7D0\
+\\x657C\xE7D1\
+\\x657D\xE7D2\
+\\x657E\xE7D3\
+\\x657F\xE7D4\
+\\x6580\xE7D5\
+\\x6581\xE7D7\
+\\x6582\xE7D8\
+\\x6583\xFBBA\
+\\x6584\xE7DC\
+\\x6585\xFBBB\
+\\x6586\xFBBC\
+\\x6587\xE7D9\
+\\x6588\xE7DA\
+\\x6589\xE7DB\
+\\x658A\xFBBD\
+\\x658B\xE7DE\
+\\x658C\xFBBE\
+\\x658D\xFBBF\
+\\x658E\xE7DF\
+\\x658F\xFBC0\
+\\x6590\xFBC1\
+\\x6591\xE7E0\
+\\x6592\xE7E1\
+\\x6593\xFBC2\
+\\x6594\xE7E2\
+\\x6595\xFBC3\
+\\x6596\xE7E3\
+\\x6597\xE7E4\
+\\x6598\xE86E\
+\\x6599\xE7E7\
+\\x659A\xE7E8\
+\\x659B\xFBC4\
+\\x659C\xE7E9\
+\\x659D\xE7EA\
+\\x659E\xFBC5\
+\\x659F\xFBC6\
+\\x65A0\xE7EB\
+\\x65A1\xFBC7\
+\\x65A2\xE7EF\
+\\x65A3\xFBC8\
+\\x65A4\xE7ED\
+\\x65A5\xFBC9\
+\\x65A6\xFBCA\
+\\x65A7\xE7EE\
+\\x65A8\xFBCB\
+\\x65A9\xE7F4\
+\\x65AA\xE7F0\
+\\x65AB\xFBCC\
+\\x65AC\xFBCD\
+\\x65AD\xFBCE\
+\\x65AE\xE7F1\
+\\x65AF\xE7F2\
+\\x65B0\xE7F3\
+\\x65B1\xE7EC\
+\\x65B2\xE7F8\
+\\x65B3\xE7F5\
+\\x65B4\xFBCF\
+\\x65B5\xFBD0\
+\\x65B6\xFBD1\
+\\x65B7\xFBD2\
+\\x65B8\xFBD3\
+\\x65B9\xFBD4\
+\\x65BA\xE7F6\
+\\x65BB\xE7F7\
+\\x65BC\xFBD5\
+\\x65BD\xFBD6\
+\\x65BE\xE844\
+\\x65BF\xE845\
+\\x65C0\xE7F9\
+\\x65C1\xFBD7\
+\\x65C2\xE7FA\
+\\x65C3\xFBD8\
+\\x65C4\xE7FB\
+\\x65C5\xFBD9\
+\\x65C6\xFBDA\
+\\x65C7\xE840\
+\\x65C8\xFBDB\
+\\x65C9\xFBDC\
+\\x65CA\xE841\
+\\x65CB\xE842\
+\\x65CC\xFBDD\
+\\x65CD\xE843\
+\\x65CE\xFBDE\
+\\x65CF\xE846\
+\\x65D0\xFBDF\
+\\x65D1\xE848\
+\\x65D2\xE849\
+\\x65D3\xE84A\
+\\x65D4\xE84B\
+\\x65D5\xFBE0\
+\\x65D6\xE850\
+\\x65D7\xE84C\
+\\x65D8\xFBE1\
+\\x65D9\xE84E\
+\\x65DA\xE84F\
+\\x65DB\xE859\
+\\x65DC\xE851\
+\\x65DD\xFBE2\
+\\x65DE\xE852\
+\\x65DF\xE853\
+\\x65E0\xE854\
+\\x65E1\xE855\
+\\x65E2\xE856\
+\\x65E3\xE857\
+\\x65E4\xFBE3\
+\\x65E5\xE858\
+\\x65E6\xE85A\
+\\x65E7\xE85B\
+\\x65E8\xFBE4\
+\\x65E9\xE85C\
+\\x65EA\xE85D\
+\\x65EB\xE864\
+\\x65EC\xE85E\
+\\x65ED\xE85F\
+\\x65EE\xE861\
+\\x65EF\xE862\
+\\x65F0\xFBE5\
+\\x65F1\xE865\
+\\x65F2\xE866\
+\\x65F3\xE867\
+\\x65F4\xFBE6\
+\\x65F5\xE868\
+\\x65F6\xFBE7\
+\\x65F7\xE869\
+\\x65F8\xE873\
+\\x65F9\xE86A\
+\\x65FA\xE86B\
+\\x65FB\xE86C\
+\\x65FC\xE86D\
+\\x65FD\xE870\
+\\x65FE\xE86F\
+\\x6641\xE871\
+\\x6642\xE877\
+\\x6643\xE872\
+\\x6644\xE874\
+\\x6645\xE875\
+\\x6646\xE876\
+\\x6647\xE878\
+\\x6648\xE879\
+\\x6649\xE87A\
+\\x664A\xFBE8\
+\\x664B\xE87B\
+\\x664C\xE87C\
+\\x664D\xE87D\
+\\x664E\xE87E\
+\\x664F\xE880\
+\\x6650\xE881\
+\\x6651\xE882\
+\\x6652\xE883\
+\\x6653\xE884\
+\\x6654\xE885\
+\\x6655\xE886\
+\\x6656\xE887\
+\\x6657\xE888\
+\\x6658\xE889\
+\\x6659\xE88A\
+\\x665A\xE88B\
+\\x665B\xE88C\
+\\x665C\xE88D\
+\\x665D\xE88E\
+\\x665E\xE88F\
+\\x665F\xE890\
+\\x6660\xE891\
+\\x6661\xE892\
+\\x6662\xE893\
+\\x6663\xE894\
+\\x6664\xE895\
+\\x6665\xE896\
+\\x6666\xE897\
+\\x6667\xE898\
+\\x6668\xE89A\
+\\x6669\xE899\
+\\x666A\xE89B\
+\\x666B\xE89D\
+\\x666C\xE89F\
+\\x666D\xE8A0\
+\\x666E\xE8A1\
+\\x666F\xE89C\
+\\x6670\xE8A2\
+\\x6671\xE8A3\
+\\x6672\xE8A4\
+\\x6673\xE440\
+\\x6674\xFBE9\
+\\x6675\xE8A5\
+\\x6676\xE8A6\
+\\x6677\xE8A7\
+\\x6678\xFBEA\
+\\x6679\xFBEB\
+\\x667A\xE8A9\
+\\x667B\xE8A8\
+\\x667C\xE8AA\
+\\x667D\xE8AB\
+\\x667E\xE8AC\
+\\x667F\xFBEC\
+\\x6680\xE8AD\
+\\x6681\xE8AE\
+\\x6682\xE8AF\
+\\x6683\xE8B0\
+\\x6684\xE8B1\
+\\x6685\xE8B2\
+\\x6686\xE8B8\
+\\x6687\xE8B6\
+\\x6688\x99D4\
+\\x6689\xE8B9\
+\\x668A\xE8BA\
+\\x668B\xE8BB\
+\\x668C\xE8BC\
+\\x668D\xE8C2\
+\\x668E\xE8B7\
+\\x668F\xE8BD\
+\\x6690\xE8BE\
+\\x6691\xE8BF\
+\\x6692\xE8C0\
+\\x6693\xE8C1\
+\\x6694\xE8C3\
+\\x6695\xE8C4\
+\\x6696\xE8C5\
+\\x6697\xFBED\
+\\x6698\xE8C6\
+\\x6699\xFBEE\
+\\x669A\xE8C7\
+\\x669B\xE8C8\
+\\x669C\xE8CA\
+\\x669D\xE8C9\
+\\x669E\xFBEF\
+\\x669F\xE8CB\
+\\x66A0\xE8CC\
+\\x66A1\xE8CD\
+\\x66A2\xFBF0\
+\\x66A3\xFBF1\
+\\x66A4\xFBF2\
+\\x66A5\xFBF3\
+\\x66A6\xE8CE\
+\\x66A7\xE8CF\
+\\x66A8\xE8D0\
+\\x66A9\xE8D1\
+\\x66AA\xE8D2\
+\\x66AB\x9078\
+\\x66AC\xE8D6\
+\\x66AD\xE8D7\
+\\x66AE\xE8D8\
+\\x66AF\xE8D9\
+\\x66B0\xE8DA\
+\\x66B1\xE8DC\
+\\x66B2\xE8DD\
+\\x66B3\xE8DE\
+\\x66B4\xE8DF\
+\\x66B5\xE8E0\
+\\x66B6\xE8E1\
+\\x66B7\xE8E2\
+\\x66B8\xE8E3\
+\\x66B9\xE8E4\
+\\x66BA\xE8E5\
+\\x66BB\xE8E6\
+\\x66BC\xE8E7\
+\\x66BD\xE8E8\
+\\x66BE\xE8E9\
+\\x66BF\xE8EA\
+\\x66C0\xE8EC\
+\\x66C1\xE8ED\
+\\x66C2\xE8EF\
+\\x66C3\xE8F0\
+\\x66C4\x8C7A\
+\\x66C5\xE8F3\
+\\x66C6\xE8F4\
+\\x66C7\xE8F5\
+\\x66C8\xE8F6\
+\\x66C9\xE8F8\
+\\x66CA\xE8F9\
+\\x66CB\xFBF4\
+\\x66CC\xFBF5\
+\\x66CD\xE8FA\
+\\x66CE\xE8FB\
+\\x66CF\xE8FC\
+\\x66D0\xE940\
+\\x66D1\xE941\
+\\x66D2\xE942\
+\\x66D3\xE943\
+\\x66D4\xE944\
+\\x66D5\xE945\
+\\x66D6\xE946\
+\\x66D7\xE947\
+\\x66D8\xE948\
+\\x66D9\xE949\
+\\x66DA\xE3CA\
+\\x66DB\x99AA\
+\\x66DC\xE94A\
+\\x66DD\xFBF6\
+\\x66DE\xE94B\
+\\x66DF\xFBF7\
+\\x66E0\xE94C\
+\\x66E1\xE952\
+\\x66E2\xE94E\
+\\x66E3\xE94F\
+\\x66E4\xE950\
+\\x66E5\xFBF8\
+\\x66E6\xFBF9\
+\\x66E7\xE951\
+\\x66E8\xE953\
+\\x66E9\xE954\
+\\x66EA\xE955\
+\\x66EB\xE956\
+\\x66EC\xE957\
+\\x66ED\xE958\
+\\x66EE\xE959\
+\\x66EF\xE95A\
+\\x66F0\xE95B\
+\\x66F1\xE95C\
+\\x66F2\xE95D\
+\\x66F3\xE95E\
+\\x66F4\xE95F\
+\\x66F5\xE961\
+\\x66F6\xE962\
+\\x66F7\xE963\
+\\x66F8\xE964\
+\\x66F9\xFBFA\
+\\x66FA\xE965\
+\\x66FB\xE966\
+\\x66FC\xE967\
+\\x66FD\xE968\
+\\x66FE\xE969\
+\\x6741\xE96A\
+\\x6742\xE96B\
+\\x6743\xE96C\
+\\x6744\xE96D\
+\\x6745\xE96E\
+\\x6746\xE96F\
+\\x6747\xE977\
+\\x6748\xE970\
+\\x6749\xE971\
+\\x674A\xE972\
+\\x674B\xE973\
+\\x674C\xE974\
+\\x674D\xE975\
+\\x674E\xE976\
+\\x674F\xE978\
+\\x6750\xE979\
+\\x6751\xE97A\
+\\x6752\xE97D\
+\\x6753\xE97B\
+\\x6754\xE97C\
+\\x6755\xE97E\
+\\x6756\xE980\
+\\x6757\xE981\
+\\x6758\xE982\
+\\x6759\xFBFB\
+\\x675A\xE983\
+\\x675B\xE984\
+\\x675C\xE985\
+\\x675D\xE986\
+\\x675E\xE989\
+\\x675F\xE987\
+\\x6760\xE988\
+\\x6761\xE98B\
+\\x6762\xE98A\
+\\x6763\xE98C\
+\\x6764\xE98D\
+\\x6765\xE98E\
+\\x6766\xE98F\
+\\x6767\xE990\
+\\x6768\xE992\
+\\x6769\xE993\
+\\x676A\xE991\
+\\x676B\xFBFC\
+\\x676C\xFC40\
+\\x676D\xE994\
+\\x676E\xE995\
+\\x676F\xE996\
+\\x6770\xE997\
+\\x6771\xE998\
+\\x6772\xE999\
+\\x6773\xE99A\
+\\x6774\xE99B\
+\\x6775\xE99C\
+\\x6776\xE99D\
+\\x6777\xE99E\
+\\x6778\xE99F\
+\\x6779\xE9A0\
+\\x677A\xE9A1\
+\\x677B\xE9A2\
+\\x677C\xE9A3\
+\\x677D\xE9A4\
+\\x677E\xE9A5\
+\\x677F\xE9A6\
+\\x6780\xE9A7\
+\\x6781\xE9A8\
+\\x6782\xE9A9\
+\\x6783\xE9AA\
+\\x6784\xE9AB\
+\\x6785\xE9AC\
+\\x6786\x9F54\
+\\x6787\xE9AD\
+\\x6788\xE2F6\
+\\x6789\xE9AE\
+\\x678A\xE9AF\
+\\x678B\xE9B1\
+\\x678C\xE9B2\
+\\x678D\xE9B3\
+\\x678E\xE9B4\
+\\x678F\xFC41\
+\\x6790\xE9B5\
+\\x6791\xFC42\
+\\x6792\xE9B6\
+\\x6793\xFC43\
+\\x6794\xE9B7\
+\\x6795\xE9B8\
+\\x6796\xE9B9\
+\\x6797\xE9BA\
+\\x6798\xE9BB\
+\\x6799\xE9BC\
+\\x679A\xE9BD\
+\\x679B\xFC44\
+\\x679C\xE9BE\
+\\x679D\xE9BF\
+\\x679E\xE9C0\
+\\x679F\xFC45\
+\\x67A0\xE9C1\
+\\x67A1\xE9C2\
+\\x67A2\xE9C3\
+\\x67A3\xE9C4\
+\\x67A4\xE9C5\
+\\x67A5\xE9C6\
+\\x67A6\xE9C7\
+\\x67A7\xE9C8\
+\\x67A8\xE9C9\
+\\x67A9\xE9CA\
+\\x67AA\x88B1\
+\\x67AB\xE9CD\
+\\x67AC\xE9CC\
+\\x67AD\xE9D8\
+\\x67AE\xE9DA\
+\\x67AF\xE9CF\
+\\x67B0\xE9D0\
+\\x67B1\xFC46\
+\\x67B2\xE9D1\
+\\x67B3\xE9D2\
+\\x67B4\xE9D3\
+\\x67B5\xE9D4\
+\\x67B6\xE9D5\
+\\x67B7\xE9D6\
+\\x67B8\xE9D7\
+\\x67B9\xE9D9\
+\\x67BA\xE9DB\
+\\x67BB\xE9DC\
+\\x67BC\xE9DD\
+\\x67BD\xE9DE\
+\\x67BE\xE9DF\
+\\x67BF\xE9E0\
+\\x67C0\xE9E1\
+\\x67C1\xE9E2\
+\\x67C2\xE9E3\
+\\x67C3\xE9E4\
+\\x67C4\xE9E5\
+\\x67C5\xE9E6\
+\\x67C6\xE9E7\
+\\x67C7\xE9ED\
+\\x67C8\xE9E8\
+\\x67C9\xE9E9\
+\\x67CA\xE9EA\
+\\x67CB\xE9EB\
+\\x67CC\xE9EE\
+\\x67CD\xE9EF\
+\\x67CE\xE9F0\
+\\x67CF\xE9F1\
+\\x67D0\x89A7\
+\\x67D1\xE9F3\
+\\x67D2\xE9F4\
+\\x67D3\xE9F6\
+\\x67D4\xE9F7\
+\\x67D5\xE9F8\
+\\x67D6\xE9F9\
+\\x67D7\xE9F5\
+\\x67D8\xE9FA\
+\\x67D9\xE9FB\
+\\x67DA\xE9FC\
+\\x67DB\xEA40\
+\\x67DC\xEA41\
+\\x67DD\xEA45\
+\\x67DE\xEA43\
+\\x67DF\xEA44\
+\\x67E0\xEA42\
+\\x67E1\xEA46\
+\\x67E2\xFC47\
+\\x67E3\xEA48\
+\\x67E4\xFC48\
+\\x67E5\xEA4A\
+\\x67E6\xEA4B\
+\\x67E7\xEA4C\
+\\x67E8\xEA4D\
+\\x67E9\xEA4E\
+\\x67EA\xEA49\
+\\x67EB\xEA4F\
+\\x67EC\xEA50\
+\\x67ED\xEA51\
+\\x67EE\xEA52\
+\\x67EF\xEA53\
+\\x67F0\xEA54\
+\\x67F1\xEA55\
+\\x67F2\xEA56\
+\\x67F3\xEA57\
+\\x67F4\xFC49\
+\\x67F5\xEA58\
+\\x67F6\xEA59\
+\\x67F7\xEA5A\
+\\x67F8\xEA5B\
+\\x67F9\xEA5C\
+\\x67FA\xEA5D\
+\\x67FB\xEA5E\
+\\x67FC\xEA5F\
+\\x67FD\xEA60\
+\\x67FE\xFC4A\
+\\x6841\xEA61\
+\\x6842\xEA62\
+\\x6843\xEA63\
+\\x6844\xEA64\
+\\x6845\xEA65\
+\\x6846\xEA66\
+\\x6847\xEA67\
+\\x6848\xEA68\
+\\x6849\xEA6A\
+\\x684A\xEA6B\
+\\x684B\xEA6C\
+\\x684C\xEA6D\
+\\x684D\xEA6F\
+\\x684E\xEA70\
+\\x684F\xEA71\
+\\x6850\x9BF5\
+\\x6851\x9F80\
+\\x6852\xEA72\
+\\x6853\xEA73\
+\\x6854\xEA75\
+\\x6855\xEA76\
+\\x6856\xFC4B\
+\\x6857\xEA77\
+\\x6858\xEA78\
+\\x6859\xEA79\
+\\x685A\xEA7A\
+\\x685B\xEA7B\
+\\x685C\xEA7C\
+\\x685D\xEA7D\
+\\x685E\xEA7E\
+\\x685F\xEA80\
+\\x6860\xEA81\
+\\x6861\xEA82\
+\\x6862\xEA83\
+\\x6863\xEA84\
+\\x6864\xEA85\
+\\x6865\xEA86\
+\\x6866\xEA87\
+\\x6867\xEA88\
+\\x6868\xEA89\
+\\x6869\xEA8A\
+\\x686A\xEA8B\
+\\x686B\xEA8C\
+\\x686C\xEA8D\
+\\x686D\xEA8E\
+\\x686E\xE6D8\
+\\x686F\xE8EB\
+\\x6870\xEA8F\
+\\x6871\xEA90\
+\\x6872\xEA91\
+\\x6873\xEA92\
+\\x6874\xEA93\
+\\x6875\xEA94\
+\\x6876\xEA95\
+\\x6877\xEA96\
+\\x6878\xEA97\
+\\x6879\xEA98\
+\\x687A\xEA99\
+\\x687B\xEA9A\
+\\x687C\xEA9B\
+\\x687D\xEA9C\
+\\x687E\xEA9D\
+\\x687F\xEA9E\
+\\x6880\x8BC4\
+\\x6881\x968A\
+\\x6882\x9779\
+\\x6883\xE0F4\
+\\x6884\xEAA3\
+\\x6885\xE086\
+\\x6941\xF040\
+\\x6942\xF041\
+\\x6943\xF042\
+\\x6944\xF043\
+\\x6945\xF044\
+\\x6946\xF045\
+\\x6947\xF046\
+\\x6948\xF047\
+\\x6949\xF048\
+\\x694A\xF049\
+\\x694B\xF04A\
+\\x694C\xF04B\
+\\x694D\xF04C\
+\\x694E\xF04D\
+\\x694F\xF04E\
+\\x6950\xF04F\
+\\x6951\xF050\
+\\x6952\xF051\
+\\x6953\xF052\
+\\x6954\xF053\
+\\x6955\xF054\
+\\x6956\xF055\
+\\x6957\xF056\
+\\x6958\xF057\
+\\x6959\xF058\
+\\x695A\xF059\
+\\x695B\xF05A\
+\\x695C\xF05B\
+\\x695D\xF05C\
+\\x695E\xF05D\
+\\x695F\xF05E\
+\\x6960\xF05F\
+\\x6961\xF060\
+\\x6962\xF061\
+\\x6963\xF062\
+\\x6964\xF063\
+\\x6965\xF064\
+\\x6966\xF065\
+\\x6967\xF066\
+\\x6968\xF067\
+\\x6969\xF068\
+\\x696A\xF069\
+\\x696B\xF06A\
+\\x696C\xF06B\
+\\x696D\xF06C\
+\\x696E\xF06D\
+\\x696F\xF06E\
+\\x6970\xF06F\
+\\x6971\xF070\
+\\x6972\xF071\
+\\x6973\xF072\
+\\x6974\xF073\
+\\x6975\xF074\
+\\x6976\xF075\
+\\x6977\xF076\
+\\x6978\xF077\
+\\x6979\xF078\
+\\x697A\xF079\
+\\x697B\xF07A\
+\\x697C\xF07B\
+\\x697D\xF07C\
+\\x697E\xF07D\
+\\x697F\xF07E\
+\\x6980\xF080\
+\\x6981\xF081\
+\\x6982\xF082\
+\\x6983\xF083\
+\\x6984\xF084\
+\\x6985\xF085\
+\\x6986\xF086\
+\\x6987\xF087\
+\\x6988\xF088\
+\\x6989\xF089\
+\\x698A\xF08A\
+\\x698B\xF08B\
+\\x698C\xF08C\
+\\x698D\xF08D\
+\\x698E\xF08E\
+\\x698F\xF08F\
+\\x6990\xF090\
+\\x6991\xF091\
+\\x6992\xF092\
+\\x6993\xF093\
+\\x6994\xF094\
+\\x6995\xF095\
+\\x6996\xF096\
+\\x6997\xF097\
+\\x6998\xF098\
+\\x6999\xF099\
+\\x699A\xF09A\
+\\x699B\xF09B\
+\\x699C\xF09C\
+\\x699D\xF09D\
+\\x699E\xF09E\
+\\x699F\xF09F\
+\\x69A0\xF0A0\
+\\x69A1\xF0A1\
+\\x69A2\xF0A2\
+\\x69A3\xF0A3\
+\\x69A4\xF0A4\
+\\x69A5\xF0A5\
+\\x69A6\xF0A6\
+\\x69A7\xF0A7\
+\\x69A8\xF0A8\
+\\x69A9\xF0A9\
+\\x69AA\xF0AA\
+\\x69AB\xF0AB\
+\\x69AC\xF0AC\
+\\x69AD\xF0AD\
+\\x69AE\xF0AE\
+\\x69AF\xF0AF\
+\\x69B0\xF0B0\
+\\x69B1\xF0B1\
+\\x69B2\xF0B2\
+\\x69B3\xF0B3\
+\\x69B4\xF0B4\
+\\x69B5\xF0B5\
+\\x69B6\xF0B6\
+\\x69B7\xF0B7\
+\\x69B8\xF0B8\
+\\x69B9\xF0B9\
+\\x69BA\xF0BA\
+\\x69BB\xF0BB\
+\\x69BC\xF0BC\
+\\x69BD\xF0BD\
+\\x69BE\xF0BE\
+\\x69BF\xF0BF\
+\\x69C0\xF0C0\
+\\x69C1\xF0C1\
+\\x69C2\xF0C2\
+\\x69C3\xF0C3\
+\\x69C4\xF0C4\
+\\x69C5\xF0C5\
+\\x69C6\xF0C6\
+\\x69C7\xF0C7\
+\\x69C8\xF0C8\
+\\x69C9\xF0C9\
+\\x69CA\xF0CA\
+\\x69CB\xF0CB\
+\\x69CC\xF0CC\
+\\x69CD\xF0CD\
+\\x69CE\xF0CE\
+\\x69CF\xF0CF\
+\\x69D0\xF0D0\
+\\x69D1\xF0D1\
+\\x69D2\xF0D2\
+\\x69D3\xF0D3\
+\\x69D4\xF0D4\
+\\x69D5\xF0D5\
+\\x69D6\xF0D6\
+\\x69D7\xF0D7\
+\\x69D8\xF0D8\
+\\x69D9\xF0D9\
+\\x69DA\xF0DA\
+\\x69DB\xF0DB\
+\\x69DC\xF0DC\
+\\x69DD\xF0DD\
+\\x69DE\xF0DE\
+\\x69DF\xF0DF\
+\\x69E0\xF0E0\
+\\x69E1\xF0E1\
+\\x69E2\xF0E2\
+\\x69E3\xF0E3\
+\\x69E4\xF0E4\
+\\x69E5\xF0E5\
+\\x69E6\xF0E6\
+\\x69E7\xF0E7\
+\\x69E8\xF0E8\
+\\x69E9\xF0E9\
+\\x69EA\xF0EA\
+\\x69EB\xF0EB\
+\\x69EC\xF0EC\
+\\x69ED\xF0ED\
+\\x69EE\xF0EE\
+\\x69EF\xF0EF\
+\\x69F0\xF0F0\
+\\x69F1\xF0F1\
+\\x69F2\xF0F2\
+\\x69F3\xF0F3\
+\\x69F4\xF0F4\
+\\x69F5\xF0F5\
+\\x69F6\xF0F6\
+\\x69F7\xF0F7\
+\\x69F8\xF0F8\
+\\x69F9\xF0F9\
+\\x69FA\xF0FA\
+\\x69FB\xF0FB\
+\\x69FC\xF0FC\
+\\x69FD\xF140\
+\\x69FE\xF141\
+\\x6A41\xF142\
+\\x6A42\xF143\
+\\x6A43\xF144\
+\\x6A44\xF145\
+\\x6A45\xF146\
+\\x6A46\xF147\
+\\x6A47\xF148\
+\\x6A48\xF149\
+\\x6A49\xF14A\
+\\x6A4A\xF14B\
+\\x6A4B\xF14C\
+\\x6A4C\xF14D\
+\\x6A4D\xF14E\
+\\x6A4E\xF14F\
+\\x6A4F\xF150\
+\\x6A50\xF151\
+\\x6A51\xF152\
+\\x6A52\xF153\
+\\x6A53\xF154\
+\\x6A54\xF155\
+\\x6A55\xF156\
+\\x6A56\xF157\
+\\x6A57\xF158\
+\\x6A58\xF159\
+\\x6A59\xF15A\
+\\x6A5A\xF15B\
+\\x6A5B\xF15C\
+\\x6A5C\xF15D\
+\\x6A5D\xF15E\
+\\x6A5E\xF15F\
+\\x6A5F\xF160\
+\\x6A60\xF161\
+\\x6A61\xF162\
+\\x6A62\xF163\
+\\x6A63\xF164\
+\\x6A64\xF165\
+\\x6A65\xF166\
+\\x6A66\xF167\
+\\x6A67\xF168\
+\\x6A68\xF169\
+\\x6A69\xF16A\
+\\x6A6A\xF16B\
+\\x6A6B\xF16C\
+\\x6A6C\xF16D\
+\\x6A6D\xF16E\
+\\x6A6E\xF16F\
+\\x6A6F\xF170\
+\\x6A70\xF171\
+\\x6A71\xF172\
+\\x6A72\xF173\
+\\x6A73\xF174\
+\\x6A74\xF175\
+\\x6A75\xF176\
+\\x6A76\xF177\
+\\x6A77\xF178\
+\\x6A78\xF179\
+\\x6A79\xF17A\
+\\x6A7A\xF17B\
+\\x6A7B\xF17C\
+\\x6A7C\xF17D\
+\\x6A7D\xF17E\
+\\x6A7E\xF180\
+\\x6A7F\xF181\
+\\x6A80\xF182\
+\\x6A81\xF183\
+\\x6A82\xF184\
+\\x6A83\xF185\
+\\x6A84\xF186\
+\\x6A85\xF187\
+\\x6A86\xF188\
+\\x6A87\xF189\
+\\x6A88\xF18A\
+\\x6A89\xF18B\
+\\x6A8A\xF18C\
+\\x6A8B\xF18D\
+\\x6A8C\xF18E\
+\\x6A8D\xF18F\
+\\x6A8E\xF190\
+\\x6A8F\xF191\
+\\x6A90\xF192\
+\\x6A91\xF193\
+\\x6A92\xF194\
+\\x6A93\xF195\
+\\x6A94\xF196\
+\\x6A95\xF197\
+\\x6A96\xF198\
+\\x6A97\xF199\
+\\x6A98\xF19A\
+\\x6A99\xF19B\
+\\x6A9A\xF19C\
+\\x6A9B\xF19D\
+\\x6A9C\xF19E\
+\\x6A9D\xF19F\
+\\x6A9E\xF1A0\
+\\x6A9F\xF1A1\
+\\x6AA0\xF1A2\
+\\x6AA1\xF1A3\
+\\x6AA2\xF1A4\
+\\x6AA3\xF1A5\
+\\x6AA4\xF1A6\
+\\x6AA5\xF1A7\
+\\x6AA6\xF1A8\
+\\x6AA7\xF1A9\
+\\x6AA8\xF1AA\
+\\x6AA9\xF1AB\
+\\x6AAA\xF1AC\
+\\x6AAB\xF1AD\
+\\x6AAC\xF1AE\
+\\x6AAD\xF1AF\
+\\x6AAE\xF1B0\
+\\x6AAF\xF1B1\
+\\x6AB0\xF1B2\
+\\x6AB1\xF1B3\
+\\x6AB2\xF1B4\
+\\x6AB3\xF1B5\
+\\x6AB4\xF1B6\
+\\x6AB5\xF1B7\
+\\x6AB6\xF1B8\
+\\x6AB7\xF1B9\
+\\x6AB8\xF1BA\
+\\x6AB9\xF1BB\
+\\x6ABA\xF1BC\
+\\x6ABB\xF1BD\
+\\x6ABC\xF1BE\
+\\x6ABD\xF1BF\
+\\x6ABE\xF1C0\
+\\x6ABF\xF1C1\
+\\x6AC0\xF1C2\
+\\x6AC1\xF1C3\
+\\x6AC2\xF1C4\
+\\x6AC3\xF1C5\
+\\x6AC4\xF1C6\
+\\x6AC5\xF1C7\
+\\x6AC6\xF1C8\
+\\x6AC7\xF1C9\
+\\x6AC8\xF1CA\
+\\x6AC9\xF1CB\
+\\x6ACA\xF1CC\
+\\x6ACB\xF1CD\
+\\x6ACC\xF1CE\
+\\x6ACD\xF1CF\
+\\x6ACE\xF1D0\
+\\x6ACF\xF1D1\
+\\x6AD0\xF1D2\
+\\x6AD1\xF1D3\
+\\x6AD2\xF1D4\
+\\x6AD3\xF1D5\
+\\x6AD4\xF1D6\
+\\x6AD5\xF1D7\
+\\x6AD6\xF1D8\
+\\x6AD7\xF1D9\
+\\x6AD8\xF1DA\
+\\x6AD9\xF1DB\
+\\x6ADA\xF1DC\
+\\x6ADB\xF1DD\
+\\x6ADC\xF1DE\
+\\x6ADD\xF1DF\
+\\x6ADE\xF1E0\
+\\x6ADF\xF1E1\
+\\x6AE0\xF1E2\
+\\x6AE1\xF1E3\
+\\x6AE2\xF1E4\
+\\x6AE3\xF1E5\
+\\x6AE4\xF1E6\
+\\x6AE5\xF1E7\
+\\x6AE6\xF1E8\
+\\x6AE7\xF1E9\
+\\x6AE8\xF1EA\
+\\x6AE9\xF1EB\
+\\x6AEA\xF1EC\
+\\x6AEB\xF1ED\
+\\x6AEC\xF1EE\
+\\x6AED\xF1EF\
+\\x6AEE\xF1F0\
+\\x6AEF\xF1F1\
+\\x6AF0\xF1F2\
+\\x6AF1\xF1F3\
+\\x6AF2\xF1F4\
+\\x6AF3\xF1F5\
+\\x6AF4\xF1F6\
+\\x6AF5\xF1F7\
+\\x6AF6\xF1F8\
+\\x6AF7\xF1F9\
+\\x6AF8\xF1FA\
+\\x6AF9\xF1FB\
+\\x6AFA\xF1FC\
+\\x6AFB\xF240\
+\\x6AFC\xF241\
+\\x6AFD\xF242\
+\\x6AFE\xF243\
+\\x6B41\xF244\
+\\x6B42\xF245\
+\\x6B43\xF246\
+\\x6B44\xF247\
+\\x6B45\xF248\
+\\x6B46\xF249\
+\\x6B47\xF24A\
+\\x6B48\xF24B\
+\\x6B49\xF24C\
+\\x6B4A\xF24D\
+\\x6B4B\xF24E\
+\\x6B4C\xF24F\
+\\x6B4D\xF250\
+\\x6B4E\xF251\
+\\x6B4F\xF252\
+\\x6B50\xF253\
+\\x6B51\xF254\
+\\x6B52\xF255\
+\\x6B53\xF256\
+\\x6B54\xF257\
+\\x6B55\xF258\
+\\x6B56\xF259\
+\\x6B57\xF25A\
+\\x6B58\xF25B\
+\\x6B59\xF25C\
+\\x6B5A\xF25D\
+\\x6B5B\xF25E\
+\\x6B5C\xF25F\
+\\x6B5D\xF260\
+\\x6B5E\xF261\
+\\x6B5F\xF262\
+\\x6B60\xF263\
+\\x6B61\xF264\
+\\x6B62\xF265\
+\\x6B63\xF266\
+\\x6B64\xF267\
+\\x6B65\xF268\
+\\x6B66\xF269\
+\\x6B67\xF26A\
+\\x6B68\xF26B\
+\\x6B69\xF26C\
+\\x6B6A\xF26D\
+\\x6B6B\xF26E\
+\\x6B6C\xF26F\
+\\x6B6D\xF270\
+\\x6B6E\xF271\
+\\x6B6F\xF272\
+\\x6B70\xF273\
+\\x6B71\xF274\
+\\x6B72\xF275\
+\\x6B73\xF276\
+\\x6B74\xF277\
+\\x6B75\xF278\
+\\x6B76\xF279\
+\\x6B77\xF27A\
+\\x6B78\xF27B\
+\\x6B79\xF27C\
+\\x6B7A\xF27D\
+\\x6B7B\xF27E\
+\\x6B7C\xF280\
+\\x6B7D\xF281\
+\\x6B7E\xF282\
+\\x6B7F\xF283\
+\\x6B80\xF284\
+\\x6B81\xF285\
+\\x6B82\xF286\
+\\x6B83\xF287\
+\\x6B84\xF288\
+\\x6B85\xF289\
+\\x6B86\xF28A\
+\\x6B87\xF28B\
+\\x6B88\xF28C\
+\\x6B89\xF28D\
+\\x6B8A\xF28E\
+\\x6B8B\xF28F\
+\\x6B8C\xF290\
+\\x6B8D\xF291\
+\\x6B8E\xF292\
+\\x6B8F\xF293\
+\\x6B90\xF294\
+\\x6B91\xF295\
+\\x6B92\xF296\
+\\x6B93\xF297\
+\\x6B94\xF298\
+\\x6B95\xF299\
+\\x6B96\xF29A\
+\\x6B97\xF29B\
+\\x6B98\xF29C\
+\\x6B99\xF29D\
+\\x6B9A\xF29E\
+\\x6B9B\xF29F\
+\\x6B9C\xF2A0\
+\\x6B9D\xF2A1\
+\\x6B9E\xF2A2\
+\\x6B9F\xF2A3\
+\\x6BA0\xF2A4\
+\\x6BA1\xF2A5\
+\\x6BA2\xF2A6\
+\\x6BA3\xF2A7\
+\\x6BA4\xF2A8\
+\\x6BA5\xF2A9\
+\\x6BA6\xF2AA\
+\\x6BA7\xF2AB\
+\\x6BA8\xF2AC\
+\\x6BA9\xF2AD\
+\\x6BAA\xF2AE\
+\\x6BAB\xF2AF\
+\\x6BAC\xF2B0\
+\\x6BAD\xF2B1\
+\\x6BAE\xF2B2\
+\\x6BAF\xF2B3\
+\\x6BB0\xF2B4\
+\\x6BB1\xF2B5\
+\\x6BB2\xF2B6\
+\\x6BB3\xF2B7\
+\\x6BB4\xF2B8\
+\\x6BB5\xF2B9\
+\\x6BB6\xF2BA\
+\\x6BB7\xF2BB\
+\\x6BB8\xF2BC\
+\\x6BB9\xF2BD\
+\\x6BBA\xF2BE\
+\\x6BBB\xF2BF\
+\\x6BBC\xF2C0\
+\\x6BBD\xF2C1\
+\\x6BBE\xF2C2\
+\\x6BBF\xF2C3\
+\\x6BC0\xF2C4\
+\\x6BC1\xF2C5\
+\\x6BC2\xF2C6\
+\\x6BC3\xF2C7\
+\\x6BC4\xF2C8\
+\\x6BC5\xF2C9\
+\\x6BC6\xF2CA\
+\\x6BC7\xF2CB\
+\\x6BC8\xF2CC\
+\\x6BC9\xF2CD\
+\\x6BCA\xF2CE\
+\\x6BCB\xF2CF\
+\\x6BCC\xF2D0\
+\\x6BCD\xF2D1\
+\\x6BCE\xF2D2\
+\\x6BCF\xF2D3\
+\\x6BD0\xF2D4\
+\\x6BD1\xF2D5\
+\\x6BD2\xF2D6\
+\\x6BD3\xF2D7\
+\\x6BD4\xF2D8\
+\\x6BD5\xF2D9\
+\\x6BD6\xF2DA\
+\\x6BD7\xF2DB\
+\\x6BD8\xF2DC\
+\\x6BD9\xF2DD\
+\\x6BDA\xF2DE\
+\\x6BDB\xF2DF\
+\\x6BDC\xF2E0\
+\\x6BDD\xF2E1\
+\\x6BDE\xF2E2\
+\\x6BDF\xF2E3\
+\\x6BE0\xF2E4\
+\\x6BE1\xF2E5\
+\\x6BE2\xF2E6\
+\\x6BE3\xF2E7\
+\\x6BE4\xF2E8\
+\\x6BE5\xF2E9\
+\\x6BE6\xF2EA\
+\\x6BE7\xF2EB\
+\\x6BE8\xF2EC\
+\\x6BE9\xF2ED\
+\\x6BEA\xF2EE\
+\\x6BEB\xF2EF\
+\\x6BEC\xF2F0\
+\\x6BED\xF2F1\
+\\x6BEE\xF2F2\
+\\x6BEF\xF2F3\
+\\x6BF0\xF2F4\
+\\x6BF1\xF2F5\
+\\x6BF2\xF2F6\
+\\x6BF3\xF2F7\
+\\x6BF4\xF2F8\
+\\x6BF5\xF2F9\
+\\x6BF6\xF2FA\
+\\x6BF7\xF2FB\
+\\x6BF8\xF2FC\
+\\x6BF9\xF340\
+\\x6BFA\xF341\
+\\x6BFB\xF342\
+\\x6BFC\xF343\
+\\x6BFD\xF344\
+\\x6BFE\xF345\
+\\x6C41\xF346\
+\\x6C42\xF347\
+\\x6C43\xF348\
+\\x6C44\xF349\
+\\x6C45\xF34A\
+\\x6C46\xF34B\
+\\x6C47\xF34C\
+\\x6C48\xF34D\
+\\x6C49\xF34E\
+\\x6C4A\xF34F\
+\\x6C4B\xF350\
+\\x6C4C\xF351\
+\\x6C4D\xF352\
+\\x6C4E\xF353\
+\\x6C4F\xF354\
+\\x6C50\xF355\
+\\x6C51\xF356\
+\\x6C52\xF357\
+\\x6C53\xF358\
+\\x6C54\xF359\
+\\x6C55\xF35A\
+\\x6C56\xF35B\
+\\x6C57\xF35C\
+\\x6C58\xF35D\
+\\x6C59\xF35E\
+\\x6C5A\xF35F\
+\\x6C5B\xF360\
+\\x6C5C\xF361\
+\\x6C5D\xF362\
+\\x6C5E\xF363\
+\\x6C5F\xF364\
+\\x6C60\xF365\
+\\x6C61\xF366\
+\\x6C62\xF367\
+\\x6C63\xF368\
+\\x6C64\xF369\
+\\x6C65\xF36A\
+\\x6C66\xF36B\
+\\x6C67\xF36C\
+\\x6C68\xF36D\
+\\x6C69\xF36E\
+\\x6C6A\xF36F\
+\\x6C6B\xF370\
+\\x6C6C\xF371\
+\\x6C6D\xF372\
+\\x6C6E\xF373\
+\\x6C6F\xF374\
+\\x6C70\xF375\
+\\x6C71\xF376\
+\\x6C72\xF377\
+\\x6C73\xF378\
+\\x6C74\xF379\
+\\x6C75\xF37A\
+\\x6C76\xF37B\
+\\x6C77\xF37C\
+\\x6C78\xF37D\
+\\x6C79\xF37E\
+\\x6C7A\xF380\
+\\x6C7B\xF381\
+\\x6C7C\xF382\
+\\x6C7D\xF383\
+\\x6C7E\xF384\
+\\x6C7F\xF385\
+\\x6C80\xF386\
+\\x6C81\xF387\
+\\x6C82\xF388\
+\\x6C83\xF389\
+\\x6C84\xF38A\
+\\x6C85\xF38B\
+\\x6C86\xF38C\
+\\x6C87\xF38D\
+\\x6C88\xF38E\
+\\x6C89\xF38F\
+\\x6C8A\xF390\
+\\x6C8B\xF391\
+\\x6C8C\xF392\
+\\x6C8D\xF393\
+\\x6C8E\xF394\
+\\x6C8F\xF395\
+\\x6C90\xF396\
+\\x6C91\xF397\
+\\x6C92\xF398\
+\\x6C93\xF399\
+\\x6C94\xF39A\
+\\x6C95\xF39B\
+\\x6C96\xF39C\
+\\x6C97\xF39D\
+\\x6C98\xF39E\
+\\x6C99\xF39F\
+\\x6C9A\xF3A0\
+\\x6C9B\xF3A1\
+\\x6C9C\xF3A2\
+\\x6C9D\xF3A3\
+\\x6C9E\xF3A4\
+\\x6C9F\xF3A5\
+\\x6CA0\xF3A6\
+\\x6CA1\xF3A7\
+\\x6CA2\xF3A8\
+\\x6CA3\xF3A9\
+\\x6CA4\xF3AA\
+\\x6CA5\xF3AB\
+\\x6CA6\xF3AC\
+\\x6CA7\xF3AD\
+\\x6CA8\xF3AE\
+\\x6CA9\xF3AF\
+\\x6CAA\xF3B0\
+\\x6CAB\xF3B1\
+\\x6CAC\xF3B2\
+\\x6CAD\xF3B3\
+\\x6CAE\xF3B4\
+\\x6CAF\xF3B5\
+\\x6CB0\xF3B6\
+\\x6CB1\xF3B7\
+\\x6CB2\xF3B8\
+\\x6CB3\xF3B9\
+\\x6CB4\xF3BA\
+\\x6CB5\xF3BB\
+\\x6CB6\xF3BC\
+\\x6CB7\xF3BD\
+\\x6CB8\xF3BE\
+\\x6CB9\xF3BF\
+\\x6CBA\xF3C0\
+\\x6CBB\xF3C1\
+\\x6CBC\xF3C2\
+\\x6CBD\xF3C3\
+\\x6CBE\xF3C4\
+\\x6CBF\xF3C5\
+\\x6CC0\xF3C6\
+\\x6CC1\xF3C7\
+\\x6CC2\xF3C8\
+\\x6CC3\xF3C9\
+\\x6CC4\xF3CA\
+\\x6CC5\xF3CB\
+\\x6CC6\xF3CC\
+\\x6CC7\xF3CD\
+\\x6CC8\xF3CE\
+\\x6CC9\xF3CF\
+\\x6CCA\xF3D0\
+\\x6CCB\xF3D1\
+\\x6CCC\xF3D2\
+\\x6CCD\xF3D3\
+\\x6CCE\xF3D4\
+\\x6CCF\xF3D5\
+\\x6CD0\xF3D6\
+\\x6CD1\xF3D7\
+\\x6CD2\xF3D8\
+\\x6CD3\xF3D9\
+\\x6CD4\xF3DA\
+\\x6CD5\xF3DB\
+\\x6CD6\xF3DC\
+\\x6CD7\xF3DD\
+\\x6CD8\xF3DE\
+\\x6CD9\xF3DF\
+\\x6CDA\xF3E0\
+\\x6CDB\xF3E1\
+\\x6CDC\xF3E2\
+\\x6CDD\xF3E3\
+\\x6CDE\xF3E4\
+\\x6CDF\xF3E5\
+\\x6CE0\xF3E6\
+\\x6CE1\xF3E7\
+\\x6CE2\xF3E8\
+\\x6CE3\xF3E9\
+\\x6CE4\xF3EA\
+\\x6CE5\xF3EB\
+\\x6CE6\xF3EC\
+\\x6CE7\xF3ED\
+\\x6CE8\xF3EE\
+\\x6CE9\xF3EF\
+\\x6CEA\xF3F0\
+\\x6CEB\xF3F1\
+\\x6CEC\xF3F2\
+\\x6CED\xF3F3\
+\\x6CEE\xF3F4\
+\\x6CEF\xF3F5\
+\\x6CF0\xF3F6\
+\\x6CF1\xF3F7\
+\\x6CF2\xF3F8\
+\\x6CF3\xF3F9\
+\\x6CF4\xF3FA\
+\\x6CF5\xF3FB\
+\\x6CF6\xF3FC\
+\\x6CF7\xF440\
+\\x6CF8\xF441\
+\\x6CF9\xF442\
+\\x6CFA\xF443\
+\\x6CFB\xF444\
+\\x6CFC\xF445\
+\\x6CFD\xF446\
+\\x6CFE\xF447\
+\\x6D41\xF448\
+\\x6D42\xF449\
+\\x6D43\xF44A\
+\\x6D44\xF44B\
+\\x6D45\xF44C\
+\\x6D46\xF44D\
+\\x6D47\xF44E\
+\\x6D48\xF44F\
+\\x6D49\xF450\
+\\x6D4A\xF451\
+\\x6D4B\xF452\
+\\x6D4C\xF453\
+\\x6D4D\xF454\
+\\x6D4E\xF455\
+\\x6D4F\xF456\
+\\x6D50\xF457\
+\\x6D51\xF458\
+\\x6D52\xF459\
+\\x6D53\xF45A\
+\\x6D54\xF45B\
+\\x6D55\xF45C\
+\\x6D56\xF45D\
+\\x6D57\xF45E\
+\\x6D58\xF45F\
+\\x6D59\xF460\
+\\x6D5A\xF461\
+\\x6D5B\xF462\
+\\x6D5C\xF463\
+\\x6D5D\xF464\
+\\x6D5E\xF465\
+\\x6D5F\xF466\
+\\x6D60\xF467\
+\\x6D61\xF468\
+\\x6D62\xF469\
+\\x6D63\xF46A\
+\\x6D64\xF46B\
+\\x6D65\xF46C\
+\\x6D66\xF46D\
+\\x6D67\xF46E\
+\\x6D68\xF46F\
+\\x6D69\xF470\
+\\x6D6A\xF471\
+\\x6D6B\xF472\
+\\x6D6C\xF473\
+\\x6D6D\xF474\
+\\x6D6E\xF475\
+\\x6D6F\xF476\
+\\x6D70\xF477\
+\\x6D71\xF478\
+\\x6D72\xF479\
+\\x6D73\xF47A\
+\\x6D74\xF47B\
+\\x6D75\xF47C\
+\\x6D76\xF47D\
+\\x6D77\xF47E\
+\\x6D78\xF480\
+\\x6D79\xF481\
+\\x6D7A\xF482\
+\\x6D7B\xF483\
+\\x6D7C\xF484\
+\\x6D7D\xF485\
+\\x6D7E\xF486\
+\\x6D7F\xF487\
+\\x6D80\xF488\
+\\x6D81\xF489\
+\\x6D82\xF48A\
+\\x6D83\xF48B\
+\\x6D84\xF48C\
+\\x6D85\xF48D\
+\\x6D86\xF48E\
+\\x6D87\xF48F\
+\\x6D88\xF490\
+\\x6D89\xF491\
+\\x6D8A\xF492\
+\\x6D8B\xF493\
+\\x6D8C\xF494\
+\\x6D8D\xF495\
+\\x6D8E\xF496\
+\\x6D8F\xF497\
+\\x6D90\xF498\
+\\x6D91\xF499\
+\\x6D92\xF49A\
+\\x6D93\xF49B\
+\\x6D94\xF49C\
+\\x6D95\xF49D\
+\\x6D96\xF49E\
+\\x6D97\xF49F\
+\\x6D98\xF4A0\
+\\x6D99\xF4A1\
+\\x6D9A\xF4A2\
+\\x6D9B\xF4A3\
+\\x6D9C\xF4A4\
+\\x6D9D\xF4A5\
+\\x6D9E\xF4A6\
+\\x6D9F\xF4A7\
+\\x6DA0\xF4A8\
+\\x6DA1\xF4A9\
+\\x6DA2\xF4AA\
+\\x6DA3\xF4AB\
+\\x6DA4\xF4AC\
+\\x6DA5\xF4AD\
+\\x6DA6\xF4AE\
+\\x6DA7\xF4AF\
+\\x6DA8\xF4B0\
+\\x6DA9\xF4B1\
+\\x6DAA\xF4B2\
+\\x6DAB\xF4B3\
+\\x6DAC\xF4B4\
+\\x6DAD\xF4B5\
+\\x6DAE\xF4B6\
+\\x6DAF\xF4B7\
+\\x6DB0\xF4B8\
+\\x6DB1\xF4B9\
+\\x6DB2\xF4BA\
+\\x6DB3\xF4BB\
+\\x6DB4\xF4BC\
+\\x6DB5\xF4BD\
+\\x6DB6\xF4BE\
+\\x6DB7\xF4BF\
+\\x6DB8\xF4C0\
+\\x6DB9\xF4C1\
+\\x6DBA\xF4C2\
+\\x6DBB\xF4C3\
+\\x6DBC\xF4C4\
+\\x6DBD\xF4C5\
+\\x6DBE\xF4C6\
+\\x6DBF\xF4C7\
+\\x6DC0\xF4C8\
+\\x6DC1\xF4C9\
+\\x6DC2\xF4CA\
+\\x6DC3\xF4CB\
+\\x6DC4\xF4CC\
+\\x6DC5\xF4CD\
+\\x6DC6\xF4CE\
+\\x6DC7\xF4CF\
+\\x6DC8\xF4D0\
+\\x6DC9\xF4D1\
+\\x6DCA\xF4D2\
+\\x6DCB\xF4D3\
+\\x6DCC\xF4D4\
+\\x6DCD\xF4D5\
+\\x6DCE\xF4D6\
+\\x6DCF\xF4D7\
+\\x6DD0\xF4D8\
+\\x6DD1\xF4D9\
+\\x6DD2\xF4DA\
+\\x6DD3\xF4DB\
+\\x6DD4\xF4DC\
+\\x6DD5\xF4DD\
+\\x6DD6\xF4DE\
+\\x6DD7\xF4DF\
+\\x6DD8\xF4E0\
+\\x6DD9\xF4E1\
+\\x6DDA\xF4E2\
+\\x6DDB\xF4E3\
+\\x6DDC\xF4E4\
+\\x6DDD\xF4E5\
+\\x6DDE\xF4E6\
+\\x6DDF\xF4E7\
+\\x6DE0\xF4E8\
+\\x6DE1\xF4E9\
+\\x6DE2\xF4EA\
+\\x6DE3\xF4EB\
+\\x6DE4\xF4EC\
+\\x6DE5\xF4ED\
+\\x6DE6\xF4EE\
+\\x6DE7\xF4EF\
+\\x6DE8\xF4F0\
+\\x6DE9\xF4F1\
+\\x6DEA\xF4F2\
+\\x6DEB\xF4F3\
+\\x6DEC\xF4F4\
+\\x6DED\xF4F5\
+\\x6DEE\xF4F6\
+\\x6DEF\xF4F7\
+\\x6DF0\xF4F8\
+\\x6DF1\xF4F9\
+\\x6DF2\xF4FA\
+\\x6DF3\xF4FB\
+\\x6DF4\xF4FC\
+\\x6DF5\xF540\
+\\x6DF6\xF541\
+\\x6DF7\xF542\
+\\x6DF8\xF543\
+\\x6DF9\xF544\
+\\x6DFA\xF545\
+\\x6DFB\xF546\
+\\x6DFC\xF547\
+\\x6DFD\xF548\
+\\x6DFE\xF549\
+\\x6E41\xF54A\
+\\x6E42\xF54B\
+\\x6E43\xF54C\
+\\x6E44\xF54D\
+\\x6E45\xF54E\
+\\x6E46\xF54F\
+\\x6E47\xF550\
+\\x6E48\xF551\
+\\x6E49\xF552\
+\\x6E4A\xF553\
+\\x6E4B\xF554\
+\\x6E4C\xF555\
+\\x6E4D\xF556\
+\\x6E4E\xF557\
+\\x6E4F\xF558\
+\\x6E50\xF559\
+\\x6E51\xF55A\
+\\x6E52\xF55B\
+\\x6E53\xF55C\
+\\x6E54\xF55D\
+\\x6E55\xF55E\
+\\x6E56\xF55F\
+\\x6E57\xF560\
+\\x6E58\xF561\
+\\x6E59\xF562\
+\\x6E5A\xF563\
+\\x6E5B\xF564\
+\\x6E5C\xF565\
+\\x6E5D\xF566\
+\\x6E5E\xF567\
+\\x6E5F\xF568\
+\\x6E60\xF569\
+\\x6E61\xF56A\
+\\x6E62\xF56B\
+\\x6E63\xF56C\
+\\x6E64\xF56D\
+\\x6E65\xF56E\
+\\x6E66\xF56F\
+\\x6E67\xF570\
+\\x6E68\xF571\
+\\x6E69\xF572\
+\\x6E6A\xF573\
+\\x6E6B\xF574\
+\\x6E6C\xF575\
+\\x6E6D\xF576\
+\\x6E6E\xF577\
+\\x6E6F\xF578\
+\\x6E70\xF579\
+\\x6E71\xF57A\
+\\x6E72\xF57B\
+\\x6E73\xF57C\
+\\x6E74\xF57D\
+\\x6E75\xF57E\
+\\x6E76\xF580\
+\\x6E77\xF581\
+\\x6E78\xF582\
+\\x6E79\xF583\
+\\x6E7A\xF584\
+\\x6E7B\xF585\
+\\x6E7C\xF586\
+\\x6E7D\xF587\
+\\x6E7E\xF588\
+\\x6E7F\xF589\
+\\x6E80\xF58A\
+\\x6E81\xF58B\
+\\x6E82\xF58C\
+\\x6E83\xF58D\
+\\x6E84\xF58E\
+\\x6E85\xF58F\
+\\x6E86\xF590\
+\\x6E87\xF591\
+\\x6E88\xF592\
+\\x6E89\xF593\
+\\x6E8A\xF594\
+\\x6E8B\xF595\
+\\x6E8C\xF596\
+\\x6E8D\xF597\
+\\x6E8E\xF598\
+\\x6E8F\xF599\
+\\x6E90\xF59A\
+\\x6E91\xF59B\
+\\x6E92\xF59C\
+\\x6E93\xF59D\
+\\x6E94\xF59E\
+\\x6E95\xF59F\
+\\x6E96\xF5A0\
+\\x6E97\xF5A1\
+\\x6E98\xF5A2\
+\\x6E99\xF5A3\
+\\x6E9A\xF5A4\
+\\x6E9B\xF5A5\
+\\x6E9C\xF5A6\
+\\x6E9D\xF5A7\
+\\x6E9E\xF5A8\
+\\x6E9F\xF5A9\
+\\x6EA0\xF5AA\
+\\x6EA1\xF5AB\
+\\x6EA2\xF5AC\
+\\x6EA3\xF5AD\
+\\x6EA4\xF5AE\
+\\x6EA5\xF5AF\
+\\x6EA6\xF5B0\
+\\x6EA7\xF5B1\
+\\x6EA8\xF5B2\
+\\x6EA9\xF5B3\
+\\x6EAA\xF5B4\
+\\x6EAB\xF5B5\
+\\x6EAC\xF5B6\
+\\x6EAD\xF5B7\
+\\x6EAE\xF5B8\
+\\x6EAF\xF5B9\
+\\x6EB0\xF5BA\
+\\x6EB1\xF5BB\
+\\x6EB2\xF5BC\
+\\x6EB3\xF5BD\
+\\x6EB4\xF5BE\
+\\x6EB5\xF5BF\
+\\x6EB6\xF5C0\
+\\x6EB7\xF5C1\
+\\x6EB8\xF5C2\
+\\x6EB9\xF5C3\
+\\x6EBA\xF5C4\
+\\x6EBB\xF5C5\
+\\x6EBC\xF5C6\
+\\x6EBD\xF5C7\
+\\x6EBE\xF5C8\
+\\x6EBF\xF5C9\
+\\x6EC0\xF5CA\
+\\x6EC1\xF5CB\
+\\x6EC2\xF5CC\
+\\x6EC3\xF5CD\
+\\x6EC4\xF5CE\
+\\x6EC5\xF5CF\
+\\x6EC6\xF5D0\
+\\x6EC7\xF5D1\
+\\x6EC8\xF5D2\
+\\x6EC9\xF5D3\
+\\x6ECA\xF5D4\
+\\x6ECB\xF5D5\
+\\x6ECC\xF5D6\
+\\x6ECD\xF5D7\
+\\x6ECE\xF5D8\
+\\x6ECF\xF5D9\
+\\x6ED0\xF5DA\
+\\x6ED1\xF5DB\
+\\x6ED2\xF5DC\
+\\x6ED3\xF5DD\
+\\x6ED4\xF5DE\
+\\x6ED5\xF5DF\
+\\x6ED6\xF5E0\
+\\x6ED7\xF5E1\
+\\x6ED8\xF5E2\
+\\x6ED9\xF5E3\
+\\x6EDA\xF5E4\
+\\x6EDB\xF5E5\
+\\x6EDC\xF5E6\
+\\x6EDD\xF5E7\
+\\x6EDE\xF5E8\
+\\x6EDF\xF5E9\
+\\x6EE0\xF5EA\
+\\x6EE1\xF5EB\
+\\x6EE2\xF5EC\
+\\x6EE3\xF5ED\
+\\x6EE4\xF5EE\
+\\x6EE5\xF5EF\
+\\x6EE6\xF5F0\
+\\x6EE7\xF5F1\
+\\x6EE8\xF5F2\
+\\x6EE9\xF5F3\
+\\x6EEA\xF5F4\
+\\x6EEB\xF5F5\
+\\x6EEC\xF5F6\
+\\x6EED\xF5F7\
+\\x6EEE\xF5F8\
+\\x6EEF\xF5F9\
+\\x6EF0\xF5FA\
+\\x6EF1\xF5FB\
+\\x6EF2\xF5FC\
+\\x6EF3\xF640\
+\\x6EF4\xF641\
+\\x6EF5\xF642\
+\\x6EF6\xF643\
+\\x6EF7\xF644\
+\\x6EF8\xF645\
+\\x6EF9\xF646\
+\\x6EFA\xF647\
+\\x6EFB\xF648\
+\\x6EFC\xF649\
+\\x6EFD\xF64A\
+\\x6EFE\xF64B\
+\\x6F41\xF64C\
+\\x6F42\xF64D\
+\\x6F43\xF64E\
+\\x6F44\xF64F\
+\\x6F45\xF650\
+\\x6F46\xF651\
+\\x6F47\xF652\
+\\x6F48\xF653\
+\\x6F49\xF654\
+\\x6F4A\xF655\
+\\x6F4B\xF656\
+\\x6F4C\xF657\
+\\x6F4D\xF658\
+\\x6F4E\xF659\
+\\x6F4F\xF65A\
+\\x6F50\xF65B\
+\\x6F51\xF65C\
+\\x6F52\xF65D\
+\\x6F53\xF65E\
+\\x6F54\xF65F\
+\\x6F55\xF660\
+\\x6F56\xF661\
+\\x6F57\xF662\
+\\x6F58\xF663\
+\\x6F59\xF664\
+\\x6F5A\xF665\
+\\x6F5B\xF666\
+\\x6F5C\xF667\
+\\x6F5D\xF668\
+\\x6F5E\xF669\
+\\x6F5F\xF66A\
+\\x6F60\xF66B\
+\\x6F61\xF66C\
+\\x6F62\xF66D\
+\\x6F63\xF66E\
+\\x6F64\xF66F\
+\\x6F65\xF670\
+\\x6F66\xF671\
+\\x6F67\xF672\
+\\x6F68\xF673\
+\\x6F69\xF674\
+\\x6F6A\xF675\
+\\x6F6B\xF676\
+\\x6F6C\xF677\
+\\x6F6D\xF678\
+\\x6F6E\xF679\
+\\x6F6F\xF67A\
+\\x6F70\xF67B\
+\\x6F71\xF67C\
+\\x6F72\xF67D\
+\\x6F73\xF67E\
+\\x6F74\xF680\
+\\x6F75\xF681\
+\\x6F76\xF682\
+\\x6F77\xF683\
+\\x6F78\xF684\
+\\x6F79\xF685\
+\\x6F7A\xF686\
+\\x6F7B\xF687\
+\\x6F7C\xF688\
+\\x6F7D\xF689\
+\\x6F7E\xF68A\
+\\x6F7F\xF68B\
+\\x6F80\xF68C\
+\\x6F81\xF68D\
+\\x6F82\xF68E\
+\\x6F83\xF68F\
+\\x6F84\xF690\
+\\x6F85\xF691\
+\\x6F86\xF692\
+\\x6F87\xF693\
+\\x6F88\xF694\
+\\x6F89\xF695\
+\\x6F8A\xF696\
+\\x6F8B\xF697\
+\\x6F8C\xF698\
+\\x6F8D\xF699\
+\\x6F8E\xF69A\
+\\x6F8F\xF69B\
+\\x6F90\xF69C\
+\\x6F91\xF69D\
+\\x6F92\xF69E\
+\\x6F93\xF69F\
+\\x6F94\xF6A0\
+\\x6F95\xF6A1\
+\\x6F96\xF6A2\
+\\x6F97\xF6A3\
+\\x6F98\xF6A4\
+\\x6F99\xF6A5\
+\\x6F9A\xF6A6\
+\\x6F9B\xF6A7\
+\\x6F9C\xF6A8\
+\\x6F9D\xF6A9\
+\\x6F9E\xF6AA\
+\\x6F9F\xF6AB\
+\\x6FA0\xF6AC\
+\\x6FA1\xF6AD\
+\\x6FA2\xF6AE\
+\\x6FA3\xF6AF\
+\\x6FA4\xF6B0\
+\\x6FA5\xF6B1\
+\\x6FA6\xF6B2\
+\\x6FA7\xF6B3\
+\\x6FA8\xF6B4\
+\\x6FA9\xF6B5\
+\\x6FAA\xF6B6\
+\\x6FAB\xF6B7\
+\\x6FAC\xF6B8\
+\\x6FAD\xF6B9\
+\\x6FAE\xF6BA\
+\\x6FAF\xF6BB\
+\\x6FB0\xF6BC\
+\\x6FB1\xF6BD\
+\\x6FB2\xF6BE\
+\\x6FB3\xF6BF\
+\\x6FB4\xF6C0\
+\\x6FB5\xF6C1\
+\\x6FB6\xF6C2\
+\\x6FB7\xF6C3\
+\\x6FB8\xF6C4\
+\\x6FB9\xF6C5\
+\\x6FBA\xF6C6\
+\\x6FBB\xF6C7\
+\\x6FBC\xF6C8\
+\\x6FBD\xF6C9\
+\\x6FBE\xF6CA\
+\\x6FBF\xF6CB\
+\\x6FC0\xF6CC\
+\\x6FC1\xF6CD\
+\\x6FC2\xF6CE\
+\\x6FC3\xF6CF\
+\\x6FC4\xF6D0\
+\\x6FC5\xF6D1\
+\\x6FC6\xF6D2\
+\\x6FC7\xF6D3\
+\\x6FC8\xF6D4\
+\\x6FC9\xF6D5\
+\\x6FCA\xF6D6\
+\\x6FCB\xF6D7\
+\\x6FCC\xF6D8\
+\\x6FCD\xF6D9\
+\\x6FCE\xF6DA\
+\\x6FCF\xF6DB\
+\\x6FD0\xF6DC\
+\\x6FD1\xF6DD\
+\\x6FD2\xF6DE\
+\\x6FD3\xF6DF\
+\\x6FD4\xF6E0\
+\\x6FD5\xF6E1\
+\\x6FD6\xF6E2\
+\\x6FD7\xF6E3\
+\\x6FD8\xF6E4\
+\\x6FD9\xF6E5\
+\\x6FDA\xF6E6\
+\\x6FDB\xF6E7\
+\\x6FDC\xF6E8\
+\\x6FDD\xF6E9\
+\\x6FDE\xF6EA\
+\\x6FDF\xF6EB\
+\\x6FE0\xF6EC\
+\\x6FE1\xF6ED\
+\\x6FE2\xF6EE\
+\\x6FE3\xF6EF\
+\\x6FE4\xF6F0\
+\\x6FE5\xF6F1\
+\\x6FE6\xF6F2\
+\\x6FE7\xF6F3\
+\\x6FE8\xF6F4\
+\\x6FE9\xF6F5\
+\\x6FEA\xF6F6\
+\\x6FEB\xF6F7\
+\\x6FEC\xF6F8\
+\\x6FED\xF6F9\
+\\x6FEE\xF6FA\
+\\x6FEF\xF6FB\
+\\x6FF0\xF6FC\
+\\x6FF1\xF740\
+\\x6FF2\xF741\
+\\x6FF3\xF742\
+\\x6FF4\xF743\
+\\x6FF5\xF744\
+\\x6FF6\xF745\
+\\x6FF7\xF746\
+\\x6FF8\xF747\
+\\x6FF9\xF748\
+\\x6FFA\xF749\
+\\x6FFB\xF74A\
+\\x6FFC\xF74B\
+\\x6FFD\xF74C\
+\\x6FFE\xF74D\
+\\x7041\xF74E\
+\\x7042\xF74F\
+\\x7043\xF750\
+\\x7044\xF751\
+\\x7045\xF752\
+\\x7046\xF753\
+\\x7047\xF754\
+\\x7048\xF755\
+\\x7049\xF756\
+\\x704A\xF757\
+\\x704B\xF758\
+\\x704C\xF759\
+\\x704D\xF75A\
+\\x704E\xF75B\
+\\x704F\xF75C\
+\\x7050\xF75D\
+\\x7051\xF75E\
+\\x7052\xF75F\
+\\x7053\xF760\
+\\x7054\xF761\
+\\x7055\xF762\
+\\x7056\xF763\
+\\x7057\xF764\
+\\x7058\xF765\
+\\x7059\xF766\
+\\x705A\xF767\
+\\x705B\xF768\
+\\x705C\xF769\
+\\x705D\xF76A\
+\\x705E\xF76B\
+\\x705F\xF76C\
+\\x7060\xF76D\
+\\x7061\xF76E\
+\\x7062\xF76F\
+\\x7063\xF770\
+\\x7064\xF771\
+\\x7065\xF772\
+\\x7066\xF773\
+\\x7067\xF774\
+\\x7068\xF775\
+\\x7069\xF776\
+\\x706A\xF777\
+\\x706B\xF778\
+\\x706C\xF779\
+\\x706D\xF77A\
+\\x706E\xF77B\
+\\x706F\xF77C\
+\\x7070\xF77D\
+\\x7071\xF77E\
+\\x7072\xF780\
+\\x7073\xF781\
+\\x7074\xF782\
+\\x7075\xF783\
+\\x7076\xF784\
+\\x7077\xF785\
+\\x7078\xF786\
+\\x7079\xF787\
+\\x707A\xF788\
+\\x707B\xF789\
+\\x707C\xF78A\
+\\x707D\xF78B\
+\\x707E\xF78C\
+\\x707F\xF78D\
+\\x7080\xF78E\
+\\x7081\xF78F\
+\\x7082\xF790\
+\\x7083\xF791\
+\\x7084\xF792\
+\\x7085\xF793\
+\\x7086\xF794\
+\\x7087\xF795\
+\\x7088\xF796\
+\\x7089\xF797\
+\\x708A\xF798\
+\\x708B\xF799\
+\\x708C\xF79A\
+\\x708D\xF79B\
+\\x708E\xF79C\
+\\x708F\xF79D\
+\\x7090\xF79E\
+\\x7091\xF79F\
+\\x7092\xF7A0\
+\\x7093\xF7A1\
+\\x7094\xF7A2\
+\\x7095\xF7A3\
+\\x7096\xF7A4\
+\\x7097\xF7A5\
+\\x7098\xF7A6\
+\\x7099\xF7A7\
+\\x709A\xF7A8\
+\\x709B\xF7A9\
+\\x709C\xF7AA\
+\\x709D\xF7AB\
+\\x709E\xF7AC\
+\\x709F\xF7AD\
+\\x70A0\xF7AE\
+\\x70A1\xF7AF\
+\\x70A2\xF7B0\
+\\x70A3\xF7B1\
+\\x70A4\xF7B2\
+\\x70A5\xF7B3\
+\\x70A6\xF7B4\
+\\x70A7\xF7B5\
+\\x70A8\xF7B6\
+\\x70A9\xF7B7\
+\\x70AA\xF7B8\
+\\x70AB\xF7B9\
+\\x70AC\xF7BA\
+\\x70AD\xF7BB\
+\\x70AE\xF7BC\
+\\x70AF\xF7BD\
+\\x70B0\xF7BE\
+\\x70B1\xF7BF\
+\\x70B2\xF7C0\
+\\x70B3\xF7C1\
+\\x70B4\xF7C2\
+\\x70B5\xF7C3\
+\\x70B6\xF7C4\
+\\x70B7\xF7C5\
+\\x70B8\xF7C6\
+\\x70B9\xF7C7\
+\\x70BA\xF7C8\
+\\x70BB\xF7C9\
+\\x70BC\xF7CA\
+\\x70BD\xF7CB\
+\\x70BE\xF7CC\
+\\x70BF\xF7CD\
+\\x70C0\xF7CE\
+\\x70C1\xF7CF\
+\\x70C2\xF7D0\
+\\x70C3\xF7D1\
+\\x70C4\xF7D2\
+\\x70C5\xF7D3\
+\\x70C6\xF7D4\
+\\x70C7\xF7D5\
+\\x70C8\xF7D6\
+\\x70C9\xF7D7\
+\\x70CA\xF7D8\
+\\x70CB\xF7D9\
+\\x70CC\xF7DA\
+\\x70CD\xF7DB\
+\\x70CE\xF7DC\
+\\x70CF\xF7DD\
+\\x70D0\xF7DE\
+\\x70D1\xF7DF\
+\\x70D2\xF7E0\
+\\x70D3\xF7E1\
+\\x70D4\xF7E2\
+\\x70D5\xF7E3\
+\\x70D6\xF7E4\
+\\x70D7\xF7E5\
+\\x70D8\xF7E6\
+\\x70D9\xF7E7\
+\\x70DA\xF7E8\
+\\x70DB\xF7E9\
+\\x70DC\xF7EA\
+\\x70DD\xF7EB\
+\\x70DE\xF7EC\
+\\x70DF\xF7ED\
+\\x70E0\xF7EE\
+\\x70E1\xF7EF\
+\\x70E2\xF7F0\
+\\x70E3\xF7F1\
+\\x70E4\xF7F2\
+\\x70E5\xF7F3\
+\\x70E6\xF7F4\
+\\x70E7\xF7F5\
+\\x70E8\xF7F6\
+\\x70E9\xF7F7\
+\\x70EA\xF7F8\
+\\x70EB\xF7F9\
+\\x70EC\xF7FA\
+\\x70ED\xF7FB\
+\\x70EE\xF7FC\
+\\x70EF\xF840\
+\\x70F0\xF841\
+\\x70F1\xF842\
+\\x70F2\xF843\
+\\x70F3\xF844\
+\\x70F4\xF845\
+\\x70F5\xF846\
+\\x70F6\xF847\
+\\x70F7\xF848\
+\\x70F8\xF849\
+\\x70F9\xF84A\
+\\x70FA\xF84B\
+\\x70FB\xF84C\
+\\x70FC\xF84D\
+\\x70FD\xF84E\
+\\x70FE\xF84F\
+\\x7141\xF850\
+\\x7142\xF851\
+\\x7143\xF852\
+\\x7144\xF853\
+\\x7145\xF854\
+\\x7146\xF855\
+\\x7147\xF856\
+\\x7148\xF857\
+\\x7149\xF858\
+\\x714A\xF859\
+\\x714B\xF85A\
+\\x714C\xF85B\
+\\x714D\xF85C\
+\\x714E\xF85D\
+\\x714F\xF85E\
+\\x7150\xF85F\
+\\x7151\xF860\
+\\x7152\xF861\
+\\x7153\xF862\
+\\x7154\xF863\
+\\x7155\xF864\
+\\x7156\xF865\
+\\x7157\xF866\
+\\x7158\xF867\
+\\x7159\xF868\
+\\x715A\xF869\
+\\x715B\xF86A\
+\\x715C\xF86B\
+\\x715D\xF86C\
+\\x715E\xF86D\
+\\x715F\xF86E\
+\\x7160\xF86F\
+\\x7161\xF870\
+\\x7162\xF871\
+\\x7163\xF872\
+\\x7164\xF873\
+\\x7165\xF874\
+\\x7166\xF875\
+\\x7167\xF876\
+\\x7168\xF877\
+\\x7169\xF878\
+\\x716A\xF879\
+\\x716B\xF87A\
+\\x716C\xF87B\
+\\x716D\xF87C\
+\\x716E\xF87D\
+\\x716F\xF87E\
+\\x7170\xF880\
+\\x7171\xF881\
+\\x7172\xF882\
+\\x7173\xF883\
+\\x7174\xF884\
+\\x7175\xF885\
+\\x7176\xF886\
+\\x7177\xF887\
+\\x7178\xF888\
+\\x7179\xF889\
+\\x717A\xF88A\
+\\x717B\xF88B\
+\\x717C\xF88C\
+\\x717D\xF88D\
+\\x717E\xF88E\
+\\x717F\xF88F\
+\\x7180\xF890\
+\\x7181\xF891\
+\\x7182\xF892\
+\\x7183\xF893\
+\\x7184\xF894\
+\\x7185\xF895\
+\\x7186\xF896\
+\\x7187\xF897\
+\\x7188\xF898\
+\\x7189\xF899\
+\\x718A\xF89A\
+\\x718B\xF89B\
+\\x718C\xF89C\
+\\x718D\xF89D\
+\\x718E\xF89E\
+\\x718F\xF89F\
+\\x7190\xF8A0\
+\\x7191\xF8A1\
+\\x7192\xF8A2\
+\\x7193\xF8A3\
+\\x7194\xF8A4\
+\\x7195\xF8A5\
+\\x7196\xF8A6\
+\\x7197\xF8A7\
+\\x7198\xF8A8\
+\\x7199\xF8A9\
+\\x719A\xF8AA\
+\\x719B\xF8AB\
+\\x719C\xF8AC\
+\\x719D\xF8AD\
+\\x719E\xF8AE\
+\\x719F\xF8AF\
+\\x71A0\xF8B0\
+\\x71A1\xF8B1\
+\\x71A2\xF8B2\
+\\x71A3\xF8B3\
+\\x71A4\xF8B4\
+\\x71A5\xF8B5\
+\\x71A6\xF8B6\
+\\x71A7\xF8B7\
+\\x71A8\xF8B8\
+\\x71A9\xF8B9\
+\\x71AA\xF8BA\
+\\x71AB\xF8BB\
+\\x71AC\xF8BC\
+\\x71AD\xF8BD\
+\\x71AE\xF8BE\
+\\x71AF\xF8BF\
+\\x71B0\xF8C0\
+\\x71B1\xF8C1\
+\\x71B2\xF8C2\
+\\x71B3\xF8C3\
+\\x71B4\xF8C4\
+\\x71B5\xF8C5\
+\\x71B6\xF8C6\
+\\x71B7\xF8C7\
+\\x71B8\xF8C8\
+\\x71B9\xF8C9\
+\\x71BA\xF8CA\
+\\x71BB\xF8CB\
+\\x71BC\xF8CC\
+\\x71BD\xF8CD\
+\\x71BE\xF8CE\
+\\x71BF\xF8CF\
+\\x71C0\xF8D0\
+\\x71C1\xF8D1\
+\\x71C2\xF8D2\
+\\x71C3\xF8D3\
+\\x71C4\xF8D4\
+\\x71C5\xF8D5\
+\\x71C6\xF8D6\
+\\x71C7\xF8D7\
+\\x71C8\xF8D8\
+\\x71C9\xF8D9\
+\\x71CA\xF8DA\
+\\x71CB\xF8DB\
+\\x71CC\xF8DC\
+\\x71CD\xF8DD\
+\\x71CE\xF8DE\
+\\x71CF\xF8DF\
+\\x71D0\xF8E0\
+\\x71D1\xF8E1\
+\\x71D2\xF8E2\
+\\x71D3\xF8E3\
+\\x71D4\xF8E4\
+\\x71D5\xF8E5\
+\\x71D6\xF8E6\
+\\x71D7\xF8E7\
+\\x71D8\xF8E8\
+\\x71D9\xF8E9\
+\\x71DA\xF8EA\
+\\x71DB\xF8EB\
+\\x71DC\xF8EC\
+\\x71DD\xF8ED\
+\\x71DE\xF8EE\
+\\x71DF\xF8EF\
+\\x71E0\xF8F0\
+\\x71E1\xF8F1\
+\\x71E2\xF8F2\
+\\x71E3\xF8F3\
+\\x71E4\xF8F4\
+\\x71E5\xF8F5\
+\\x71E6\xF8F6\
+\\x71E7\xF8F7\
+\\x71E8\xF8F8\
+\\x71E9\xF8F9\
+\\x71EA\xF8FA\
+\\x71EB\xF8FB\
+\\x71EC\xF8FC\
+\\x71ED\xF940\
+\\x71EE\xF941\
+\\x71EF\xF942\
+\\x71F0\xF943\
+\\x71F1\xF944\
+\\x71F2\xF945\
+\\x71F3\xF946\
+\\x71F4\xF947\
+\\x71F5\xF948\
+\\x71F6\xF949\
+\\x71F7\xF94A\
+\\x71F8\xF94B\
+\\x71F9\xF94C\
+\\x71FA\xF94D\
+\\x71FB\xF94E\
+\\x71FC\xF94F\
+\\x71FD\xF950\
+\\x71FE\xF951\
+\\x7241\xF952\
+\\x7242\xF953\
+\\x7243\xF954\
+\\x7244\xF955\
+\\x7245\xF956\
+\\x7246\xF957\
+\\x7247\xF958\
+\\x7248\xF959\
+\\x7249\xF95A\
+\\x724A\xF95B\
+\\x724B\xF95C\
+\\x724C\xF95D\
+\\x724D\xF95E\
+\\x724E\xF95F\
+\\x724F\xF960\
+\\x7250\xF961\
+\\x7251\xF962\
+\\x7252\xF963\
+\\x7253\xF964\
+\\x7254\xF965\
+\\x7255\xF966\
+\\x7256\xF967\
+\\x7257\xF968\
+\\x7258\xF969\
+\\x7259\xF96A\
+\\x725A\xF96B\
+\\x725B\xF96C\
+\\x725C\xF96D\
+\\x725D\xF96E\
+\\x725E\xF96F\
+\\x725F\xF970\
+\\x7260\xF971\
+\\x7261\xF972\
+\\x7262\xF973\
+\\x7263\xF974\
+\\x7264\xF975\
+\\x7265\xF976\
+\\x7266\xF977\
+\\x7267\xF978\
+\\x7268\xF979\
+\\x7269\xF97A\
+\\x726A\xF97B\
+\\x726B\xF97C\
+\\x726C\xF97D\
+\\x726D\xF97E\
+\\x726E\xF980\
+\\x726F\xF981\
+\\x7270\xF982\
+\\x7271\xF983\
+\\x7272\xF984\
+\\x7273\xF985\
+\\x7274\xF986\
+\\x7275\xF987\
+\\x7276\xF988\
+\\x7277\xF989\
+\\x7278\xF98A\
+\\x7279\xF98B\
+\\x727A\xF98C\
+\\x727B\xF98D\
+\\x727C\xF98E\
+\\x727D\xF98F\
+\\x727E\xF990\
+\\x727F\xF991\
+\\x7280\xF992\
+\\x7281\xF993\
+\\x7282\xF994\
+\\x7283\xF995\
+\\x7284\xF996\
+\\x7285\xF997\
+\\x7286\xF998\
+\\x7287\xF999\
+\\x7288\xF99A\
+\\x7289\xF99B\
+\\x728A\xF99C\
+\\x728B\xF99D\
+\\x728C\xF99E\
+\\x728D\xF99F\
+\\x728E\xF9A0\
+\\x728F\xF9A1\
+\\x7290\xF9A2\
+\\x7291\xF9A3\
+\\x7292\xF9A4\
+\\x7293\xF9A5\
+\\x7294\xF9A6\
+\\x7295\xF9A7\
+\\x7296\xF9A8\
+\\x7297\xF9A9\
+\\x7298\xF9AA\
+\\x7299\xF9AB\
+\\x729A\xF9AC\
+\\x729B\xF9AD\
+\\x729C\xF9AE\
+\\x729D\xF9AF\
+\\x729E\xF9B0\
+\\x729F\xF9B1\
+\\x72A0\xF9B2\
+\\x72A1\xF9B3\
+\\x72A2\xF9B4\
+\\x72A3\xF9B5\
+\\x72A4\xF9B6\
+\\x72A5\xF9B7\
+\\x72A6\xF9B8\
+\\x72A7\xF9B9\
+\\x72A8\xF9BA\
+\\x72A9\xF9BB\
+\\x72AA\xF9BC\
+\\x72AB\xF9BD\
+\\x72AC\xF9BE\
+\\x72AD\xF9BF\
+\\x72AE\xF9C0\
+\\x72AF\xF9C1\
+\\x72B0\xF9C2\
+\\x72B1\xF9C3\
+\\x72B2\xF9C4\
+\\x72B3\xF9C5\
+\\x72B4\xF9C6\
+\\x72B5\xF9C7\
+\\x72B6\xF9C8\
+\\x72B7\xF9C9\
+\\x72B8\xF9CA\
+\\x72B9\xF9CB\
+\\x72BA\xF9CC\
+\\x72BB\xF9CD\
+\\x72BC\xF9CE\
+\\x72BD\xF9CF\
+\\x72BE\xF9D0\
+\\x72BF\xF9D1\
+\\x72C0\xF9D2\
+\\x72C1\xF9D3\
+\\x72C2\xF9D4\
+\\x72C3\xF9D5\
+\\x72C4\xF9D6\
+\\x72C5\xF9D7\
+\\x72C6\xF9D8\
+\\x72C7\xF9D9\
+\\x72C8\xF9DA\
+\\x72C9\xF9DB\
+\\x72CA\xF9DC\
+\\x72CB\xF9DD\
+\\x72CC\xF9DE\
+\\x72CD\xF9DF\
+\\x72CE\xF9E0\
+\\x72CF\xF9E1\
+\\x72D0\xF9E2\
+\\x72D1\xF9E3\
+\\x72D2\xF9E4\
+\\x72D3\xF9E5\
+\\x72D4\xF9E6\
+\\x72D5\xF9E7\
+\\x72D6\xF9E8\
+\\x72D7\xF9E9\
+\\x72D8\xF9EA\
+\\x72D9\xF9EB\
+\\x72DA\xF9EC\
+\\x72DB\xF9ED\
+\\x72DC\xF9EE\
+\\x72DD\xF9EF\
+\\x72DE\xF9F0\
+\\x72DF\xF9F1\
+\\x72E0\xF9F2\
+\\x72E1\xF9F3\
+\\x72E2\xF9F4\
+\\x72E3\xF9F5\
+\\x72E4\xF9F6\
+\\x72E5\xF9F7\
+\\x72E6\xF9F8\
+\\x72E7\xF9F9\
+\\x72E8\xF9FA\
+\\x72E9\xF9FB\
+\\x72EA\xF9FC\
+\\x72EB\x3F3F\
+\\x72EC\x3F3F\
+\\x72ED\x3F3F\
+\\x72EE\x3F3F\
+\\x72EF\x3F3F\
+\\x72F0\x3F3F\
+\\x72F1\x3F3F\
+\\x72F2\x3F3F\
+\\x72F3\x3F3F\
+\\x72F4\x3F3F\
+\\x72F5\x3F3F\
+\\x72F6\x3F3F\
+\\x72F7\x3F3F\
+\\x72F8\x3F3F\
+\\x72F9\x3F3F\
+\\x72FA\x3F3F\
+\\x72FB\x3F3F\
+\\x72FC\x3F3F\
+\\x72FD\x3F3F\
+\\x72FE\x3F3F\
+\\x7341\x3F3F\
+\\x7342\x3F3F\
+\\x7343\x3F3F\
+\\x7344\x3F3F\
+\\x7345\x3F3F\
+\\x7346\x3F3F\
+\\x7347\x3F3F\
+\\x7348\x3F3F\
+\\x7349\x3F3F\
+\\x734A\x3F3F\
+\\x734B\x3F3F\
+\\x734C\x3F3F\
+\\x734D\x3F3F\
+\\x734E\x3F3F\
+\\x734F\x3F3F\
+\\x7350\x3F3F\
+\\x7351\x3F3F\
+\\x7352\x3F3F\
+\\x7353\x3F3F\
+\\x7354\x3F3F\
+\\x7355\x3F3F\
+\\x7356\x3F3F\
+\\x7357\x3F3F\
+\\x7358\x3F3F\
+\\x7359\x3F3F\
+\\x735A\x3F3F\
+\\x735B\x3F3F\
+\\x735C\x3F3F\
+\\x735D\x3F3F\
+\\x735E\x3F3F\
+\\x735F\x3F3F\
+\\x7360\x3F3F\
+\\x7361\x3F3F\
+\\x7362\x3F3F\
+\\x7363\x3F3F\
+\\x7364\x3F3F\
+\\x7365\x3F3F\
+\\x7366\x3F3F\
+\\x7367\x3F3F\
+\\x7368\x3F3F\
+\\x7369\x3F3F\
+\\x736A\x3F3F\
+\\x736B\x3F3F\
+\\x736C\x3F3F\
+\\x736D\x3F3F\
+\\x736E\x3F3F\
+\\x736F\x3F3F\
+\\x7370\x3F3F\
+\\x7371\x3F3F\
+\\x7372\x3F3F\
+\\x7373\x3F3F\
+\\x7374\x3F3F\
+\\x7375\x3F3F\
+\\x7376\x3F3F\
+\\x7377\x3F3F\
+\\x7378\x3F3F\
+\\x7379\x3F3F\
+\\x737A\x3F3F\
+\\x737B\x3F3F\
+\\x737C\x3F3F\
+\\x737D\x3F3F\
+\\x737E\x3F3F\
+\\x737F\x3F3F\
+\\x7380\x3F3F\
+\\x7381\x3F3F\
+\\x7382\x3F3F\
+\\x7383\x3F3F\
+\\x7384\x3F3F\
+\\x7385\x3F3F\
+\\x7386\x3F3F\
+\\x7387\x3F3F\
+\\x7388\x3F3F\
+\\x7389\x3F3F\
+\\x738A\x3F3F\
+\\x738B\x3F3F\
+\\x738C\x3F3F\
+\\x738D\x3F3F\
+\\x738E\x3F3F\
+\\x738F\x3F3F\
+\\x7390\x3F3F\
+\\x7391\x3F3F\
+\\x7392\x3F3F\
+\\x7393\x3F3F\
+\\x7394\x3F3F\
+\\x7395\x3F3F\
+\\x7396\x3F3F\
+\\x7397\x3F3F\
+\\x7398\x3F3F\
+\\x7399\x3F3F\
+\\x739A\x3F3F\
+\\x739B\x3F3F\
+\\x739C\x3F3F\
+\\x739D\x3F3F\
+\\x739E\x3F3F\
+\\x739F\x3F3F\
+\\x73A0\x3F3F\
+\\x73A1\x3F3F\
+\\x73A2\x3F3F\
+\\x73A3\x3F3F\
+\\x73A4\x3F3F\
+\\x73A5\x3F3F\
+\\x73A6\x3F3F\
+\\x73A7\x3F3F\
+\\x73A8\x3F3F\
+\\x73A9\x3F3F\
+\\x73AA\x3F3F\
+\\x73AB\x3F3F\
+\\x73AC\x3F3F\
+\\x73AD\x3F3F\
+\\x73AE\x3F3F\
+\\x73AF\x3F3F\
+\\x73B0\x3F3F\
+\\x73B1\x3F3F\
+\\x73B2\x3F3F\
+\\x73B3\x3F3F\
+\\x73B4\x3F3F\
+\\x73B5\x3F3F\
+\\x73B6\x3F3F\
+\\x73B7\x3F3F\
+\\x73B8\x3F3F\
+\\x73B9\x3F3F\
+\\x73BA\x3F3F\
+\\x73BB\x3F3F\
+\\x73BC\x3F3F\
+\\x73BD\x3F3F\
+\\x73BE\x3F3F\
+\\x73BF\x3F3F\
+\\x73C0\x3F3F\
+\\x73C1\x3F3F\
+\\x73C2\x3F3F\
+\\x73C3\x3F3F\
+\\x73C4\x3F3F\
+\\x73C5\x3F3F\
+\\x73C6\x3F3F\
+\\x73C7\x3F3F\
+\\x73C8\x3F3F\
+\\x73C9\x3F3F\
+\\x73CA\x3F3F\
+\\x73CB\x3F3F\
+\\x73CC\x3F3F\
+\\x73CD\x3F3F\
+\\x73CE\x3F3F\
+\\x73CF\x3F3F\
+\\x73D0\x3F3F\
+\\x73D1\x3F3F\
+\\x73D2\x3F3F\
+\\x73D3\x3F3F\
+\\x73D4\x3F3F\
+\\x73D5\x3F3F\
+\\x73D6\x3F3F\
+\\x73D7\x3F3F\
+\\x73D8\x3F3F\
+\\x73D9\x3F3F\
+\\x73DA\x3F3F\
+\\x73DB\x3F3F\
+\\x73DC\x3F3F\
+\\x73DD\x3F3F\
+\\x73DE\x3F3F\
+\\x73DF\x3F3F\
+\\x73E0\x3F3F\
+\\x73E1\x3F3F\
+\\x73E2\x3F3F\
+\\x73E3\x3F3F\
+\\x73E4\x3F3F\
+\\x73E5\x3F3F\
+\\x73E6\x3F3F\
+\\x73E7\x3F3F\
+\\x73E8\x3F3F\
+\\x73E9\x3F3F\
+\\x73EA\x3F3F\
+\\x73EB\x3F3F\
+\\x73EC\x3F3F\
+\\x73ED\x3F3F\
+\\x73EE\x3F3F\
+\\x73EF\x3F3F\
+\\x73F0\x3F3F\
+\\x73F1\x3F3F\
+\\x73F2\x3F3F\
+\\x73F3\x3F3F\
+\\x73F4\x3F3F\
+\\x73F5\x3F3F\
+\\x73F6\x3F3F\
+\\x73F7\x3F3F\
+\\x73F8\x3F3F\
+\\x73F9\x3F3F\
+\\x73FA\x3F3F\
+\\x73FB\x3F3F\
+\\x73FC\x3F3F\
+\\x73FD\x3F3F\
+\\x73FE\x3F3F\
+\\x7441\x3F3F\
+\\x7442\x3F3F\
+\\x7443\x3F3F\
+\\x7444\x3F3F\
+\\x7445\x3F3F\
+\\x7446\x3F3F\
+\\x7447\x3F3F\
+\\x7448\x3F3F\
+\\x7449\x3F3F\
+\\x744A\x3F3F\
+\\x744B\x3F3F\
+\\x744C\x3F3F\
+\\x744D\x3F3F\
+\\x744E\x3F3F\
+\\x744F\x3F3F\
+\\x7450\x3F3F\
+\\x7451\x3F3F\
+\\x7452\x3F3F\
+\\x7453\x3F3F\
+\\x7454\x3F3F\
+\\x7455\x3F3F\
+\\x7456\x3F3F\
+\\x7457\x3F3F\
+\\x7458\x3F3F\
+\\x7459\x3F3F\
+\\x745A\x3F3F\
+\\x745B\x3F3F\
+\\x745C\x3F3F\
+\\x745D\x3F3F\
+\\x745E\x3F3F\
+\\x745F\x3F3F\
+\\x7460\x3F3F\
+\\x7461\x3F3F\
+\\x7462\x3F3F\
+\\x7463\x3F3F\
+\\x7464\x3F3F\
+\\x7465\x3F3F\
+\\x7466\x3F3F\
+\\x7467\x3F3F\
+\\x7468\x3F3F\
+\\x7469\x3F3F\
+\\x746A\x3F3F\
+\\x746B\x3F3F\
+\\x746C\x3F3F\
+\\x746D\x3F3F\
+\\x746E\x3F3F\
+\\x746F\x3F3F\
+\\x7470\x3F3F\
+\\x7471\x3F3F\
+\\x7472\x3F3F\
+\\x7473\x3F3F\
+\\x7474\x3F3F\
+\\x7475\x3F3F\
+\\x7476\x3F3F\
+\\x7477\x3F3F\
+\\x7478\x3F3F\
+\\x7479\x3F3F\
+\\x747A\x3F3F\
+\\x747B\x3F3F\
+\\x747C\x3F3F\
+\\x747D\x3F3F\
+\\x747E\x3F3F\
+\\x747F\x3F3F\
+\\x7480\x3F3F\
+\\x7481\x3F3F\
+\\x7482\x3F3F\
+\\x7483\x3F3F\
+\\x7484\x3F3F\
+\\x7485\x3F3F\
+\\x7486\x3F3F\
+\\x7487\x3F3F\
+\\x7488\x3F3F\
+\\x7489\x3F3F\
+\\x748A\x3F3F\
+\\x748B\x3F3F\
+\\x748C\x3F3F\
+\\x748D\x3F3F\
+\\x748E\x3F3F\
+\\x748F\x3F3F\
+\\x7490\x3F3F\
+\\x7491\x3F3F\
+\\x7492\x3F3F\
+\\x7493\x3F3F\
+\\x7494\x3F3F\
+\\x7495\x3F3F\
+\\x7496\x3F3F\
+\\x7497\x3F3F\
+\\x7498\x3F3F\
+\\x7499\x3F3F\
+\\x749A\x3F3F\
+\\x749B\x3F3F\
+\\x749C\x3F3F\
+\\x749D\x3F3F\
+\\x749E\x3F3F\
+\\x749F\x3F3F\
+\\x74A0\x3F3F\
+\\x74A1\x3F3F\
+\\x74A2\x3F3F\
+\\x74A3\x3F3F\
+\\x74A4\x3F3F\
+\\x74A5\x3F3F\
+\\x74A6\x3F3F\
+\\x74A7\x3F3F\
+\\x74A8\x3F3F\
+\\x74A9\x3F3F\
+\\x74AA\x3F3F\
+\\x74AB\x3F3F\
+\\x74AC\x3F3F\
+\\x74AD\x3F3F\
+\\x74AE\x3F3F\
+\\x74AF\x3F3F\
+\\x74B0\x3F3F\
+\\x74B1\x3F3F\
+\\x74B2\x3F3F\
+\\x74B3\x3F3F\
+\\x74B4\x3F3F\
+\\x74B5\x3F3F\
+\\x74B6\x3F3F\
+\\x74B7\x3F3F\
+\\x74B8\x3F3F\
+\\x74B9\x3F3F\
+\\x74BA\x3F3F\
+\\x74BB\x3F3F\
+\\x74BC\x3F3F\
+\\x74BD\x3F3F\
+\\x74BE\x3F3F\
+\\x74BF\x3F3F\
+\\x74C0\x3F3F\
+\\x74C1\x3F3F\
+\\x74C2\x3F3F\
+\\x74C3\x3F3F\
+\\x74C4\x3F3F\
+\\x74C5\x3F3F\
+\\x74C6\x3F3F\
+\\x74C7\x3F3F\
+\\x74C8\x3F3F\
+\\x74C9\x3F3F\
+\\x74CA\x3F3F\
+\\x74CB\x3F3F\
+\\x74CC\x3F3F\
+\\x74CD\x3F3F\
+\\x74CE\x3F3F\
+\\x74CF\x3F3F\
+\\x74D0\x3F3F\
+\\x74D1\x3F3F\
+\\x74D2\x3F3F\
+\\x74D3\x3F3F\
+\\x74D4\x3F3F\
+\\x74D5\x3F3F\
+\\x74D6\x3F3F\
+\\x74D7\x3F3F\
+\\x74D8\x3F3F\
+\\x74D9\x3F3F\
+\\x74DA\x3F3F\
+\\x74DB\x3F3F\
+\\x74DC\x3F3F\
+\\x74DD\x3F3F\
+\\x74DE\x3F3F\
+\\x74DF\x3F3F\
+\\x74E0\x3F3F\
+\\x74E1\x3F3F\
+\\x74E2\x3F3F\
+\\x74E3\x3F3F\
+\\x74E4\x3F3F\
+\\x74E5\x3F3F\
+\\x74E6\x3F3F\
+\\x74E7\x3F3F\
+\\x74E8\x3F3F\
+\\x74E9\x3F3F\
+\\x74EA\x3F3F\
+\\x74EB\x3F3F\
+\\x74EC\x3F3F\
+\\x74ED\x3F3F\
+\\x74EE\x3F3F\
+\\x74EF\x3F3F\
+\\x74F0\x3F3F\
+\\x74F1\x3F3F\
+\\x74F2\x3F3F\
+\\x74F3\x3F3F\
+\\x74F4\x3F3F\
+\\x74F5\x3F3F\
+\\x74F6\x3F3F\
+\\x74F7\x3F3F\
+\\x74F8\x3F3F\
+\\x74F9\x3F3F\
+\\x74FA\x3F3F\
+\\x74FB\x3F3F\
+\\x74FC\x3F3F\
+\\x74FD\x3F3F\
+\\x74FE\x3F3F\
+\\x7541\x3F3F\
+\\x7542\x3F3F\
+\\x7543\x3F3F\
+\\x7544\x3F3F\
+\\x7545\x3F3F\
+\\x7546\x3F3F\
+\\x7547\x3F3F\
+\\x7548\x3F3F\
+\\x7549\x3F3F\
+\\x754A\x3F3F\
+\\x754B\x3F3F\
+\\x754C\x3F3F\
+\\x754D\x3F3F\
+\\x754E\x3F3F\
+\\x754F\x3F3F\
+\\x7550\x3F3F\
+\\x7551\x3F3F\
+\\x7552\x3F3F\
+\\x7553\x3F3F\
+\\x7554\x3F3F\
+\\x7555\x3F3F\
+\\x7556\x3F3F\
+\\x7557\x3F3F\
+\\x7558\x3F3F\
+\\x7559\x3F3F\
+\\x755A\x3F3F\
+\\x755B\x3F3F\
+\\x755C\x3F3F\
+\\x755D\x3F3F\
+\\x755E\x3F3F\
+\\x755F\x3F3F\
+\\x7560\x3F3F\
+\\x7561\x3F3F\
+\\x7562\x3F3F\
+\\x7563\x3F3F\
+\\x7564\x3F3F\
+\\x7565\x3F3F\
+\\x7566\x3F3F\
+\\x7567\x3F3F\
+\\x7568\x3F3F\
+\\x7569\x3F3F\
+\\x756A\x3F3F\
+\\x756B\x3F3F\
+\\x756C\x3F3F\
+\\x756D\x3F3F\
+\\x756E\x3F3F\
+\\x756F\x3F3F\
+\\x7570\x3F3F\
+\\x7571\x3F3F\
+\\x7572\x3F3F\
+\\x7573\x3F3F\
+\\x7574\x3F3F\
+\\x7575\x3F3F\
+\\x7576\x3F3F\
+\\x7577\x3F3F\
+\\x7578\x3F3F\
+\\x7579\x3F3F\
+\\x757A\x3F3F\
+\\x757B\x3F3F\
+\\x757C\x3F3F\
+\\x757D\x3F3F\
+\\x757E\x3F3F\
+\\x757F\x3F3F\
+\\x7580\x3F3F\
+\\x7581\x3F3F\
+\\x7582\x3F3F\
+\\x7583\x3F3F\
+\\x7584\x3F3F\
+\\x7585\x3F3F\
+\\x7586\x3F3F\
+\\x7587\x3F3F\
+\\x7588\x3F3F\
+\\x7589\x3F3F\
+\\x758A\x3F3F\
+\\x758B\x3F3F\
+\\x758C\x3F3F\
+\\x758D\x3F3F\
+\\x758E\x3F3F\
+\\x758F\x3F3F\
+\\x7590\x3F3F\
+\\x7591\x3F3F\
+\\x7592\x3F3F\
+\\x7593\x3F3F\
+\\x7594\x3F3F\
+\\x7595\x3F3F\
+\\x7596\x3F3F\
+\\x7597\x3F3F\
+\\x7598\x3F3F\
+\\x7599\x3F3F\
+\\x759A\x3F3F\
+\\x759B\x3F3F\
+\\x759C\x3F3F\
+\\x759D\x3F3F\
+\\x759E\x3F3F\
+\\x759F\x3F3F\
+\\x75A0\x3F3F\
+\\x75A1\x3F3F\
+\\x75A2\x3F3F\
+\\x75A3\x3F3F\
+\\x75A4\x3F3F\
+\\x75A5\x3F3F\
+\\x75A6\x3F3F\
+\\x75A7\x3F3F\
+\\x75A8\x3F3F\
+\\x75A9\x3F3F\
+\\x75AA\x3F3F\
+\\x75AB\x3F3F\
+\\x75AC\x3F3F\
+\\x75AD\x3F3F\
+\\x75AE\x3F3F\
+\\x75AF\x3F3F\
+\\x75B0\x3F3F\
+\\x75B1\x3F3F\
+\\x75B2\x3F3F\
+\\x75B3\x3F3F\
+\\x75B4\x3F3F\
+\\x75B5\x3F3F\
+\\x75B6\x3F3F\
+\\x75B7\x3F3F\
+\\x75B8\x3F3F\
+\\x75B9\x3F3F\
+\\x75BA\x3F3F\
+\\x75BB\x3F3F\
+\\x75BC\x3F3F\
+\\x75BD\x3F3F\
+\\x75BE\x3F3F\
+\\x75BF\x3F3F\
+\\x75C0\x3F3F\
+\\x75C1\x3F3F\
+\\x75C2\x3F3F\
+\\x75C3\x3F3F\
+\\x75C4\x3F3F\
+\\x75C5\x3F3F\
+\\x75C6\x3F3F\
+\\x75C7\x3F3F\
+\\x75C8\x3F3F\
+\\x75C9\x3F3F\
+\\x75CA\x3F3F\
+\\x75CB\x3F3F\
+\\x75CC\x3F3F\
+\\x75CD\x3F3F\
+\\x75CE\x3F3F\
+\\x75CF\x3F3F\
+\\x75D0\x3F3F\
+\\x75D1\x3F3F\
+\\x75D2\x3F3F\
+\\x75D3\x3F3F\
+\\x75D4\x3F3F\
+\\x75D5\x3F3F\
+\\x75D6\x3F3F\
+\\x75D7\x3F3F\
+\\x75D8\x3F3F\
+\\x75D9\x3F3F\
+\\x75DA\x3F3F\
+\\x75DB\x3F3F\
+\\x75DC\x3F3F\
+\\x75DD\x3F3F\
+\\x75DE\x3F3F\
+\\x75DF\x3F3F\
+\\x75E0\x3F3F\
+\\x75E1\x3F3F\
+\\x75E2\x3F3F\
+\\x75E3\x3F3F\
+\\x75E4\x3F3F\
+\\x75E5\x3F3F\
+\\x75E6\x3F3F\
+\\x75E7\x3F3F\
+\\x75E8\x3F3F\
+\\x75E9\x3F3F\
+\\x75EA\x3F3F\
+\\x75EB\x3F3F\
+\\x75EC\x3F3F\
+\\x75ED\x3F3F\
+\\x75EE\x3F3F\
+\\x75EF\x3F3F\
+\\x75F0\x3F3F\
+\\x75F1\x3F3F\
+\\x75F2\x3F3F\
+\\x75F3\x3F3F\
+\\x75F4\x3F3F\
+\\x75F5\x3F3F\
+\\x75F6\x3F3F\
+\\x75F7\x3F3F\
+\\x75F8\x3F3F\
+\\x75F9\x3F3F\
+\\x75FA\x3F3F\
+\\x75FB\x3F3F\
+\\x75FC\x3F3F\
+\\x75FD\x3F3F\
+\\x75FE\x3F3F\
+\\x7641\x3F3F\
+\\x7642\x3F3F\
+\\x7643\x3F3F\
+\\x7644\x3F3F\
+\\x7645\x3F3F\
+\\x7646\x3F3F\
+\\x7647\x3F3F\
+\\x7648\x3F3F\
+\\x7649\x3F3F\
+\\x764A\x3F3F\
+\\x764B\x3F3F\
+\\x764C\x3F3F\
+\\x764D\x3F3F\
+\\x764E\x3F3F\
+\\x764F\x3F3F\
+\\x7650\x3F3F\
+\\x7651\x3F3F\
+\\x7652\x3F3F\
+\\x7653\x3F3F\
+\\x7654\x3F3F\
+\\x7655\x3F3F\
+\\x7656\x3F3F\
+\\x7657\x3F3F\
+\\x7658\x3F3F\
+\\x7659\x3F3F\
+\\x765A\x3F3F\
+\\x765B\x3F3F\
+\\x765C\x3F3F\
+\\x765D\x3F3F\
+\\x765E\x3F3F\
+\\x765F\x3F3F\
+\\x7660\x3F3F\
+\\x7661\x3F3F\
+\\x7662\x3F3F\
+\\x7663\x3F3F\
+\\x7664\x3F3F\
+\\x7665\x3F3F\
+\\x7666\x3F3F\
+\\x7667\x3F3F\
+\\x7668\x3F3F\
+\\x7669\x3F3F\
+\\x766A\x3F3F\
+\\x766B\x3F3F\
+\\x766C\x3F3F\
+\\x766D\x3F3F\
+\\x766E\x3F3F\
+\\x766F\x3F3F\
+\\x7670\x3F3F\
+\\x7671\x3F3F\
+\\x7672\x3F3F\
+\\x7673\x3F3F\
+\\x7674\x3F3F\
+\\x7675\x3F3F\
+\\x7676\x3F3F\
+\\x7677\x3F3F\
+\\x7678\x3F3F\
+\\x7679\x3F3F\
+\\x767A\x3F3F\
+\\x767B\x3F3F\
+\\x767C\x3F3F\
+\\x767D\x3F3F\
+\\x767E\x3F3F\
+\\x767F\x3F3F\
+\\x7680\x3F3F\
+\\x7681\x3F3F\
+\\x7682\x3F3F\
+\\x7683\x3F3F\
+\\x7684\x3F3F\
+\\x7685\x3F3F\
+\\x7686\x3F3F\
+\\x7687\x3F3F\
+\\x7688\x3F3F\
+\\x7689\x3F3F\
+\\x768A\x3F3F\
+\\x768B\x3F3F\
+\\x768C\x3F3F\
+\\x768D\x3F3F\
+\\x768E\x3F3F\
+\\x768F\x3F3F\
+\\x7690\x3F3F\
+\\x7691\x3F3F\
+\\x7692\x3F3F\
+\\x7693\x3F3F\
+\\x7694\x3F3F\
+\\x7695\x3F3F\
+\\x7696\x3F3F\
+\\x7697\x3F3F\
+\\x7698\x3F3F\
+\\x7699\x3F3F\
+\\x769A\x3F3F\
+\\x769B\x3F3F\
+\\x769C\x3F3F\
+\\x769D\x3F3F\
+\\x769E\x3F3F\
+\\x769F\x3F3F\
+\\x76A0\x3F3F\
+\\x76A1\x3F3F\
+\\x76A2\x3F3F\
+\\x76A3\x3F3F\
+\\x76A4\x3F3F\
+\\x76A5\x3F3F\
+\\x76A6\x3F3F\
+\\x76A7\x3F3F\
+\\x76A8\x3F3F\
+\\x76A9\x3F3F\
+\\x76AA\x3F3F\
+\\x76AB\x3F3F\
+\\x76AC\x3F3F\
+\\x76AD\x3F3F\
+\\x76AE\x3F3F\
+\\x76AF\x3F3F\
+\\x76B0\x3F3F\
+\\x76B1\x3F3F\
+\\x76B2\x3F3F\
+\\x76B3\x3F3F\
+\\x76B4\x3F3F\
+\\x76B5\x3F3F\
+\\x76B6\x3F3F\
+\\x76B7\x3F3F\
+\\x76B8\x3F3F\
+\\x76B9\x3F3F\
+\\x76BA\x3F3F\
+\\x76BB\x3F3F\
+\\x76BC\x3F3F\
+\\x76BD\x3F3F\
+\\x76BE\x3F3F\
+\\x76BF\x3F3F\
+\\x76C0\x3F3F\
+\\x76C1\x3F3F\
+\\x76C2\x3F3F\
+\\x76C3\x3F3F\
+\\x76C4\x3F3F\
+\\x76C5\x3F3F\
+\\x76C6\x3F3F\
+\\x76C7\x3F3F\
+\\x76C8\x3F3F\
+\\x76C9\x3F3F\
+\\x76CA\x3F3F\
+\\x76CB\x3F3F\
+\\x76CC\x3F3F\
+\\x76CD\x3F3F\
+\\x76CE\x3F3F\
+\\x76CF\x3F3F\
+\\x76D0\x3F3F\
+\\x76D1\x3F3F\
+\\x76D2\x3F3F\
+\\x76D3\x3F3F\
+\\x76D4\x3F3F\
+\\x76D5\x3F3F\
+\\x76D6\x3F3F\
+\\x76D7\x3F3F\
+\\x76D8\x3F3F\
+\\x76D9\x3F3F\
+\\x76DA\x3F3F\
+\\x76DB\x3F3F\
+\\x76DC\x3F3F\
+\\x76DD\x3F3F\
+\\x76DE\x3F3F\
+\\x76DF\x3F3F\
+\\x76E0\x3F3F\
+\\x76E1\x3F3F\
+\\x76E2\x3F3F\
+\\x76E3\x3F3F\
+\\x76E4\x3F3F\
+\\x76E5\x3F3F\
+\\x76E6\x3F3F\
+\\x76E7\x3F3F\
+\\x76E8\x3F3F\
+\\x76E9\x3F3F\
+\\x76EA\x3F3F\
+\\x76EB\x3F3F\
+\\x76EC\x3F3F\
+\\x76ED\x3F3F\
+\\x76EE\x3F3F\
+\\x76EF\x3F3F\
+\\x76F0\x3F3F\
+\\x76F1\x3F3F\
+\\x76F2\x3F3F\
+\\x76F3\x3F3F\
+\\x76F4\x3F3F\
+\\x76F5\x3F3F\
+\\x76F6\x3F3F\
+\\x76F7\x3F3F\
+\\x76F8\x3F3F\
+\\x76F9\x3F3F\
+\\x76FA\x3F3F\
+\\x76FB\x3F3F\
+\\x76FC\x3F3F\
+\\x76FD\x3F3F\
+\\x76FE\x3F3F\
+\\x7741\x3F3F\
+\\x7742\x3F3F\
+\\x7743\x3F3F\
+\\x7744\x3F3F\
+\\x7745\x3F3F\
+\\x7746\x3F3F\
+\\x7747\x3F3F\
+\\x7748\x3F3F\
+\\x7749\x3F3F\
+\\x774A\x3F3F\
+\\x774B\x3F3F\
+\\x774C\x3F3F\
+\\x774D\x3F3F\
+\\x774E\x3F3F\
+\\x774F\x3F3F\
+\\x7750\x3F3F\
+\\x7751\x3F3F\
+\\x7752\x3F3F\
+\\x7753\x3F3F\
+\\x7754\x3F3F\
+\\x7755\x3F3F\
+\\x7756\x3F3F\
+\\x7757\x3F3F\
+\\x7758\x3F3F\
+\\x7759\x3F3F\
+\\x775A\x3F3F\
+\\x775B\x3F3F\
+\\x775C\x3F3F\
+\\x775D\x3F3F\
+\\x775E\x3F3F\
+\\x775F\x3F3F\
+\\x7760\x3F3F\
+\\x7761\x3F3F\
+\\x7762\x3F3F\
+\\x7763\x3F3F\
+\\x7764\x3F3F\
+\\x7765\x3F3F\
+\\x7766\x3F3F\
+\\x7767\x3F3F\
+\\x7768\x3F3F\
+\\x7769\x3F3F\
+\\x776A\x3F3F\
+\\x776B\x3F3F\
+\\x776C\x3F3F\
+\\x776D\x3F3F\
+\\x776E\x3F3F\
+\\x776F\x3F3F\
+\\x7770\x3F3F\
+\\x7771\x3F3F\
+\\x7772\x3F3F\
+\\x7773\x3F3F\
+\\x7774\x3F3F\
+\\x7775\x3F3F\
+\\x7776\x3F3F\
+\\x7777\x3F3F\
+\\x7778\x3F3F\
+\\x7779\x3F3F\
+\\x777A\x3F3F\
+\\x777B\x3F3F\
+\\x777C\x3F3F\
+\\x777D\x3F3F\
+\\x777E\x3F3F\
+\\x777F\x3F3F\
+\\x7780\x3F3F\
+\\x7781\x3F3F\
+\\x7782\x3F3F\
+\\x7783\x3F3F\
+\\x7784\x3F3F\
+\\x7785\x3F3F\
+\\x7786\x3F3F\
+\\x7787\x3F3F\
+\\x7788\x3F3F\
+\\x7789\x3F3F\
+\\x778A\x3F3F\
+\\x778B\x3F3F\
+\\x778C\x3F3F\
+\\x778D\x3F3F\
+\\x778E\x3F3F\
+\\x778F\x3F3F\
+\\x7790\x3F3F\
+\\x7791\x3F3F\
+\\x7792\x3F3F\
+\\x7793\x3F3F\
+\\x7794\x3F3F\
+\\x7795\x3F3F\
+\\x7796\x3F3F\
+\\x7797\x3F3F\
+\\x7798\x3F3F\
+\\x7799\x3F3F\
+\\x779A\x3F3F\
+\\x779B\x3F3F\
+\\x779C\x3F3F\
+\\x779D\x3F3F\
+\\x779E\x3F3F\
+\\x779F\x3F3F\
+\\x77A0\x3F3F\
+\\x77A1\x3F3F\
+\\x77A2\x3F3F\
+\\x77A3\x3F3F\
+\\x77A4\x3F3F\
+\\x77A5\x3F3F\
+\\x77A6\x3F3F\
+\\x77A7\x3F3F\
+\\x77A8\x3F3F\
+\\x77A9\x3F3F\
+\\x77AA\x3F3F\
+\\x77AB\x3F3F\
+\\x77AC\x3F3F\
+\\x77AD\x3F3F\
+\\x77AE\x3F3F\
+\\x77AF\x3F3F\
+\\x77B0\x3F3F\
+\\x77B1\x3F3F\
+\\x77B2\x3F3F\
+\\x77B3\x3F3F\
+\\x77B4\x3F3F\
+\\x77B5\x3F3F\
+\\x77B6\x3F3F\
+\\x77B7\x3F3F\
+\\x77B8\x3F3F\
+\\x77B9\x3F3F\
+\\x77BA\x3F3F\
+\\x77BB\x3F3F\
+\\x77BC\x3F3F\
+\\x77BD\x3F3F\
+\\x77BE\x3F3F\
+\\x77BF\x3F3F\
+\\x77C0\x3F3F\
+\\x77C1\x3F3F\
+\\x77C2\x3F3F\
+\\x77C3\x3F3F\
+\\x77C4\x3F3F\
+\\x77C5\x3F3F\
+\\x77C6\x3F3F\
+\\x77C7\x3F3F\
+\\x77C8\x3F3F\
+\\x77C9\x3F3F\
+\\x77CA\x3F3F\
+\\x77CB\x3F3F\
+\\x77CC\x3F3F\
+\\x77CD\x3F3F\
+\\x77CE\x3F3F\
+\\x77CF\x3F3F\
+\\x77D0\x3F3F\
+\\x77D1\x3F3F\
+\\x77D2\x3F3F\
+\\x77D3\x3F3F\
+\\x77D4\x3F3F\
+\\x77D5\x3F3F\
+\\x77D6\x3F3F\
+\\x77D7\x3F3F\
+\\x77D8\x3F3F\
+\\x77D9\x3F3F\
+\\x77DA\x3F3F\
+\\x77DB\x3F3F\
+\\x77DC\x3F3F\
+\\x77DD\x3F3F\
+\\x77DE\x3F3F\
+\\x77DF\x3F3F\
+\\x77E0\x3F3F\
+\\x77E1\x3F3F\
+\\x77E2\x3F3F\
+\\x77E3\x3F3F\
+\\x77E4\x3F3F\
+\\x77E5\x3F3F\
+\\x77E6\x3F3F\
+\\x77E7\x3F3F\
+\\x77E8\x3F3F\
+\\x77E9\x3F3F\
+\\x77EA\x3F3F\
+\\x77EB\x3F3F\
+\\x77EC\x3F3F\
+\\x77ED\x3F3F\
+\\x77EE\x3F3F\
+\\x77EF\x3F3F\
+\\x77F0\x3F3F\
+\\x77F1\x3F3F\
+\\x77F2\x3F3F\
+\\x77F3\x3F3F\
+\\x77F4\x3F3F\
+\\x77F5\x3F3F\
+\\x77F6\x3F3F\
+\\x77F7\x3F3F\
+\\x77F8\x3F3F\
+\\x77F9\x3F3F\
+\\x77FA\x3F3F\
+\\x77FB\x3F3F\
+\\x77FC\x3F3F\
+\\x77FD\x3F3F\
+\\x77FE\x3F3F\
+\\x7841\x3F3F\
+\\x7842\x3F3F\
+\\x7843\x3F3F\
+\\x7844\x3F3F\
+\\x7845\x3F3F\
+\\x7846\x3F3F\
+\\x7847\x3F3F\
+\\x7848\x3F3F\
+\\x7849\x3F3F\
+\\x784A\x3F3F\
+\\x784B\x3F3F\
+\\x784C\x3F3F\
+\\x784D\x3F3F\
+\\x784E\x3F3F\
+\\x784F\x3F3F\
+\\x7850\x3F3F\
+\\x7851\x3F3F\
+\\x7852\x3F3F\
+\\x7853\x3F3F\
+\\x7854\x3F3F\
+\\x7855\x3F3F\
+\\x7856\x3F3F\
+\\x7857\x3F3F\
+\\x7858\x3F3F\
+\\x7859\x3F3F\
+\\x785A\x3F3F\
+\\x785B\x3F3F\
+\\x785C\x3F3F\
+\\x785D\x3F3F\
+\\x785E\x3F3F\
+\\x785F\x3F3F\
+\\x7860\x3F3F\
+\\x7861\x3F3F\
+\\x7862\x3F3F\
+\\x7863\x3F3F\
+\\x7864\x3F3F\
+\\x7865\x3F3F\
+\\x7866\x3F3F\
+\\x7867\x3F3F\
+\\x7868\x3F3F\
+\\x7869\x3F3F\
+\\x786A\x3F3F\
+\\x786B\x3F3F\
+\\x786C\x3F3F\
+\\x786D\x3F3F\
+\\x786E\x3F3F\
+\\x786F\x3F3F\
+\\x7870\x3F3F\
+\\x7871\x3F3F\
+\\x7872\x3F3F\
+\\x7873\x3F3F\
+\\x7874\x3F3F\
+\\x7875\x3F3F\
+\\x7876\x3F3F\
+\\x7877\x3F3F\
+\\x7878\x3F3F\
+\\x7879\x3F3F\
+\\x787A\x3F3F\
+\\x787B\x3F3F\
+\\x787C\x3F3F\
+\\x787D\x3F3F\
+\\x787E\x3F3F\
+\\x787F\x3F3F\
+\\x7880\x3F3F\
+\\x7881\x3F3F\
+\\x7882\x3F3F\
+\\x7883\x3F3F\
+\\x7884\x3F3F\
+\\x7885\x3F3F\
+\\x7886\x3F3F\
+\\x7887\x3F3F\
+\\x7888\x3F3F\
+\\x7889\x3F3F\
+\\x788A\x3F3F\
+\\x788B\x3F3F\
+\\x788C\x3F3F\
+\\x788D\x3F3F\
+\\x788E\x3F3F\
+\\x788F\x3F3F\
+\\x7890\x3F3F\
+\\x7891\x3F3F\
+\\x7892\x3F3F\
+\\x7893\x3F3F\
+\\x7894\x3F3F\
+\\x7895\x3F3F\
+\\x7896\x3F3F\
+\\x7897\x3F3F\
+\\x7898\x3F3F\
+\\x7899\x3F3F\
+\\x789A\x3F3F\
+\\x789B\x3F3F\
+\\x789C\x3F3F\
+\\x789D\x3F3F\
+\\x789E\x3F3F\
+\\x789F\x3F3F\
+\\x78A0\x3F3F\
+\\x78A1\x3F3F\
+\\x78A2\x3F3F\
+\\x78A3\x3F3F\
+\\x78A4\x3F3F\
+\\x78A5\x3F3F\
+\\x78A6\x3F3F\
+\\x78A7\x3F3F\
+\\x78A8\x3F3F\
+\\x78A9\x3F3F\
+\\x78AA\x3F3F\
+\\x78AB\x3F3F\
+\\x78AC\x3F3F\
+\\x78AD\x3F3F\
+\\x78AE\x3F3F\
+\\x78AF\x3F3F\
+\\x78B0\x3F3F\
+\\x78B1\x3F3F\
+\\x78B2\x3F3F\
+\\x78B3\x3F3F\
+\\x78B4\x3F3F\
+\\x78B5\x3F3F\
+\\x78B6\x3F3F\
+\\x78B7\x3F3F\
+\\x78B8\x3F3F\
+\\x78B9\x3F3F\
+\\x78BA\x3F3F\
+\\x78BB\x3F3F\
+\\x78BC\x3F3F\
+\\x78BD\x3F3F\
+\\x78BE\x3F3F\
+\\x78BF\x3F3F\
+\\x78C0\x3F3F\
+\\x78C1\x3F3F\
+\\x78C2\x3F3F\
+\\x78C3\x3F3F\
+\\x78C4\x3F3F\
+\\x78C5\x3F3F\
+\\x78C6\x3F3F\
+\\x78C7\x3F3F\
+\\x78C8\x3F3F\
+\\x78C9\x3F3F\
+\\x78CA\x3F3F\
+\\x78CB\x3F3F\
+\\x78CC\x3F3F\
+\\x78CD\x3F3F\
+\\x78CE\x3F3F\
+\\x78CF\x3F3F\
+\\x78D0\x3F3F\
+\\x78D1\x3F3F\
+\\x78D2\x3F3F\
+\\x78D3\x3F3F\
+\\x78D4\x3F3F\
+\\x78D5\x3F3F\
+\\x78D6\x3F3F\
+\\x78D7\x3F3F\
+\\x78D8\x3F3F\
+\\x78D9\x3F3F\
+\\x78DA\x3F3F\
+\\x78DB\x3F3F\
+\\x78DC\x3F3F\
+\\x78DD\x3F3F\
+\\x78DE\x3F3F\
+\\x78DF\x3F3F\
+\\x78E0\x3F3F\
+\\x78E1\x3F3F\
+\\x78E2\x3F3F\
+\\x78E3\x3F3F\
+\\x78E4\x3F3F\
+\\x78E5\x3F3F\
+\\x78E6\x3F3F\
+\\x78E7\x3F3F\
+\\x78E8\x3F3F\
+\\x78E9\x3F3F\
+\\x78EA\x3F3F\
+\\x78EB\x3F3F\
+\\x78EC\x3F3F\
+\\x78ED\x3F3F\
+\\x78EE\x3F3F\
+\\x78EF\x3F3F\
+\\x78F0\x3F3F\
+\\x78F1\x3F3F\
+\\x78F2\x3F3F\
+\\x78F3\x3F3F\
+\\x78F4\x3F3F\
+\\x78F5\x3F3F\
+\\x78F6\x3F3F\
+\\x78F7\x3F3F\
+\\x78F8\x3F3F\
+\\x78F9\x3F3F\
+\\x78FA\x3F3F\
+\\x78FB\x3F3F\
+\\x78FC\x3F3F\
+\\x78FD\x3F3F\
+\\x78FE\x3F3F\
+\\x7941\x3F3F\
+\\x7942\x3F3F\
+\\x7943\x3F3F\
+\\x7944\x3F3F\
+\\x7945\x3F3F\
+\\x7946\x3F3F\
+\\x7947\x3F3F\
+\\x7948\x3F3F\
+\\x7949\x3F3F\
+\\x794A\x3F3F\
+\\x794B\x3F3F\
+\\x794C\x3F3F\
+\\x794D\x3F3F\
+\\x794E\x3F3F\
+\\x794F\x3F3F\
+\\x7950\x3F3F\
+\\x7951\x3F3F\
+\\x7952\x3F3F\
+\\x7953\x3F3F\
+\\x7954\x3F3F\
+\\x7955\x3F3F\
+\\x7956\x3F3F\
+\\x7957\x3F3F\
+\\x7958\x3F3F\
+\\x7959\x3F3F\
+\\x795A\x3F3F\
+\\x795B\x3F3F\
+\\x795C\x3F3F\
+\\x795D\x3F3F\
+\\x795E\x3F3F\
+\\x795F\x3F3F\
+\\x7960\x3F3F\
+\\x7961\x3F3F\
+\\x7962\x3F3F\
+\\x7963\x3F3F\
+\\x7964\x3F3F\
+\\x7965\x3F3F\
+\\x7966\x3F3F\
+\\x7967\x3F3F\
+\\x7968\x3F3F\
+\\x7969\x3F3F\
+\\x796A\x3F3F\
+\\x796B\x3F3F\
+\\x796C\x3F3F\
+\\x796D\x3F3F\
+\\x796E\x3F3F\
+\\x796F\x3F3F\
+\\x7970\x3F3F\
+\\x7971\x3F3F\
+\\x7972\x3F3F\
+\\x7973\x3F3F\
+\\x7974\x3F3F\
+\\x7975\x3F3F\
+\\x7976\x3F3F\
+\\x7977\x3F3F\
+\\x7978\x3F3F\
+\\x7979\x3F3F\
+\\x797A\x3F3F\
+\\x797B\x3F3F\
+\\x797C\x3F3F\
+\\x797D\x3F3F\
+\\x797E\x3F3F\
+\\x797F\x3F3F\
+\\x7980\x3F3F\
+\\x7981\x3F3F\
+\\x7982\x3F3F\
+\\x7983\x3F3F\
+\\x7984\x3F3F\
+\\x7985\x3F3F\
+\\x7986\x3F3F\
+\\x7987\x3F3F\
+\\x7988\x3F3F\
+\\x7989\x3F3F\
+\\x798A\x3F3F\
+\\x798B\x3F3F\
+\\x798C\x3F3F\
+\\x798D\x3F3F\
+\\x798E\x3F3F\
+\\x798F\x3F3F\
+\\x7990\x3F3F\
+\\x7991\x3F3F\
+\\x7992\x3F3F\
+\\x7993\x3F3F\
+\\x7994\x3F3F\
+\\x7995\x3F3F\
+\\x7996\x3F3F\
+\\x7997\x3F3F\
+\\x7998\x3F3F\
+\\x7999\x3F3F\
+\\x799A\x3F3F\
+\\x799B\x3F3F\
+\\x799C\x3F3F\
+\\x799D\x3F3F\
+\\x799E\x3F3F\
+\\x799F\x3F3F\
+\\x79A0\x3F3F\
+\\x79A1\x3F3F\
+\\x79A2\x3F3F\
+\\x79A3\x3F3F\
+\\x79A4\x3F3F\
+\\x79A5\x3F3F\
+\\x79A6\x3F3F\
+\\x79A7\x3F3F\
+\\x79A8\x3F3F\
+\\x79A9\x3F3F\
+\\x79AA\x3F3F\
+\\x79AB\x3F3F\
+\\x79AC\x3F3F\
+\\x79AD\x3F3F\
+\\x79AE\x3F3F\
+\\x79AF\x3F3F\
+\\x79B0\x3F3F\
+\\x79B1\x3F3F\
+\\x79B2\x3F3F\
+\\x79B3\x3F3F\
+\\x79B4\x3F3F\
+\\x79B5\x3F3F\
+\\x79B6\x3F3F\
+\\x79B7\x3F3F\
+\\x79B8\x3F3F\
+\\x79B9\x3F3F\
+\\x79BA\x3F3F\
+\\x79BB\x3F3F\
+\\x79BC\x3F3F\
+\\x79BD\x3F3F\
+\\x79BE\x3F3F\
+\\x79BF\x3F3F\
+\\x79C0\x3F3F\
+\\x79C1\x3F3F\
+\\x79C2\x3F3F\
+\\x79C3\x3F3F\
+\\x79C4\x3F3F\
+\\x79C5\x3F3F\
+\\x79C6\x3F3F\
+\\x79C7\x3F3F\
+\\x79C8\x3F3F\
+\\x79C9\x3F3F\
+\\x79CA\x3F3F\
+\\x79CB\x3F3F\
+\\x79CC\x3F3F\
+\\x79CD\x3F3F\
+\\x79CE\x3F3F\
+\\x79CF\x3F3F\
+\\x79D0\x3F3F\
+\\x79D1\x3F3F\
+\\x79D2\x3F3F\
+\\x79D3\x3F3F\
+\\x79D4\x3F3F\
+\\x79D5\x3F3F\
+\\x79D6\x3F3F\
+\\x79D7\x3F3F\
+\\x79D8\x3F3F\
+\\x79D9\x3F3F\
+\\x79DA\x3F3F\
+\\x79DB\x3F3F\
+\\x79DC\x3F3F\
+\\x79DD\x3F3F\
+\\x79DE\x3F3F\
+\\x79DF\x3F3F\
+\\x79E0\x3F3F\
+\\x79E1\x3F3F\
+\\x79E2\x3F3F\
+\\x79E3\x3F3F\
+\\x79E4\x3F3F\
+\\x79E5\x3F3F\
+\\x79E6\x3F3F\
+\\x79E7\x3F3F\
+\\x79E8\x3F3F\
+\\x79E9\x3F3F\
+\\x79EA\x3F3F\
+\\x79EB\x3F3F\
+\\x79EC\x3F3F\
+\\x79ED\x3F3F\
+\\x79EE\x3F3F\
+\\x79EF\x3F3F\
+\\x79F0\x3F3F\
+\\x79F1\x3F3F\
+\\x79F2\x3F3F\
+\\x79F3\x3F3F\
+\\x79F4\x3F3F\
+\\x79F5\x3F3F\
+\\x79F6\x3F3F\
+\\x79F7\x3F3F\
+\\x79F8\x3F3F\
+\\x79F9\x3F3F\
+\\x79FA\x3F3F\
+\\x79FB\x3F3F\
+\\x79FC\x3F3F\
+\\x79FD\x3F3F\
+\\x79FE\x3F3F\
+\\x7A41\x3F3F\
+\\x7A42\x3F3F\
+\\x7A43\x3F3F\
+\\x7A44\x3F3F\
+\\x7A45\x3F3F\
+\\x7A46\x3F3F\
+\\x7A47\x3F3F\
+\\x7A48\x3F3F\
+\\x7A49\x3F3F\
+\\x7A4A\x3F3F\
+\\x7A4B\x3F3F\
+\\x7A4C\x3F3F\
+\\x7A4D\x3F3F\
+\\x7A4E\x3F3F\
+\\x7A4F\x3F3F\
+\\x7A50\x3F3F\
+\\x7A51\x3F3F\
+\\x7A52\x3F3F\
+\\x7A53\x3F3F\
+\\x7A54\x3F3F\
+\\x7A55\x3F3F\
+\\x7A56\x3F3F\
+\\x7A57\x3F3F\
+\\x7A58\x3F3F\
+\\x7A59\x3F3F\
+\\x7A5A\x3F3F\
+\\x7A5B\x3F3F\
+\\x7A5C\x3F3F\
+\\x7A5D\x3F3F\
+\\x7A5E\x3F3F\
+\\x7A5F\x3F3F\
+\\x7A60\x3F3F\
+\\x7A61\x3F3F\
+\\x7A62\x3F3F\
+\\x7A63\x3F3F\
+\\x7A64\x3F3F\
+\\x7A65\x3F3F\
+\\x7A66\x3F3F\
+\\x7A67\x3F3F\
+\\x7A68\x3F3F\
+\\x7A69\x3F3F\
+\\x7A6A\x3F3F\
+\\x7A6B\x3F3F\
+\\x7A6C\x3F3F\
+\\x7A6D\x3F3F\
+\\x7A6E\x3F3F\
+\\x7A6F\x3F3F\
+\\x7A70\x3F3F\
+\\x7A71\x3F3F\
+\\x7A72\x3F3F\
+\\x7A73\x3F3F\
+\\x7A74\x3F3F\
+\\x7A75\x3F3F\
+\\x7A76\x3F3F\
+\\x7A77\x3F3F\
+\\x7A78\x3F3F\
+\\x7A79\x3F3F\
+\\x7A7A\x3F3F\
+\\x7A7B\x3F3F\
+\\x7A7C\x3F3F\
+\\x7A7D\x3F3F\
+\\x7A7E\x3F3F\
+\\x7A7F\x3F3F\
+\\x7A80\x3F3F\
+\\x7A81\x3F3F\
+\\x7A82\x3F3F\
+\\x7A83\x3F3F\
+\\x7A84\x3F3F\
+\\x7A85\x3F3F\
+\\x7A86\x3F3F\
+\\x7A87\x3F3F\
+\\x7A88\x3F3F\
+\\x7A89\x3F3F\
+\\x7A8A\x3F3F\
+\\x7A8B\x3F3F\
+\\x7A8C\x3F3F\
+\\x7A8D\x3F3F\
+\\x7A8E\x3F3F\
+\\x7A8F\x3F3F\
+\\x7A90\x3F3F\
+\\x7A91\x3F3F\
+\\x7A92\x3F3F\
+\\x7A93\x3F3F\
+\\x7A94\x3F3F\
+\\x7A95\x3F3F\
+\\x7A96\x3F3F\
+\\x7A97\x3F3F\
+\\x7A98\x3F3F\
+\\x7A99\x3F3F\
+\\x7A9A\x3F3F\
+\\x7A9B\x3F3F\
+\\x7A9C\x3F3F\
+\\x7A9D\x3F3F\
+\\x7A9E\x3F3F\
+\\x7A9F\x3F3F\
+\\x7AA0\x3F3F\
+\\x7AA1\x3F3F\
+\\x7AA2\x3F3F\
+\\x7AA3\x3F3F\
+\\x7AA4\x3F3F\
+\\x7AA5\x3F3F\
+\\x7AA6\x3F3F\
+\\x7AA7\x3F3F\
+\\x7AA8\x3F3F\
+\\x7AA9\x3F3F\
+\\x7AAA\x3F3F\
+\\x7AAB\x3F3F\
+\\x7AAC\x3F3F\
+\\x7AAD\x3F3F\
+\\x7AAE\x3F3F\
+\\x7AAF\x3F3F\
+\\x7AB0\x3F3F\
+\\x7AB1\x3F3F\
+\\x7AB2\x3F3F\
+\\x7AB3\x3F3F\
+\\x7AB4\x3F3F\
+\\x7AB5\x3F3F\
+\\x7AB6\x3F3F\
+\\x7AB7\x3F3F\
+\\x7AB8\x3F3F\
+\\x7AB9\x3F3F\
+\\x7ABA\x3F3F\
+\\x7ABB\x3F3F\
+\\x7ABC\x3F3F\
+\\x7ABD\x3F3F\
+\\x7ABE\x3F3F\
+\\x7ABF\x3F3F\
+\\x7AC0\x3F3F\
+\\x7AC1\x3F3F\
+\\x7AC2\x3F3F\
+\\x7AC3\x3F3F\
+\\x7AC4\x3F3F\
+\\x7AC5\x3F3F\
+\\x7AC6\x3F3F\
+\\x7AC7\x3F3F\
+\\x7AC8\x3F3F\
+\\x7AC9\x3F3F\
+\\x7ACA\x3F3F\
+\\x7ACB\x3F3F\
+\\x7ACC\x3F3F\
+\\x7ACD\x3F3F\
+\\x7ACE\x3F3F\
+\\x7ACF\x3F3F\
+\\x7AD0\x3F3F\
+\\x7AD1\x3F3F\
+\\x7AD2\x3F3F\
+\\x7AD3\x3F3F\
+\\x7AD4\x3F3F\
+\\x7AD5\x3F3F\
+\\x7AD6\x3F3F\
+\\x7AD7\x3F3F\
+\\x7AD8\x3F3F\
+\\x7AD9\x3F3F\
+\\x7ADA\x3F3F\
+\\x7ADB\x3F3F\
+\\x7ADC\x3F3F\
+\\x7ADD\x3F3F\
+\\x7ADE\x3F3F\
+\\x7ADF\x3F3F\
+\\x7AE0\x3F3F\
+\\x7AE1\x3F3F\
+\\x7AE2\x3F3F\
+\\x7AE3\x3F3F\
+\\x7AE4\x3F3F\
+\\x7AE5\x3F3F\
+\\x7AE6\x3F3F\
+\\x7AE7\x3F3F\
+\\x7AE8\x3F3F\
+\\x7AE9\x3F3F\
+\\x7AEA\x3F3F\
+\\x7AEB\x3F3F\
+\\x7AEC\x3F3F\
+\\x7AED\x3F3F\
+\\x7AEE\x3F3F\
+\\x7AEF\x3F3F\
+\\x7AF0\x3F3F\
+\\x7AF1\x3F3F\
+\\x7AF2\x3F3F\
+\\x7AF3\x3F3F\
+\\x7AF4\x3F3F\
+\\x7AF5\x3F3F\
+\\x7AF6\x3F3F\
+\\x7AF7\x3F3F\
+\\x7AF8\x3F3F\
+\\x7AF9\x3F3F\
+\\x7AFA\x3F3F\
+\\x7AFB\x3F3F\
+\\x7AFC\x3F3F\
+\\x7AFD\x3F3F\
+\\x7AFE\x3F3F\
+\\x7B41\x3F3F\
+\\x7B42\x3F3F\
+\\x7B43\x3F3F\
+\\x7B44\x3F3F\
+\\x7B45\x3F3F\
+\\x7B46\x3F3F\
+\\x7B47\x3F3F\
+\\x7B48\x3F3F\
+\\x7B49\x3F3F\
+\\x7B4A\x3F3F\
+\\x7B4B\x3F3F\
+\\x7B4C\x3F3F\
+\\x7B4D\x3F3F\
+\\x7B4E\x3F3F\
+\\x7B4F\x3F3F\
+\\x7B50\x3F3F\
+\\x7B51\x3F3F\
+\\x7B52\x3F3F\
+\\x7B53\x3F3F\
+\\x7B54\x3F3F\
+\\x7B55\x3F3F\
+\\x7B56\x3F3F\
+\\x7B57\x3F3F\
+\\x7B58\x3F3F\
+\\x7B59\x3F3F\
+\\x7B5A\x3F3F\
+\\x7B5B\x3F3F\
+\\x7B5C\x3F3F\
+\\x7B5D\x3F3F\
+\\x7B5E\x3F3F\
+\\x7B5F\x3F3F\
+\\x7B60\x3F3F\
+\\x7B61\x3F3F\
+\\x7B62\x3F3F\
+\\x7B63\x3F3F\
+\\x7B64\x3F3F\
+\\x7B65\x3F3F\
+\\x7B66\x3F3F\
+\\x7B67\x3F3F\
+\\x7B68\x3F3F\
+\\x7B69\x3F3F\
+\\x7B6A\x3F3F\
+\\x7B6B\x3F3F\
+\\x7B6C\x3F3F\
+\\x7B6D\x3F3F\
+\\x7B6E\x3F3F\
+\\x7B6F\x3F3F\
+\\x7B70\x3F3F\
+\\x7B71\x3F3F\
+\\x7B72\x3F3F\
+\\x7B73\x3F3F\
+\\x7B74\x3F3F\
+\\x7B75\x3F3F\
+\\x7B76\x3F3F\
+\\x7B77\x3F3F\
+\\x7B78\x3F3F\
+\\x7B79\x3F3F\
+\\x7B7A\x3F3F\
+\\x7B7B\x3F3F\
+\\x7B7C\x3F3F\
+\\x7B7D\x3F3F\
+\\x7B7E\x3F3F\
+\\x7B7F\x3F3F\
+\\x7B80\x3F3F\
+\\x7B81\x3F3F\
+\\x7B82\x3F3F\
+\\x7B83\x3F3F\
+\\x7B84\x3F3F\
+\\x7B85\x3F3F\
+\\x7B86\x3F3F\
+\\x7B87\x3F3F\
+\\x7B88\x3F3F\
+\\x7B89\x3F3F\
+\\x7B8A\x3F3F\
+\\x7B8B\x3F3F\
+\\x7B8C\x3F3F\
+\\x7B8D\x3F3F\
+\\x7B8E\x3F3F\
+\\x7B8F\x3F3F\
+\\x7B90\x3F3F\
+\\x7B91\x3F3F\
+\\x7B92\x3F3F\
+\\x7B93\x3F3F\
+\\x7B94\x3F3F\
+\\x7B95\x3F3F\
+\\x7B96\x3F3F\
+\\x7B97\x3F3F\
+\\x7B98\x3F3F\
+\\x7B99\x3F3F\
+\\x7B9A\x3F3F\
+\\x7B9B\x3F3F\
+\\x7B9C\x3F3F\
+\\x7B9D\x3F3F\
+\\x7B9E\x3F3F\
+\\x7B9F\x3F3F\
+\\x7BA0\x3F3F\
+\\x7BA1\x3F3F\
+\\x7BA2\x3F3F\
+\\x7BA3\x3F3F\
+\\x7BA4\x3F3F\
+\\x7BA5\x3F3F\
+\\x7BA6\x3F3F\
+\\x7BA7\x3F3F\
+\\x7BA8\x3F3F\
+\\x7BA9\x3F3F\
+\\x7BAA\x3F3F\
+\\x7BAB\x3F3F\
+\\x7BAC\x3F3F\
+\\x7BAD\x3F3F\
+\\x7BAE\x3F3F\
+\\x7BAF\x3F3F\
+\\x7BB0\x3F3F\
+\\x7BB1\x3F3F\
+\\x7BB2\x3F3F\
+\\x7BB3\x3F3F\
+\\x7BB4\x3F3F\
+\\x7BB5\x3F3F\
+\\x7BB6\x3F3F\
+\\x7BB7\x3F3F\
+\\x7BB8\x3F3F\
+\\x7BB9\x3F3F\
+\\x7BBA\x3F3F\
+\\x7BBB\x3F3F\
+\\x7BBC\x3F3F\
+\\x7BBD\x3F3F\
+\\x7BBE\x3F3F\
+\\x7BBF\x3F3F\
+\\x7BC0\x3F3F\
+\\x7BC1\x3F3F\
+\\x7BC2\x3F3F\
+\\x7BC3\x3F3F\
+\\x7BC4\x3F3F\
+\\x7BC5\x3F3F\
+\\x7BC6\x3F3F\
+\\x7BC7\x3F3F\
+\\x7BC8\x3F3F\
+\\x7BC9\x3F3F\
+\\x7BCA\x3F3F\
+\\x7BCB\x3F3F\
+\\x7BCC\x3F3F\
+\\x7BCD\x3F3F\
+\\x7BCE\x3F3F\
+\\x7BCF\x3F3F\
+\\x7BD0\x3F3F\
+\\x7BD1\x3F3F\
+\\x7BD2\x3F3F\
+\\x7BD3\x3F3F\
+\\x7BD4\x3F3F\
+\\x7BD5\x3F3F\
+\\x7BD6\x3F3F\
+\\x7BD7\x3F3F\
+\\x7BD8\x3F3F\
+\\x7BD9\x3F3F\
+\\x7BDA\x3F3F\
+\\x7BDB\x3F3F\
+\\x7BDC\x3F3F\
+\\x7BDD\x3F3F\
+\\x7BDE\x3F3F\
+\\x7BDF\x3F3F\
+\\x7BE0\x3F3F\
+\\x7BE1\x3F3F\
+\\x7BE2\x3F3F\
+\\x7BE3\x3F3F\
+\\x7BE4\x3F3F\
+\\x7BE5\x3F3F\
+\\x7BE6\x3F3F\
+\\x7BE7\x3F3F\
+\\x7BE8\x3F3F\
+\\x7BE9\x3F3F\
+\\x7BEA\x3F3F\
+\\x7BEB\x3F3F\
+\\x7BEC\x3F3F\
+\\x7BED\x3F3F\
+\\x7BEE\x3F3F\
+\\x7BEF\x3F3F\
+\\x7BF0\x3F3F\
+\\x7BF1\x3F3F\
+\\x7BF2\x3F3F\
+\\x7BF3\x3F3F\
+\\x7BF4\x3F3F\
+\\x7BF5\x3F3F\
+\\x7BF6\x3F3F\
+\\x7BF7\x3F3F\
+\\x7BF8\x3F3F\
+\\x7BF9\x3F3F\
+\\x7BFA\x3F3F\
+\\x7BFB\x3F3F\
+\\x7BFC\x3F3F\
+\\x7BFD\x3F3F\
+\\x7BFE\x3F3F\
+\\x7C41\x3F3F\
+\\x7C42\x3F3F\
+\\x7C43\x3F3F\
+\\x7C44\x3F3F\
+\\x7C45\x3F3F\
+\\x7C46\x3F3F\
+\\x7C47\x3F3F\
+\\x7C48\x3F3F\
+\\x7C49\x3F3F\
+\\x7C4A\x3F3F\
+\\x7C4B\x3F3F\
+\\x7C4C\x3F3F\
+\\x7C4D\x3F3F\
+\\x7C4E\x3F3F\
+\\x7C4F\x3F3F\
+\\x7C50\x3F3F\
+\\x7C51\x3F3F\
+\\x7C52\x3F3F\
+\\x7C53\x3F3F\
+\\x7C54\x3F3F\
+\\x7C55\x3F3F\
+\\x7C56\x3F3F\
+\\x7C57\x3F3F\
+\\x7C58\x3F3F\
+\\x7C59\x3F3F\
+\\x7C5A\x3F3F\
+\\x7C5B\x3F3F\
+\\x7C5C\x3F3F\
+\\x7C5D\x3F3F\
+\\x7C5E\x3F3F\
+\\x7C5F\x3F3F\
+\\x7C60\x3F3F\
+\\x7C61\x3F3F\
+\\x7C62\x3F3F\
+\\x7C63\x3F3F\
+\\x7C64\x3F3F\
+\\x7C65\x3F3F\
+\\x7C66\x3F3F\
+\\x7C67\x3F3F\
+\\x7C68\x3F3F\
+\\x7C69\x3F3F\
+\\x7C6A\x3F3F\
+\\x7C6B\x3F3F\
+\\x7C6C\x3F3F\
+\\x7C6D\x3F3F\
+\\x7C6E\x3F3F\
+\\x7C6F\x3F3F\
+\\x7C70\x3F3F\
+\\x7C71\x3F3F\
+\\x7C72\x3F3F\
+\\x7C73\x3F3F\
+\\x7C74\x3F3F\
+\\x7C75\x3F3F\
+\\x7C76\x3F3F\
+\\x7C77\x3F3F\
+\\x7C78\x3F3F\
+\\x7C79\x3F3F\
+\\x7C7A\x3F3F\
+\\x7C7B\x3F3F\
+\\x7C7C\x3F3F\
+\\x7C7D\x3F3F\
+\\x7C7E\x3F3F\
+\\x7C7F\x3F3F\
+\\x7C80\x3F3F\
+\\x7C81\x3F3F\
+\\x7C82\x3F3F\
+\\x7C83\x3F3F\
+\\x7C84\x3F3F\
+\\x7C85\x3F3F\
+\\x7C86\x3F3F\
+\\x7C87\x3F3F\
+\\x7C88\x3F3F\
+\\x7C89\x3F3F\
+\\x7C8A\x3F3F\
+\\x7C8B\x3F3F\
+\\x7C8C\x3F3F\
+\\x7C8D\x3F3F\
+\\x7C8E\x3F3F\
+\\x7C8F\x3F3F\
+\\x7C90\x3F3F\
+\\x7C91\x3F3F\
+\\x7C92\x3F3F\
+\\x7C93\x3F3F\
+\\x7C94\x3F3F\
+\\x7C95\x3F3F\
+\\x7C96\x3F3F\
+\\x7C97\x3F3F\
+\\x7C98\x3F3F\
+\\x7C99\x3F3F\
+\\x7C9A\x3F3F\
+\\x7C9B\x3F3F\
+\\x7C9C\x3F3F\
+\\x7C9D\x3F3F\
+\\x7C9E\x3F3F\
+\\x7C9F\x3F3F\
+\\x7CA0\x3F3F\
+\\x7CA1\x3F3F\
+\\x7CA2\x3F3F\
+\\x7CA3\x3F3F\
+\\x7CA4\x3F3F\
+\\x7CA5\x3F3F\
+\\x7CA6\x3F3F\
+\\x7CA7\x3F3F\
+\\x7CA8\x3F3F\
+\\x7CA9\x3F3F\
+\\x7CAA\x3F3F\
+\\x7CAB\x3F3F\
+\\x7CAC\x3F3F\
+\\x7CAD\x3F3F\
+\\x7CAE\x3F3F\
+\\x7CAF\x3F3F\
+\\x7CB0\x3F3F\
+\\x7CB1\x3F3F\
+\\x7CB2\x3F3F\
+\\x7CB3\x3F3F\
+\\x7CB4\x3F3F\
+\\x7CB5\x3F3F\
+\\x7CB6\x3F3F\
+\\x7CB7\x3F3F\
+\\x7CB8\x3F3F\
+\\x7CB9\x3F3F\
+\\x7CBA\x3F3F\
+\\x7CBB\x3F3F\
+\\x7CBC\x3F3F\
+\\x7CBD\x3F3F\
+\\x7CBE\x3F3F\
+\\x7CBF\x3F3F\
+\\x7CC0\x3F3F\
+\\x7CC1\x3F3F\
+\\x7CC2\x3F3F\
+\\x7CC3\x3F3F\
+\\x7CC4\x3F3F\
+\\x7CC5\x3F3F\
+\\x7CC6\x3F3F\
+\\x7CC7\x3F3F\
+\\x7CC8\x3F3F\
+\\x7CC9\x3F3F\
+\\x7CCA\x3F3F\
+\\x7CCB\x3F3F\
+\\x7CCC\x3F3F\
+\\x7CCD\x3F3F\
+\\x7CCE\x3F3F\
+\\x7CCF\x3F3F\
+\\x7CD0\x3F3F\
+\\x7CD1\x3F3F\
+\\x7CD2\x3F3F\
+\\x7CD3\x3F3F\
+\\x7CD4\x3F3F\
+\\x7CD5\x3F3F\
+\\x7CD6\x3F3F\
+\\x7CD7\x3F3F\
+\\x7CD8\x3F3F\
+\\x7CD9\x3F3F\
+\\x7CDA\x3F3F\
+\\x7CDB\x3F3F\
+\\x7CDC\x3F3F\
+\\x7CDD\x3F3F\
+\\x7CDE\x3F3F\
+\\x7CDF\x3F3F\
+\\x7CE0\x3F3F\
+\\x7CE1\x3F3F\
+\\x7CE2\x3F3F\
+\\x7CE3\x3F3F\
+\\x7CE4\x3F3F\
+\\x7CE5\x3F3F\
+\\x7CE6\x3F3F\
+\\x7CE7\x3F3F\
+\\x7CE8\x3F3F\
+\\x7CE9\x3F3F\
+\\x7CEA\x3F3F\
+\\x7CEB\x3F3F\
+\\x7CEC\x3F3F\
+\\x7CED\x3F3F\
+\\x7CEE\x3F3F\
+\\x7CEF\x3F3F\
+\\x7CF0\x3F3F\
+\\x7CF1\x3F3F\
+\\x7CF2\x3F3F\
+\\x7CF3\x3F3F\
+\\x7CF4\x3F3F\
+\\x7CF5\x3F3F\
+\\x7CF6\x3F3F\
+\\x7CF7\x3F3F\
+\\x7CF8\x3F3F\
+\\x7CF9\x3F3F\
+\\x7CFA\x3F3F\
+\\x7CFB\x3F3F\
+\\x7CFC\x3F3F\
+\\x7CFD\x3F3F\
+\\x7CFE\x3F3F\
+\\x7D41\x3F3F\
+\\x7D42\x3F3F\
+\\x7D43\x3F3F\
+\\x7D44\x3F3F\
+\\x7D45\x3F3F\
+\\x7D46\x3F3F\
+\\x7D47\x3F3F\
+\\x7D48\x3F3F\
+\\x7D49\x3F3F\
+\\x7D4A\x3F3F\
+\\x7D4B\x3F3F\
+\\x7D4C\x3F3F\
+\\x7D4D\x3F3F\
+\\x7D4E\x3F3F\
+\\x7D4F\x3F3F\
+\\x7D50\x3F3F\
+\\x7D51\x3F3F\
+\\x7D52\x3F3F\
+\\x7D53\x3F3F\
+\\x7D54\x3F3F\
+\\x7D55\x3F3F\
+\\x7D56\x3F3F\
+\\x7D57\x3F3F\
+\\x7D58\x3F3F\
+\\x7D59\x3F3F\
+\\x7D5A\x3F3F\
+\\x7D5B\x3F3F\
+\\x7D5C\x3F3F\
+\\x7D5D\x3F3F\
+\\x7D5E\x3F3F\
+\\x7D5F\x3F3F\
+\\x7D60\x3F3F\
+\\x7D61\x3F3F\
+\\x7D62\x3F3F\
+\\x7D63\x3F3F\
+\\x7D64\x3F3F\
+\\x7D65\x3F3F\
+\\x7D66\x3F3F\
+\\x7D67\x3F3F\
+\\x7D68\x3F3F\
+\\x7D69\x3F3F\
+\\x7D6A\x3F3F\
+\\x7D6B\x3F3F\
+\\x7D6C\x3F3F\
+\\x7D6D\x3F3F\
+\\x7D6E\x3F3F\
+\\x7D6F\x3F3F\
+\\x7D70\x3F3F\
+\\x7D71\x3F3F\
+\\x7D72\x3F3F\
+\\x7D73\x3F3F\
+\\x7D74\x3F3F\
+\\x7D75\x3F3F\
+\\x7D76\x3F3F\
+\\x7D77\x3F3F\
+\\x7D78\x3F3F\
+\\x7D79\x3F3F\
+\\x7D7A\x3F3F\
+\\x7D7B\x3F3F\
+\\x7D7C\x3F3F\
+\\x7D7D\x3F3F\
+\\x7D7E\x3F3F\
+\\x7D7F\x3F3F\
+\\x7D80\x3F3F\
+\\x7D81\x3F3F\
+\\x7D82\x3F3F\
+\\x7D83\x3F3F\
+\\x7D84\x3F3F\
+\\x7D85\x3F3F\
+\\x7D86\x3F3F\
+\\x7D87\x3F3F\
+\\x7D88\x3F3F\
+\\x7D89\x3F3F\
+\\x7D8A\x3F3F\
+\\x7D8B\x3F3F\
+\\x7D8C\x3F3F\
+\\x7D8D\x3F3F\
+\\x7D8E\x3F3F\
+\\x7D8F\x3F3F\
+\\x7D90\x3F3F\
+\\x7D91\x3F3F\
+\\x7D92\x3F3F\
+\\x7D93\x3F3F\
+\\x7D94\x3F3F\
+\\x7D95\x3F3F\
+\\x7D96\x3F3F\
+\\x7D97\x3F3F\
+\\x7D98\x3F3F\
+\\x7D99\x3F3F\
+\\x7D9A\x3F3F\
+\\x7D9B\x3F3F\
+\\x7D9C\x3F3F\
+\\x7D9D\x3F3F\
+\\x7D9E\x3F3F\
+\\x7D9F\x3F3F\
+\\x7DA0\x3F3F\
+\\x7DA1\x3F3F\
+\\x7DA2\x3F3F\
+\\x7DA3\x3F3F\
+\\x7DA4\x3F3F\
+\\x7DA5\x3F3F\
+\\x7DA6\x3F3F\
+\\x7DA7\x3F3F\
+\\x7DA8\x3F3F\
+\\x7DA9\x3F3F\
+\\x7DAA\x3F3F\
+\\x7DAB\x3F3F\
+\\x7DAC\x3F3F\
+\\x7DAD\x3F3F\
+\\x7DAE\x3F3F\
+\\x7DAF\x3F3F\
+\\x7DB0\x3F3F\
+\\x7DB1\x3F3F\
+\\x7DB2\x3F3F\
+\\x7DB3\x3F3F\
+\\x7DB4\x3F3F\
+\\x7DB5\x3F3F\
+\\x7DB6\x3F3F\
+\\x7DB7\x3F3F\
+\\x7DB8\x3F3F\
+\\x7DB9\x3F3F\
+\\x7DBA\x3F3F\
+\\x7DBB\x3F3F\
+\\x7DBC\x3F3F\
+\\x7DBD\x3F3F\
+\\x7DBE\x3F3F\
+\\x7DBF\x3F3F\
+\\x7DC0\x3F3F\
+\\x7DC1\x3F3F\
+\\x7DC2\x3F3F\
+\\x7DC3\x3F3F\
+\\x7DC4\x3F3F\
+\\x7DC5\x3F3F\
+\\x7DC6\x3F3F\
+\\x7DC7\x3F3F\
+\\x7DC8\x3F3F\
+\\x7DC9\x3F3F\
+\\x7DCA\x3F3F\
+\\x7DCB\x3F3F\
+\\x7DCC\x3F3F\
+\\x7DCD\x3F3F\
+\\x7DCE\x3F3F\
+\\x7DCF\x3F3F\
+\\x7DD0\x3F3F\
+\\x7DD1\x3F3F\
+\\x7DD2\x3F3F\
+\\x7DD3\x3F3F\
+\\x7DD4\x3F3F\
+\\x7DD5\x3F3F\
+\\x7DD6\x3F3F\
+\\x7DD7\x3F3F\
+\\x7DD8\x3F3F\
+\\x7DD9\x3F3F\
+\\x7DDA\x3F3F\
+\\x7DDB\x3F3F\
+\\x7DDC\x3F3F\
+\\x7DDD\x3F3F\
+\\x7DDE\x3F3F\
+\\x7DDF\x3F3F\
+\\x7DE0\x3F3F\
+\\x7DE1\x3F3F\
+\\x7DE2\x3F3F\
+\\x7DE3\x3F3F\
+\\x7DE4\x3F3F\
+\\x7DE5\x3F3F\
+\\x7DE6\x3F3F\
+\\x7DE7\x3F3F\
+\\x7DE8\x3F3F\
+\\x7DE9\x3F3F\
+\\x7DEA\x3F3F\
+\\x7DEB\x3F3F\
+\\x7DEC\x3F3F\
+\\x7DED\x3F3F\
+\\x7DEE\x3F3F\
+\\x7DEF\x3F3F\
+\\x7DF0\x3F3F\
+\\x7DF1\x3F3F\
+\\x7DF2\x3F3F\
+\\x7DF3\x3F3F\
+\\x7DF4\x3F3F\
+\\x7DF5\x3F3F\
+\\x7DF6\x3F3F\
+\\x7DF7\x3F3F\
+\\x7DF8\x3F3F\
+\\x7DF9\x3F3F\
+\\x7DFA\x3F3F\
+\\x7DFB\x3F3F\
+\\x7DFC\x3F3F\
+\\x7DFD\x3F3F\
+\\x7DFE\x3F3F\
+\\x7E41\x3F3F\
+\\x7E42\x3F3F\
+\\x7E43\x3F3F\
+\\x7E44\x3F3F\
+\\x7E45\x3F3F\
+\\x7E46\x3F3F\
+\\x7E47\x3F3F\
+\\x7E48\x3F3F\
+\\x7E49\x3F3F\
+\\x7E4A\x3F3F\
+\\x7E4B\x3F3F\
+\\x7E4C\x3F3F\
+\\x7E4D\x3F3F\
+\\x7E4E\x3F3F\
+\\x7E4F\x3F3F\
+\\x7E50\x3F3F\
+\\x7E51\x3F3F\
+\\x7E52\x3F3F\
+\\x7E53\x3F3F\
+\\x7E54\x3F3F\
+\\x7E55\x3F3F\
+\\x7E56\x3F3F\
+\\x7E57\x3F3F\
+\\x7E58\x3F3F\
+\\x7E59\x3F3F\
+\\x7E5A\x3F3F\
+\\x7E5B\x3F3F\
+\\x7E5C\x3F3F\
+\\x7E5D\x3F3F\
+\\x7E5E\x3F3F\
+\\x7E5F\x3F3F\
+\\x7E60\x3F3F\
+\\x7E61\x3F3F\
+\\x7E62\x3F3F\
+\\x7E63\x3F3F\
+\\x7E64\x3F3F\
+\\x7E65\x3F3F\
+\\x7E66\x3F3F\
+\\x7E67\x3F3F\
+\\x7E68\x3F3F\
+\\x7E69\x3F3F\
+\\x7E6A\x3F3F\
+\\x7E6B\x3F3F\
+\\x7E6C\x3F3F\
+\\x7E6D\x3F3F\
+\\x7E6E\x3F3F\
+\\x7E6F\x3F3F\
+\\x7E70\x3F3F\
+\\x7E71\x3F3F\
+\\x7E72\x3F3F\
+\\x7E73\x3F3F\
+\\x7E74\x3F3F\
+\\x7E75\x3F3F\
+\\x7E76\x3F3F\
+\\x7E77\x3F3F\
+\\x7E78\x3F3F\
+\\x7E79\x3F3F\
+\\x7E7A\x3F3F\
+\\x7E7B\x3F3F\
+\\x7E7C\x3F3F\
+\\x7E7D\x3F3F\
+\\x7E7E\x3F3F\
+\\x7E7F\x3F3F\
+\\x7E80\x3F3F\
+\\x7E81\x3F3F\
+\\x7E82\x3F3F\
+\\x7E83\x3F3F\
+\\x7E84\x3F3F\
+\\x7E85\x3F3F\
+\\x7E86\x3F3F\
+\\x7E87\x3F3F\
+\\x7E88\x3F3F\
+\\x7E89\x3F3F\
+\\x7E8A\x3F3F\
+\\x7E8B\x3F3F\
+\\x7E8C\x3F3F\
+\\x7E8D\x3F3F\
+\\x7E8E\x3F3F\
+\\x7E8F\x3F3F\
+\\x7E90\x3F3F\
+\\x7E91\x3F3F\
+\\x7E92\x3F3F\
+\\x7E93\x3F3F\
+\\x7E94\x3F3F\
+\\x7E95\x3F3F\
+\\x7E96\x3F3F\
+\\x7E97\x3F3F\
+\\x7E98\x3F3F\
+\\x7E99\x3F3F\
+\\x7E9A\x3F3F\
+\\x7E9B\x3F3F\
+\\x7E9C\x3F3F\
+\\x7E9D\x3F3F\
+\\x7E9E\x3F3F\
+\\x7E9F\x3F3F\
+\\x7EA0\x3F3F\
+\\x7EA1\x3F3F\
+\\x7EA2\x3F3F\
+\\x7EA3\x3F3F\
+\\x7EA4\x3F3F\
+\\x7EA5\x3F3F\
+\\x7EA6\x3F3F\
+\\x7EA7\x3F3F\
+\\x7EA8\x3F3F\
+\\x7EA9\x3F3F\
+\\x7EAA\x3F3F\
+\\x7EAB\x3F3F\
+\\x7EAC\x3F3F\
+\\x7EAD\x3F3F\
+\\x7EAE\x3F3F\
+\\x7EAF\x3F3F\
+\\x7EB0\x3F3F\
+\\x7EB1\x3F3F\
+\\x7EB2\x3F3F\
+\\x7EB3\x3F3F\
+\\x7EB4\x3F3F\
+\\x7EB5\x3F3F\
+\\x7EB6\x3F3F\
+\\x7EB7\x3F3F\
+\\x7EB8\x3F3F\
+\\x7EB9\x3F3F\
+\\x7EBA\x3F3F\
+\\x7EBB\x3F3F\
+\\x7EBC\x3F3F\
+\\x7EBD\x3F3F\
+\\x7EBE\x3F3F\
+\\x7EBF\x3F3F\
+\\x7EC0\x3F3F\
+\\x7EC1\x3F3F\
+\\x7EC2\x3F3F\
+\\x7EC3\x3F3F\
+\\x7EC4\x3F3F\
+\\x7EC5\x3F3F\
+\\x7EC6\x3F3F\
+\\x7EC7\x3F3F\
+\\x7EC8\x3F3F\
+\\x7EC9\x3F3F\
+\\x7ECA\x3F3F\
+\\x7ECB\x3F3F\
+\\x7ECC\x3F3F\
+\\x7ECD\x3F3F\
+\\x7ECE\x3F3F\
+\\x7ECF\x3F3F\
+\\x7ED0\x3F3F\
+\\x7ED1\x3F3F\
+\\x7ED2\x3F3F\
+\\x7ED3\x3F3F\
+\\x7ED4\x3F3F\
+\\x7ED5\x3F3F\
+\\x7ED6\x3F3F\
+\\x7ED7\x3F3F\
+\\x7ED8\x3F3F\
+\\x7ED9\x3F3F\
+\\x7EDA\x3F3F\
+\\x7EDB\x3F3F\
+\\x7EDC\x3F3F\
+\\x7EDD\x3F3F\
+\\x7EDE\x3F3F\
+\\x7EDF\x3F3F\
+\\x7EE0\x3F3F\
+\\x7EE1\x3F3F\
+\\x7EE2\x3F3F\
+\\x7EE3\x3F3F\
+\\x7EE4\x3F3F\
+\\x7EE5\x3F3F\
+\\x7EE6\x3F3F\
+\\x7EE7\x3F3F\
+\\x7EE8\x3F3F\
+\\x7EE9\x3F3F\
+\\x7EEA\x3F3F\
+\\x7EEB\x3F3F\
+\\x7EEC\x3F3F\
+\\x7EED\x3F3F\
+\\x7EEE\x3F3F\
+\\x7EEF\x3F3F\
+\\x7EF0\x3F3F\
+\\x7EF1\x3F3F\
+\\x7EF2\x3F3F\
+\\x7EF3\x3F3F\
+\\x7EF4\x3F3F\
+\\x7EF5\x3F3F\
+\\x7EF6\x3F3F\
+\\x7EF7\x3F3F\
+\\x7EF8\x3F3F\
+\\x7EF9\x3F3F\
+\\x7EFA\x3F3F\
+\\x7EFB\x3F3F\
+\\x7EFC\x3F3F\
+\\x7EFD\x3F3F\
+\\x7EFE\x3F3F\
+\\x7F41\x3F3F\
+\\x7F42\x3F3F\
+\\x7F43\x3F3F\
+\\x7F44\x3F3F\
+\\x7F45\x3F3F\
+\\x7F46\x3F3F\
+\\x7F47\x3F3F\
+\\x7F48\x3F3F\
+\\x7F49\x3F3F\
+\\x7F4A\x3F3F\
+\\x7F4B\x3F3F\
+\\x7F4C\x3F3F\
+\\x7F4D\x3F3F\
+\\x7F4E\x3F3F\
+\\x7F4F\x3F3F\
+\\x7F50\x3F3F\
+\\x7F51\x3F3F\
+\\x7F52\x3F3F\
+\\x7F53\x3F3F\
+\\x7F54\x3F3F\
+\\x7F55\x3F3F\
+\\x7F56\x3F3F\
+\\x7F57\x3F3F\
+\\x7F58\x3F3F\
+\\x7F59\x3F3F\
+\\x7F5A\x3F3F\
+\\x7F5B\x3F3F\
+\\x7F5C\x3F3F\
+\\x7F5D\x3F3F\
+\\x7F5E\x3F3F\
+\\x7F5F\x3F3F\
+\\x7F60\x3F3F\
+\\x7F61\x3F3F\
+\\x7F62\x3F3F\
+\\x7F63\x3F3F\
+\\x7F64\x3F3F\
+\\x7F65\x3F3F\
+\\x7F66\x3F3F\
+\\x7F67\x3F3F\
+\\x7F68\x3F3F\
+\\x7F69\x3F3F\
+\\x7F6A\x3F3F\
+\\x7F6B\x3F3F\
+\\x7F6C\x3F3F\
+\\x7F6D\x3F3F\
+\\x7F6E\x3F3F\
+\\x7F6F\x3F3F\
+\\x7F70\x3F3F\
+\\x7F71\x3F3F\
+\\x7F72\x3F3F\
+\\x7F73\x3F3F\
+\\x7F74\x3F3F\
+\\x7F75\x3F3F\
+\\x7F76\x3F3F\
+\\x7F77\x3F3F\
+\\x7F78\x3F3F\
+\\x7F79\x3F3F\
+\\x7F7A\x3F3F\
+\\x7F7B\x3F3F\
+\\x7F7C\x3F3F\
+\\x7F7D\x3F3F\
+\\x7F7E\x3F3F\
+\\x7F7F\x3F3F\
+\\x7F80\x3F3F\
+\\x7F81\x3F3F\
+\\x7F82\x3F3F\
+\\x7F83\x3F3F\
+\\x7F84\x3F3F\
+\\x7F85\x3F3F\
+\\x7F86\x3F3F\
+\\x7F87\x3F3F\
+\\x7F88\x3F3F\
+\\x7F89\x3F3F\
+\\x7F8A\x3F3F\
+\\x7F8B\x3F3F\
+\\x7F8C\x3F3F\
+\\x7F8D\x3F3F\
+\\x7F8E\x3F3F\
+\\x7F8F\x3F3F\
+\\x7F90\x3F3F\
+\\x7F91\x3F3F\
+\\x7F92\x3F3F\
+\\x7F93\x3F3F\
+\\x7F94\x3F3F\
+\\x7F95\x3F3F\
+\\x7F96\x3F3F\
+\\x7F97\x3F3F\
+\\x7F98\x3F3F\
+\\x7F99\x3F3F\
+\\x7F9A\x3F3F\
+\\x7F9B\x3F3F\
+\\x7F9C\x3F3F\
+\\x7F9D\x3F3F\
+\\x7F9E\x3F3F\
+\\x7F9F\x3F3F\
+\\x7FA0\x3F3F\
+\\x7FA1\x3F3F\
+\\x7FA2\x3F3F\
+\\x7FA3\x3F3F\
+\\x7FA4\x3F3F\
+\\x7FA5\x3F3F\
+\\x7FA6\x3F3F\
+\\x7FA7\x3F3F\
+\\x7FA8\x3F3F\
+\\x7FA9\x3F3F\
+\\x7FAA\x3F3F\
+\\x7FAB\x3F3F\
+\\x7FAC\x3F3F\
+\\x7FAD\x3F3F\
+\\x7FAE\x3F3F\
+\\x7FAF\x3F3F\
+\\x7FB0\x3F3F\
+\\x7FB1\x3F3F\
+\\x7FB2\x3F3F\
+\\x7FB3\x3F3F\
+\\x7FB4\x3F3F\
+\\x7FB5\x3F3F\
+\\x7FB6\x3F3F\
+\\x7FB7\x3F3F\
+\\x7FB8\x3F3F\
+\\x7FB9\x3F3F\
+\\x7FBA\x3F3F\
+\\x7FBB\x3F3F\
+\\x7FBC\x3F3F\
+\\x7FBD\x3F3F\
+\\x7FBE\x3F3F\
+\\x7FBF\x3F3F\
+\\x7FC0\x3F3F\
+\\x7FC1\x3F3F\
+\\x7FC2\x3F3F\
+\\x7FC3\x3F3F\
+\\x7FC4\x3F3F\
+\\x7FC5\x3F3F\
+\\x7FC6\x3F3F\
+\\x7FC7\x3F3F\
+\\x7FC8\x3F3F\
+\\x7FC9\x3F3F\
+\\x7FCA\x3F3F\
+\\x7FCB\x3F3F\
+\\x7FCC\x3F3F\
+\\x7FCD\x3F3F\
+\\x7FCE\x3F3F\
+\\x7FCF\x3F3F\
+\\x7FD0\x3F3F\
+\\x7FD1\x3F3F\
+\\x7FD2\x3F3F\
+\\x7FD3\x3F3F\
+\\x7FD4\x3F3F\
+\\x7FD5\x3F3F\
+\\x7FD6\x3F3F\
+\\x7FD7\x3F3F\
+\\x7FD8\x3F3F\
+\\x7FD9\x3F3F\
+\\x7FDA\x3F3F\
+\\x7FDB\x3F3F\
+\\x7FDC\x3F3F\
+\\x7FDD\x3F3F\
+\\x7FDE\x3F3F\
+\\x7FDF\x3F3F\
+\\x7FE0\x3F3F\
+\\x7FE1\x3F3F\
+\\x7FE2\x3F3F\
+\\x7FE3\x3F3F\
+\\x7FE4\x3F3F\
+\\x7FE5\x3F3F\
+\\x7FE6\x3F3F\
+\\x7FE7\x3F3F\
+\\x7FE8\x3F3F\
+\\x7FE9\x3F3F\
+\\x7FEA\x3F3F\
+\\x7FEB\x3F3F\
+\\x7FEC\x3F3F\
+\\x7FED\x3F3F\
+\\x7FEE\x3F3F\
+\\x7FEF\x3F3F\
+\\x7FF0\x3F3F\
+\\x7FF1\x3F3F\
+\\x7FF2\x3F3F\
+\\x7FF3\x3F3F\
+\\x7FF4\x3F3F\
+\\x7FF5\x3F3F\
+\\x7FF6\x3F3F\
+\\x7FF7\x3F3F\
+\\x7FF8\x3F3F\
+\\x7FF9\x3F3F\
+\\x7FFA\x3F3F\
+\\x7FFB\x3F3F\
+\\x7FFC\x3F3F\
+\\x7FFD\x3F3F\
+\\x7FFE\x3F3F"
+
+_str835to950 :: String
+_str835to950 = "\x4040\xA140\
+\\x4141\xA35C\
+\\x4142\xA35D\
+\\x4143\xA35E\
+\\x4144\xA35F\
+\\x4145\xA360\
+\\x4146\xA361\
+\\x4147\xA362\
+\\x4148\xA363\
+\\x4149\xA364\
+\\x414A\xA365\
+\\x414B\xA366\
+\\x414C\xA367\
+\\x414D\xA368\
+\\x414E\xA369\
+\\x414F\xA36A\
+\\x4150\xA36B\
+\\x4151\xA36C\
+\\x4152\xA36D\
+\\x4153\xA36E\
+\\x4154\xA36F\
+\\x4155\xA370\
+\\x4156\xA371\
+\\x4157\xA372\
+\\x4158\xA373\
+\\x4161\xA344\
+\\x4162\xA345\
+\\x4163\xA346\
+\\x4164\xA347\
+\\x4165\xA348\
+\\x4166\xA349\
+\\x4167\xA34A\
+\\x4168\xA34B\
+\\x4169\xA34C\
+\\x416A\xA34D\
+\\x416B\xA34E\
+\\x416C\xA34F\
+\\x416D\xA350\
+\\x416E\xA351\
+\\x416F\xA352\
+\\x4170\xA353\
+\\x4171\xA354\
+\\x4172\xA355\
+\\x4173\xA356\
+\\x4174\xA357\
+\\x4175\xA358\
+\\x4176\xA359\
+\\x4177\xA35A\
+\\x4178\xA35B\
+\\x4180\x3F3F\
+\\x4181\x3F3F\
+\\x4182\x3F3F\
+\\x4183\x3F3F\
+\\x4184\x3F3F\
+\\x4185\x3F3F\
+\\x4186\x3F3F\
+\\x4187\x3F3F\
+\\x4188\x3F3F\
+\\x4189\x3F3F\
+\\x418A\x3F3F\
+\\x418B\x3F3F\
+\\x418C\x3F3F\
+\\x418D\x3F3F\
+\\x418E\x3F3F\
+\\x418F\x3F3F\
+\\x4190\x3F3F\
+\\x4191\x3F3F\
+\\x4192\x3F3F\
+\\x4193\x3F3F\
+\\x4194\x3F3F\
+\\x4195\x3F3F\
+\\x4196\x3F3F\
+\\x4197\x3F3F\
+\\x4198\x3F3F\
+\\x4199\x3F3F\
+\\x419A\x3F3F\
+\\x419B\x3F3F\
+\\x419C\x3F3F\
+\\x419D\x3F3F\
+\\x419E\x3F3F\
+\\x419F\x3F3F\
+\\x41A0\x3F3F\
+\\x41B1\x3F3F\
+\\x41B2\x3F3F\
+\\x41B3\x3F3F\
+\\x41B4\x3F3F\
+\\x41B5\x3F3F\
+\\x41B6\x3F3F\
+\\x41B7\x3F3F\
+\\x41B8\x3F3F\
+\\x41B9\x3F3F\
+\\x41BA\x3F3F\
+\\x41C0\x3F3F\
+\\x41C1\x3F3F\
+\\x41C2\x3F3F\
+\\x41C3\x3F3F\
+\\x41C4\x3F3F\
+\\x41C5\x3F3F\
+\\x41C6\x3F3F\
+\\x41C7\x3F3F\
+\\x41C8\x3F3F\
+\\x41C9\x3F3F\
+\\x41CA\x3F3F\
+\\x41CB\x3F3F\
+\\x41CC\x3F3F\
+\\x41CD\x3F3F\
+\\x41CE\x3F3F\
+\\x41CF\x3F3F\
+\\x41D0\x3F3F\
+\\x41D1\x3F3F\
+\\x41D2\x3F3F\
+\\x41D3\x3F3F\
+\\x41D4\x3F3F\
+\\x41D5\x3F3F\
+\\x41D6\x3F3F\
+\\x41D7\x3F3F\
+\\x41D8\x3F3F\
+\\x41D9\x3F3F\
+\\x41DA\x3F3F\
+\\x41DB\x3F3F\
+\\x41DC\x3F3F\
+\\x41DD\x3F3F\
+\\x41DE\x3F3F\
+\\x41DF\x3F3F\
+\\x41E0\x3F3F\
+\\x41F1\xA2B9\
+\\x41F2\xA2BA\
+\\x41F3\xA2BB\
+\\x41F4\xA2BC\
+\\x41F5\xA2BD\
+\\x41F6\xA2BE\
+\\x41F7\xA2BF\
+\\x41F8\xA2C0\
+\\x41F9\xA2C1\
+\\x41FA\xA2C2\
+\\x424A\xA247\
+\\x424B\xA144\
+\\x424C\xA1D5\
+\\x424D\xA15D\
+\\x424E\xA1CF\
+\\x424F\xA155\
+\\x4250\xA1AE\
+\\x425A\xA149\
+\\x425B\xA244\
+\\x425C\x3F3F\
+\\x425D\xA15E\
+\\x425E\xA146\
+\\x425F\x3F3F\
+\\x4260\xA1D0\
+\\x4261\xA1FE\
+\\x426A\x3F3F\
+\\x426B\xA141\
+\\x426C\xA248\
+\\x426D\xA1C4\
+\\x426E\xA1D6\
+\\x426F\xA148\
+\\x4279\xA1AB\
+\\x427A\xA147\
+\\x427B\xA1AD\
+\\x427C\xA249\
+\\x427D\xA1A6\
+\\x427E\xA1D7\
+\\x427F\xA1A8\
+\\x4281\xA2E9\
+\\x4282\xA2EA\
+\\x4283\xA2EB\
+\\x4284\xA2EC\
+\\x4285\xA2ED\
+\\x4286\xA2EE\
+\\x4287\xA2EF\
+\\x4288\xA2F0\
+\\x4289\xA2F1\
+\\x4291\xA2F2\
+\\x4292\xA2F3\
+\\x4293\xA2F4\
+\\x4294\xA2F5\
+\\x4295\xA2F6\
+\\x4296\xA2F7\
+\\x4297\xA2F8\
+\\x4298\xA2F9\
+\\x4299\xA2FA\
+\\x42A1\xA1C3\
+\\x42A2\xA2FB\
+\\x42A3\xA2FC\
+\\x42A4\xA2FD\
+\\x42A5\xA2FE\
+\\x42A6\xA340\
+\\x42A7\xA341\
+\\x42A8\xA342\
+\\x42A9\xA343\
+\\x42C0\xA161\
+\\x42C1\xA2CF\
+\\x42C2\xA2D0\
+\\x42C3\xA2D1\
+\\x42C4\xA2D2\
+\\x42C5\xA2D3\
+\\x42C6\xA2D4\
+\\x42C7\xA2D5\
+\\x42C8\xA2D6\
+\\x42C9\xA2D7\
+\\x42D0\xA162\
+\\x42D1\xA2D8\
+\\x42D2\xA2D9\
+\\x42D3\xA2DA\
+\\x42D4\xA2DB\
+\\x42D5\xA2DC\
+\\x42D6\xA2DD\
+\\x42D7\xA2DE\
+\\x42D8\xA2DF\
+\\x42D9\xA2E0\
+\\x42E0\xA243\
+\\x42E2\xA2E1\
+\\x42E3\xA2E2\
+\\x42E4\xA2E3\
+\\x42E5\xA2E4\
+\\x42E6\xA2E5\
+\\x42E7\xA2E6\
+\\x42E8\xA2E7\
+\\x42E9\xA2E8\
+\\x42F0\xA2AF\
+\\x42F1\xA2B0\
+\\x42F2\xA2B1\
+\\x42F3\xA2B2\
+\\x42F4\xA2B3\
+\\x42F5\xA2B4\
+\\x42F6\xA2B5\
+\\x42F7\xA2B6\
+\\x42F8\xA2B7\
+\\x42F9\xA2B8\
+\\x4341\xA143\
+\\x4342\xA175\
+\\x4343\xA176\
+\\x4344\xA142\
+\\x4345\xA145\
+\\x4346\x3F3F\
+\\x4347\x3F3F\
+\\x4348\x3F3F\
+\\x4349\x3F3F\
+\\x434A\xA246\
+\\x434D\x3F3F\
+\\x434E\x3F3F\
+\\x434F\x3F3F\
+\\x4351\x3F3F\
+\\x4352\x3F3F\
+\\x4353\x3F3F\
+\\x4354\x3F3F\
+\\x4355\x3F3F\
+\\x4356\x3F3F\
+\\x4357\x3F3F\
+\\x4358\x3F3F\
+\\x4359\x3F3F\
+\\x435A\x3F3F\
+\\x435D\x3F3F\
+\\x435E\x3F3F\
+\\x4360\x3F3F\
+\\x4361\x3F3F\
+\\x4363\x3F3F\
+\\x4364\x3F3F\
+\\x4365\x3F3F\
+\\x4366\x3F3F\
+\\x4367\x3F3F\
+\\x4368\x3F3F\
+\\x4369\x3F3F\
+\\x436C\x3F3F\
+\\x436D\x3F3F\
+\\x436E\x3F3F\
+\\x436F\x3F3F\
+\\x4370\x3F3F\
+\\x4371\x3F3F\
+\\x4372\x3F3F\
+\\x4373\x3F3F\
+\\x4374\x3F3F\
+\\x4375\x3F3F\
+\\x4376\x3F3F\
+\\x4377\x3F3F\
+\\x4378\x3F3F\
+\\x4379\x3F3F\
+\\x437A\x3F3F\
+\\x4381\x3F3F\
+\\x4382\x3F3F\
+\\x4383\x3F3F\
+\\x4384\x3F3F\
+\\x4385\x3F3F\
+\\x4386\x3F3F\
+\\x4387\x3F3F\
+\\x4388\x3F3F\
+\\x4389\x3F3F\
+\\x438A\x3F3F\
+\\x438C\x3F3F\
+\\x438D\x3F3F\
+\\x438E\x3F3F\
+\\x438F\x3F3F\
+\\x4390\x3F3F\
+\\x4391\x3F3F\
+\\x4392\x3F3F\
+\\x4393\x3F3F\
+\\x4394\x3F3F\
+\\x4395\x3F3F\
+\\x4396\x3F3F\
+\\x4397\x3F3F\
+\\x4398\x3F3F\
+\\x4399\x3F3F\
+\\x439A\x3F3F\
+\\x439D\x3F3F\
+\\x439E\x3F3F\
+\\x439F\x3F3F\
+\\x43A1\x3F3F\
+\\x43A2\x3F3F\
+\\x43A3\x3F3F\
+\\x43A4\x3F3F\
+\\x43A5\x3F3F\
+\\x43A6\x3F3F\
+\\x43A7\x3F3F\
+\\x43A8\x3F3F\
+\\x43A9\x3F3F\
+\\x43AA\x3F3F\
+\\x43AC\x3F3F\
+\\x43AD\x3F3F\
+\\x43AE\x3F3F\
+\\x43AF\x3F3F\
+\\x43B7\x3F3F\
+\\x43B8\x3F3F\
+\\x43B9\x3F3F\
+\\x43BA\x3F3F\
+\\x43BB\x3F3F\
+\\x43BC\x3F3F\
+\\x43BD\x3F3F\
+\\x43BE\x3F3F\
+\\x43BF\x3F3F\
+\\x43C0\x3F3F\
+\\x43C1\x3F3F\
+\\x43C2\x3F3F\
+\\x43C3\x3F3F\
+\\x43C4\x3F3F\
+\\x43C5\x3F3F\
+\\x43C6\x3F3F\
+\\x43C7\x3F3F\
+\\x43C8\x3F3F\
+\\x43C9\x3F3F\
+\\x43CA\x3F3F\
+\\x43CB\x3F3F\
+\\x43CC\x3F3F\
+\\x43CD\x3F3F\
+\\x43CE\x3F3F\
+\\x43CF\x3F3F\
+\\x43D0\x3F3F\
+\\x43D1\x3F3F\
+\\x43D2\x3F3F\
+\\x43D3\x3F3F\
+\\x43D4\x3F3F\
+\\x43D5\x3F3F\
+\\x43D6\x3F3F\
+\\x43D7\x3F3F\
+\\x43D8\x3F3F\
+\\x43D9\x3F3F\
+\\x43DA\x3F3F\
+\\x43DB\x3F3F\
+\\x43DC\x3F3F\
+\\x43DD\x3F3F\
+\\x43E0\xA240\
+\\x43E1\x3F3F\
+\\x43E2\x3F3F\
+\\x43E3\x3F3F\
+\\x43E4\x3F3F\
+\\x43E5\x3F3F\
+\\x43E6\x3F3F\
+\\x43E7\x3F3F\
+\\x43E8\x3F3F\
+\\x43E9\x3F3F\
+\\x43EA\x3F3F\
+\\x43EB\x3F3F\
+\\x43EC\x3F3F\
+\\x43ED\x3F3F\
+\\x43EE\x3F3F\
+\\x43EF\x3F3F\
+\\x43F0\x3F3F\
+\\x43F1\x3F3F\
+\\x43F2\x3F3F\
+\\x4442\xA179\
+\\x4443\xA17A\
+\\x4444\xA165\
+\\x4445\xA166\
+\\x4446\x3F3F\
+\\x4447\x3F3F\
+\\x4448\x3F3F\
+\\x4449\x3F3F\
+\\x444A\xA158\
+\\x444B\xA1D3\
+\\x444C\xA1DA\
+\\x444D\xA1DB\
+\\x444E\xA24A\
+\\x4450\xA1AC\
+\\x4451\x3F3F\
+\\x4452\x3F3F\
+\\x4453\x3F3F\
+\\x4454\x3F3F\
+\\x4455\x3F3F\
+\\x4456\x3F3F\
+\\x4457\x3F3F\
+\\x445A\x3F3F\
+\\x445B\x3F3F\
+\\x445C\xC8F4\
+\\x445D\x3F3F\
+\\x445E\x3F3F\
+\\x445F\x3F3F\
+\\x4460\xA14C\
+\\x4461\xA1A5\
+\\x4462\xA1A7\
+\\x4463\xA165\
+\\x4464\xA171\
+\\x4465\xA16D\
+\\x4466\xA169\
+\\x4467\xA1D8\
+\\x4468\xA1EF\
+\\x4469\xA1F1\
+\\x446A\xA1B1\
+\\x446B\xA1B0\
+\\x446C\xA245\
+\\x446D\xAEE8\
+\\x446E\x3F3F\
+\\x446F\x3F3F\
+\\x4470\xA173\
+\\x4471\xA1A6\
+\\x4472\xA1A8\
+\\x4473\xA166\
+\\x4474\xA172\
+\\x4475\xA16E\
+\\x4476\xA16A\
+\\x4477\xA1D9\
+\\x4478\xA1EE\
+\\x4479\xA1F0\
+\\x447A\xA1D1\
+\\x447B\xA1D2\
+\\x447C\xA1FC\
+\\x447D\x3F3F\
+\\x447E\xA14C\
+\\x447F\xA14B\
+\\x4481\x3F3F\
+\\x4482\x3F3F\
+\\x4483\x3F3F\
+\\x4484\x3F3F\
+\\x4485\x3F3F\
+\\x4486\x3F3F\
+\\x4487\x3F3F\
+\\x4488\x3F3F\
+\\x4489\x3F3F\
+\\x448A\x3F3F\
+\\x448C\x3F3F\
+\\x448D\x3F3F\
+\\x448E\x3F3F\
+\\x448F\x3F3F\
+\\x4490\x3F3F\
+\\x4491\x3F3F\
+\\x4492\x3F3F\
+\\x4493\x3F3F\
+\\x4494\x3F3F\
+\\x4495\x3F3F\
+\\x4496\x3F3F\
+\\x4497\x3F3F\
+\\x4498\x3F3F\
+\\x4499\x3F3F\
+\\x449A\x3F3F\
+\\x449D\x3F3F\
+\\x449E\x3F3F\
+\\x449F\x3F3F\
+\\x44A2\x3F3F\
+\\x44A3\x3F3F\
+\\x44A4\x3F3F\
+\\x44A5\x3F3F\
+\\x44A6\x3F3F\
+\\x44A7\x3F3F\
+\\x44A8\x3F3F\
+\\x44A9\x3F3F\
+\\x44AA\x3F3F\
+\\x44AC\x3F3F\
+\\x44AD\x3F3F\
+\\x44AE\x3F3F\
+\\x44AF\x3F3F\
+\\x44BA\x3F3F\
+\\x44BB\x3F3F\
+\\x44BC\x3F3F\
+\\x44BD\x3F3F\
+\\x44C0\x3F3F\
+\\x44C1\x3F3F\
+\\x44C2\x3F3F\
+\\x44C3\x3F3F\
+\\x44C4\x3F3F\
+\\x44C5\x3F3F\
+\\x44C6\x3F3F\
+\\x44C7\x3F3F\
+\\x44C8\x3F3F\
+\\x44C9\x3F3F\
+\\x44CA\x3F3F\
+\\x44CB\x3F3F\
+\\x44CC\x3F3F\
+\\x44CD\x3F3F\
+\\x44CE\x3F3F\
+\\x44CF\x3F3F\
+\\x44D0\x3F3F\
+\\x44D1\x3F3F\
+\\x44D2\x3F3F\
+\\x44D3\x3F3F\
+\\x44D5\x3F3F\
+\\x44D6\x3F3F\
+\\x44D7\x3F3F\
+\\x44D8\x3F3F\
+\\x44D9\x3F3F\
+\\x44DA\x3F3F\
+\\x44DB\x3F3F\
+\\x44DC\x3F3F\
+\\x44DD\x3F3F\
+\\x44E0\xA1B3\
+\\x44E1\xA1B4\
+\\x44E2\xA1B5\
+\\x44E3\xA1B6\
+\\x44E4\xA1B7\
+\\x44E5\xA1B8\
+\\x44E6\xA1B9\
+\\x44E7\xA1BA\
+\\x44E8\xA1BB\
+\\x44E9\xA1BC\
+\\x44EA\xA1BD\
+\\x44EB\xA1BE\
+\\x44EC\xA1BF\
+\\x44ED\xA258\
+\\x44EE\xA1A6\
+\\x44EF\xA1B2\
+\\x44F0\xA1F7\
+\\x44F1\xA1F6\
+\\x44F2\xA1F4\
+\\x44F3\xA1F5\
+\\x4541\xA2C3\
+\\x4542\xA2C4\
+\\x4543\xA2C5\
+\\x4544\xA2C6\
+\\x4545\xA2C7\
+\\x4546\xA2C8\
+\\x4547\xA2C9\
+\\x4548\xA2CA\
+\\x4549\xA2CB\
+\\x454A\xA451\
+\\x454B\xA2CD\
+\\x454C\xA4CA\
+\\x4551\xA3BC\
+\\x4552\xA3BD\
+\\x4553\xA3BE\
+\\x4554\xA3BF\
+\\x4555\xA3BB\
+\\x4556\xA374\
+\\x4557\xA375\
+\\x4558\xA376\
+\\x4559\xA377\
+\\x455A\xA378\
+\\x455B\xA379\
+\\x455C\xA37A\
+\\x455D\xA37B\
+\\x455E\xA37C\
+\\x455F\xA37D\
+\\x4560\xA37E\
+\\x4561\xA3A1\
+\\x4562\xA3A2\
+\\x4563\xA3A3\
+\\x4564\xA3A4\
+\\x4565\xA3A5\
+\\x4566\xA3A6\
+\\x4567\xA3A7\
+\\x4568\xA3A8\
+\\x4569\xA3A9\
+\\x456A\xA3AA\
+\\x456B\xA3AB\
+\\x456C\xA3AC\
+\\x456D\xA3AD\
+\\x456E\xA3AE\
+\\x456F\xA3AF\
+\\x4570\xA3B0\
+\\x4571\xA3B1\
+\\x4572\xA3B2\
+\\x4573\xA3B3\
+\\x4574\xA3B4\
+\\x4575\xA3B5\
+\\x4576\xA3B6\
+\\x4577\xA3B7\
+\\x4578\xA3B8\
+\\x4579\xA3B9\
+\\x457A\xA3BA\
+\\x4641\x3F3F\
+\\x4642\x3F3F\
+\\x4643\x3F3F\
+\\x4644\x3F3F\
+\\x4645\x3F3F\
+\\x4646\x3F3F\
+\\x4647\x3F3F\
+\\x4648\x3F3F\
+\\x4649\x3F3F\
+\\x464A\x3F3F\
+\\x4651\x3F3F\
+\\x4652\x3F3F\
+\\x4653\x3F3F\
+\\x4654\x3F3F\
+\\x4655\x3F3F\
+\\x4656\x3F3F\
+\\x4657\x3F3F\
+\\x4658\x3F3F\
+\\x4659\x3F3F\
+\\x465A\x3F3F\
+\\x4660\xA262\
+\\x4661\xA263\
+\\x4662\xA264\
+\\x4663\xA265\
+\\x4664\xA266\
+\\x4665\xA267\
+\\x4666\xA268\
+\\x4667\xA269\
+\\x4668\xA26A\
+\\x4669\xA26B\
+\\x466A\xA26C\
+\\x466B\xA26D\
+\\x466C\xA26E\
+\\x466D\xA26F\
+\\x466E\xA270\
+\\x466F\xA271\
+\\x4670\xA272\
+\\x4671\xA273\
+\\x4672\xA274\
+\\x4673\xA275\
+\\x4674\xA276\
+\\x4675\xA277\
+\\x4676\xA278\
+\\x4677\xA279\
+\\x4678\xA27A\
+\\x4679\xA27B\
+\\x467A\xA27C\
+\\x467B\xA27D\
+\\x467C\xA27E\
+\\x467D\xA2A1\
+\\x467E\xA2A2\
+\\x467F\xA2A3\
+\\x4681\xF9F9\
+\\x4682\xF9E9\
+\\x4683\xF9EA\
+\\x4684\xF9EB\
+\\x4685\xA2A8\
+\\x4686\xA2A9\
+\\x4687\xA2AA\
+\\x4688\xA2AB\
+\\x4689\xA2AC\
+\\x468A\xA2AD\
+\\x468B\xA2AE\
+\\x46A0\xA177\
+\\x46A1\xA178\
+\\x46A2\xA17B\
+\\x46A3\xA17C\
+\\x46A4\xA16B\
+\\x46A5\xA16C\
+\\x46A7\xA157\
+\\x46A8\xC8F5\
+\\x46A9\xC8F6\
+\\x46AA\xC8F7\
+\\x46AB\xC8F8\
+\\x46AC\xA15F\
+\\x46AD\xA160\
+\\x46AE\xA163\
+\\x46AF\xA164\
+\\x46B0\xA167\
+\\x46B1\xA168\
+\\x46B2\xA16F\
+\\x46B3\xA170\
+\\x46B4\xA173\
+\\x46B5\xA174\
+\\x46B6\xA159\
+\\x46B7\xA15A\
+\\x46B8\xA1AF\
+\\x46B9\xA1B2\
+\\x46BA\xA1C0\
+\\x46BB\xA1C1\
+\\x46BC\xA15B\
+\\x46BD\xA15C\
+\\x46BE\xA1C6\
+\\x46BF\xA1C7\
+\\x46C0\xA1C8\
+\\x46C1\xA1C9\
+\\x46C2\xA1CA\
+\\x46C3\xA1CB\
+\\x46C4\xA1CE\
+\\x46C5\xA1D4\
+\\x46C6\xA1DC\
+\\x46C7\xA1DD\
+\\x46C8\xA1E4\
+\\x46C9\xA1E5\
+\\x46CA\xA1E6\
+\\x46CB\xA1E7\
+\\x46CC\xA1E8\
+\\x46CD\xA1E9\
+\\x46CE\xA1EA\
+\\x46CF\xA1EB\
+\\x46D0\xA1EC\
+\\x46D1\xA1ED\
+\\x46D2\xA1F2\
+\\x46D3\xA1F3\
+\\x46D4\xA1F8\
+\\x46D5\xA1F9\
+\\x46D6\xA1FA\
+\\x46D7\xA1FB\
+\\x46DA\xA241\
+\\x46DB\xA24B\
+\\x46DC\xA24F\
+\\x46DD\xA250\
+\\x46DE\xA251\
+\\x46DF\xA252\
+\\x46E0\xA253\
+\\x46E1\xA254\
+\\x46E2\xA255\
+\\x46E3\xA256\
+\\x46E4\xA257\
+\\x46E5\xA150\
+\\x46E9\xA1A9\
+\\x46EA\xA1AA\
+\\x46EE\x3F3F\
+\\x46EF\x3F3F\
+\\x46F0\x3F3F\
+\\x46F1\xA259\
+\\x46F2\xA25A\
+\\x46F3\xA25B\
+\\x46F4\xA25C\
+\\x46F5\xA25D\
+\\x46F6\xA25E\
+\\x46F7\xA25F\
+\\x46F8\xA260\
+\\x46F9\xA261\
+\\x4741\xA14A\
+\\x4742\xA14D\
+\\x4743\xA14E\
+\\x4744\xA14F\
+\\x4745\xA151\
+\\x4746\xA152\
+\\x4747\xA153\
+\\x4748\xA154\
+\\x4749\x3F3F\
+\\x474A\x3F3F\
+\\x474B\xA17D\
+\\x474C\xA17E\
+\\x474D\xA1A1\
+\\x474E\xA1A2\
+\\x474F\xA1A3\
+\\x4750\xA1A4\
+\\x4751\xA1C3\
+\\x4752\xA1C5\
+\\x4753\xA1CC\
+\\x4754\xA1CD\
+\\x4755\xA1DE\
+\\x4756\xA1DF\
+\\x4757\xA1E0\
+\\x4758\xA1E1\
+\\x4759\xA1E2\
+\\x475A\xA242\
+\\x475B\xA24C\
+\\x475C\xA24D\
+\\x475D\xA24E\
+\\x4781\x3F3F\
+\\x4782\x3F3F\
+\\x4783\x3F3F\
+\\x4784\x3F3F\
+\\x4785\x3F3F\
+\\x4786\x3F3F\
+\\x4787\x3F3F\
+\\x4788\x3F3F\
+\\x4789\x3F3F\
+\\x478A\x3F3F\
+\\x478B\x3F3F\
+\\x478C\x3F3F\
+\\x478D\x3F3F\
+\\x478E\x3F3F\
+\\x478F\x3F3F\
+\\x4790\x3F3F\
+\\x4791\x3F3F\
+\\x4792\x3F3F\
+\\x4793\x3F3F\
+\\x4794\x3F3F\
+\\x4795\x3F3F\
+\\x4796\x3F3F\
+\\x4797\x3F3F\
+\\x4798\x3F3F\
+\\x4799\x3F3F\
+\\x479A\x3F3F\
+\\x479B\x3F3F\
+\\x479C\x3F3F\
+\\x479D\x3F3F\
+\\x479E\x3F3F\
+\\x479F\x3F3F\
+\\x47A0\x3F3F\
+\\x47A1\x3F3F\
+\\x4841\xA440\
+\\x4842\x3F3F\
+\\x4843\x3F3F\
+\\x4844\x3F3F\
+\\x4845\xA441\
+\\x4846\x3F3F\
+\\x4847\xA447\
+\\x4848\x3F3F\
+\\x4849\xA448\
+\\x484A\xA449\
+\\x484B\xA44A\
+\\x484C\xA44B\
+\\x484D\x3F3F\
+\\x484E\x3F3F\
+\\x484F\x3F3F\
+\\x4850\xA44C\
+\\x4851\xC942\
+\\x4852\xA44D\
+\\x4853\xA44F\
+\\x4854\x3F3F\
+\\x4855\xA450\
+\\x4856\xC943\
+\\x4857\x3F3F\
+\\x4858\xA451\
+\\x4859\xA452\
+\\x485A\x3F3F\
+\\x485B\xC944\
+\\x485C\x3F3F\
+\\x485D\xA453\
+\\x485E\xA466\
+\\x485F\xC949\
+\\x4860\xA467\
+\\x4861\xA468\
+\\x4862\x3F3F\
+\\x4863\xA469\
+\\x4864\xA46A\
+\\x4865\xA46B\
+\\x4866\xA46C\
+\\x4867\x3F3F\
+\\x4868\xA46F\
+\\x4869\xA470\
+\\x486A\xA471\
+\\x486B\xA472\
+\\x486C\xC94B\
+\\x486D\xA473\
+\\x486E\x3F3F\
+\\x486F\xA475\
+\\x4870\xA476\
+\\x4871\xA479\
+\\x4872\xA47A\
+\\x4873\x3F3F\
+\\x4874\x3F3F\
+\\x4875\x3F3F\
+\\x4876\xA47B\
+\\x4877\xA47C\
+\\x4878\xA47D\
+\\x4879\x3F3F\
+\\x487A\x3F3F\
+\\x487B\xC94C\
+\\x487C\xA4DF\
+\\x487D\xA4E0\
+\\x487E\xA4E1\
+\\x487F\xA4E2\
+\\x4881\xA4E4\
+\\x4882\x3F3F\
+\\x4883\xA4E5\
+\\x4884\xA4E6\
+\\x4885\xA4E7\
+\\x4886\xA4E8\
+\\x4887\x3F3F\
+\\x4888\xA4E9\
+\\x4889\xA4EA\
+\\x488A\xA4EB\
+\\x488B\xA4EC\
+\\x488C\xA4ED\
+\\x488D\xA4EE\
+\\x488E\xA4EF\
+\\x488F\xC95F\
+\\x4890\xA4F0\
+\\x4891\xA4F1\
+\\x4892\xA4F2\
+\\x4893\xA4F3\
+\\x4894\xC961\
+\\x4895\xA4F4\
+\\x4896\xA4F5\
+\\x4897\xA4F6\
+\\x4898\xA4F7\
+\\x4899\xA4F8\
+\\x489A\xC962\
+\\x489B\xA4F9\
+\\x489C\xA4FA\
+\\x489D\xA4FB\
+\\x489E\xA4FC\
+\\x489F\xA5C8\
+\\x48A0\xA5C9\
+\\x48A1\xA5CA\
+\\x48A2\xA5CB\
+\\x48A3\xA5CC\
+\\x48A4\xA5CD\
+\\x48A5\xA5CE\
+\\x48A6\xA5D0\
+\\x48A7\xA5D4\
+\\x48A8\x3F3F\
+\\x48A9\x3F3F\
+\\x48AA\xA5D5\
+\\x48AB\xA5D6\
+\\x48AC\xA5D7\
+\\x48AD\xA5D8\
+\\x48AE\xA5D9\
+\\x48AF\xA5DA\
+\\x48B0\xA5DB\
+\\x48B1\xA5DC\
+\\x48B2\xC9A8\
+\\x48B3\xA5DD\
+\\x48B4\xA5DE\
+\\x48B5\xA5DF\
+\\x48B6\xA6CB\
+\\x48B7\xA6CC\
+\\x48B8\xA6CD\
+\\x48B9\xA6CE\
+\\x48BA\xCA49\
+\\x48BB\xA6CF\
+\\x48BC\xA6D0\
+\\x48BD\xA6D1\
+\\x48BE\xA6D3\
+\\x48BF\xA6D4\
+\\x48C0\xA6D5\
+\\x48C1\xA6D6\
+\\x48C2\xA6D7\
+\\x48C3\xA6DA\
+\\x48C4\xA6DB\
+\\x48C5\xA6DC\
+\\x48C6\xA6DD\
+\\x48C7\xA6DE\
+\\x48C8\xA6DF\
+\\x48C9\xA6E0\
+\\x48CA\xA6E1\
+\\x48CB\xA6E2\
+\\x48CC\xCA4A\
+\\x48CD\xCA4F\
+\\x48CE\xA6E4\
+\\x48CF\xA6E5\
+\\x48D0\xA6E6\
+\\x48D1\xA6E7\
+\\x48D2\xCA50\
+\\x48D3\xA8A3\
+\\x48D4\xA8A4\
+\\x48D5\xA8A5\
+\\x48D6\xA8A6\
+\\x48D7\xA8A7\
+\\x48D8\xA8A8\
+\\x48D9\xCBA4\
+\\x48DA\xA8A9\
+\\x48DB\xA8AA\
+\\x48DC\xA8AB\
+\\x48DD\xA8AC\
+\\x48DE\xA8AD\
+\\x48DF\xA8AE\
+\\x48E0\xA8AF\
+\\x48E1\xA8B0\
+\\x48E2\x3F3F\
+\\x48E3\xA8B6\
+\\x48E4\xA8BB\
+\\x48E5\xA8BC\
+\\x48E6\xA8BD\
+\\x48E7\xAAF7\
+\\x48E8\xAAF8\
+\\x48E9\xAAF9\
+\\x48EA\xAAFA\
+\\x48EB\x3F3F\
+\\x48EC\xAB41\
+\\x48ED\xAB42\
+\\x48EE\xAB43\
+\\x48EF\xAB44\
+\\x48F0\xADB1\
+\\x48F1\xADB2\
+\\x48F2\xADB3\
+\\x48F3\xADB4\
+\\x48F4\xADB5\
+\\x48F5\xADB6\
+\\x48F6\xADB7\
+\\x48F7\xADB8\
+\\x48F8\xADB9\
+\\x48F9\xADBA\
+\\x48FA\xADBB\
+\\x48FB\xB0A8\
+\\x48FC\xB0A9\
+\\x48FD\xB0AA\
+\\x4941\xD449\
+\\x4942\xB0AB\
+\\x4943\xD44A\
+\\x4944\xB0AC\
+\\x4945\xB0AD\
+\\x4946\xB3BD\
+\\x4947\xB3BE\
+\\x4948\xB3BF\
+\\x4949\xB3C0\
+\\x494A\xB3C1\
+\\x494B\xB3C2\
+\\x494C\xB6C0\
+\\x494D\xB6C1\
+\\x494E\xB6C2\
+\\x494F\xDCB0\
+\\x4950\xE0EF\
+\\x4951\xB9A9\
+\\x4952\xB9AA\
+\\x4953\xB9AB\
+\\x4954\xBBF3\
+\\x4955\xBBF4\
+\\x4956\xBEA6\
+\\x4957\xC073\
+\\x4958\xC074\
+\\x4959\xEFB6\
+\\x4C41\xA440\
+\\x4C42\xA441\
+\\x4C43\xA442\
+\\x4C44\xA443\
+\\x4C45\xA444\
+\\x4C46\xA445\
+\\x4C47\xA446\
+\\x4C48\xA447\
+\\x4C49\xA448\
+\\x4C4A\xA449\
+\\x4C4B\xA44A\
+\\x4C4C\xA44B\
+\\x4C4D\xA44C\
+\\x4C4E\xA44D\
+\\x4C4F\xA44E\
+\\x4C50\xA44F\
+\\x4C51\xA450\
+\\x4C52\xA451\
+\\x4C53\xA452\
+\\x4C54\xA453\
+\\x4C55\xA454\
+\\x4C56\xA455\
+\\x4C57\xA456\
+\\x4C58\xA457\
+\\x4C59\xA458\
+\\x4C5A\xA459\
+\\x4C5B\xA45A\
+\\x4C5C\xA45B\
+\\x4C5D\xA45C\
+\\x4C5E\xA45D\
+\\x4C5F\xA45E\
+\\x4C60\xA45F\
+\\x4C61\xA460\
+\\x4C62\xA461\
+\\x4C63\xA462\
+\\x4C64\xA463\
+\\x4C65\xA464\
+\\x4C66\xA465\
+\\x4C67\xA466\
+\\x4C68\xA467\
+\\x4C69\xA468\
+\\x4C6A\xA469\
+\\x4C6B\xA46A\
+\\x4C6C\xA46B\
+\\x4C6D\xA46C\
+\\x4C6E\xA46D\
+\\x4C6F\xA46E\
+\\x4C70\xA46F\
+\\x4C71\xA470\
+\\x4C72\xA471\
+\\x4C73\xA472\
+\\x4C74\xA473\
+\\x4C75\xA474\
+\\x4C76\xA475\
+\\x4C77\xA476\
+\\x4C78\xA477\
+\\x4C79\xA478\
+\\x4C7A\xA479\
+\\x4C7B\xA47A\
+\\x4C7C\xA47B\
+\\x4C7D\xA47C\
+\\x4C7E\xA47D\
+\\x4C7F\xA47E\
+\\x4C81\xA4A1\
+\\x4C82\xA4A2\
+\\x4C83\xA4A3\
+\\x4C84\xA4A4\
+\\x4C85\xA4A5\
+\\x4C86\xA4A6\
+\\x4C87\xA4A7\
+\\x4C88\xA4A8\
+\\x4C89\xA4A9\
+\\x4C8A\xA4AA\
+\\x4C8B\xA4AB\
+\\x4C8C\xA4AC\
+\\x4C8D\xA4AD\
+\\x4C8E\xA4AE\
+\\x4C8F\xA4AF\
+\\x4C90\xA4B0\
+\\x4C91\xA4B1\
+\\x4C92\xA4B2\
+\\x4C93\xA4B3\
+\\x4C94\xA4B4\
+\\x4C95\xA4B5\
+\\x4C96\xA4B6\
+\\x4C97\xA4B7\
+\\x4C98\xA4B8\
+\\x4C99\xA4B9\
+\\x4C9A\xA4BA\
+\\x4C9B\xA4BB\
+\\x4C9C\xA4BC\
+\\x4C9D\xA4BD\
+\\x4C9E\xA4BE\
+\\x4C9F\xA4BF\
+\\x4CA0\xA4C0\
+\\x4CA1\xA4C1\
+\\x4CA2\xA4C2\
+\\x4CA3\xA4C3\
+\\x4CA4\xA4C4\
+\\x4CA5\xA4C5\
+\\x4CA6\xA4C6\
+\\x4CA7\xA4C7\
+\\x4CA8\xA4C8\
+\\x4CA9\xA4C9\
+\\x4CAA\xA4CA\
+\\x4CAB\xA4CB\
+\\x4CAC\xA4CC\
+\\x4CAD\xA4CD\
+\\x4CAE\xA4CE\
+\\x4CAF\xA4CF\
+\\x4CB0\xA4D0\
+\\x4CB1\xA4D1\
+\\x4CB2\xA4D2\
+\\x4CB3\xA4D3\
+\\x4CB4\xA4D4\
+\\x4CB5\xA4D5\
+\\x4CB6\xA4D6\
+\\x4CB7\xA4D7\
+\\x4CB8\xA4D8\
+\\x4CB9\xA4D9\
+\\x4CBA\xA4DA\
+\\x4CBB\xA4DB\
+\\x4CBC\xA4DC\
+\\x4CBD\xA4DD\
+\\x4CBE\xA4DE\
+\\x4CBF\xA4DF\
+\\x4CC0\xA4E0\
+\\x4CC1\xA4E1\
+\\x4CC2\xA4E2\
+\\x4CC3\xA4E3\
+\\x4CC4\xA4E4\
+\\x4CC5\xA4E5\
+\\x4CC6\xA4E6\
+\\x4CC7\xA4E7\
+\\x4CC8\xA4E8\
+\\x4CC9\xA4E9\
+\\x4CCA\xA4EA\
+\\x4CCB\xA4EB\
+\\x4CCC\xA4EC\
+\\x4CCD\xA4ED\
+\\x4CCE\xA4EE\
+\\x4CCF\xA4EF\
+\\x4CD0\xA4F0\
+\\x4CD1\xA4F1\
+\\x4CD2\xA4F2\
+\\x4CD3\xA4F3\
+\\x4CD4\xA4F4\
+\\x4CD5\xA4F5\
+\\x4CD6\xA4F6\
+\\x4CD7\xA4F7\
+\\x4CD8\xA4F8\
+\\x4CD9\xA4F9\
+\\x4CDA\xA4FA\
+\\x4CDB\xA4FB\
+\\x4CDC\xA4FC\
+\\x4CDD\xA4FD\
+\\x4CDE\xA4FE\
+\\x4CDF\xA540\
+\\x4CE0\xA541\
+\\x4CE1\xA542\
+\\x4CE2\xA543\
+\\x4CE3\xA544\
+\\x4CE4\xA545\
+\\x4CE5\xA546\
+\\x4CE6\xA547\
+\\x4CE7\xA548\
+\\x4CE8\xA549\
+\\x4CE9\xA54A\
+\\x4CEA\xA54B\
+\\x4CEB\xA54C\
+\\x4CEC\xA54D\
+\\x4CED\xA54E\
+\\x4CEE\xA54F\
+\\x4CEF\xA550\
+\\x4CF0\xA551\
+\\x4CF1\xA552\
+\\x4CF2\xA553\
+\\x4CF3\xA554\
+\\x4CF4\xA555\
+\\x4CF5\xA556\
+\\x4CF6\xA557\
+\\x4CF7\xA558\
+\\x4CF8\xA559\
+\\x4CF9\xA55A\
+\\x4CFA\xA55B\
+\\x4CFB\xA55C\
+\\x4CFC\xA55D\
+\\x4CFD\xA55E\
+\\x4D41\xA55F\
+\\x4D42\xA560\
+\\x4D43\xA561\
+\\x4D44\xA562\
+\\x4D45\xA563\
+\\x4D46\xA564\
+\\x4D47\xA565\
+\\x4D48\xA566\
+\\x4D49\xA567\
+\\x4D4A\xA568\
+\\x4D4B\xA569\
+\\x4D4C\xA56A\
+\\x4D4D\xA56B\
+\\x4D4E\xA56C\
+\\x4D4F\xA56D\
+\\x4D50\xA56E\
+\\x4D51\xA56F\
+\\x4D52\xA570\
+\\x4D53\xA571\
+\\x4D54\xA572\
+\\x4D55\xA573\
+\\x4D56\xA574\
+\\x4D57\xA575\
+\\x4D58\xA576\
+\\x4D59\xA577\
+\\x4D5A\xA578\
+\\x4D5B\xA579\
+\\x4D5C\xA57A\
+\\x4D5D\xA57B\
+\\x4D5E\xA57C\
+\\x4D5F\xA57D\
+\\x4D60\xA57E\
+\\x4D61\xA5A1\
+\\x4D62\xA5A2\
+\\x4D63\xA5A3\
+\\x4D64\xA5A4\
+\\x4D65\xA5A5\
+\\x4D66\xA5A6\
+\\x4D67\xA5A7\
+\\x4D68\xA5A8\
+\\x4D69\xA5A9\
+\\x4D6A\xA5AA\
+\\x4D6B\xA5AB\
+\\x4D6C\xA5AC\
+\\x4D6D\xA5AD\
+\\x4D6E\xA5AE\
+\\x4D6F\xA5AF\
+\\x4D70\xA5B0\
+\\x4D71\xA5B1\
+\\x4D72\xA5B2\
+\\x4D73\xA5B3\
+\\x4D74\xA5B4\
+\\x4D75\xA5B5\
+\\x4D76\xA5B6\
+\\x4D77\xA5B7\
+\\x4D78\xA5B8\
+\\x4D79\xA5B9\
+\\x4D7A\xA5BA\
+\\x4D7B\xA5BB\
+\\x4D7C\xA5BC\
+\\x4D7D\xA5BD\
+\\x4D7E\xA5BE\
+\\x4D7F\xA5BF\
+\\x4D81\xA5C0\
+\\x4D82\xA5C1\
+\\x4D83\xA5C2\
+\\x4D84\xA5C3\
+\\x4D85\xA5C4\
+\\x4D86\xA5C5\
+\\x4D87\xA5C6\
+\\x4D88\xA5C7\
+\\x4D89\xA5C8\
+\\x4D8A\xA5C9\
+\\x4D8B\xA5CA\
+\\x4D8C\xA5CB\
+\\x4D8D\xA5CC\
+\\x4D8E\xA5CD\
+\\x4D8F\xA5CE\
+\\x4D90\xA5CF\
+\\x4D91\xA5D0\
+\\x4D92\xA5D1\
+\\x4D93\xA5D2\
+\\x4D94\xA5D3\
+\\x4D95\xA5D4\
+\\x4D96\xA5D5\
+\\x4D97\xA5D6\
+\\x4D98\xA5D7\
+\\x4D99\xA5D8\
+\\x4D9A\xA5D9\
+\\x4D9B\xA5DA\
+\\x4D9C\xA5DB\
+\\x4D9D\xA5DC\
+\\x4D9E\xA5DD\
+\\x4D9F\xA5DE\
+\\x4DA0\xA5DF\
+\\x4DA1\xA5E0\
+\\x4DA2\xA5E1\
+\\x4DA3\xA5E2\
+\\x4DA4\xA5E3\
+\\x4DA5\xA5E4\
+\\x4DA6\xA5E5\
+\\x4DA7\xA5E6\
+\\x4DA8\xA5E7\
+\\x4DA9\xA5E8\
+\\x4DAA\xA5E9\
+\\x4DAB\xA5EA\
+\\x4DAC\xA5EB\
+\\x4DAD\xA5EC\
+\\x4DAE\xA5ED\
+\\x4DAF\xA5EE\
+\\x4DB0\xA5EF\
+\\x4DB1\xA5F0\
+\\x4DB2\xA5F1\
+\\x4DB3\xA5F2\
+\\x4DB4\xA5F3\
+\\x4DB5\xA5F4\
+\\x4DB6\xA5F5\
+\\x4DB7\xA5F6\
+\\x4DB8\xA5F7\
+\\x4DB9\xA5F8\
+\\x4DBA\xA5F9\
+\\x4DBB\xA5FA\
+\\x4DBC\xA5FB\
+\\x4DBD\xA5FC\
+\\x4DBE\xA5FD\
+\\x4DBF\xA5FE\
+\\x4DC0\xA640\
+\\x4DC1\xA641\
+\\x4DC2\xA642\
+\\x4DC3\xA643\
+\\x4DC4\xA644\
+\\x4DC5\xA645\
+\\x4DC6\xA646\
+\\x4DC7\xA647\
+\\x4DC8\xA648\
+\\x4DC9\xA649\
+\\x4DCA\xA64A\
+\\x4DCB\xA64B\
+\\x4DCC\xA64C\
+\\x4DCD\xA64D\
+\\x4DCE\xA64E\
+\\x4DCF\xA64F\
+\\x4DD0\xA650\
+\\x4DD1\xA651\
+\\x4DD2\xA652\
+\\x4DD3\xA653\
+\\x4DD4\xA654\
+\\x4DD5\xA655\
+\\x4DD6\xA656\
+\\x4DD7\xA657\
+\\x4DD8\xA658\
+\\x4DD9\xA659\
+\\x4DDA\xA65A\
+\\x4DDB\xA65B\
+\\x4DDC\xA65C\
+\\x4DDD\xA65D\
+\\x4DDE\xA65E\
+\\x4DDF\xA65F\
+\\x4DE0\xA660\
+\\x4DE1\xA661\
+\\x4DE2\xA662\
+\\x4DE3\xA663\
+\\x4DE4\xA664\
+\\x4DE5\xA665\
+\\x4DE6\xA666\
+\\x4DE7\xA667\
+\\x4DE8\xA668\
+\\x4DE9\xA669\
+\\x4DEA\xA66A\
+\\x4DEB\xA66B\
+\\x4DEC\xA66C\
+\\x4DED\xA66D\
+\\x4DEE\xA66E\
+\\x4DEF\xA66F\
+\\x4DF0\xA670\
+\\x4DF1\xA671\
+\\x4DF2\xA672\
+\\x4DF3\xA673\
+\\x4DF4\xA674\
+\\x4DF5\xA675\
+\\x4DF6\xA676\
+\\x4DF7\xA677\
+\\x4DF8\xA678\
+\\x4DF9\xA679\
+\\x4DFA\xA67A\
+\\x4DFB\xA67B\
+\\x4DFC\xA67C\
+\\x4DFD\xA67D\
+\\x4E41\xA67E\
+\\x4E42\xA6A1\
+\\x4E43\xA6A2\
+\\x4E44\xA6A3\
+\\x4E45\xA6A4\
+\\x4E46\xA6A5\
+\\x4E47\xA6A6\
+\\x4E48\xA6A7\
+\\x4E49\xA6A8\
+\\x4E4A\xA6A9\
+\\x4E4B\xA6AA\
+\\x4E4C\xA6AB\
+\\x4E4D\xA6AC\
+\\x4E4E\xA6AD\
+\\x4E4F\xA6AE\
+\\x4E50\xA6AF\
+\\x4E51\xA6B0\
+\\x4E52\xA6B1\
+\\x4E53\xA6B2\
+\\x4E54\xA6B3\
+\\x4E55\xA6B4\
+\\x4E56\xA6B5\
+\\x4E57\xA6B6\
+\\x4E58\xA6B7\
+\\x4E59\xA6B8\
+\\x4E5A\xA6B9\
+\\x4E5B\xA6BA\
+\\x4E5C\xA6BB\
+\\x4E5D\xA6BC\
+\\x4E5E\xA6BD\
+\\x4E5F\xA6BE\
+\\x4E60\xA6BF\
+\\x4E61\xA6C0\
+\\x4E62\xA6C1\
+\\x4E63\xA6C2\
+\\x4E64\xA6C3\
+\\x4E65\xA6C4\
+\\x4E66\xA6C5\
+\\x4E67\xA6C6\
+\\x4E68\xA6C7\
+\\x4E69\xA6C8\
+\\x4E6A\xA6C9\
+\\x4E6B\xA6CA\
+\\x4E6C\xA6CB\
+\\x4E6D\xA6CC\
+\\x4E6E\xA6CD\
+\\x4E6F\xA6CE\
+\\x4E70\xA6CF\
+\\x4E71\xA6D0\
+\\x4E72\xA6D1\
+\\x4E73\xA6D2\
+\\x4E74\xA6D3\
+\\x4E75\xA6D4\
+\\x4E76\xA6D5\
+\\x4E77\xA6D6\
+\\x4E78\xA6D7\
+\\x4E79\xA6D8\
+\\x4E7A\xA6D9\
+\\x4E7B\xA6DA\
+\\x4E7C\xA6DB\
+\\x4E7D\xA6DC\
+\\x4E7E\xA6DD\
+\\x4E7F\xA6DE\
+\\x4E81\xA6DF\
+\\x4E82\xA6E0\
+\\x4E83\xA6E1\
+\\x4E84\xA6E2\
+\\x4E85\xA6E3\
+\\x4E86\xA6E4\
+\\x4E87\xA6E5\
+\\x4E88\xA6E6\
+\\x4E89\xA6E7\
+\\x4E8A\xA6E8\
+\\x4E8B\xA6E9\
+\\x4E8C\xA6EA\
+\\x4E8D\xA6EB\
+\\x4E8E\xA6EC\
+\\x4E8F\xA6ED\
+\\x4E90\xA6EE\
+\\x4E91\xA6EF\
+\\x4E92\xA6F0\
+\\x4E93\xA6F1\
+\\x4E94\xA6F2\
+\\x4E95\xA6F3\
+\\x4E96\xA6F4\
+\\x4E97\xA6F5\
+\\x4E98\xA6F6\
+\\x4E99\xA6F7\
+\\x4E9A\xA6F8\
+\\x4E9B\xA6F9\
+\\x4E9C\xA6FA\
+\\x4E9D\xA6FB\
+\\x4E9E\xA6FC\
+\\x4E9F\xA6FD\
+\\x4EA0\xA6FE\
+\\x4EA1\xA740\
+\\x4EA2\xA741\
+\\x4EA3\xA742\
+\\x4EA4\xA743\
+\\x4EA5\xA744\
+\\x4EA6\xA745\
+\\x4EA7\xA746\
+\\x4EA8\xA747\
+\\x4EA9\xA748\
+\\x4EAA\xA749\
+\\x4EAB\xA74A\
+\\x4EAC\xA74B\
+\\x4EAD\xA74C\
+\\x4EAE\xA74D\
+\\x4EAF\xA74E\
+\\x4EB0\xA74F\
+\\x4EB1\xA750\
+\\x4EB2\xA751\
+\\x4EB3\xA752\
+\\x4EB4\xA753\
+\\x4EB5\xA754\
+\\x4EB6\xA755\
+\\x4EB7\xA756\
+\\x4EB8\xA757\
+\\x4EB9\xA758\
+\\x4EBA\xA759\
+\\x4EBB\xA75A\
+\\x4EBC\xA75B\
+\\x4EBD\xA75C\
+\\x4EBE\xA75D\
+\\x4EBF\xA75E\
+\\x4EC0\xA75F\
+\\x4EC1\xA760\
+\\x4EC2\xA761\
+\\x4EC3\xA762\
+\\x4EC4\xA763\
+\\x4EC5\xA764\
+\\x4EC6\xA765\
+\\x4EC7\xA766\
+\\x4EC8\xA767\
+\\x4EC9\xA768\
+\\x4ECA\xA769\
+\\x4ECB\xA76A\
+\\x4ECC\xA76B\
+\\x4ECD\xA76C\
+\\x4ECE\xA76D\
+\\x4ECF\xA76E\
+\\x4ED0\xA76F\
+\\x4ED1\xA770\
+\\x4ED2\xA771\
+\\x4ED3\xA772\
+\\x4ED4\xA773\
+\\x4ED5\xA774\
+\\x4ED6\xA775\
+\\x4ED7\xA776\
+\\x4ED8\xA777\
+\\x4ED9\xA778\
+\\x4EDA\xA779\
+\\x4EDB\xA77A\
+\\x4EDC\xA77B\
+\\x4EDD\xA77C\
+\\x4EDE\xA77D\
+\\x4EDF\xA77E\
+\\x4EE0\xA7A1\
+\\x4EE1\xA7A2\
+\\x4EE2\xA7A3\
+\\x4EE3\xA7A4\
+\\x4EE4\xA7A5\
+\\x4EE5\xA7A6\
+\\x4EE6\xA7A7\
+\\x4EE7\xA7A8\
+\\x4EE8\xA7A9\
+\\x4EE9\xA7AA\
+\\x4EEA\xA7AB\
+\\x4EEB\xA7AC\
+\\x4EEC\xA7AD\
+\\x4EED\xA7AE\
+\\x4EEE\xA7AF\
+\\x4EEF\xA7B0\
+\\x4EF0\xA7B1\
+\\x4EF1\xA7B2\
+\\x4EF2\xA7B3\
+\\x4EF3\xA7B4\
+\\x4EF4\xA7B5\
+\\x4EF5\xA7B6\
+\\x4EF6\xA7B7\
+\\x4EF7\xA7B8\
+\\x4EF8\xA7B9\
+\\x4EF9\xA7BA\
+\\x4EFA\xA7BB\
+\\x4EFB\xA7BC\
+\\x4EFC\xA7BD\
+\\x4EFD\xA7BE\
+\\x4F41\xA7BF\
+\\x4F42\xA7C0\
+\\x4F43\xA7C1\
+\\x4F44\xA7C2\
+\\x4F45\xA7C3\
+\\x4F46\xA7C4\
+\\x4F47\xA7C5\
+\\x4F48\xA7C6\
+\\x4F49\xA7C7\
+\\x4F4A\xA7C8\
+\\x4F4B\xA7C9\
+\\x4F4C\xA7CA\
+\\x4F4D\xA7CB\
+\\x4F4E\xA7CC\
+\\x4F4F\xA7CD\
+\\x4F50\xA7CE\
+\\x4F51\xA7CF\
+\\x4F52\xA7D0\
+\\x4F53\xA7D1\
+\\x4F54\xA7D2\
+\\x4F55\xA7D3\
+\\x4F56\xA7D4\
+\\x4F57\xA7D5\
+\\x4F58\xA7D6\
+\\x4F59\xA7D7\
+\\x4F5A\xA7D8\
+\\x4F5B\xA7D9\
+\\x4F5C\xA7DA\
+\\x4F5D\xA7DB\
+\\x4F5E\xA7DC\
+\\x4F5F\xA7DD\
+\\x4F60\xA7DE\
+\\x4F61\xA7DF\
+\\x4F62\xA7E0\
+\\x4F63\xA7E1\
+\\x4F64\xA7E2\
+\\x4F65\xA7E3\
+\\x4F66\xA7E4\
+\\x4F67\xA7E5\
+\\x4F68\xA7E6\
+\\x4F69\xA7E7\
+\\x4F6A\xA7E8\
+\\x4F6B\xA7E9\
+\\x4F6C\xA7EA\
+\\x4F6D\xA7EB\
+\\x4F6E\xA7EC\
+\\x4F6F\xA7ED\
+\\x4F70\xA7EE\
+\\x4F71\xA7EF\
+\\x4F72\xA7F0\
+\\x4F73\xA7F1\
+\\x4F74\xA7F2\
+\\x4F75\xA7F3\
+\\x4F76\xA7F4\
+\\x4F77\xA7F5\
+\\x4F78\xA7F6\
+\\x4F79\xA7F7\
+\\x4F7A\xA7F8\
+\\x4F7B\xA7F9\
+\\x4F7C\xA7FA\
+\\x4F7D\xA7FB\
+\\x4F7E\xA7FC\
+\\x4F7F\xA7FD\
+\\x4F81\xA7FE\
+\\x4F82\xA840\
+\\x4F83\xA841\
+\\x4F84\xA842\
+\\x4F85\xA843\
+\\x4F86\xA844\
+\\x4F87\xA845\
+\\x4F88\xA846\
+\\x4F89\xA847\
+\\x4F8A\xA848\
+\\x4F8B\xA849\
+\\x4F8C\xA84A\
+\\x4F8D\xA84B\
+\\x4F8E\xA84C\
+\\x4F8F\xA84D\
+\\x4F90\xA84E\
+\\x4F91\xA84F\
+\\x4F92\xA850\
+\\x4F93\xA851\
+\\x4F94\xA852\
+\\x4F95\xA853\
+\\x4F96\xA854\
+\\x4F97\xA855\
+\\x4F98\xA856\
+\\x4F99\xA857\
+\\x4F9A\xA858\
+\\x4F9B\xA859\
+\\x4F9C\xA85A\
+\\x4F9D\xA85B\
+\\x4F9E\xA85C\
+\\x4F9F\xA85D\
+\\x4FA0\xA85E\
+\\x4FA1\xA85F\
+\\x4FA2\xA860\
+\\x4FA3\xA861\
+\\x4FA4\xA862\
+\\x4FA5\xA863\
+\\x4FA6\xA864\
+\\x4FA7\xA865\
+\\x4FA8\xA866\
+\\x4FA9\xA867\
+\\x4FAA\xA868\
+\\x4FAB\xA869\
+\\x4FAC\xA86A\
+\\x4FAD\xA86B\
+\\x4FAE\xA86C\
+\\x4FAF\xA86D\
+\\x4FB0\xA86E\
+\\x4FB1\xA86F\
+\\x4FB2\xA870\
+\\x4FB3\xA871\
+\\x4FB4\xA872\
+\\x4FB5\xA873\
+\\x4FB6\xA874\
+\\x4FB7\xA875\
+\\x4FB8\xA876\
+\\x4FB9\xA877\
+\\x4FBA\xA878\
+\\x4FBB\xA879\
+\\x4FBC\xA87A\
+\\x4FBD\xA87B\
+\\x4FBE\xA87C\
+\\x4FBF\xA87D\
+\\x4FC0\xA87E\
+\\x4FC1\xA8A1\
+\\x4FC2\xA8A2\
+\\x4FC3\xA8A3\
+\\x4FC4\xA8A4\
+\\x4FC5\xA8A5\
+\\x4FC6\xA8A6\
+\\x4FC7\xA8A7\
+\\x4FC8\xA8A8\
+\\x4FC9\xA8A9\
+\\x4FCA\xA8AA\
+\\x4FCB\xA8AB\
+\\x4FCC\xA8AC\
+\\x4FCD\xA8AD\
+\\x4FCE\xA8AE\
+\\x4FCF\xA8AF\
+\\x4FD0\xA8B0\
+\\x4FD1\xA8B1\
+\\x4FD2\xA8B2\
+\\x4FD3\xA8B3\
+\\x4FD4\xA8B4\
+\\x4FD5\xA8B5\
+\\x4FD6\xA8B6\
+\\x4FD7\xA8B7\
+\\x4FD8\xA8B8\
+\\x4FD9\xA8B9\
+\\x4FDA\xA8BA\
+\\x4FDB\xA8BB\
+\\x4FDC\xA8BC\
+\\x4FDD\xA8BD\
+\\x4FDE\xA8BE\
+\\x4FDF\xA8BF\
+\\x4FE0\xA8C0\
+\\x4FE1\xA8C1\
+\\x4FE2\xA8C2\
+\\x4FE3\xA8C3\
+\\x4FE4\xA8C4\
+\\x4FE5\xA8C5\
+\\x4FE6\xA8C6\
+\\x4FE7\xA8C7\
+\\x4FE8\xA8C8\
+\\x4FE9\xA8C9\
+\\x4FEA\xA8CA\
+\\x4FEB\xA8CB\
+\\x4FEC\xA8CC\
+\\x4FED\xA8CD\
+\\x4FEE\xA8CE\
+\\x4FEF\xA8CF\
+\\x4FF0\xA8D0\
+\\x4FF1\xA8D1\
+\\x4FF2\xA8D2\
+\\x4FF3\xA8D3\
+\\x4FF4\xA8D4\
+\\x4FF5\xA8D5\
+\\x4FF6\xA8D6\
+\\x4FF7\xA8D7\
+\\x4FF8\xA8D8\
+\\x4FF9\xA8D9\
+\\x4FFA\xA8DA\
+\\x4FFB\xA8DB\
+\\x4FFC\xA8DC\
+\\x4FFD\xA8DD\
+\\x5041\xA8DE\
+\\x5042\xA8DF\
+\\x5043\xA8E0\
+\\x5044\xA8E1\
+\\x5045\xA8E2\
+\\x5046\xA8E3\
+\\x5047\xA8E4\
+\\x5048\xA8E5\
+\\x5049\xA8E6\
+\\x504A\xA8E7\
+\\x504B\xA8E8\
+\\x504C\xA8E9\
+\\x504D\xA8EA\
+\\x504E\xA8EB\
+\\x504F\xA8EC\
+\\x5050\xA8ED\
+\\x5051\xA8EE\
+\\x5052\xA8EF\
+\\x5053\xA8F0\
+\\x5054\xA8F1\
+\\x5055\xA8F2\
+\\x5056\xA8F3\
+\\x5057\xA8F4\
+\\x5058\xA8F5\
+\\x5059\xA8F6\
+\\x505A\xA8F7\
+\\x505B\xA8F8\
+\\x505C\xA8F9\
+\\x505D\xA8FA\
+\\x505E\xA8FB\
+\\x505F\xA8FC\
+\\x5060\xA8FD\
+\\x5061\xA8FE\
+\\x5062\xA940\
+\\x5063\xA941\
+\\x5064\xA942\
+\\x5065\xA943\
+\\x5066\xA944\
+\\x5067\xA945\
+\\x5068\xA946\
+\\x5069\xA947\
+\\x506A\xA948\
+\\x506B\xA949\
+\\x506C\xA94A\
+\\x506D\xA94B\
+\\x506E\xA94C\
+\\x506F\xA94D\
+\\x5070\xA94E\
+\\x5071\xA94F\
+\\x5072\xA950\
+\\x5073\xA951\
+\\x5074\xA952\
+\\x5075\xA953\
+\\x5076\xA954\
+\\x5077\xA955\
+\\x5078\xA956\
+\\x5079\xA957\
+\\x507A\xA958\
+\\x507B\xA959\
+\\x507C\xA95A\
+\\x507D\xA95B\
+\\x507E\xA95C\
+\\x507F\xA95D\
+\\x5081\xA95E\
+\\x5082\xA95F\
+\\x5083\xA960\
+\\x5084\xA961\
+\\x5085\xA962\
+\\x5086\xA963\
+\\x5087\xA964\
+\\x5088\xA965\
+\\x5089\xA966\
+\\x508A\xA967\
+\\x508B\xA968\
+\\x508C\xA969\
+\\x508D\xA96A\
+\\x508E\xA96B\
+\\x508F\xA96C\
+\\x5090\xA96D\
+\\x5091\xA96E\
+\\x5092\xA96F\
+\\x5093\xA970\
+\\x5094\xA971\
+\\x5095\xA972\
+\\x5096\xA973\
+\\x5097\xA974\
+\\x5098\xA975\
+\\x5099\xA976\
+\\x509A\xA977\
+\\x509B\xA978\
+\\x509C\xA979\
+\\x509D\xA97A\
+\\x509E\xA97B\
+\\x509F\xA97C\
+\\x50A0\xA97D\
+\\x50A1\xA97E\
+\\x50A2\xA9A1\
+\\x50A3\xA9A2\
+\\x50A4\xA9A3\
+\\x50A5\xA9A4\
+\\x50A6\xA9A5\
+\\x50A7\xA9A6\
+\\x50A8\xA9A7\
+\\x50A9\xA9A8\
+\\x50AA\xA9A9\
+\\x50AB\xA9AA\
+\\x50AC\xA9AB\
+\\x50AD\xA9AC\
+\\x50AE\xA9AD\
+\\x50AF\xA9AE\
+\\x50B0\xA9AF\
+\\x50B1\xA9B0\
+\\x50B2\xA9B1\
+\\x50B3\xA9B2\
+\\x50B4\xA9B3\
+\\x50B5\xA9B4\
+\\x50B6\xA9B5\
+\\x50B7\xA9B6\
+\\x50B8\xA9B7\
+\\x50B9\xA9B8\
+\\x50BA\xA9B9\
+\\x50BB\xA9BA\
+\\x50BC\xA9BB\
+\\x50BD\xA9BC\
+\\x50BE\xA9BD\
+\\x50BF\xA9BE\
+\\x50C0\xA9BF\
+\\x50C1\xA9C0\
+\\x50C2\xA9C1\
+\\x50C3\xA9C2\
+\\x50C4\xA9C3\
+\\x50C5\xA9C4\
+\\x50C6\xA9C5\
+\\x50C7\xA9C6\
+\\x50C8\xA9C7\
+\\x50C9\xA9C8\
+\\x50CA\xA9C9\
+\\x50CB\xA9CA\
+\\x50CC\xA9CB\
+\\x50CD\xA9CC\
+\\x50CE\xA9CD\
+\\x50CF\xA9CE\
+\\x50D0\xA9CF\
+\\x50D1\xA9D0\
+\\x50D2\xA9D1\
+\\x50D3\xA9D2\
+\\x50D4\xA9D3\
+\\x50D5\xA9D4\
+\\x50D6\xA9D5\
+\\x50D7\xA9D6\
+\\x50D8\xA9D7\
+\\x50D9\xA9D8\
+\\x50DA\xA9D9\
+\\x50DB\xA9DA\
+\\x50DC\xA9DB\
+\\x50DD\xA9DC\
+\\x50DE\xA9DD\
+\\x50DF\xA9DE\
+\\x50E0\xA9DF\
+\\x50E1\xA9E0\
+\\x50E2\xA9E1\
+\\x50E3\xA9E2\
+\\x50E4\xA9E3\
+\\x50E5\xA9E4\
+\\x50E6\xA9E5\
+\\x50E7\xA9E6\
+\\x50E8\xA9E7\
+\\x50E9\xA9E8\
+\\x50EA\xA9E9\
+\\x50EB\xA9EA\
+\\x50EC\xA9EB\
+\\x50ED\xA9EC\
+\\x50EE\xA9ED\
+\\x50EF\xA9EE\
+\\x50F0\xA9EF\
+\\x50F1\xA9F0\
+\\x50F2\xA9F1\
+\\x50F3\xA9F2\
+\\x50F4\xA9F3\
+\\x50F5\xA9F4\
+\\x50F6\xA9F5\
+\\x50F7\xA9F6\
+\\x50F8\xA9F7\
+\\x50F9\xA9F8\
+\\x50FA\xA9F9\
+\\x50FB\xA9FA\
+\\x50FC\xA9FB\
+\\x50FD\xA9FC\
+\\x5141\xA9FD\
+\\x5142\xA9FE\
+\\x5143\xAA40\
+\\x5144\xAA41\
+\\x5145\xAA42\
+\\x5146\xAA43\
+\\x5147\xAA44\
+\\x5148\xAA45\
+\\x5149\xAA46\
+\\x514A\xAA47\
+\\x514B\xAA48\
+\\x514C\xAA49\
+\\x514D\xAA4A\
+\\x514E\xAA4B\
+\\x514F\xAA4C\
+\\x5150\xAA4D\
+\\x5151\xAA4E\
+\\x5152\xAA4F\
+\\x5153\xAA50\
+\\x5154\xAA51\
+\\x5155\xAA52\
+\\x5156\xAA53\
+\\x5157\xAA54\
+\\x5158\xAA55\
+\\x5159\xAA56\
+\\x515A\xAA57\
+\\x515B\xAA58\
+\\x515C\xAA59\
+\\x515D\xAA5A\
+\\x515E\xAA5B\
+\\x515F\xAA5C\
+\\x5160\xAA5D\
+\\x5161\xAA5E\
+\\x5162\xAA5F\
+\\x5163\xAA60\
+\\x5164\xAA61\
+\\x5165\xAA62\
+\\x5166\xAA63\
+\\x5167\xAA64\
+\\x5168\xAA65\
+\\x5169\xAA66\
+\\x516A\xAA67\
+\\x516B\xAA68\
+\\x516C\xAA69\
+\\x516D\xAA6A\
+\\x516E\xAA6B\
+\\x516F\xAA6C\
+\\x5170\xAA6D\
+\\x5171\xAA6E\
+\\x5172\xAA6F\
+\\x5173\xAA70\
+\\x5174\xAA71\
+\\x5175\xAA72\
+\\x5176\xAA73\
+\\x5177\xAA74\
+\\x5178\xAA75\
+\\x5179\xAA76\
+\\x517A\xAA77\
+\\x517B\xAA78\
+\\x517C\xAA79\
+\\x517D\xAA7A\
+\\x517E\xAA7B\
+\\x517F\xAA7C\
+\\x5181\xAA7D\
+\\x5182\xAA7E\
+\\x5183\xAAA1\
+\\x5184\xAAA2\
+\\x5185\xAAA3\
+\\x5186\xAAA4\
+\\x5187\xAAA5\
+\\x5188\xAAA6\
+\\x5189\xAAA7\
+\\x518A\xAAA8\
+\\x518B\xAAA9\
+\\x518C\xAAAA\
+\\x518D\xAAAB\
+\\x518E\xAAAC\
+\\x518F\xAAAD\
+\\x5190\xAAAE\
+\\x5191\xAAAF\
+\\x5192\xAAB0\
+\\x5193\xAAB1\
+\\x5194\xAAB2\
+\\x5195\xAAB3\
+\\x5196\xAAB4\
+\\x5197\xAAB5\
+\\x5198\xAAB6\
+\\x5199\xAAB7\
+\\x519A\xAAB8\
+\\x519B\xAAB9\
+\\x519C\xAABA\
+\\x519D\xAABB\
+\\x519E\xAABC\
+\\x519F\xAABD\
+\\x51A0\xAABE\
+\\x51A1\xAABF\
+\\x51A2\xAAC0\
+\\x51A3\xAAC1\
+\\x51A4\xAAC2\
+\\x51A5\xAAC3\
+\\x51A6\xAAC4\
+\\x51A7\xAAC5\
+\\x51A8\xAAC6\
+\\x51A9\xAAC7\
+\\x51AA\xAAC8\
+\\x51AB\xAAC9\
+\\x51AC\xAACA\
+\\x51AD\xAACB\
+\\x51AE\xAACC\
+\\x51AF\xAACD\
+\\x51B0\xAACE\
+\\x51B1\xAACF\
+\\x51B2\xAAD0\
+\\x51B3\xAAD1\
+\\x51B4\xAAD2\
+\\x51B5\xAAD3\
+\\x51B6\xAAD4\
+\\x51B7\xAAD5\
+\\x51B8\xAAD6\
+\\x51B9\xAAD7\
+\\x51BA\xAAD8\
+\\x51BB\xAAD9\
+\\x51BC\xAADA\
+\\x51BD\xAADB\
+\\x51BE\xAADC\
+\\x51BF\xAADD\
+\\x51C0\xAADE\
+\\x51C1\xAADF\
+\\x51C2\xAAE0\
+\\x51C3\xAAE1\
+\\x51C4\xAAE2\
+\\x51C5\xAAE3\
+\\x51C6\xAAE4\
+\\x51C7\xAAE5\
+\\x51C8\xAAE6\
+\\x51C9\xAAE7\
+\\x51CA\xAAE8\
+\\x51CB\xAAE9\
+\\x51CC\xAAEA\
+\\x51CD\xAAEB\
+\\x51CE\xAAEC\
+\\x51CF\xAAED\
+\\x51D0\xAAEE\
+\\x51D1\xAAEF\
+\\x51D2\xAAF0\
+\\x51D3\xAAF1\
+\\x51D4\xAAF2\
+\\x51D5\xAAF3\
+\\x51D6\xAAF4\
+\\x51D7\xAAF5\
+\\x51D8\xAAF6\
+\\x51D9\xAAF7\
+\\x51DA\xAAF8\
+\\x51DB\xAAF9\
+\\x51DC\xAAFA\
+\\x51DD\xAAFB\
+\\x51DE\xAAFC\
+\\x51DF\xAAFD\
+\\x51E0\xAAFE\
+\\x51E1\xAB40\
+\\x51E2\xAB41\
+\\x51E3\xAB42\
+\\x51E4\xAB43\
+\\x51E5\xAB44\
+\\x51E6\xAB45\
+\\x51E7\xAB46\
+\\x51E8\xAB47\
+\\x51E9\xAB48\
+\\x51EA\xAB49\
+\\x51EB\xAB4A\
+\\x51EC\xAB4B\
+\\x51ED\xAB4C\
+\\x51EE\xAB4D\
+\\x51EF\xAB4E\
+\\x51F0\xAB4F\
+\\x51F1\xAB50\
+\\x51F2\xAB51\
+\\x51F3\xAB52\
+\\x51F4\xAB53\
+\\x51F5\xAB54\
+\\x51F6\xAB55\
+\\x51F7\xAB56\
+\\x51F8\xAB57\
+\\x51F9\xAB58\
+\\x51FA\xAB59\
+\\x51FB\xAB5A\
+\\x51FC\xAB5B\
+\\x51FD\xAB5C\
+\\x5241\xAB5D\
+\\x5242\xAB5E\
+\\x5243\xAB5F\
+\\x5244\xAB60\
+\\x5245\xAB61\
+\\x5246\xAB62\
+\\x5247\xAB63\
+\\x5248\xAB64\
+\\x5249\xAB65\
+\\x524A\xAB66\
+\\x524B\xAB67\
+\\x524C\xAB68\
+\\x524D\xAB69\
+\\x524E\xAB6A\
+\\x524F\xAB6B\
+\\x5250\xAB6C\
+\\x5251\xAB6D\
+\\x5252\xAB6E\
+\\x5253\xAB6F\
+\\x5254\xAB70\
+\\x5255\xAB71\
+\\x5256\xAB72\
+\\x5257\xAB73\
+\\x5258\xAB74\
+\\x5259\xAB75\
+\\x525A\xAB76\
+\\x525B\xAB77\
+\\x525C\xAB78\
+\\x525D\xAB79\
+\\x525E\xAB7A\
+\\x525F\xAB7B\
+\\x5260\xAB7C\
+\\x5261\xAB7D\
+\\x5262\xAB7E\
+\\x5263\xABA1\
+\\x5264\xABA2\
+\\x5265\xABA3\
+\\x5266\xABA4\
+\\x5267\xABA5\
+\\x5268\xABA6\
+\\x5269\xABA7\
+\\x526A\xABA8\
+\\x526B\xABA9\
+\\x526C\xABAA\
+\\x526D\xABAB\
+\\x526E\xABAC\
+\\x526F\xABAD\
+\\x5270\xABAE\
+\\x5271\xABAF\
+\\x5272\xABB0\
+\\x5273\xABB1\
+\\x5274\xABB2\
+\\x5275\xABB3\
+\\x5276\xABB4\
+\\x5277\xABB5\
+\\x5278\xABB6\
+\\x5279\xABB7\
+\\x527A\xABB8\
+\\x527B\xABB9\
+\\x527C\xABBA\
+\\x527D\xABBB\
+\\x527E\xABBC\
+\\x527F\xABBD\
+\\x5281\xABBE\
+\\x5282\xABBF\
+\\x5283\xABC0\
+\\x5284\xABC1\
+\\x5285\xABC2\
+\\x5286\xABC3\
+\\x5287\xABC4\
+\\x5288\xABC5\
+\\x5289\xABC6\
+\\x528A\xABC7\
+\\x528B\xABC8\
+\\x528C\xABC9\
+\\x528D\xABCA\
+\\x528E\xABCB\
+\\x528F\xABCC\
+\\x5290\xABCD\
+\\x5291\xABCE\
+\\x5292\xABCF\
+\\x5293\xABD0\
+\\x5294\xABD1\
+\\x5295\xABD2\
+\\x5296\xABD3\
+\\x5297\xABD4\
+\\x5298\xABD5\
+\\x5299\xABD6\
+\\x529A\xABD7\
+\\x529B\xABD8\
+\\x529C\xABD9\
+\\x529D\xABDA\
+\\x529E\xABDB\
+\\x529F\xABDC\
+\\x52A0\xABDD\
+\\x52A1\xABDE\
+\\x52A2\xABDF\
+\\x52A3\xABE0\
+\\x52A4\xABE1\
+\\x52A5\xABE2\
+\\x52A6\xABE3\
+\\x52A7\xABE4\
+\\x52A8\xABE5\
+\\x52A9\xABE6\
+\\x52AA\xABE7\
+\\x52AB\xABE8\
+\\x52AC\xABE9\
+\\x52AD\xABEA\
+\\x52AE\xABEB\
+\\x52AF\xABEC\
+\\x52B0\xABED\
+\\x52B1\xABEE\
+\\x52B2\xABEF\
+\\x52B3\xABF0\
+\\x52B4\xABF1\
+\\x52B5\xABF2\
+\\x52B6\xABF3\
+\\x52B7\xABF4\
+\\x52B8\xABF5\
+\\x52B9\xABF6\
+\\x52BA\xABF7\
+\\x52BB\xABF8\
+\\x52BC\xABF9\
+\\x52BD\xABFA\
+\\x52BE\xABFB\
+\\x52BF\xABFC\
+\\x52C0\xABFD\
+\\x52C1\xABFE\
+\\x52C2\xAC40\
+\\x52C3\xAC41\
+\\x52C4\xAC42\
+\\x52C5\xAC43\
+\\x52C6\xAC44\
+\\x52C7\xAC45\
+\\x52C8\xAC46\
+\\x52C9\xAC47\
+\\x52CA\xAC48\
+\\x52CB\xAC49\
+\\x52CC\xAC4A\
+\\x52CD\xAC4B\
+\\x52CE\xAC4C\
+\\x52CF\xAC4D\
+\\x52D0\xAC4E\
+\\x52D1\xAC4F\
+\\x52D2\xAC50\
+\\x52D3\xAC51\
+\\x52D4\xAC52\
+\\x52D5\xAC53\
+\\x52D6\xAC54\
+\\x52D7\xAC55\
+\\x52D8\xAC56\
+\\x52D9\xAC57\
+\\x52DA\xAC58\
+\\x52DB\xAC59\
+\\x52DC\xAC5A\
+\\x52DD\xAC5B\
+\\x52DE\xAC5C\
+\\x52DF\xAC5D\
+\\x52E0\xAC5E\
+\\x52E1\xAC5F\
+\\x52E2\xAC60\
+\\x52E3\xAC61\
+\\x52E4\xAC62\
+\\x52E5\xAC63\
+\\x52E6\xAC64\
+\\x52E7\xAC65\
+\\x52E8\xAC66\
+\\x52E9\xAC67\
+\\x52EA\xAC68\
+\\x52EB\xAC69\
+\\x52EC\xAC6A\
+\\x52ED\xAC6B\
+\\x52EE\xAC6C\
+\\x52EF\xAC6D\
+\\x52F0\xAC6E\
+\\x52F1\xAC6F\
+\\x52F2\xAC70\
+\\x52F3\xAC71\
+\\x52F4\xAC72\
+\\x52F5\xAC73\
+\\x52F6\xAC74\
+\\x52F7\xAC75\
+\\x52F8\xAC76\
+\\x52F9\xAC77\
+\\x52FA\xAC78\
+\\x52FB\xAC79\
+\\x52FC\xAC7A\
+\\x52FD\xAC7B\
+\\x5341\xAC7C\
+\\x5342\xAC7D\
+\\x5343\xAC7E\
+\\x5344\xACA1\
+\\x5345\xACA2\
+\\x5346\xACA3\
+\\x5347\xACA4\
+\\x5348\xACA5\
+\\x5349\xACA6\
+\\x534A\xACA7\
+\\x534B\xACA8\
+\\x534C\xACA9\
+\\x534D\xACAA\
+\\x534E\xACAB\
+\\x534F\xACAC\
+\\x5350\xACAD\
+\\x5351\xACAE\
+\\x5352\xACAF\
+\\x5353\xACB0\
+\\x5354\xACB1\
+\\x5355\xACB2\
+\\x5356\xACB3\
+\\x5357\xACB4\
+\\x5358\xACB5\
+\\x5359\xACB6\
+\\x535A\xACB7\
+\\x535B\xACB8\
+\\x535C\xACB9\
+\\x535D\xACBA\
+\\x535E\xACBB\
+\\x535F\xACBC\
+\\x5360\xACBD\
+\\x5361\xACBE\
+\\x5362\xACBF\
+\\x5363\xACC0\
+\\x5364\xACC1\
+\\x5365\xACC2\
+\\x5366\xACC3\
+\\x5367\xACC4\
+\\x5368\xACC5\
+\\x5369\xACC6\
+\\x536A\xACC7\
+\\x536B\xACC8\
+\\x536C\xACC9\
+\\x536D\xACCA\
+\\x536E\xACCB\
+\\x536F\xACCC\
+\\x5370\xACCD\
+\\x5371\xACCE\
+\\x5372\xACCF\
+\\x5373\xACD0\
+\\x5374\xACD1\
+\\x5375\xACD2\
+\\x5376\xACD3\
+\\x5377\xACD4\
+\\x5378\xACD5\
+\\x5379\xACD6\
+\\x537A\xACD7\
+\\x537B\xACD8\
+\\x537C\xACD9\
+\\x537D\xACDA\
+\\x537E\xACDB\
+\\x537F\xACDC\
+\\x5381\xACDD\
+\\x5382\xACDE\
+\\x5383\xACDF\
+\\x5384\xACE0\
+\\x5385\xACE1\
+\\x5386\xACE2\
+\\x5387\xACE3\
+\\x5388\xACE4\
+\\x5389\xACE5\
+\\x538A\xACE6\
+\\x538B\xACE7\
+\\x538C\xACE8\
+\\x538D\xACE9\
+\\x538E\xACEA\
+\\x538F\xACEB\
+\\x5390\xACEC\
+\\x5391\xACED\
+\\x5392\xACEE\
+\\x5393\xACEF\
+\\x5394\xACF0\
+\\x5395\xACF1\
+\\x5396\xACF2\
+\\x5397\xACF3\
+\\x5398\xACF4\
+\\x5399\xACF5\
+\\x539A\xACF6\
+\\x539B\xACF7\
+\\x539C\xACF8\
+\\x539D\xACF9\
+\\x539E\xACFA\
+\\x539F\xACFB\
+\\x53A0\xACFC\
+\\x53A1\xACFD\
+\\x53A2\xACFE\
+\\x53A3\xAD40\
+\\x53A4\xAD41\
+\\x53A5\xAD42\
+\\x53A6\xAD43\
+\\x53A7\xAD44\
+\\x53A8\xAD45\
+\\x53A9\xAD46\
+\\x53AA\xAD47\
+\\x53AB\xAD48\
+\\x53AC\xAD49\
+\\x53AD\xAD4A\
+\\x53AE\xAD4B\
+\\x53AF\xAD4C\
+\\x53B0\xAD4D\
+\\x53B1\xAD4E\
+\\x53B2\xAD4F\
+\\x53B3\xAD50\
+\\x53B4\xAD51\
+\\x53B5\xAD52\
+\\x53B6\xAD53\
+\\x53B7\xAD54\
+\\x53B8\xAD55\
+\\x53B9\xAD56\
+\\x53BA\xAD57\
+\\x53BB\xAD58\
+\\x53BC\xAD59\
+\\x53BD\xAD5A\
+\\x53BE\xAD5B\
+\\x53BF\xAD5C\
+\\x53C0\xAD5D\
+\\x53C1\xAD5E\
+\\x53C2\xAD5F\
+\\x53C3\xAD60\
+\\x53C4\xAD61\
+\\x53C5\xAD62\
+\\x53C6\xAD63\
+\\x53C7\xAD64\
+\\x53C8\xAD65\
+\\x53C9\xAD66\
+\\x53CA\xAD67\
+\\x53CB\xAD68\
+\\x53CC\xAD69\
+\\x53CD\xAD6A\
+\\x53CE\xAD6B\
+\\x53CF\xAD6C\
+\\x53D0\xAD6D\
+\\x53D1\xAD6E\
+\\x53D2\xAD6F\
+\\x53D3\xAD70\
+\\x53D4\xAD71\
+\\x53D5\xAD72\
+\\x53D6\xAD73\
+\\x53D7\xAD74\
+\\x53D8\xAD75\
+\\x53D9\xAD76\
+\\x53DA\xAD77\
+\\x53DB\xAD78\
+\\x53DC\xAD79\
+\\x53DD\xAD7A\
+\\x53DE\xAD7B\
+\\x53DF\xAD7C\
+\\x53E0\xAD7D\
+\\x53E1\xAD7E\
+\\x53E2\xADA1\
+\\x53E3\xADA2\
+\\x53E4\xADA3\
+\\x53E5\xADA4\
+\\x53E6\xADA5\
+\\x53E7\xADA6\
+\\x53E8\xADA7\
+\\x53E9\xADA8\
+\\x53EA\xADA9\
+\\x53EB\xADAA\
+\\x53EC\xADAB\
+\\x53ED\xADAC\
+\\x53EE\xADAD\
+\\x53EF\xADAE\
+\\x53F0\xADAF\
+\\x53F1\xADB0\
+\\x53F2\xADB1\
+\\x53F3\xADB2\
+\\x53F4\xADB3\
+\\x53F5\xADB4\
+\\x53F6\xADB5\
+\\x53F7\xADB6\
+\\x53F8\xADB7\
+\\x53F9\xADB8\
+\\x53FA\xADB9\
+\\x53FB\xADBA\
+\\x53FC\xADBB\
+\\x53FD\xADBC\
+\\x5441\xADBD\
+\\x5442\xADBE\
+\\x5443\xADBF\
+\\x5444\xADC0\
+\\x5445\xADC1\
+\\x5446\xADC2\
+\\x5447\xADC3\
+\\x5448\xADC4\
+\\x5449\xADC5\
+\\x544A\xADC6\
+\\x544B\xADC7\
+\\x544C\xADC8\
+\\x544D\xADC9\
+\\x544E\xADCA\
+\\x544F\xADCB\
+\\x5450\xADCC\
+\\x5451\xADCD\
+\\x5452\xADCE\
+\\x5453\xADCF\
+\\x5454\xADD0\
+\\x5455\xADD1\
+\\x5456\xADD2\
+\\x5457\xADD3\
+\\x5458\xADD4\
+\\x5459\xADD5\
+\\x545A\xADD6\
+\\x545B\xADD7\
+\\x545C\xADD8\
+\\x545D\xADD9\
+\\x545E\xADDA\
+\\x545F\xADDB\
+\\x5460\xADDC\
+\\x5461\xADDD\
+\\x5462\xADDE\
+\\x5463\xADDF\
+\\x5464\xADE0\
+\\x5465\xADE1\
+\\x5466\xADE2\
+\\x5467\xADE3\
+\\x5468\xADE4\
+\\x5469\xADE5\
+\\x546A\xADE6\
+\\x546B\xADE7\
+\\x546C\xADE8\
+\\x546D\xADE9\
+\\x546E\xADEA\
+\\x546F\xADEB\
+\\x5470\xADEC\
+\\x5471\xADED\
+\\x5472\xADEE\
+\\x5473\xADEF\
+\\x5474\xADF0\
+\\x5475\xADF1\
+\\x5476\xADF2\
+\\x5477\xADF3\
+\\x5478\xADF4\
+\\x5479\xADF5\
+\\x547A\xADF6\
+\\x547B\xADF7\
+\\x547C\xADF8\
+\\x547D\xADF9\
+\\x547E\xADFA\
+\\x547F\xADFB\
+\\x5481\xADFC\
+\\x5482\xADFD\
+\\x5483\xADFE\
+\\x5484\xAE40\
+\\x5485\xAE41\
+\\x5486\xAE42\
+\\x5487\xAE43\
+\\x5488\xAE44\
+\\x5489\xAE45\
+\\x548A\xAE46\
+\\x548B\xAE47\
+\\x548C\xAE48\
+\\x548D\xAE49\
+\\x548E\xAE4A\
+\\x548F\xAE4B\
+\\x5490\xAE4C\
+\\x5491\xAE4D\
+\\x5492\xAE4E\
+\\x5493\xAE4F\
+\\x5494\xAE50\
+\\x5495\xAE51\
+\\x5496\xAE52\
+\\x5497\xAE53\
+\\x5498\xAE54\
+\\x5499\xAE55\
+\\x549A\xAE56\
+\\x549B\xAE57\
+\\x549C\xAE58\
+\\x549D\xAE59\
+\\x549E\xAE5A\
+\\x549F\xAE5B\
+\\x54A0\xAE5C\
+\\x54A1\xAE5D\
+\\x54A2\xAE5E\
+\\x54A3\xAE5F\
+\\x54A4\xAE60\
+\\x54A5\xAE61\
+\\x54A6\xAE62\
+\\x54A7\xAE63\
+\\x54A8\xAE64\
+\\x54A9\xAE65\
+\\x54AA\xAE66\
+\\x54AB\xAE67\
+\\x54AC\xAE68\
+\\x54AD\xAE69\
+\\x54AE\xAE6A\
+\\x54AF\xAE6B\
+\\x54B0\xAE6C\
+\\x54B1\xAE6D\
+\\x54B2\xAE6E\
+\\x54B3\xAE6F\
+\\x54B4\xAE70\
+\\x54B5\xAE71\
+\\x54B6\xAE72\
+\\x54B7\xAE73\
+\\x54B8\xAE74\
+\\x54B9\xAE75\
+\\x54BA\xAE76\
+\\x54BB\xAE77\
+\\x54BC\xAE78\
+\\x54BD\xAE79\
+\\x54BE\xAE7A\
+\\x54BF\xAE7B\
+\\x54C0\xAE7C\
+\\x54C1\xAE7D\
+\\x54C2\xAE7E\
+\\x54C3\xAEA1\
+\\x54C4\xAEA2\
+\\x54C5\xAEA3\
+\\x54C6\xAEA4\
+\\x54C7\xAEA5\
+\\x54C8\xAEA6\
+\\x54C9\xAEA7\
+\\x54CA\xAEA8\
+\\x54CB\xAEA9\
+\\x54CC\xAEAA\
+\\x54CD\xAEAB\
+\\x54CE\xAEAC\
+\\x54CF\xAEAD\
+\\x54D0\xAEAE\
+\\x54D1\xAEAF\
+\\x54D2\xAEB0\
+\\x54D3\xAEB1\
+\\x54D4\xAEB2\
+\\x54D5\xAEB3\
+\\x54D6\xAEB4\
+\\x54D7\xAEB5\
+\\x54D8\xAEB6\
+\\x54D9\xAEB7\
+\\x54DA\xAEB8\
+\\x54DB\xAEB9\
+\\x54DC\xAEBA\
+\\x54DD\xAEBB\
+\\x54DE\xAEBC\
+\\x54DF\xAEBD\
+\\x54E0\xAEBE\
+\\x54E1\xAEBF\
+\\x54E2\xAEC0\
+\\x54E3\xAEC1\
+\\x54E4\xAEC2\
+\\x54E5\xAEC3\
+\\x54E6\xAEC4\
+\\x54E7\xAEC5\
+\\x54E8\xAEC6\
+\\x54E9\xAEC7\
+\\x54EA\xAEC8\
+\\x54EB\xAEC9\
+\\x54EC\xAECA\
+\\x54ED\xAECB\
+\\x54EE\xAECC\
+\\x54EF\xAECD\
+\\x54F0\xAECE\
+\\x54F1\xAECF\
+\\x54F2\xAED0\
+\\x54F3\xAED1\
+\\x54F4\xAED2\
+\\x54F5\xAED3\
+\\x54F6\xAED4\
+\\x54F7\xAED5\
+\\x54F8\xAED6\
+\\x54F9\xAED7\
+\\x54FA\xAED8\
+\\x54FB\xAED9\
+\\x54FC\xAEDA\
+\\x54FD\xAEDB\
+\\x5541\xAEDC\
+\\x5542\xAEDD\
+\\x5543\xAEDE\
+\\x5544\xAEDF\
+\\x5545\xAEE0\
+\\x5546\xAEE1\
+\\x5547\xAEE2\
+\\x5548\xAEE3\
+\\x5549\xAEE4\
+\\x554A\xAEE5\
+\\x554B\xAEE6\
+\\x554C\xAEE7\
+\\x554D\xAEE8\
+\\x554E\xAEE9\
+\\x554F\xAEEA\
+\\x5550\xAEEB\
+\\x5551\xAEEC\
+\\x5552\xAEED\
+\\x5553\xAEEE\
+\\x5554\xAEEF\
+\\x5555\xAEF0\
+\\x5556\xAEF1\
+\\x5557\xAEF2\
+\\x5558\xAEF3\
+\\x5559\xAEF4\
+\\x555A\xAEF5\
+\\x555B\xAEF6\
+\\x555C\xAEF7\
+\\x555D\xAEF8\
+\\x555E\xAEF9\
+\\x555F\xAEFA\
+\\x5560\xAEFB\
+\\x5561\xAEFC\
+\\x5562\xAEFD\
+\\x5563\xAEFE\
+\\x5564\xAF40\
+\\x5565\xAF41\
+\\x5566\xAF42\
+\\x5567\xAF43\
+\\x5568\xAF44\
+\\x5569\xAF45\
+\\x556A\xAF46\
+\\x556B\xAF47\
+\\x556C\xAF48\
+\\x556D\xAF49\
+\\x556E\xAF4A\
+\\x556F\xAF4B\
+\\x5570\xAF4C\
+\\x5571\xAF4D\
+\\x5572\xAF4E\
+\\x5573\xAF4F\
+\\x5574\xAF50\
+\\x5575\xAF51\
+\\x5576\xAF52\
+\\x5577\xAF53\
+\\x5578\xAF54\
+\\x5579\xAF55\
+\\x557A\xAF56\
+\\x557B\xAF57\
+\\x557C\xAF58\
+\\x557D\xAF59\
+\\x557E\xAF5A\
+\\x557F\xAF5B\
+\\x5581\xAF5C\
+\\x5582\xAF5D\
+\\x5583\xAF5E\
+\\x5584\xAF5F\
+\\x5585\xAF60\
+\\x5586\xAF61\
+\\x5587\xAF62\
+\\x5588\xAF63\
+\\x5589\xAF64\
+\\x558A\xAF65\
+\\x558B\xAF66\
+\\x558C\xAF67\
+\\x558D\xAF68\
+\\x558E\xAF69\
+\\x558F\xAF6A\
+\\x5590\xAF6B\
+\\x5591\xAF6C\
+\\x5592\xAF6D\
+\\x5593\xAF6E\
+\\x5594\xAF6F\
+\\x5595\xAF70\
+\\x5596\xAF71\
+\\x5597\xAF72\
+\\x5598\xAF73\
+\\x5599\xAF74\
+\\x559A\xAF75\
+\\x559B\xAF76\
+\\x559C\xAF77\
+\\x559D\xAF78\
+\\x559E\xAF79\
+\\x559F\xAF7A\
+\\x55A0\xAF7B\
+\\x55A1\xAF7C\
+\\x55A2\xAF7D\
+\\x55A3\xAF7E\
+\\x55A4\xAFA1\
+\\x55A5\xAFA2\
+\\x55A6\xAFA3\
+\\x55A7\xAFA4\
+\\x55A8\xAFA5\
+\\x55A9\xAFA6\
+\\x55AA\xAFA7\
+\\x55AB\xAFA8\
+\\x55AC\xAFA9\
+\\x55AD\xAFAA\
+\\x55AE\xAFAB\
+\\x55AF\xAFAC\
+\\x55B0\xAFAD\
+\\x55B1\xAFAE\
+\\x55B2\xAFAF\
+\\x55B3\xAFB0\
+\\x55B4\xAFB1\
+\\x55B5\xAFB2\
+\\x55B6\xAFB3\
+\\x55B7\xAFB4\
+\\x55B8\xAFB5\
+\\x55B9\xAFB6\
+\\x55BA\xAFB7\
+\\x55BB\xAFB8\
+\\x55BC\xAFB9\
+\\x55BD\xAFBA\
+\\x55BE\xAFBB\
+\\x55BF\xAFBC\
+\\x55C0\xAFBD\
+\\x55C1\xAFBE\
+\\x55C2\xAFBF\
+\\x55C3\xAFC0\
+\\x55C4\xAFC1\
+\\x55C5\xAFC2\
+\\x55C6\xAFC3\
+\\x55C7\xAFC4\
+\\x55C8\xAFC5\
+\\x55C9\xAFC6\
+\\x55CA\xAFC7\
+\\x55CB\xAFC8\
+\\x55CC\xAFC9\
+\\x55CD\xAFCA\
+\\x55CE\xAFCB\
+\\x55CF\xAFCC\
+\\x55D0\xAFCD\
+\\x55D1\xAFCE\
+\\x55D2\xAFCF\
+\\x55D3\xAFD0\
+\\x55D4\xAFD1\
+\\x55D5\xAFD2\
+\\x55D6\xAFD3\
+\\x55D7\xAFD4\
+\\x55D8\xAFD5\
+\\x55D9\xAFD6\
+\\x55DA\xAFD7\
+\\x55DB\xAFD8\
+\\x55DC\xAFD9\
+\\x55DD\xAFDA\
+\\x55DE\xAFDB\
+\\x55DF\xAFDC\
+\\x55E0\xAFDD\
+\\x55E1\xAFDE\
+\\x55E2\xAFDF\
+\\x55E3\xAFE0\
+\\x55E4\xAFE1\
+\\x55E5\xAFE2\
+\\x55E6\xAFE3\
+\\x55E7\xAFE4\
+\\x55E8\xAFE5\
+\\x55E9\xAFE6\
+\\x55EA\xAFE7\
+\\x55EB\xAFE8\
+\\x55EC\xAFE9\
+\\x55ED\xAFEA\
+\\x55EE\xAFEB\
+\\x55EF\xAFEC\
+\\x55F0\xAFED\
+\\x55F1\xAFEE\
+\\x55F2\xAFEF\
+\\x55F3\xAFF0\
+\\x55F4\xAFF1\
+\\x55F5\xAFF2\
+\\x55F6\xAFF3\
+\\x55F7\xAFF4\
+\\x55F8\xAFF5\
+\\x55F9\xAFF6\
+\\x55FA\xAFF7\
+\\x55FB\xAFF8\
+\\x55FC\xAFF9\
+\\x55FD\xAFFA\
+\\x5641\xAFFB\
+\\x5642\xAFFC\
+\\x5643\xAFFD\
+\\x5644\xAFFE\
+\\x5645\xB040\
+\\x5646\xB041\
+\\x5647\xB042\
+\\x5648\xB043\
+\\x5649\xB044\
+\\x564A\xB045\
+\\x564B\xB046\
+\\x564C\xB047\
+\\x564D\xB048\
+\\x564E\xB049\
+\\x564F\xB04A\
+\\x5650\xB04B\
+\\x5651\xB04C\
+\\x5652\xB04D\
+\\x5653\xB04E\
+\\x5654\xB04F\
+\\x5655\xB050\
+\\x5656\xB051\
+\\x5657\xB052\
+\\x5658\xB053\
+\\x5659\xB054\
+\\x565A\xB055\
+\\x565B\xB056\
+\\x565C\xB057\
+\\x565D\xB058\
+\\x565E\xB059\
+\\x565F\xB05A\
+\\x5660\xB05B\
+\\x5661\xB05C\
+\\x5662\xB05D\
+\\x5663\xB05E\
+\\x5664\xB05F\
+\\x5665\xB060\
+\\x5666\xB061\
+\\x5667\xB062\
+\\x5668\xB063\
+\\x5669\xB064\
+\\x566A\xB065\
+\\x566B\xB066\
+\\x566C\xB067\
+\\x566D\xB068\
+\\x566E\xB069\
+\\x566F\xB06A\
+\\x5670\xB06B\
+\\x5671\xB06C\
+\\x5672\xB06D\
+\\x5673\xB06E\
+\\x5674\xB06F\
+\\x5675\xB070\
+\\x5676\xB071\
+\\x5677\xB072\
+\\x5678\xB073\
+\\x5679\xB074\
+\\x567A\xB075\
+\\x567B\xB076\
+\\x567C\xB077\
+\\x567D\xB078\
+\\x567E\xB079\
+\\x567F\xB07A\
+\\x5681\xB07B\
+\\x5682\xB07C\
+\\x5683\xB07D\
+\\x5684\xB07E\
+\\x5685\xB0A1\
+\\x5686\xB0A2\
+\\x5687\xB0A3\
+\\x5688\xB0A4\
+\\x5689\xB0A5\
+\\x568A\xB0A6\
+\\x568B\xB0A7\
+\\x568C\xB0A8\
+\\x568D\xB0A9\
+\\x568E\xB0AA\
+\\x568F\xB0AB\
+\\x5690\xB0AC\
+\\x5691\xB0AD\
+\\x5692\xB0AE\
+\\x5693\xB0AF\
+\\x5694\xB0B0\
+\\x5695\xB0B1\
+\\x5696\xB0B2\
+\\x5697\xB0B3\
+\\x5698\xB0B4\
+\\x5699\xB0B5\
+\\x569A\xB0B6\
+\\x569B\xB0B7\
+\\x569C\xB0B8\
+\\x569D\xB0B9\
+\\x569E\xB0BA\
+\\x569F\xB0BB\
+\\x56A0\xB0BC\
+\\x56A1\xB0BD\
+\\x56A2\xB0BE\
+\\x56A3\xB0BF\
+\\x56A4\xB0C0\
+\\x56A5\xB0C1\
+\\x56A6\xB0C2\
+\\x56A7\xB0C3\
+\\x56A8\xB0C4\
+\\x56A9\xB0C5\
+\\x56AA\xB0C6\
+\\x56AB\xB0C7\
+\\x56AC\xB0C8\
+\\x56AD\xB0C9\
+\\x56AE\xB0CA\
+\\x56AF\xB0CB\
+\\x56B0\xB0CC\
+\\x56B1\xB0CD\
+\\x56B2\xB0CE\
+\\x56B3\xB0CF\
+\\x56B4\xB0D0\
+\\x56B5\xB0D1\
+\\x56B6\xB0D2\
+\\x56B7\xB0D3\
+\\x56B8\xB0D4\
+\\x56B9\xB0D5\
+\\x56BA\xB0D6\
+\\x56BB\xB0D7\
+\\x56BC\xB0D8\
+\\x56BD\xB0D9\
+\\x56BE\xB0DA\
+\\x56BF\xB0DB\
+\\x56C0\xB0DC\
+\\x56C1\xB0DD\
+\\x56C2\xB0DE\
+\\x56C3\xB0DF\
+\\x56C4\xB0E0\
+\\x56C5\xB0E1\
+\\x56C6\xB0E2\
+\\x56C7\xB0E3\
+\\x56C8\xB0E4\
+\\x56C9\xB0E5\
+\\x56CA\xB0E6\
+\\x56CB\xB0E7\
+\\x56CC\xB0E8\
+\\x56CD\xB0E9\
+\\x56CE\xB0EA\
+\\x56CF\xB0EB\
+\\x56D0\xB0EC\
+\\x56D1\xB0ED\
+\\x56D2\xB0EE\
+\\x56D3\xB0EF\
+\\x56D4\xB0F0\
+\\x56D5\xB0F1\
+\\x56D6\xB0F2\
+\\x56D7\xB0F3\
+\\x56D8\xB0F4\
+\\x56D9\xB0F5\
+\\x56DA\xB0F6\
+\\x56DB\xB0F7\
+\\x56DC\xB0F8\
+\\x56DD\xB0F9\
+\\x56DE\xB0FA\
+\\x56DF\xB0FB\
+\\x56E0\xB0FC\
+\\x56E1\xB0FD\
+\\x56E2\xB0FE\
+\\x56E3\xB140\
+\\x56E4\xB141\
+\\x56E5\xB142\
+\\x56E6\xB143\
+\\x56E7\xB144\
+\\x56E8\xB145\
+\\x56E9\xB146\
+\\x56EA\xB147\
+\\x56EB\xB148\
+\\x56EC\xB149\
+\\x56ED\xB14A\
+\\x56EE\xB14B\
+\\x56EF\xB14C\
+\\x56F0\xB14D\
+\\x56F1\xB14E\
+\\x56F2\xB14F\
+\\x56F3\xB150\
+\\x56F4\xB151\
+\\x56F5\xB152\
+\\x56F6\xB153\
+\\x56F7\xB154\
+\\x56F8\xB155\
+\\x56F9\xB156\
+\\x56FA\xB157\
+\\x56FB\xB158\
+\\x56FC\xB159\
+\\x56FD\xB15A\
+\\x5741\xB15B\
+\\x5742\xB15C\
+\\x5743\xB15D\
+\\x5744\xB15E\
+\\x5745\xB15F\
+\\x5746\xB160\
+\\x5747\xB161\
+\\x5748\xB162\
+\\x5749\xB163\
+\\x574A\xB164\
+\\x574B\xB165\
+\\x574C\xB166\
+\\x574D\xB167\
+\\x574E\xB168\
+\\x574F\xB169\
+\\x5750\xB16A\
+\\x5751\xB16B\
+\\x5752\xB16C\
+\\x5753\xB16D\
+\\x5754\xB16E\
+\\x5755\xB16F\
+\\x5756\xB170\
+\\x5757\xB171\
+\\x5758\xB172\
+\\x5759\xB173\
+\\x575A\xB174\
+\\x575B\xB175\
+\\x575C\xB176\
+\\x575D\xB177\
+\\x575E\xB178\
+\\x575F\xB179\
+\\x5760\xB17A\
+\\x5761\xB17B\
+\\x5762\xB17C\
+\\x5763\xB17D\
+\\x5764\xB17E\
+\\x5765\xB1A1\
+\\x5766\xB1A2\
+\\x5767\xB1A3\
+\\x5768\xB1A4\
+\\x5769\xB1A5\
+\\x576A\xB1A6\
+\\x576B\xB1A7\
+\\x576C\xB1A8\
+\\x576D\xB1A9\
+\\x576E\xB1AA\
+\\x576F\xB1AB\
+\\x5770\xB1AC\
+\\x5771\xB1AD\
+\\x5772\xB1AE\
+\\x5773\xB1AF\
+\\x5774\xB1B0\
+\\x5775\xB1B1\
+\\x5776\xB1B2\
+\\x5777\xB1B3\
+\\x5778\xB1B4\
+\\x5779\xB1B5\
+\\x577A\xB1B6\
+\\x577B\xB1B7\
+\\x577C\xB1B8\
+\\x577D\xB1B9\
+\\x577E\xB1BA\
+\\x577F\xB1BB\
+\\x5781\xB1BC\
+\\x5782\xB1BD\
+\\x5783\xB1BE\
+\\x5784\xB1BF\
+\\x5785\xB1C0\
+\\x5786\xB1C1\
+\\x5787\xB1C2\
+\\x5788\xB1C3\
+\\x5789\xB1C4\
+\\x578A\xB1C5\
+\\x578B\xB1C6\
+\\x578C\xB1C7\
+\\x578D\xB1C8\
+\\x578E\xB1C9\
+\\x578F\xB1CA\
+\\x5790\xB1CB\
+\\x5791\xB1CC\
+\\x5792\xB1CD\
+\\x5793\xB1CE\
+\\x5794\xB1CF\
+\\x5795\xB1D0\
+\\x5796\xB1D1\
+\\x5797\xB1D2\
+\\x5798\xB1D3\
+\\x5799\xB1D4\
+\\x579A\xB1D5\
+\\x579B\xB1D6\
+\\x579C\xB1D7\
+\\x579D\xB1D8\
+\\x579E\xB1D9\
+\\x579F\xB1DA\
+\\x57A0\xB1DB\
+\\x57A1\xB1DC\
+\\x57A2\xB1DD\
+\\x57A3\xB1DE\
+\\x57A4\xB1DF\
+\\x57A5\xB1E0\
+\\x57A6\xB1E1\
+\\x57A7\xB1E2\
+\\x57A8\xB1E3\
+\\x57A9\xB1E4\
+\\x57AA\xB1E5\
+\\x57AB\xB1E6\
+\\x57AC\xB1E7\
+\\x57AD\xB1E8\
+\\x57AE\xB1E9\
+\\x57AF\xB1EA\
+\\x57B0\xB1EB\
+\\x57B1\xB1EC\
+\\x57B2\xB1ED\
+\\x57B3\xB1EE\
+\\x57B4\xB1EF\
+\\x57B5\xB1F0\
+\\x57B6\xB1F1\
+\\x57B7\xB1F2\
+\\x57B8\xB1F3\
+\\x57B9\xB1F4\
+\\x57BA\xB1F5\
+\\x57BB\xB1F6\
+\\x57BC\xB1F7\
+\\x57BD\xB1F8\
+\\x57BE\xB1F9\
+\\x57BF\xB1FA\
+\\x57C0\xB1FB\
+\\x57C1\xB1FC\
+\\x57C2\xB1FD\
+\\x57C3\xB1FE\
+\\x57C4\xB240\
+\\x57C5\xB241\
+\\x57C6\xB242\
+\\x57C7\xB243\
+\\x57C8\xB244\
+\\x57C9\xB245\
+\\x57CA\xB246\
+\\x57CB\xB247\
+\\x57CC\xB248\
+\\x57CD\xB249\
+\\x57CE\xB24A\
+\\x57CF\xB24B\
+\\x57D0\xB24C\
+\\x57D1\xB24D\
+\\x57D2\xB24E\
+\\x57D3\xB24F\
+\\x57D4\xB250\
+\\x57D5\xB251\
+\\x57D6\xB252\
+\\x57D7\xB253\
+\\x57D8\xB254\
+\\x57D9\xB255\
+\\x57DA\xB256\
+\\x57DB\xB257\
+\\x57DC\xB258\
+\\x57DD\xB259\
+\\x57DE\xB25A\
+\\x57DF\xB25B\
+\\x57E0\xB25C\
+\\x57E1\xB25D\
+\\x57E2\xB25E\
+\\x57E3\xB25F\
+\\x57E4\xB260\
+\\x57E5\xB261\
+\\x57E6\xB262\
+\\x57E7\xB263\
+\\x57E8\xB264\
+\\x57E9\xB265\
+\\x57EA\xB266\
+\\x57EB\xB267\
+\\x57EC\xB268\
+\\x57ED\xB269\
+\\x57EE\xB26A\
+\\x57EF\xB26B\
+\\x57F0\xB26C\
+\\x57F1\xB26D\
+\\x57F2\xB26E\
+\\x57F3\xB26F\
+\\x57F4\xB270\
+\\x57F5\xB271\
+\\x57F6\xB272\
+\\x57F7\xB273\
+\\x57F8\xB274\
+\\x57F9\xB275\
+\\x57FA\xB276\
+\\x57FB\xB277\
+\\x57FC\xB278\
+\\x57FD\xB279\
+\\x5841\xB27A\
+\\x5842\xB27B\
+\\x5843\xB27C\
+\\x5844\xB27D\
+\\x5845\xB27E\
+\\x5846\xB2A1\
+\\x5847\xB2A2\
+\\x5848\xB2A3\
+\\x5849\xB2A4\
+\\x584A\xB2A5\
+\\x584B\xB2A6\
+\\x584C\xB2A7\
+\\x584D\xB2A8\
+\\x584E\xB2A9\
+\\x584F\xB2AA\
+\\x5850\xB2AB\
+\\x5851\xB2AC\
+\\x5852\xB2AD\
+\\x5853\xB2AE\
+\\x5854\xB2AF\
+\\x5855\xB2B0\
+\\x5856\xB2B1\
+\\x5857\xB2B2\
+\\x5858\xB2B3\
+\\x5859\xB2B4\
+\\x585A\xB2B5\
+\\x585B\xB2B6\
+\\x585C\xB2B7\
+\\x585D\xB2B8\
+\\x585E\xB2B9\
+\\x585F\xB2BA\
+\\x5860\xB2BB\
+\\x5861\xB2BC\
+\\x5862\xB2BD\
+\\x5863\xB2BE\
+\\x5864\xB2BF\
+\\x5865\xB2C0\
+\\x5866\xB2C1\
+\\x5867\xB2C2\
+\\x5868\xB2C3\
+\\x5869\xB2C4\
+\\x586A\xB2C5\
+\\x586B\xB2C6\
+\\x586C\xB2C7\
+\\x586D\xB2C8\
+\\x586E\xB2C9\
+\\x586F\xB2CA\
+\\x5870\xB2CB\
+\\x5871\xB2CC\
+\\x5872\xB2CD\
+\\x5873\xB2CE\
+\\x5874\xB2CF\
+\\x5875\xB2D0\
+\\x5876\xB2D1\
+\\x5877\xB2D2\
+\\x5878\xB2D3\
+\\x5879\xB2D4\
+\\x587A\xB2D5\
+\\x587B\xB2D6\
+\\x587C\xB2D7\
+\\x587D\xB2D8\
+\\x587E\xB2D9\
+\\x587F\xB2DA\
+\\x5881\xB2DB\
+\\x5882\xB2DC\
+\\x5883\xB2DD\
+\\x5884\xB2DE\
+\\x5885\xB2DF\
+\\x5886\xB2E0\
+\\x5887\xB2E1\
+\\x5888\xB2E2\
+\\x5889\xB2E3\
+\\x588A\xB2E4\
+\\x588B\xB2E5\
+\\x588C\xB2E6\
+\\x588D\xB2E7\
+\\x588E\xB2E8\
+\\x588F\xB2E9\
+\\x5890\xB2EA\
+\\x5891\xB2EB\
+\\x5892\xB2EC\
+\\x5893\xB2ED\
+\\x5894\xB2EE\
+\\x5895\xB2EF\
+\\x5896\xB2F0\
+\\x5897\xB2F1\
+\\x5898\xB2F2\
+\\x5899\xB2F3\
+\\x589A\xB2F4\
+\\x589B\xB2F5\
+\\x589C\xB2F6\
+\\x589D\xB2F7\
+\\x589E\xB2F8\
+\\x589F\xB2F9\
+\\x58A0\xB2FA\
+\\x58A1\xB2FB\
+\\x58A2\xB2FC\
+\\x58A3\xB2FD\
+\\x58A4\xB2FE\
+\\x58A5\xB340\
+\\x58A6\xB341\
+\\x58A7\xB342\
+\\x58A8\xB343\
+\\x58A9\xB344\
+\\x58AA\xB345\
+\\x58AB\xB346\
+\\x58AC\xB347\
+\\x58AD\xB348\
+\\x58AE\xB349\
+\\x58AF\xB34A\
+\\x58B0\xB34B\
+\\x58B1\xB34C\
+\\x58B2\xB34D\
+\\x58B3\xB34E\
+\\x58B4\xB34F\
+\\x58B5\xB350\
+\\x58B6\xB351\
+\\x58B7\xB352\
+\\x58B8\xB353\
+\\x58B9\xB354\
+\\x58BA\xB355\
+\\x58BB\xB356\
+\\x58BC\xB357\
+\\x58BD\xB358\
+\\x58BE\xB359\
+\\x58BF\xB35A\
+\\x58C0\xB35B\
+\\x58C1\xB35C\
+\\x58C2\xB35D\
+\\x58C3\xB35E\
+\\x58C4\xB35F\
+\\x58C5\xB360\
+\\x58C6\xB361\
+\\x58C7\xB362\
+\\x58C8\xB363\
+\\x58C9\xB364\
+\\x58CA\xB365\
+\\x58CB\xB366\
+\\x58CC\xB367\
+\\x58CD\xB368\
+\\x58CE\xB369\
+\\x58CF\xB36A\
+\\x58D0\xB36B\
+\\x58D1\xB36C\
+\\x58D2\xB36D\
+\\x58D3\xB36E\
+\\x58D4\xB36F\
+\\x58D5\xB370\
+\\x58D6\xB371\
+\\x58D7\xB372\
+\\x58D8\xB373\
+\\x58D9\xB374\
+\\x58DA\xB375\
+\\x58DB\xB376\
+\\x58DC\xB377\
+\\x58DD\xB378\
+\\x58DE\xB379\
+\\x58DF\xB37A\
+\\x58E0\xB37B\
+\\x58E1\xB37C\
+\\x58E2\xB37D\
+\\x58E3\xB37E\
+\\x58E4\xB3A1\
+\\x58E5\xB3A2\
+\\x58E6\xB3A3\
+\\x58E7\xB3A4\
+\\x58E8\xB3A5\
+\\x58E9\xB3A6\
+\\x58EA\xB3A7\
+\\x58EB\xB3A8\
+\\x58EC\xB3A9\
+\\x58ED\xB3AA\
+\\x58EE\xB3AB\
+\\x58EF\xB3AC\
+\\x58F0\xB3AD\
+\\x58F1\xB3AE\
+\\x58F2\xB3AF\
+\\x58F3\xB3B0\
+\\x58F4\xB3B1\
+\\x58F5\xB3B2\
+\\x58F6\xB3B3\
+\\x58F7\xB3B4\
+\\x58F8\xB3B5\
+\\x58F9\xB3B6\
+\\x58FA\xB3B7\
+\\x58FB\xB3B8\
+\\x58FC\xB3B9\
+\\x58FD\xB3BA\
+\\x5941\xB3BB\
+\\x5942\xB3BC\
+\\x5943\xB3BD\
+\\x5944\xB3BE\
+\\x5945\xB3BF\
+\\x5946\xB3C0\
+\\x5947\xB3C1\
+\\x5948\xB3C2\
+\\x5949\xB3C3\
+\\x594A\xB3C4\
+\\x594B\xB3C5\
+\\x594C\xB3C6\
+\\x594D\xB3C7\
+\\x594E\xB3C8\
+\\x594F\xB3C9\
+\\x5950\xB3CA\
+\\x5951\xB3CB\
+\\x5952\xB3CC\
+\\x5953\xB3CD\
+\\x5954\xB3CE\
+\\x5955\xB3CF\
+\\x5956\xB3D0\
+\\x5957\xB3D1\
+\\x5958\xB3D2\
+\\x5959\xB3D3\
+\\x595A\xB3D4\
+\\x595B\xB3D5\
+\\x595C\xB3D6\
+\\x595D\xB3D7\
+\\x595E\xB3D8\
+\\x595F\xB3D9\
+\\x5960\xB3DA\
+\\x5961\xB3DB\
+\\x5962\xB3DC\
+\\x5963\xB3DD\
+\\x5964\xB3DE\
+\\x5965\xB3DF\
+\\x5966\xB3E0\
+\\x5967\xB3E1\
+\\x5968\xB3E2\
+\\x5969\xB3E3\
+\\x596A\xB3E4\
+\\x596B\xB3E5\
+\\x596C\xB3E6\
+\\x596D\xB3E7\
+\\x596E\xB3E8\
+\\x596F\xB3E9\
+\\x5970\xB3EA\
+\\x5971\xB3EB\
+\\x5972\xB3EC\
+\\x5973\xB3ED\
+\\x5974\xB3EE\
+\\x5975\xB3EF\
+\\x5976\xB3F0\
+\\x5977\xB3F1\
+\\x5978\xB3F2\
+\\x5979\xB3F3\
+\\x597A\xB3F4\
+\\x597B\xB3F5\
+\\x597C\xB3F6\
+\\x597D\xB3F7\
+\\x597E\xB3F8\
+\\x597F\xB3F9\
+\\x5981\xB3FA\
+\\x5982\xB3FB\
+\\x5983\xB3FC\
+\\x5984\xB3FD\
+\\x5985\xB3FE\
+\\x5986\xB440\
+\\x5987\xB441\
+\\x5988\xB442\
+\\x5989\xB443\
+\\x598A\xB444\
+\\x598B\xB445\
+\\x598C\xB446\
+\\x598D\xB447\
+\\x598E\xB448\
+\\x598F\xB449\
+\\x5990\xB44A\
+\\x5991\xB44B\
+\\x5992\xB44C\
+\\x5993\xB44D\
+\\x5994\xB44E\
+\\x5995\xB44F\
+\\x5996\xB450\
+\\x5997\xB451\
+\\x5998\xB452\
+\\x5999\xB453\
+\\x599A\xB454\
+\\x599B\xB455\
+\\x599C\xB456\
+\\x599D\xB457\
+\\x599E\xB458\
+\\x599F\xB459\
+\\x59A0\xB45A\
+\\x59A1\xB45B\
+\\x59A2\xB45C\
+\\x59A3\xB45D\
+\\x59A4\xB45E\
+\\x59A5\xB45F\
+\\x59A6\xB460\
+\\x59A7\xB461\
+\\x59A8\xB462\
+\\x59A9\xB463\
+\\x59AA\xB464\
+\\x59AB\xB465\
+\\x59AC\xB466\
+\\x59AD\xB467\
+\\x59AE\xB468\
+\\x59AF\xB469\
+\\x59B0\xB46A\
+\\x59B1\xB46B\
+\\x59B2\xB46C\
+\\x59B3\xB46D\
+\\x59B4\xB46E\
+\\x59B5\xB46F\
+\\x59B6\xB470\
+\\x59B7\xB471\
+\\x59B8\xB472\
+\\x59B9\xB473\
+\\x59BA\xB474\
+\\x59BB\xB475\
+\\x59BC\xB476\
+\\x59BD\xB477\
+\\x59BE\xB478\
+\\x59BF\xB479\
+\\x59C0\xB47A\
+\\x59C1\xB47B\
+\\x59C2\xB47C\
+\\x59C3\xB47D\
+\\x59C4\xB47E\
+\\x59C5\xB4A1\
+\\x59C6\xB4A2\
+\\x59C7\xB4A3\
+\\x59C8\xB4A4\
+\\x59C9\xB4A5\
+\\x59CA\xB4A6\
+\\x59CB\xB4A7\
+\\x59CC\xB4A8\
+\\x59CD\xB4A9\
+\\x59CE\xB4AA\
+\\x59CF\xB4AB\
+\\x59D0\xB4AC\
+\\x59D1\xB4AD\
+\\x59D2\xB4AE\
+\\x59D3\xB4AF\
+\\x59D4\xB4B0\
+\\x59D5\xB4B1\
+\\x59D6\xB4B2\
+\\x59D7\xB4B3\
+\\x59D8\xB4B4\
+\\x59D9\xB4B5\
+\\x59DA\xB4B6\
+\\x59DB\xB4B7\
+\\x59DC\xB4B8\
+\\x59DD\xB4B9\
+\\x59DE\xB4BA\
+\\x59DF\xB4BB\
+\\x59E0\xB4BC\
+\\x59E1\xB4BD\
+\\x59E2\xB4BE\
+\\x59E3\xB4BF\
+\\x59E4\xB4C0\
+\\x59E5\xB4C1\
+\\x59E6\xB4C2\
+\\x59E7\xB4C3\
+\\x59E8\xB4C4\
+\\x59E9\xB4C5\
+\\x59EA\xB4C6\
+\\x59EB\xB4C7\
+\\x59EC\xB4C8\
+\\x59ED\xB4C9\
+\\x59EE\xB4CA\
+\\x59EF\xB4CB\
+\\x59F0\xB4CC\
+\\x59F1\xB4CD\
+\\x59F2\xB4CE\
+\\x59F3\xB4CF\
+\\x59F4\xB4D0\
+\\x59F5\xB4D1\
+\\x59F6\xB4D2\
+\\x59F7\xB4D3\
+\\x59F8\xB4D4\
+\\x59F9\xB4D5\
+\\x59FA\xB4D6\
+\\x59FB\xB4D7\
+\\x59FC\xB4D8\
+\\x59FD\xB4D9\
+\\x5A41\xB4DA\
+\\x5A42\xB4DB\
+\\x5A43\xB4DC\
+\\x5A44\xB4DD\
+\\x5A45\xB4DE\
+\\x5A46\xB4DF\
+\\x5A47\xB4E0\
+\\x5A48\xB4E1\
+\\x5A49\xB4E2\
+\\x5A4A\xB4E3\
+\\x5A4B\xB4E4\
+\\x5A4C\xB4E5\
+\\x5A4D\xB4E6\
+\\x5A4E\xB4E7\
+\\x5A4F\xB4E8\
+\\x5A50\xB4E9\
+\\x5A51\xB4EA\
+\\x5A52\xB4EB\
+\\x5A53\xB4EC\
+\\x5A54\xB4ED\
+\\x5A55\xB4EE\
+\\x5A56\xB4EF\
+\\x5A57\xB4F0\
+\\x5A58\xB4F1\
+\\x5A59\xB4F2\
+\\x5A5A\xB4F3\
+\\x5A5B\xB4F4\
+\\x5A5C\xB4F5\
+\\x5A5D\xB4F6\
+\\x5A5E\xB4F7\
+\\x5A5F\xB4F8\
+\\x5A60\xB4F9\
+\\x5A61\xB4FA\
+\\x5A62\xB4FB\
+\\x5A63\xB4FC\
+\\x5A64\xB4FD\
+\\x5A65\xB4FE\
+\\x5A66\xB540\
+\\x5A67\xB541\
+\\x5A68\xB542\
+\\x5A69\xB543\
+\\x5A6A\xB544\
+\\x5A6B\xB545\
+\\x5A6C\xB546\
+\\x5A6D\xB547\
+\\x5A6E\xB548\
+\\x5A6F\xB549\
+\\x5A70\xB54A\
+\\x5A71\xB54B\
+\\x5A72\xB54C\
+\\x5A73\xB54D\
+\\x5A74\xB54E\
+\\x5A75\xB54F\
+\\x5A76\xB550\
+\\x5A77\xB551\
+\\x5A78\xB552\
+\\x5A79\xB553\
+\\x5A7A\xB554\
+\\x5A7B\xB555\
+\\x5A7C\xB556\
+\\x5A7D\xB557\
+\\x5A7E\xB558\
+\\x5A7F\xB559\
+\\x5A81\xB55A\
+\\x5A82\xB55B\
+\\x5A83\xB55C\
+\\x5A84\xB55D\
+\\x5A85\xB55E\
+\\x5A86\xB55F\
+\\x5A87\xB560\
+\\x5A88\xB561\
+\\x5A89\xB562\
+\\x5A8A\xB563\
+\\x5A8B\xB564\
+\\x5A8C\xB565\
+\\x5A8D\xB566\
+\\x5A8E\xB567\
+\\x5A8F\xB568\
+\\x5A90\xB569\
+\\x5A91\xB56A\
+\\x5A92\xB56B\
+\\x5A93\xB56C\
+\\x5A94\xB56D\
+\\x5A95\xB56E\
+\\x5A96\xB56F\
+\\x5A97\xB570\
+\\x5A98\xB571\
+\\x5A99\xB572\
+\\x5A9A\xB573\
+\\x5A9B\xB574\
+\\x5A9C\xB575\
+\\x5A9D\xB576\
+\\x5A9E\xB577\
+\\x5A9F\xB578\
+\\x5AA0\xB579\
+\\x5AA1\xB57A\
+\\x5AA2\xB57B\
+\\x5AA3\xB57C\
+\\x5AA4\xB57D\
+\\x5AA5\xB57E\
+\\x5AA6\xB5A1\
+\\x5AA7\xB5A2\
+\\x5AA8\xB5A3\
+\\x5AA9\xB5A4\
+\\x5AAA\xB5A5\
+\\x5AAB\xB5A6\
+\\x5AAC\xB5A7\
+\\x5AAD\xB5A8\
+\\x5AAE\xB5A9\
+\\x5AAF\xB5AA\
+\\x5AB0\xB5AB\
+\\x5AB1\xB5AC\
+\\x5AB2\xB5AD\
+\\x5AB3\xB5AE\
+\\x5AB4\xB5AF\
+\\x5AB5\xB5B0\
+\\x5AB6\xB5B1\
+\\x5AB7\xB5B2\
+\\x5AB8\xB5B3\
+\\x5AB9\xB5B4\
+\\x5ABA\xB5B5\
+\\x5ABB\xB5B6\
+\\x5ABC\xB5B7\
+\\x5ABD\xB5B8\
+\\x5ABE\xB5B9\
+\\x5ABF\xB5BA\
+\\x5AC0\xB5BB\
+\\x5AC1\xB5BC\
+\\x5AC2\xB5BD\
+\\x5AC3\xB5BE\
+\\x5AC4\xB5BF\
+\\x5AC5\xB5C0\
+\\x5AC6\xB5C1\
+\\x5AC7\xB5C2\
+\\x5AC8\xB5C3\
+\\x5AC9\xB5C4\
+\\x5ACA\xB5C5\
+\\x5ACB\xB5C6\
+\\x5ACC\xB5C7\
+\\x5ACD\xB5C8\
+\\x5ACE\xB5C9\
+\\x5ACF\xB5CA\
+\\x5AD0\xB5CB\
+\\x5AD1\xB5CC\
+\\x5AD2\xB5CD\
+\\x5AD3\xB5CE\
+\\x5AD4\xB5CF\
+\\x5AD5\xB5D0\
+\\x5AD6\xB5D1\
+\\x5AD7\xB5D2\
+\\x5AD8\xB5D3\
+\\x5AD9\xB5D4\
+\\x5ADA\xB5D5\
+\\x5ADB\xB5D6\
+\\x5ADC\xB5D7\
+\\x5ADD\xB5D8\
+\\x5ADE\xB5D9\
+\\x5ADF\xB5DA\
+\\x5AE0\xB5DB\
+\\x5AE1\xB5DC\
+\\x5AE2\xB5DD\
+\\x5AE3\xB5DE\
+\\x5AE4\xB5DF\
+\\x5AE5\xB5E0\
+\\x5AE6\xB5E1\
+\\x5AE7\xB5E2\
+\\x5AE8\xB5E3\
+\\x5AE9\xB5E4\
+\\x5AEA\xB5E5\
+\\x5AEB\xB5E6\
+\\x5AEC\xB5E7\
+\\x5AED\xB5E8\
+\\x5AEE\xB5E9\
+\\x5AEF\xB5EA\
+\\x5AF0\xB5EB\
+\\x5AF1\xB5EC\
+\\x5AF2\xB5ED\
+\\x5AF3\xB5EE\
+\\x5AF4\xB5EF\
+\\x5AF5\xB5F0\
+\\x5AF6\xB5F1\
+\\x5AF7\xB5F2\
+\\x5AF8\xB5F3\
+\\x5AF9\xB5F4\
+\\x5AFA\xB5F5\
+\\x5AFB\xB5F6\
+\\x5AFC\xB5F7\
+\\x5AFD\xB5F8\
+\\x5B41\xB5F9\
+\\x5B42\xB5FA\
+\\x5B43\xB5FB\
+\\x5B44\xB5FC\
+\\x5B45\xB5FD\
+\\x5B46\xB5FE\
+\\x5B47\xB640\
+\\x5B48\xB641\
+\\x5B49\xB642\
+\\x5B4A\xB643\
+\\x5B4B\xB644\
+\\x5B4C\xB645\
+\\x5B4D\xB646\
+\\x5B4E\xB647\
+\\x5B4F\xB648\
+\\x5B50\xB649\
+\\x5B51\xB64A\
+\\x5B52\xB64B\
+\\x5B53\xB64C\
+\\x5B54\xB64D\
+\\x5B55\xB64E\
+\\x5B56\xB64F\
+\\x5B57\xB650\
+\\x5B58\xB651\
+\\x5B59\xB652\
+\\x5B5A\xB653\
+\\x5B5B\xB654\
+\\x5B5C\xB655\
+\\x5B5D\xB656\
+\\x5B5E\xB657\
+\\x5B5F\xB658\
+\\x5B60\xB659\
+\\x5B61\xB65A\
+\\x5B62\xB65B\
+\\x5B63\xB65C\
+\\x5B64\xB65D\
+\\x5B65\xB65E\
+\\x5B66\xB65F\
+\\x5B67\xB660\
+\\x5B68\xB661\
+\\x5B69\xB662\
+\\x5B6A\xB663\
+\\x5B6B\xB664\
+\\x5B6C\xB665\
+\\x5B6D\xB666\
+\\x5B6E\xB667\
+\\x5B6F\xB668\
+\\x5B70\xB669\
+\\x5B71\xB66A\
+\\x5B72\xB66B\
+\\x5B73\xB66C\
+\\x5B74\xB66D\
+\\x5B75\xB66E\
+\\x5B76\xB66F\
+\\x5B77\xB670\
+\\x5B78\xB671\
+\\x5B79\xB672\
+\\x5B7A\xB673\
+\\x5B7B\xB674\
+\\x5B7C\xB675\
+\\x5B7D\xB676\
+\\x5B7E\xB677\
+\\x5B7F\xB678\
+\\x5B81\xB679\
+\\x5B82\xB67A\
+\\x5B83\xB67B\
+\\x5B84\xB67C\
+\\x5B85\xB67D\
+\\x5B86\xB67E\
+\\x5B87\xB6A1\
+\\x5B88\xB6A2\
+\\x5B89\xB6A3\
+\\x5B8A\xB6A4\
+\\x5B8B\xB6A5\
+\\x5B8C\xB6A6\
+\\x5B8D\xB6A7\
+\\x5B8E\xB6A8\
+\\x5B8F\xB6A9\
+\\x5B90\xB6AA\
+\\x5B91\xB6AB\
+\\x5B92\xB6AC\
+\\x5B93\xB6AD\
+\\x5B94\xB6AE\
+\\x5B95\xB6AF\
+\\x5B96\xB6B0\
+\\x5B97\xB6B1\
+\\x5B98\xB6B2\
+\\x5B99\xB6B3\
+\\x5B9A\xB6B4\
+\\x5B9B\xB6B5\
+\\x5B9C\xB6B6\
+\\x5B9D\xB6B7\
+\\x5B9E\xB6B8\
+\\x5B9F\xB6B9\
+\\x5BA0\xB6BA\
+\\x5BA1\xB6BB\
+\\x5BA2\xB6BC\
+\\x5BA3\xB6BD\
+\\x5BA4\xB6BE\
+\\x5BA5\xB6BF\
+\\x5BA6\xB6C0\
+\\x5BA7\xB6C1\
+\\x5BA8\xB6C2\
+\\x5BA9\xB6C3\
+\\x5BAA\xB6C4\
+\\x5BAB\xB6C5\
+\\x5BAC\xB6C6\
+\\x5BAD\xB6C7\
+\\x5BAE\xB6C8\
+\\x5BAF\xB6C9\
+\\x5BB0\xB6CA\
+\\x5BB1\xB6CB\
+\\x5BB2\xB6CC\
+\\x5BB3\xB6CD\
+\\x5BB4\xB6CE\
+\\x5BB5\xB6CF\
+\\x5BB6\xB6D0\
+\\x5BB7\xB6D1\
+\\x5BB8\xB6D2\
+\\x5BB9\xB6D3\
+\\x5BBA\xB6D4\
+\\x5BBB\xB6D5\
+\\x5BBC\xB6D6\
+\\x5BBD\xB6D7\
+\\x5BBE\xB6D8\
+\\x5BBF\xB6D9\
+\\x5BC0\xB6DA\
+\\x5BC1\xB6DB\
+\\x5BC2\xB6DC\
+\\x5BC3\xB6DD\
+\\x5BC4\xB6DE\
+\\x5BC5\xB6DF\
+\\x5BC6\xB6E0\
+\\x5BC7\xB6E1\
+\\x5BC8\xB6E2\
+\\x5BC9\xB6E3\
+\\x5BCA\xB6E4\
+\\x5BCB\xB6E5\
+\\x5BCC\xB6E6\
+\\x5BCD\xB6E7\
+\\x5BCE\xB6E8\
+\\x5BCF\xB6E9\
+\\x5BD0\xB6EA\
+\\x5BD1\xB6EB\
+\\x5BD2\xB6EC\
+\\x5BD3\xB6ED\
+\\x5BD4\xB6EE\
+\\x5BD5\xB6EF\
+\\x5BD6\xB6F0\
+\\x5BD7\xB6F1\
+\\x5BD8\xB6F2\
+\\x5BD9\xB6F3\
+\\x5BDA\xB6F4\
+\\x5BDB\xB6F5\
+\\x5BDC\xB6F6\
+\\x5BDD\xB6F7\
+\\x5BDE\xB6F8\
+\\x5BDF\xB6F9\
+\\x5BE0\xB6FA\
+\\x5BE1\xB6FB\
+\\x5BE2\xB6FC\
+\\x5BE3\xB6FD\
+\\x5BE4\xB6FE\
+\\x5BE5\xB740\
+\\x5BE6\xB741\
+\\x5BE7\xB742\
+\\x5BE8\xB743\
+\\x5BE9\xB744\
+\\x5BEA\xB745\
+\\x5BEB\xB746\
+\\x5BEC\xB747\
+\\x5BED\xB748\
+\\x5BEE\xB749\
+\\x5BEF\xB74A\
+\\x5BF0\xB74B\
+\\x5BF1\xB74C\
+\\x5BF2\xB74D\
+\\x5BF3\xB74E\
+\\x5BF4\xB74F\
+\\x5BF5\xB750\
+\\x5BF6\xB751\
+\\x5BF7\xB752\
+\\x5BF8\xB753\
+\\x5BF9\xB754\
+\\x5BFA\xB755\
+\\x5BFB\xB756\
+\\x5BFC\xB757\
+\\x5BFD\xB758\
+\\x5C41\xB759\
+\\x5C42\xB75A\
+\\x5C43\xB75B\
+\\x5C44\xB75C\
+\\x5C45\xB75D\
+\\x5C46\xB75E\
+\\x5C47\xB75F\
+\\x5C48\xB760\
+\\x5C49\xB761\
+\\x5C4A\xB762\
+\\x5C4B\xB763\
+\\x5C4C\xB764\
+\\x5C4D\xB765\
+\\x5C4E\xB766\
+\\x5C4F\xB767\
+\\x5C50\xB768\
+\\x5C51\xB769\
+\\x5C52\xB76A\
+\\x5C53\xB76B\
+\\x5C54\xB76C\
+\\x5C55\xB76D\
+\\x5C56\xB76E\
+\\x5C57\xB76F\
+\\x5C58\xB770\
+\\x5C59\xB771\
+\\x5C5A\xB772\
+\\x5C5B\xB773\
+\\x5C5C\xB774\
+\\x5C5D\xB775\
+\\x5C5E\xB776\
+\\x5C5F\xB777\
+\\x5C60\xB778\
+\\x5C61\xB779\
+\\x5C62\xB77A\
+\\x5C63\xB77B\
+\\x5C64\xB77C\
+\\x5C65\xB77D\
+\\x5C66\xB77E\
+\\x5C67\xB7A1\
+\\x5C68\xB7A2\
+\\x5C69\xB7A3\
+\\x5C6A\xB7A4\
+\\x5C6B\xB7A5\
+\\x5C6C\xB7A6\
+\\x5C6D\xB7A7\
+\\x5C6E\xB7A8\
+\\x5C6F\xB7A9\
+\\x5C70\xB7AA\
+\\x5C71\xB7AB\
+\\x5C72\xB7AC\
+\\x5C73\xB7AD\
+\\x5C74\xB7AE\
+\\x5C75\xB7AF\
+\\x5C76\xB7B0\
+\\x5C77\xB7B1\
+\\x5C78\xB7B2\
+\\x5C79\xB7B3\
+\\x5C7A\xB7B4\
+\\x5C7B\xB7B5\
+\\x5C7C\xB7B6\
+\\x5C7D\xB7B7\
+\\x5C7E\xB7B8\
+\\x5C7F\xB7B9\
+\\x5C81\xB7BA\
+\\x5C82\xB7BB\
+\\x5C83\xB7BC\
+\\x5C84\xB7BD\
+\\x5C85\xB7BE\
+\\x5C86\xB7BF\
+\\x5C87\xB7C0\
+\\x5C88\xB7C1\
+\\x5C89\xB7C2\
+\\x5C8A\xB7C3\
+\\x5C8B\xB7C4\
+\\x5C8C\xB7C5\
+\\x5C8D\xB7C6\
+\\x5C8E\xB7C7\
+\\x5C8F\xB7C8\
+\\x5C90\xB7C9\
+\\x5C91\xB7CA\
+\\x5C92\xB7CB\
+\\x5C93\xB7CC\
+\\x5C94\xB7CD\
+\\x5C95\xB7CE\
+\\x5C96\xB7CF\
+\\x5C97\xB7D0\
+\\x5C98\xB7D1\
+\\x5C99\xB7D2\
+\\x5C9A\xB7D3\
+\\x5C9B\xB7D4\
+\\x5C9C\xB7D5\
+\\x5C9D\xB7D6\
+\\x5C9E\xB7D7\
+\\x5C9F\xB7D8\
+\\x5CA0\xB7D9\
+\\x5CA1\xB7DA\
+\\x5CA2\xB7DB\
+\\x5CA3\xB7DC\
+\\x5CA4\xB7DD\
+\\x5CA5\xB7DE\
+\\x5CA6\xB7DF\
+\\x5CA7\xB7E0\
+\\x5CA8\xB7E1\
+\\x5CA9\xB7E2\
+\\x5CAA\xB7E3\
+\\x5CAB\xB7E4\
+\\x5CAC\xB7E5\
+\\x5CAD\xB7E6\
+\\x5CAE\xB7E7\
+\\x5CAF\xB7E8\
+\\x5CB0\xB7E9\
+\\x5CB1\xB7EA\
+\\x5CB2\xB7EB\
+\\x5CB3\xB7EC\
+\\x5CB4\xB7ED\
+\\x5CB5\xB7EE\
+\\x5CB6\xB7EF\
+\\x5CB7\xB7F0\
+\\x5CB8\xB7F1\
+\\x5CB9\xB7F2\
+\\x5CBA\xB7F3\
+\\x5CBB\xB7F4\
+\\x5CBC\xB7F5\
+\\x5CBD\xB7F6\
+\\x5CBE\xB7F7\
+\\x5CBF\xB7F8\
+\\x5CC0\xB7F9\
+\\x5CC1\xB7FA\
+\\x5CC2\xB7FB\
+\\x5CC3\xB7FC\
+\\x5CC4\xB7FD\
+\\x5CC5\xB7FE\
+\\x5CC6\xB840\
+\\x5CC7\xB841\
+\\x5CC8\xB842\
+\\x5CC9\xB843\
+\\x5CCA\xB844\
+\\x5CCB\xB845\
+\\x5CCC\xB846\
+\\x5CCD\xB847\
+\\x5CCE\xB848\
+\\x5CCF\xB849\
+\\x5CD0\xB84A\
+\\x5CD1\xB84B\
+\\x5CD2\xB84C\
+\\x5CD3\xB84D\
+\\x5CD4\xB84E\
+\\x5CD5\xB84F\
+\\x5CD6\xB850\
+\\x5CD7\xB851\
+\\x5CD8\xB852\
+\\x5CD9\xB853\
+\\x5CDA\xB854\
+\\x5CDB\xB855\
+\\x5CDC\xB856\
+\\x5CDD\xB857\
+\\x5CDE\xB858\
+\\x5CDF\xB859\
+\\x5CE0\xB85A\
+\\x5CE1\xB85B\
+\\x5CE2\xB85C\
+\\x5CE3\xB85D\
+\\x5CE4\xB85E\
+\\x5CE5\xB85F\
+\\x5CE6\xB860\
+\\x5CE7\xB861\
+\\x5CE8\xB862\
+\\x5CE9\xB863\
+\\x5CEA\xB864\
+\\x5CEB\xB865\
+\\x5CEC\xB866\
+\\x5CED\xB867\
+\\x5CEE\xB868\
+\\x5CEF\xB869\
+\\x5CF0\xB86A\
+\\x5CF1\xB86B\
+\\x5CF2\xB86C\
+\\x5CF3\xB86D\
+\\x5CF4\xB86E\
+\\x5CF5\xB86F\
+\\x5CF6\xB870\
+\\x5CF7\xB871\
+\\x5CF8\xB872\
+\\x5CF9\xB873\
+\\x5CFA\xB874\
+\\x5CFB\xB875\
+\\x5CFC\xB876\
+\\x5CFD\xB877\
+\\x5D41\xB878\
+\\x5D42\xB879\
+\\x5D43\xB87A\
+\\x5D44\xB87B\
+\\x5D45\xB87C\
+\\x5D46\xB87D\
+\\x5D47\xB87E\
+\\x5D48\xB8A1\
+\\x5D49\xB8A2\
+\\x5D4A\xB8A3\
+\\x5D4B\xB8A4\
+\\x5D4C\xB8A5\
+\\x5D4D\xB8A6\
+\\x5D4E\xB8A7\
+\\x5D4F\xB8A8\
+\\x5D50\xB8A9\
+\\x5D51\xB8AA\
+\\x5D52\xB8AB\
+\\x5D53\xB8AC\
+\\x5D54\xB8AD\
+\\x5D55\xB8AE\
+\\x5D56\xB8AF\
+\\x5D57\xB8B0\
+\\x5D58\xB8B1\
+\\x5D59\xB8B2\
+\\x5D5A\xB8B3\
+\\x5D5B\xB8B4\
+\\x5D5C\xB8B5\
+\\x5D5D\xB8B6\
+\\x5D5E\xB8B7\
+\\x5D5F\xB8B8\
+\\x5D60\xB8B9\
+\\x5D61\xB8BA\
+\\x5D62\xB8BB\
+\\x5D63\xB8BC\
+\\x5D64\xB8BD\
+\\x5D65\xB8BE\
+\\x5D66\xB8BF\
+\\x5D67\xB8C0\
+\\x5D68\xB8C1\
+\\x5D69\xB8C2\
+\\x5D6A\xB8C3\
+\\x5D6B\xB8C4\
+\\x5D6C\xB8C5\
+\\x5D6D\xB8C6\
+\\x5D6E\xB8C7\
+\\x5D6F\xB8C8\
+\\x5D70\xB8C9\
+\\x5D71\xB8CA\
+\\x5D72\xB8CB\
+\\x5D73\xB8CC\
+\\x5D74\xB8CD\
+\\x5D75\xB8CE\
+\\x5D76\xB8CF\
+\\x5D77\xB8D0\
+\\x5D78\xB8D1\
+\\x5D79\xB8D2\
+\\x5D7A\xB8D3\
+\\x5D7B\xB8D4\
+\\x5D7C\xB8D5\
+\\x5D7D\xB8D6\
+\\x5D7E\xB8D7\
+\\x5D7F\xB8D8\
+\\x5D81\xB8D9\
+\\x5D82\xB8DA\
+\\x5D83\xB8DB\
+\\x5D84\xB8DC\
+\\x5D85\xB8DD\
+\\x5D86\xB8DE\
+\\x5D87\xB8DF\
+\\x5D88\xB8E0\
+\\x5D89\xB8E1\
+\\x5D8A\xB8E2\
+\\x5D8B\xB8E3\
+\\x5D8C\xB8E4\
+\\x5D8D\xB8E5\
+\\x5D8E\xB8E6\
+\\x5D8F\xB8E7\
+\\x5D90\xB8E8\
+\\x5D91\xB8E9\
+\\x5D92\xB8EA\
+\\x5D93\xB8EB\
+\\x5D94\xB8EC\
+\\x5D95\xB8ED\
+\\x5D96\xB8EE\
+\\x5D97\xB8EF\
+\\x5D98\xB8F0\
+\\x5D99\xB8F1\
+\\x5D9A\xB8F2\
+\\x5D9B\xB8F3\
+\\x5D9C\xB8F4\
+\\x5D9D\xB8F5\
+\\x5D9E\xB8F6\
+\\x5D9F\xB8F7\
+\\x5DA0\xB8F8\
+\\x5DA1\xB8F9\
+\\x5DA2\xB8FA\
+\\x5DA3\xB8FB\
+\\x5DA4\xB8FC\
+\\x5DA5\xB8FD\
+\\x5DA6\xB8FE\
+\\x5DA7\xB940\
+\\x5DA8\xB941\
+\\x5DA9\xB942\
+\\x5DAA\xB943\
+\\x5DAB\xB944\
+\\x5DAC\xB945\
+\\x5DAD\xB946\
+\\x5DAE\xB947\
+\\x5DAF\xB948\
+\\x5DB0\xB949\
+\\x5DB1\xB94A\
+\\x5DB2\xB94B\
+\\x5DB3\xB94C\
+\\x5DB4\xB94D\
+\\x5DB5\xB94E\
+\\x5DB6\xB94F\
+\\x5DB7\xB950\
+\\x5DB8\xB951\
+\\x5DB9\xB952\
+\\x5DBA\xB953\
+\\x5DBB\xB954\
+\\x5DBC\xB955\
+\\x5DBD\xB956\
+\\x5DBE\xB957\
+\\x5DBF\xB958\
+\\x5DC0\xB959\
+\\x5DC1\xB95A\
+\\x5DC2\xB95B\
+\\x5DC3\xB95C\
+\\x5DC4\xB95D\
+\\x5DC5\xB95E\
+\\x5DC6\xB95F\
+\\x5DC7\xB960\
+\\x5DC8\xB961\
+\\x5DC9\xB962\
+\\x5DCA\xB963\
+\\x5DCB\xB964\
+\\x5DCC\xB965\
+\\x5DCD\xB966\
+\\x5DCE\xB967\
+\\x5DCF\xB968\
+\\x5DD0\xB969\
+\\x5DD1\xB96A\
+\\x5DD2\xB96B\
+\\x5DD3\xB96C\
+\\x5DD4\xB96D\
+\\x5DD5\xB96E\
+\\x5DD6\xB96F\
+\\x5DD7\xB970\
+\\x5DD8\xB971\
+\\x5DD9\xB972\
+\\x5DDA\xB973\
+\\x5DDB\xB974\
+\\x5DDC\xB975\
+\\x5DDD\xB976\
+\\x5DDE\xB977\
+\\x5DDF\xB978\
+\\x5DE0\xB979\
+\\x5DE1\xB97A\
+\\x5DE2\xB97B\
+\\x5DE3\xB97C\
+\\x5DE4\xB97D\
+\\x5DE5\xB97E\
+\\x5DE6\xB9A1\
+\\x5DE7\xB9A2\
+\\x5DE8\xB9A3\
+\\x5DE9\xB9A4\
+\\x5DEA\xB9A5\
+\\x5DEB\xB9A6\
+\\x5DEC\xB9A7\
+\\x5DED\xB9A8\
+\\x5DEE\xB9A9\
+\\x5DEF\xB9AA\
+\\x5DF0\xB9AB\
+\\x5DF1\xB9AC\
+\\x5DF2\xB9AD\
+\\x5DF3\xB9AE\
+\\x5DF4\xB9AF\
+\\x5DF5\xB9B0\
+\\x5DF6\xB9B1\
+\\x5DF7\xB9B2\
+\\x5DF8\xB9B3\
+\\x5DF9\xB9B4\
+\\x5DFA\xB9B5\
+\\x5DFB\xB9B6\
+\\x5DFC\xB9B7\
+\\x5DFD\xB9B8\
+\\x5E41\xB9B9\
+\\x5E42\xB9BA\
+\\x5E43\xB9BB\
+\\x5E44\xB9BC\
+\\x5E45\xB9BD\
+\\x5E46\xB9BE\
+\\x5E47\xB9BF\
+\\x5E48\xB9C0\
+\\x5E49\xB9C1\
+\\x5E4A\xB9C2\
+\\x5E4B\xB9C3\
+\\x5E4C\xB9C4\
+\\x5E4D\xB9C5\
+\\x5E4E\xB9C6\
+\\x5E4F\xB9C7\
+\\x5E50\xB9C8\
+\\x5E51\xB9C9\
+\\x5E52\xB9CA\
+\\x5E53\xB9CB\
+\\x5E54\xB9CC\
+\\x5E55\xB9CD\
+\\x5E56\xB9CE\
+\\x5E57\xB9CF\
+\\x5E58\xB9D0\
+\\x5E59\xB9D1\
+\\x5E5A\xB9D2\
+\\x5E5B\xB9D3\
+\\x5E5C\xB9D4\
+\\x5E5D\xB9D5\
+\\x5E5E\xB9D6\
+\\x5E5F\xB9D7\
+\\x5E60\xB9D8\
+\\x5E61\xB9D9\
+\\x5E62\xB9DA\
+\\x5E63\xB9DB\
+\\x5E64\xB9DC\
+\\x5E65\xB9DD\
+\\x5E66\xB9DE\
+\\x5E67\xB9DF\
+\\x5E68\xB9E0\
+\\x5E69\xB9E1\
+\\x5E6A\xB9E2\
+\\x5E6B\xB9E3\
+\\x5E6C\xB9E4\
+\\x5E6D\xB9E5\
+\\x5E6E\xB9E6\
+\\x5E6F\xB9E7\
+\\x5E70\xB9E8\
+\\x5E71\xB9E9\
+\\x5E72\xB9EA\
+\\x5E73\xB9EB\
+\\x5E74\xB9EC\
+\\x5E75\xB9ED\
+\\x5E76\xB9EE\
+\\x5E77\xB9EF\
+\\x5E78\xB9F0\
+\\x5E79\xB9F1\
+\\x5E7A\xB9F2\
+\\x5E7B\xB9F3\
+\\x5E7C\xB9F4\
+\\x5E7D\xB9F5\
+\\x5E7E\xB9F6\
+\\x5E7F\xB9F7\
+\\x5E81\xB9F8\
+\\x5E82\xB9F9\
+\\x5E83\xB9FA\
+\\x5E84\xB9FB\
+\\x5E85\xB9FC\
+\\x5E86\xB9FD\
+\\x5E87\xB9FE\
+\\x5E88\xBA40\
+\\x5E89\xBA41\
+\\x5E8A\xBA42\
+\\x5E8B\xBA43\
+\\x5E8C\xBA44\
+\\x5E8D\xBA45\
+\\x5E8E\xBA46\
+\\x5E8F\xBA47\
+\\x5E90\xBA48\
+\\x5E91\xBA49\
+\\x5E92\xBA4A\
+\\x5E93\xBA4B\
+\\x5E94\xBA4C\
+\\x5E95\xBA4D\
+\\x5E96\xBA4E\
+\\x5E97\xBA4F\
+\\x5E98\xBA50\
+\\x5E99\xBA51\
+\\x5E9A\xBA52\
+\\x5E9B\xBA53\
+\\x5E9C\xBA54\
+\\x5E9D\xBA55\
+\\x5E9E\xBA56\
+\\x5E9F\xBA57\
+\\x5EA0\xBA58\
+\\x5EA1\xBA59\
+\\x5EA2\xBA5A\
+\\x5EA3\xBA5B\
+\\x5EA4\xBA5C\
+\\x5EA5\xBA5D\
+\\x5EA6\xBA5E\
+\\x5EA7\xBA5F\
+\\x5EA8\xBA60\
+\\x5EA9\xBA61\
+\\x5EAA\xBA62\
+\\x5EAB\xBA63\
+\\x5EAC\xBA64\
+\\x5EAD\xBA65\
+\\x5EAE\xBA66\
+\\x5EAF\xBA67\
+\\x5EB0\xBA68\
+\\x5EB1\xBA69\
+\\x5EB2\xBA6A\
+\\x5EB3\xBA6B\
+\\x5EB4\xBA6C\
+\\x5EB5\xBA6D\
+\\x5EB6\xBA6E\
+\\x5EB7\xBA6F\
+\\x5EB8\xBA70\
+\\x5EB9\xBA71\
+\\x5EBA\xBA72\
+\\x5EBB\xBA73\
+\\x5EBC\xBA74\
+\\x5EBD\xBA75\
+\\x5EBE\xBA76\
+\\x5EBF\xBA77\
+\\x5EC0\xBA78\
+\\x5EC1\xBA79\
+\\x5EC2\xBA7A\
+\\x5EC3\xBA7B\
+\\x5EC4\xBA7C\
+\\x5EC5\xBA7D\
+\\x5EC6\xBA7E\
+\\x5EC7\xBAA1\
+\\x5EC8\xBAA2\
+\\x5EC9\xBAA3\
+\\x5ECA\xBAA4\
+\\x5ECB\xBAA5\
+\\x5ECC\xBAA6\
+\\x5ECD\xBAA7\
+\\x5ECE\xBAA8\
+\\x5ECF\xBAA9\
+\\x5ED0\xBAAA\
+\\x5ED1\xBAAB\
+\\x5ED2\xBAAC\
+\\x5ED3\xBAAD\
+\\x5ED4\xBAAE\
+\\x5ED5\xBAAF\
+\\x5ED6\xBAB0\
+\\x5ED7\xBAB1\
+\\x5ED8\xBAB2\
+\\x5ED9\xBAB3\
+\\x5EDA\xBAB4\
+\\x5EDB\xBAB5\
+\\x5EDC\xBAB6\
+\\x5EDD\xBAB7\
+\\x5EDE\xBAB8\
+\\x5EDF\xBAB9\
+\\x5EE0\xBABA\
+\\x5EE1\xBABB\
+\\x5EE2\xBABC\
+\\x5EE3\xBABD\
+\\x5EE4\xBABE\
+\\x5EE5\xBABF\
+\\x5EE6\xBAC0\
+\\x5EE7\xBAC1\
+\\x5EE8\xBAC2\
+\\x5EE9\xBAC3\
+\\x5EEA\xBAC4\
+\\x5EEB\xBAC5\
+\\x5EEC\xBAC6\
+\\x5EED\xBAC7\
+\\x5EEE\xBAC8\
+\\x5EEF\xBAC9\
+\\x5EF0\xBACA\
+\\x5EF1\xBACB\
+\\x5EF2\xBACC\
+\\x5EF3\xBACD\
+\\x5EF4\xBACE\
+\\x5EF5\xBACF\
+\\x5EF6\xBAD0\
+\\x5EF7\xBAD1\
+\\x5EF8\xBAD2\
+\\x5EF9\xBAD3\
+\\x5EFA\xBAD4\
+\\x5EFB\xBAD5\
+\\x5EFC\xBAD6\
+\\x5EFD\xBAD7\
+\\x5F41\xBAD8\
+\\x5F42\xBAD9\
+\\x5F43\xBADA\
+\\x5F44\xBADB\
+\\x5F45\xBADC\
+\\x5F46\xBADD\
+\\x5F47\xBADE\
+\\x5F48\xBADF\
+\\x5F49\xBAE0\
+\\x5F4A\xBAE1\
+\\x5F4B\xBAE2\
+\\x5F4C\xBAE3\
+\\x5F4D\xBAE4\
+\\x5F4E\xBAE5\
+\\x5F4F\xBAE6\
+\\x5F50\xBAE7\
+\\x5F51\xBAE8\
+\\x5F52\xBAE9\
+\\x5F53\xBAEA\
+\\x5F54\xBAEB\
+\\x5F55\xBAEC\
+\\x5F56\xBAED\
+\\x5F57\xBAEE\
+\\x5F58\xBAEF\
+\\x5F59\xBAF0\
+\\x5F5A\xBAF1\
+\\x5F5B\xBAF2\
+\\x5F5C\xBAF3\
+\\x5F5D\xBAF4\
+\\x5F5E\xBAF5\
+\\x5F5F\xBAF6\
+\\x5F60\xBAF7\
+\\x5F61\xBAF8\
+\\x5F62\xBAF9\
+\\x5F63\xBAFA\
+\\x5F64\xBAFB\
+\\x5F65\xBAFC\
+\\x5F66\xBAFD\
+\\x5F67\xBAFE\
+\\x5F68\xBB40\
+\\x5F69\xBB41\
+\\x5F6A\xBB42\
+\\x5F6B\xBB43\
+\\x5F6C\xBB44\
+\\x5F6D\xBB45\
+\\x5F6E\xBB46\
+\\x5F6F\xBB47\
+\\x5F70\xBB48\
+\\x5F71\xBB49\
+\\x5F72\xBB4A\
+\\x5F73\xBB4B\
+\\x5F74\xBB4C\
+\\x5F75\xBB4D\
+\\x5F76\xBB4E\
+\\x5F77\xBB4F\
+\\x5F78\xBB50\
+\\x5F79\xBB51\
+\\x5F7A\xBB52\
+\\x5F7B\xBB53\
+\\x5F7C\xBB54\
+\\x5F7D\xBB55\
+\\x5F7E\xBB56\
+\\x5F7F\xBB57\
+\\x5F81\xBB58\
+\\x5F82\xBB59\
+\\x5F83\xBB5A\
+\\x5F84\xBB5B\
+\\x5F85\xBB5C\
+\\x5F86\xBB5D\
+\\x5F87\xBB5E\
+\\x5F88\xBB5F\
+\\x5F89\xBB60\
+\\x5F8A\xBB61\
+\\x5F8B\xBB62\
+\\x5F8C\xBB63\
+\\x5F8D\xBB64\
+\\x5F8E\xBB65\
+\\x5F8F\xBB66\
+\\x5F90\xBB67\
+\\x5F91\xBB68\
+\\x5F92\xBB69\
+\\x5F93\xBB6A\
+\\x5F94\xBB6B\
+\\x5F95\xBB6C\
+\\x5F96\xBB6D\
+\\x5F97\xBB6E\
+\\x5F98\xBB6F\
+\\x5F99\xBB70\
+\\x5F9A\xBB71\
+\\x5F9B\xBB72\
+\\x5F9C\xBB73\
+\\x5F9D\xBB74\
+\\x5F9E\xBB75\
+\\x5F9F\xBB76\
+\\x5FA0\xBB77\
+\\x5FA1\xBB78\
+\\x5FA2\xBB79\
+\\x5FA3\xBB7A\
+\\x5FA4\xBB7B\
+\\x5FA5\xBB7C\
+\\x5FA6\xBB7D\
+\\x5FA7\xBB7E\
+\\x5FA8\xBBA1\
+\\x5FA9\xBBA2\
+\\x5FAA\xBBA3\
+\\x5FAB\xBBA4\
+\\x5FAC\xBBA5\
+\\x5FAD\xBBA6\
+\\x5FAE\xBBA7\
+\\x5FAF\xBBA8\
+\\x5FB0\xBBA9\
+\\x5FB1\xBBAA\
+\\x5FB2\xBBAB\
+\\x5FB3\xBBAC\
+\\x5FB4\xBBAD\
+\\x5FB5\xBBAE\
+\\x5FB6\xBBAF\
+\\x5FB7\xBBB0\
+\\x5FB8\xBBB1\
+\\x5FB9\xBBB2\
+\\x5FBA\xBBB3\
+\\x5FBB\xBBB4\
+\\x5FBC\xBBB5\
+\\x5FBD\xBBB6\
+\\x5FBE\xBBB7\
+\\x5FBF\xBBB8\
+\\x5FC0\xBBB9\
+\\x5FC1\xBBBA\
+\\x5FC2\xBBBB\
+\\x5FC3\xBBBC\
+\\x5FC4\xBBBD\
+\\x5FC5\xBBBE\
+\\x5FC6\xBBBF\
+\\x5FC7\xBBC0\
+\\x5FC8\xBBC1\
+\\x5FC9\xBBC2\
+\\x5FCA\xBBC3\
+\\x5FCB\xBBC4\
+\\x5FCC\xBBC5\
+\\x5FCD\xBBC6\
+\\x5FCE\xBBC7\
+\\x5FCF\xBBC8\
+\\x5FD0\xBBC9\
+\\x5FD1\xBBCA\
+\\x5FD2\xBBCB\
+\\x5FD3\xBBCC\
+\\x5FD4\xBBCD\
+\\x5FD5\xBBCE\
+\\x5FD6\xBBCF\
+\\x5FD7\xBBD0\
+\\x5FD8\xBBD1\
+\\x5FD9\xBBD2\
+\\x5FDA\xBBD3\
+\\x5FDB\xBBD4\
+\\x5FDC\xBBD5\
+\\x5FDD\xBBD6\
+\\x5FDE\xBBD7\
+\\x5FDF\xBBD8\
+\\x5FE0\xBBD9\
+\\x5FE1\xBBDA\
+\\x5FE2\xBBDB\
+\\x5FE3\xBBDC\
+\\x5FE4\xBBDD\
+\\x5FE5\xBBDE\
+\\x5FE6\xBBDF\
+\\x5FE7\xBBE0\
+\\x5FE8\xBBE1\
+\\x5FE9\xBBE2\
+\\x5FEA\xBBE3\
+\\x5FEB\xBBE4\
+\\x5FEC\xBBE5\
+\\x5FED\xBBE6\
+\\x5FEE\xBBE7\
+\\x5FEF\xBBE8\
+\\x5FF0\xBBE9\
+\\x5FF1\xBBEA\
+\\x5FF2\xBBEB\
+\\x5FF3\xBBEC\
+\\x5FF4\xBBED\
+\\x5FF5\xBBEE\
+\\x5FF6\xBBEF\
+\\x5FF7\xBBF0\
+\\x5FF8\xBBF1\
+\\x5FF9\xBBF2\
+\\x5FFA\xBBF3\
+\\x5FFB\xBBF4\
+\\x5FFC\xBBF5\
+\\x5FFD\xBBF6\
+\\x6041\xBBF7\
+\\x6042\xBBF8\
+\\x6043\xBBF9\
+\\x6044\xBBFA\
+\\x6045\xBBFB\
+\\x6046\xBBFC\
+\\x6047\xBBFD\
+\\x6048\xBBFE\
+\\x6049\xBC40\
+\\x604A\xBC41\
+\\x604B\xBC42\
+\\x604C\xBC43\
+\\x604D\xBC44\
+\\x604E\xBC45\
+\\x604F\xBC46\
+\\x6050\xBC47\
+\\x6051\xBC48\
+\\x6052\xBC49\
+\\x6053\xBC4A\
+\\x6054\xBC4B\
+\\x6055\xBC4C\
+\\x6056\xBC4D\
+\\x6057\xBC4E\
+\\x6058\xBC4F\
+\\x6059\xBC50\
+\\x605A\xBC51\
+\\x605B\xBC52\
+\\x605C\xBC53\
+\\x605D\xBC54\
+\\x605E\xBC55\
+\\x605F\xBC56\
+\\x6060\xBC57\
+\\x6061\xBC58\
+\\x6062\xBC59\
+\\x6063\xBC5A\
+\\x6064\xBC5B\
+\\x6065\xBC5C\
+\\x6066\xBC5D\
+\\x6067\xBC5E\
+\\x6068\xBC5F\
+\\x6069\xBC60\
+\\x606A\xBC61\
+\\x606B\xBC62\
+\\x606C\xBC63\
+\\x606D\xBC64\
+\\x606E\xBC65\
+\\x606F\xBC66\
+\\x6070\xBC67\
+\\x6071\xBC68\
+\\x6072\xBC69\
+\\x6073\xBC6A\
+\\x6074\xBC6B\
+\\x6075\xBC6C\
+\\x6076\xBC6D\
+\\x6077\xBC6E\
+\\x6078\xBC6F\
+\\x6079\xBC70\
+\\x607A\xBC71\
+\\x607B\xBC72\
+\\x607C\xBC73\
+\\x607D\xBC74\
+\\x607E\xBC75\
+\\x607F\xBC76\
+\\x6081\xBC77\
+\\x6082\xBC78\
+\\x6083\xBC79\
+\\x6084\xBC7A\
+\\x6085\xBC7B\
+\\x6086\xBC7C\
+\\x6087\xBC7D\
+\\x6088\xBC7E\
+\\x6089\xBCA1\
+\\x608A\xBCA2\
+\\x608B\xBCA3\
+\\x608C\xBCA4\
+\\x608D\xBCA5\
+\\x608E\xBCA6\
+\\x608F\xBCA7\
+\\x6090\xBCA8\
+\\x6091\xBCA9\
+\\x6092\xBCAA\
+\\x6093\xBCAB\
+\\x6094\xBCAC\
+\\x6095\xBCAD\
+\\x6096\xBCAE\
+\\x6097\xBCAF\
+\\x6098\xBCB0\
+\\x6099\xBCB1\
+\\x609A\xBCB2\
+\\x609B\xBCB3\
+\\x609C\xBCB4\
+\\x609D\xBCB5\
+\\x609E\xBCB6\
+\\x609F\xBCB7\
+\\x60A0\xBCB8\
+\\x60A1\xBCB9\
+\\x60A2\xBCBA\
+\\x60A3\xBCBB\
+\\x60A4\xBCBC\
+\\x60A5\xBCBD\
+\\x60A6\xBCBE\
+\\x60A7\xBCBF\
+\\x60A8\xBCC0\
+\\x60A9\xBCC1\
+\\x60AA\xBCC2\
+\\x60AB\xBCC3\
+\\x60AC\xBCC4\
+\\x60AD\xBCC5\
+\\x60AE\xBCC6\
+\\x60AF\xBCC7\
+\\x60B0\xBCC8\
+\\x60B1\xBCC9\
+\\x60B2\xBCCA\
+\\x60B3\xBCCB\
+\\x60B4\xBCCC\
+\\x60B5\xBCCD\
+\\x60B6\xBCCE\
+\\x60B7\xBCCF\
+\\x60B8\xBCD0\
+\\x60B9\xBCD1\
+\\x60BA\xBCD2\
+\\x60BB\xBCD3\
+\\x60BC\xBCD4\
+\\x60BD\xBCD5\
+\\x60BE\xBCD6\
+\\x60BF\xBCD7\
+\\x60C0\xBCD8\
+\\x60C1\xBCD9\
+\\x60C2\xBCDA\
+\\x60C3\xBCDB\
+\\x60C4\xBCDC\
+\\x60C5\xBCDD\
+\\x60C6\xBCDE\
+\\x60C7\xBCDF\
+\\x60C8\xBCE0\
+\\x60C9\xBCE1\
+\\x60CA\xBCE2\
+\\x60CB\xBCE3\
+\\x60CC\xBCE4\
+\\x60CD\xBCE5\
+\\x60CE\xBCE6\
+\\x60CF\xBCE7\
+\\x60D0\xBCE8\
+\\x60D1\xBCE9\
+\\x60D2\xBCEA\
+\\x60D3\xBCEB\
+\\x60D4\xBCEC\
+\\x60D5\xBCED\
+\\x60D6\xBCEE\
+\\x60D7\xBCEF\
+\\x60D8\xBCF0\
+\\x60D9\xBCF1\
+\\x60DA\xBCF2\
+\\x60DB\xBCF3\
+\\x60DC\xBCF4\
+\\x60DD\xBCF5\
+\\x60DE\xBCF6\
+\\x60DF\xBCF7\
+\\x60E0\xBCF8\
+\\x60E1\xBCF9\
+\\x60E2\xBCFA\
+\\x60E3\xBCFB\
+\\x60E4\xBCFC\
+\\x60E5\xBCFD\
+\\x60E6\xBCFE\
+\\x60E7\xBD40\
+\\x60E8\xBD41\
+\\x60E9\xBD42\
+\\x60EA\xBD43\
+\\x60EB\xBD44\
+\\x60EC\xBD45\
+\\x60ED\xBD46\
+\\x60EE\xBD47\
+\\x60EF\xBD48\
+\\x60F0\xBD49\
+\\x60F1\xBD4A\
+\\x60F2\xBD4B\
+\\x60F3\xBD4C\
+\\x60F4\xBD4D\
+\\x60F5\xBD4E\
+\\x60F6\xBD4F\
+\\x60F7\xBD50\
+\\x60F8\xBD51\
+\\x60F9\xBD52\
+\\x60FA\xBD53\
+\\x60FB\xBD54\
+\\x60FC\xBD55\
+\\x60FD\xBD56\
+\\x6141\xBD57\
+\\x6142\xBD58\
+\\x6143\xBD59\
+\\x6144\xBD5A\
+\\x6145\xBD5B\
+\\x6146\xBD5C\
+\\x6147\xBD5D\
+\\x6148\xBD5E\
+\\x6149\xBD5F\
+\\x614A\xBD60\
+\\x614B\xBD61\
+\\x614C\xBD62\
+\\x614D\xBD63\
+\\x614E\xBD64\
+\\x614F\xBD65\
+\\x6150\xBD66\
+\\x6151\xBD67\
+\\x6152\xBD68\
+\\x6153\xBD69\
+\\x6154\xBD6A\
+\\x6155\xBD6B\
+\\x6156\xBD6C\
+\\x6157\xBD6D\
+\\x6158\xBD6E\
+\\x6159\xBD6F\
+\\x615A\xBD70\
+\\x615B\xBD71\
+\\x615C\xBD72\
+\\x615D\xBD73\
+\\x615E\xBD74\
+\\x615F\xBD75\
+\\x6160\xBD76\
+\\x6161\xBD77\
+\\x6162\xBD78\
+\\x6163\xBD79\
+\\x6164\xBD7A\
+\\x6165\xBD7B\
+\\x6166\xBD7C\
+\\x6167\xBD7D\
+\\x6168\xBD7E\
+\\x6169\xBDA1\
+\\x616A\xBDA2\
+\\x616B\xBDA3\
+\\x616C\xBDA4\
+\\x616D\xBDA5\
+\\x616E\xBDA6\
+\\x616F\xBDA7\
+\\x6170\xBDA8\
+\\x6171\xBDA9\
+\\x6172\xBDAA\
+\\x6173\xBDAB\
+\\x6174\xBDAC\
+\\x6175\xBDAD\
+\\x6176\xBDAE\
+\\x6177\xBDAF\
+\\x6178\xBDB0\
+\\x6179\xBDB1\
+\\x617A\xBDB2\
+\\x617B\xBDB3\
+\\x617C\xBDB4\
+\\x617D\xBDB5\
+\\x617E\xBDB6\
+\\x617F\xBDB7\
+\\x6181\xBDB8\
+\\x6182\xBDB9\
+\\x6183\xBDBA\
+\\x6184\xBDBB\
+\\x6185\xBDBC\
+\\x6186\xBDBD\
+\\x6187\xBDBE\
+\\x6188\xBDBF\
+\\x6189\xBDC0\
+\\x618A\xBDC1\
+\\x618B\xBDC2\
+\\x618C\xBDC3\
+\\x618D\xBDC4\
+\\x618E\xBDC5\
+\\x618F\xBDC6\
+\\x6190\xBDC7\
+\\x6191\xBDC8\
+\\x6192\xBDC9\
+\\x6193\xBDCA\
+\\x6194\xBDCB\
+\\x6195\xBDCC\
+\\x6196\xBDCD\
+\\x6197\xBDCE\
+\\x6198\xBDCF\
+\\x6199\xBDD0\
+\\x619A\xBDD1\
+\\x619B\xBDD2\
+\\x619C\xBDD3\
+\\x619D\xBDD4\
+\\x619E\xBDD5\
+\\x619F\xBDD6\
+\\x61A0\xBDD7\
+\\x61A1\xBDD8\
+\\x61A2\xBDD9\
+\\x61A3\xBDDA\
+\\x61A4\xBDDB\
+\\x61A5\xBDDC\
+\\x61A6\xBDDD\
+\\x61A7\xBDDE\
+\\x61A8\xBDDF\
+\\x61A9\xBDE0\
+\\x61AA\xBDE1\
+\\x61AB\xBDE2\
+\\x61AC\xBDE3\
+\\x61AD\xBDE4\
+\\x61AE\xBDE5\
+\\x61AF\xBDE6\
+\\x61B0\xBDE7\
+\\x61B1\xBDE8\
+\\x61B2\xBDE9\
+\\x61B3\xBDEA\
+\\x61B4\xBDEB\
+\\x61B5\xBDEC\
+\\x61B6\xBDED\
+\\x61B7\xBDEE\
+\\x61B8\xBDEF\
+\\x61B9\xBDF0\
+\\x61BA\xBDF1\
+\\x61BB\xBDF2\
+\\x61BC\xBDF3\
+\\x61BD\xBDF4\
+\\x61BE\xBDF5\
+\\x61BF\xBDF6\
+\\x61C0\xBDF7\
+\\x61C1\xBDF8\
+\\x61C2\xBDF9\
+\\x61C3\xBDFA\
+\\x61C4\xBDFB\
+\\x61C5\xBDFC\
+\\x61C6\xBDFD\
+\\x61C7\xBDFE\
+\\x61C8\xBE40\
+\\x61C9\xBE41\
+\\x61CA\xBE42\
+\\x61CB\xBE43\
+\\x61CC\xBE44\
+\\x61CD\xBE45\
+\\x61CE\xBE46\
+\\x61CF\xBE47\
+\\x61D0\xBE48\
+\\x61D1\xBE49\
+\\x61D2\xBE4A\
+\\x61D3\xBE4B\
+\\x61D4\xBE4C\
+\\x61D5\xBE4D\
+\\x61D6\xBE4E\
+\\x61D7\xBE4F\
+\\x61D8\xBE50\
+\\x61D9\xBE51\
+\\x61DA\xBE52\
+\\x61DB\xBE53\
+\\x61DC\xBE54\
+\\x61DD\xBE55\
+\\x61DE\xBE56\
+\\x61DF\xBE57\
+\\x61E0\xBE58\
+\\x61E1\xBE59\
+\\x61E2\xBE5A\
+\\x61E3\xBE5B\
+\\x61E4\xBE5C\
+\\x61E5\xBE5D\
+\\x61E6\xBE5E\
+\\x61E7\xBE5F\
+\\x61E8\xBE60\
+\\x61E9\xBE61\
+\\x61EA\xBE62\
+\\x61EB\xBE63\
+\\x61EC\xBE64\
+\\x61ED\xBE65\
+\\x61EE\xBE66\
+\\x61EF\xBE67\
+\\x61F0\xBE68\
+\\x61F1\xBE69\
+\\x61F2\xBE6A\
+\\x61F3\xBE6B\
+\\x61F4\xBE6C\
+\\x61F5\xBE6D\
+\\x61F6\xBE6E\
+\\x61F7\xBE6F\
+\\x61F8\xBE70\
+\\x61F9\xBE71\
+\\x61FA\xBE72\
+\\x61FB\xBE73\
+\\x61FC\xBE74\
+\\x61FD\xBE75\
+\\x6241\xBE76\
+\\x6242\xBE77\
+\\x6243\xBE78\
+\\x6244\xBE79\
+\\x6245\xBE7A\
+\\x6246\xBE7B\
+\\x6247\xBE7C\
+\\x6248\xBE7D\
+\\x6249\xBE7E\
+\\x624A\xBEA1\
+\\x624B\xBEA2\
+\\x624C\xBEA3\
+\\x624D\xBEA4\
+\\x624E\xBEA5\
+\\x624F\xBEA6\
+\\x6250\xBEA7\
+\\x6251\xBEA8\
+\\x6252\xBEA9\
+\\x6253\xBEAA\
+\\x6254\xBEAB\
+\\x6255\xBEAC\
+\\x6256\xBEAD\
+\\x6257\xBEAE\
+\\x6258\xBEAF\
+\\x6259\xBEB0\
+\\x625A\xBEB1\
+\\x625B\xBEB2\
+\\x625C\xBEB3\
+\\x625D\xBEB4\
+\\x625E\xBEB5\
+\\x625F\xBEB6\
+\\x6260\xBEB7\
+\\x6261\xBEB8\
+\\x6262\xBEB9\
+\\x6263\xBEBA\
+\\x6264\xBEBB\
+\\x6265\xBEBC\
+\\x6266\xBEBD\
+\\x6267\xBEBE\
+\\x6268\xBEBF\
+\\x6269\xBEC0\
+\\x626A\xBEC1\
+\\x626B\xBEC2\
+\\x626C\xBEC3\
+\\x626D\xBEC4\
+\\x626E\xBEC5\
+\\x626F\xBEC6\
+\\x6270\xBEC7\
+\\x6271\xBEC8\
+\\x6272\xBEC9\
+\\x6273\xBECA\
+\\x6274\xBECB\
+\\x6275\xBECC\
+\\x6276\xBECD\
+\\x6277\xBECE\
+\\x6278\xBECF\
+\\x6279\xBED0\
+\\x627A\xBED1\
+\\x627B\xBED2\
+\\x627C\xBED3\
+\\x627D\xBED4\
+\\x627E\xBED5\
+\\x627F\xBED6\
+\\x6281\xBED7\
+\\x6282\xBED8\
+\\x6283\xBED9\
+\\x6284\xBEDA\
+\\x6285\xBEDB\
+\\x6286\xBEDC\
+\\x6287\xBEDD\
+\\x6288\xBEDE\
+\\x6289\xBEDF\
+\\x628A\xBEE0\
+\\x628B\xBEE1\
+\\x628C\xBEE2\
+\\x628D\xBEE3\
+\\x628E\xBEE4\
+\\x628F\xBEE5\
+\\x6290\xBEE6\
+\\x6291\xBEE7\
+\\x6292\xBEE8\
+\\x6293\xBEE9\
+\\x6294\xBEEA\
+\\x6295\xBEEB\
+\\x6296\xBEEC\
+\\x6297\xBEED\
+\\x6298\xBEEE\
+\\x6299\xBEEF\
+\\x629A\xBEF0\
+\\x629B\xBEF1\
+\\x629C\xBEF2\
+\\x629D\xBEF3\
+\\x629E\xBEF4\
+\\x629F\xBEF5\
+\\x62A0\xBEF6\
+\\x62A1\xBEF7\
+\\x62A2\xBEF8\
+\\x62A3\xBEF9\
+\\x62A4\xBEFA\
+\\x62A5\xBEFB\
+\\x62A6\xBEFC\
+\\x62A7\xBEFD\
+\\x62A8\xBEFE\
+\\x62A9\xBF40\
+\\x62AA\xBF41\
+\\x62AB\xBF42\
+\\x62AC\xBF43\
+\\x62AD\xBF44\
+\\x62AE\xBF45\
+\\x62AF\xBF46\
+\\x62B0\xBF47\
+\\x62B1\xBF48\
+\\x62B2\xBF49\
+\\x62B3\xBF4A\
+\\x62B4\xBF4B\
+\\x62B5\xBF4C\
+\\x62B6\xBF4D\
+\\x62B7\xBF4E\
+\\x62B8\xBF4F\
+\\x62B9\xBF50\
+\\x62BA\xBF51\
+\\x62BB\xBF52\
+\\x62BC\xBF53\
+\\x62BD\xBF54\
+\\x62BE\xBF55\
+\\x62BF\xBF56\
+\\x62C0\xBF57\
+\\x62C1\xBF58\
+\\x62C2\xBF59\
+\\x62C3\xBF5A\
+\\x62C4\xBF5B\
+\\x62C5\xBF5C\
+\\x62C6\xBF5D\
+\\x62C7\xBF5E\
+\\x62C8\xBF5F\
+\\x62C9\xBF60\
+\\x62CA\xBF61\
+\\x62CB\xBF62\
+\\x62CC\xBF63\
+\\x62CD\xBF64\
+\\x62CE\xBF65\
+\\x62CF\xBF66\
+\\x62D0\xBF67\
+\\x62D1\xBF68\
+\\x62D2\xBF69\
+\\x62D3\xBF6A\
+\\x62D4\xBF6B\
+\\x62D5\xBF6C\
+\\x62D6\xBF6D\
+\\x62D7\xBF6E\
+\\x62D8\xBF6F\
+\\x62D9\xBF70\
+\\x62DA\xBF71\
+\\x62DB\xBF72\
+\\x62DC\xBF73\
+\\x62DD\xBF74\
+\\x62DE\xBF75\
+\\x62DF\xBF76\
+\\x62E0\xBF77\
+\\x62E1\xBF78\
+\\x62E2\xBF79\
+\\x62E3\xBF7A\
+\\x62E4\xBF7B\
+\\x62E5\xBF7C\
+\\x62E6\xBF7D\
+\\x62E7\xBF7E\
+\\x62E8\xBFA1\
+\\x62E9\xBFA2\
+\\x62EA\xBFA3\
+\\x62EB\xBFA4\
+\\x62EC\xBFA5\
+\\x62ED\xBFA6\
+\\x62EE\xBFA7\
+\\x62EF\xBFA8\
+\\x62F0\xBFA9\
+\\x62F1\xBFAA\
+\\x62F2\xBFAB\
+\\x62F3\xBFAC\
+\\x62F4\xBFAD\
+\\x62F5\xBFAE\
+\\x62F6\xBFAF\
+\\x62F7\xBFB0\
+\\x62F8\xBFB1\
+\\x62F9\xBFB2\
+\\x62FA\xBFB3\
+\\x62FB\xBFB4\
+\\x62FC\xBFB5\
+\\x62FD\xBFB6\
+\\x6341\xBFB7\
+\\x6342\xBFB8\
+\\x6343\xBFB9\
+\\x6344\xBFBA\
+\\x6345\xBFBB\
+\\x6346\xBFBC\
+\\x6347\xBFBD\
+\\x6348\xBFBE\
+\\x6349\xBFBF\
+\\x634A\xBFC0\
+\\x634B\xBFC1\
+\\x634C\xBFC2\
+\\x634D\xBFC3\
+\\x634E\xBFC4\
+\\x634F\xBFC5\
+\\x6350\xBFC6\
+\\x6351\xBFC7\
+\\x6352\xBFC8\
+\\x6353\xBFC9\
+\\x6354\xBFCA\
+\\x6355\xBFCB\
+\\x6356\xBFCC\
+\\x6357\xBFCD\
+\\x6358\xBFCE\
+\\x6359\xBFCF\
+\\x635A\xBFD0\
+\\x635B\xBFD1\
+\\x635C\xBFD2\
+\\x635D\xBFD3\
+\\x635E\xBFD4\
+\\x635F\xBFD5\
+\\x6360\xBFD6\
+\\x6361\xBFD7\
+\\x6362\xBFD8\
+\\x6363\xBFD9\
+\\x6364\xBFDA\
+\\x6365\xBFDB\
+\\x6366\xBFDC\
+\\x6367\xBFDD\
+\\x6368\xBFDE\
+\\x6369\xBFDF\
+\\x636A\xBFE0\
+\\x636B\xBFE1\
+\\x636C\xBFE2\
+\\x636D\xBFE3\
+\\x636E\xBFE4\
+\\x636F\xBFE5\
+\\x6370\xBFE6\
+\\x6371\xBFE7\
+\\x6372\xBFE8\
+\\x6373\xBFE9\
+\\x6374\xBFEA\
+\\x6375\xBFEB\
+\\x6376\xBFEC\
+\\x6377\xBFED\
+\\x6378\xBFEE\
+\\x6379\xBFEF\
+\\x637A\xBFF0\
+\\x637B\xBFF1\
+\\x637C\xBFF2\
+\\x637D\xBFF3\
+\\x637E\xBFF4\
+\\x637F\xBFF5\
+\\x6381\xBFF6\
+\\x6382\xBFF7\
+\\x6383\xBFF8\
+\\x6384\xBFF9\
+\\x6385\xBFFA\
+\\x6386\xBFFB\
+\\x6387\xBFFC\
+\\x6388\xBFFD\
+\\x6389\xBFFE\
+\\x638A\xC040\
+\\x638B\xC041\
+\\x638C\xC042\
+\\x638D\xC043\
+\\x638E\xC044\
+\\x638F\xC045\
+\\x6390\xC046\
+\\x6391\xC047\
+\\x6392\xC048\
+\\x6393\xC049\
+\\x6394\xC04A\
+\\x6395\xC04B\
+\\x6396\xC04C\
+\\x6397\xC04D\
+\\x6398\xC04E\
+\\x6399\xC04F\
+\\x639A\xC050\
+\\x639B\xC051\
+\\x639C\xC052\
+\\x639D\xC053\
+\\x639E\xC054\
+\\x639F\xC055\
+\\x63A0\xC056\
+\\x63A1\xC057\
+\\x63A2\xC058\
+\\x63A3\xC059\
+\\x63A4\xC05A\
+\\x63A5\xC05B\
+\\x63A6\xC05C\
+\\x63A7\xC05D\
+\\x63A8\xC05E\
+\\x63A9\xC05F\
+\\x63AA\xC060\
+\\x63AB\xC061\
+\\x63AC\xC062\
+\\x63AD\xC063\
+\\x63AE\xC064\
+\\x63AF\xC065\
+\\x63B0\xC066\
+\\x63B1\xC067\
+\\x63B2\xC068\
+\\x63B3\xC069\
+\\x63B4\xC06A\
+\\x63B5\xC06B\
+\\x63B6\xC06C\
+\\x63B7\xC06D\
+\\x63B8\xC06E\
+\\x63B9\xC06F\
+\\x63BA\xC070\
+\\x63BB\xC071\
+\\x63BC\xC072\
+\\x63BD\xC073\
+\\x63BE\xC074\
+\\x63BF\xC075\
+\\x63C0\xC076\
+\\x63C1\xC077\
+\\x63C2\xC078\
+\\x63C3\xC079\
+\\x63C4\xC07A\
+\\x63C5\xC07B\
+\\x63C6\xC07C\
+\\x63C7\xC07D\
+\\x63C8\xC07E\
+\\x63C9\xC0A1\
+\\x63CA\xC0A2\
+\\x63CB\xC0A3\
+\\x63CC\xC0A4\
+\\x63CD\xC0A5\
+\\x63CE\xC0A6\
+\\x63CF\xC0A7\
+\\x63D0\xC0A8\
+\\x63D1\xC0A9\
+\\x63D2\xC0AA\
+\\x63D3\xC0AB\
+\\x63D4\xC0AC\
+\\x63D5\xC0AD\
+\\x63D6\xC0AE\
+\\x63D7\xC0AF\
+\\x63D8\xC0B0\
+\\x63D9\xC0B1\
+\\x63DA\xC0B2\
+\\x63DB\xC0B3\
+\\x63DC\xC0B4\
+\\x63DD\xC0B5\
+\\x63DE\xC0B6\
+\\x63DF\xC0B7\
+\\x63E0\xC0B8\
+\\x63E1\xC0B9\
+\\x63E2\xC0BA\
+\\x63E3\xC0BB\
+\\x63E4\xC0BC\
+\\x63E5\xC0BD\
+\\x63E6\xC0BE\
+\\x63E7\xC0BF\
+\\x63E8\xC0C0\
+\\x63E9\xC0C1\
+\\x63EA\xC0C2\
+\\x63EB\xC0C3\
+\\x63EC\xC0C4\
+\\x63ED\xC0C5\
+\\x63EE\xC0C6\
+\\x63EF\xC0C7\
+\\x63F0\xC0C8\
+\\x63F1\xC0C9\
+\\x63F2\xC0CA\
+\\x63F3\xC0CB\
+\\x63F4\xC0CC\
+\\x63F5\xC0CD\
+\\x63F6\xC0CE\
+\\x63F7\xC0CF\
+\\x63F8\xC0D0\
+\\x63F9\xC0D1\
+\\x63FA\xC0D2\
+\\x63FB\xC0D3\
+\\x63FC\xC0D4\
+\\x63FD\xC0D5\
+\\x6441\xC0D6\
+\\x6442\xC0D7\
+\\x6443\xC0D8\
+\\x6444\xC0D9\
+\\x6445\xC0DA\
+\\x6446\xC0DB\
+\\x6447\xC0DC\
+\\x6448\xC0DD\
+\\x6449\xC0DE\
+\\x644A\xC0DF\
+\\x644B\xC0E0\
+\\x644C\xC0E1\
+\\x644D\xC0E2\
+\\x644E\xC0E3\
+\\x644F\xC0E4\
+\\x6450\xC0E5\
+\\x6451\xC0E6\
+\\x6452\xC0E7\
+\\x6453\xC0E8\
+\\x6454\xC0E9\
+\\x6455\xC0EA\
+\\x6456\xC0EB\
+\\x6457\xC0EC\
+\\x6458\xC0ED\
+\\x6459\xC0EE\
+\\x645A\xC0EF\
+\\x645B\xC0F0\
+\\x645C\xC0F1\
+\\x645D\xC0F2\
+\\x645E\xC0F3\
+\\x645F\xC0F4\
+\\x6460\xC0F5\
+\\x6461\xC0F6\
+\\x6462\xC0F7\
+\\x6463\xC0F8\
+\\x6464\xC0F9\
+\\x6465\xC0FA\
+\\x6466\xC0FB\
+\\x6467\xC0FC\
+\\x6468\xC0FD\
+\\x6469\xC0FE\
+\\x646A\xC140\
+\\x646B\xC141\
+\\x646C\xC142\
+\\x646D\xC143\
+\\x646E\xC144\
+\\x646F\xC145\
+\\x6470\xC146\
+\\x6471\xC147\
+\\x6472\xC148\
+\\x6473\xC149\
+\\x6474\xC14A\
+\\x6475\xC14B\
+\\x6476\xC14C\
+\\x6477\xC14D\
+\\x6478\xC14E\
+\\x6479\xC14F\
+\\x647A\xC150\
+\\x647B\xC151\
+\\x647C\xC152\
+\\x647D\xC153\
+\\x647E\xC154\
+\\x647F\xC155\
+\\x6481\xC156\
+\\x6482\xC157\
+\\x6483\xC158\
+\\x6484\xC159\
+\\x6485\xC15A\
+\\x6486\xC15B\
+\\x6487\xC15C\
+\\x6488\xC15D\
+\\x6489\xC15E\
+\\x648A\xC15F\
+\\x648B\xC160\
+\\x648C\xC161\
+\\x648D\xC162\
+\\x648E\xC163\
+\\x648F\xC164\
+\\x6490\xC165\
+\\x6491\xC166\
+\\x6492\xC167\
+\\x6493\xC168\
+\\x6494\xC169\
+\\x6495\xC16A\
+\\x6496\xC16B\
+\\x6497\xC16C\
+\\x6498\xC16D\
+\\x6499\xC16E\
+\\x649A\xC16F\
+\\x649B\xC170\
+\\x649C\xC171\
+\\x649D\xC172\
+\\x649E\xC173\
+\\x649F\xC174\
+\\x64A0\xC175\
+\\x64A1\xC176\
+\\x64A2\xC177\
+\\x64A3\xC178\
+\\x64A4\xC179\
+\\x64A5\xC17A\
+\\x64A6\xC17B\
+\\x64A7\xC17C\
+\\x64A8\xC17D\
+\\x64A9\xC17E\
+\\x64AA\xC1A1\
+\\x64AB\xC1A2\
+\\x64AC\xC1A3\
+\\x64AD\xC1A4\
+\\x64AE\xC1A5\
+\\x64AF\xC1A6\
+\\x64B0\xC1A7\
+\\x64B1\xC1A8\
+\\x64B2\xC1A9\
+\\x64B3\xC1AA\
+\\x64B4\xC1AB\
+\\x64B5\xC1AC\
+\\x64B6\xC1AD\
+\\x64B7\xC1AE\
+\\x64B8\xC1AF\
+\\x64B9\xC1B0\
+\\x64BA\xC1B1\
+\\x64BB\xC1B2\
+\\x64BC\xC1B3\
+\\x64BD\xC1B4\
+\\x64BE\xC1B5\
+\\x64BF\xC1B6\
+\\x64C0\xC1B7\
+\\x64C1\xC1B8\
+\\x64C2\xC1B9\
+\\x64C3\xC1BA\
+\\x64C4\xC1BB\
+\\x64C5\xC1BC\
+\\x64C6\xC1BD\
+\\x64C7\xC1BE\
+\\x64C8\xC1BF\
+\\x64C9\xC1C0\
+\\x64CA\xC1C1\
+\\x64CB\xC1C2\
+\\x64CC\xC1C3\
+\\x64CD\xC1C4\
+\\x64CE\xC1C5\
+\\x64CF\xC1C6\
+\\x64D0\xC1C7\
+\\x64D1\xC1C8\
+\\x64D2\xC1C9\
+\\x64D3\xC1CA\
+\\x64D4\xC1CB\
+\\x64D5\xC1CC\
+\\x64D6\xC1CD\
+\\x64D7\xC1CE\
+\\x64D8\xC1CF\
+\\x64D9\xC1D0\
+\\x64DA\xC1D1\
+\\x64DB\xC1D2\
+\\x64DC\xC1D3\
+\\x64DD\xC1D4\
+\\x64DE\xC1D5\
+\\x64DF\xC1D6\
+\\x64E0\xC1D7\
+\\x64E1\xC1D8\
+\\x64E2\xC1D9\
+\\x64E3\xC1DA\
+\\x64E4\xC1DB\
+\\x64E5\xC1DC\
+\\x64E6\xC1DD\
+\\x64E7\xC1DE\
+\\x64E8\xC1DF\
+\\x64E9\xC1E0\
+\\x64EA\xC1E1\
+\\x64EB\xC1E2\
+\\x64EC\xC1E3\
+\\x64ED\xC1E4\
+\\x64EE\xC1E5\
+\\x64EF\xC1E6\
+\\x64F0\xC1E7\
+\\x64F1\xC1E8\
+\\x64F2\xC1E9\
+\\x64F3\xC1EA\
+\\x64F4\xC1EB\
+\\x64F5\xC1EC\
+\\x64F6\xC1ED\
+\\x64F7\xC1EE\
+\\x64F8\xC1EF\
+\\x64F9\xC1F0\
+\\x64FA\xC1F1\
+\\x64FB\xC1F2\
+\\x64FC\xC1F3\
+\\x64FD\xC1F4\
+\\x6541\xC1F5\
+\\x6542\xC1F6\
+\\x6543\xC1F7\
+\\x6544\xC1F8\
+\\x6545\xC1F9\
+\\x6546\xC1FA\
+\\x6547\xC1FB\
+\\x6548\xC1FC\
+\\x6549\xC1FD\
+\\x654A\xC1FE\
+\\x654B\xC240\
+\\x654C\xC241\
+\\x654D\xC242\
+\\x654E\xC243\
+\\x654F\xC244\
+\\x6550\xC245\
+\\x6551\xC246\
+\\x6552\xC247\
+\\x6553\xC248\
+\\x6554\xC249\
+\\x6555\xC24A\
+\\x6556\xC24B\
+\\x6557\xC24C\
+\\x6558\xC24D\
+\\x6559\xC24E\
+\\x655A\xC24F\
+\\x655B\xC250\
+\\x655C\xC251\
+\\x655D\xC252\
+\\x655E\xC253\
+\\x655F\xC254\
+\\x6560\x3F3F\
+\\x6561\xC256\
+\\x6562\xC257\
+\\x6563\xC258\
+\\x6564\xC259\
+\\x6565\xC25A\
+\\x6566\xC25B\
+\\x6567\xC25C\
+\\x6568\xC25D\
+\\x6569\xC25E\
+\\x656A\xC25F\
+\\x656B\xC260\
+\\x656C\xC261\
+\\x656D\xC262\
+\\x656E\xC263\
+\\x656F\xC264\
+\\x6570\xC265\
+\\x6571\xC266\
+\\x6572\xC267\
+\\x6573\xC268\
+\\x6574\xC269\
+\\x6575\xC26A\
+\\x6576\xC26B\
+\\x6577\xC26C\
+\\x6578\xC26D\
+\\x6579\xC26E\
+\\x657A\xC26F\
+\\x657B\xC270\
+\\x657C\xC271\
+\\x657D\xC272\
+\\x657E\xC273\
+\\x657F\xC274\
+\\x6581\xC275\
+\\x6582\xC276\
+\\x6583\xC277\
+\\x6584\xC278\
+\\x6585\xC279\
+\\x6586\xC27A\
+\\x6587\xC27B\
+\\x6588\xC27C\
+\\x6589\xC27D\
+\\x658A\xC27E\
+\\x658B\xC2A1\
+\\x658C\xC2A2\
+\\x658D\xC2A3\
+\\x658E\xC2A4\
+\\x658F\xC2A5\
+\\x6590\xC2A6\
+\\x6591\xC2A7\
+\\x6592\xC2A8\
+\\x6593\xC2A9\
+\\x6594\xC2AA\
+\\x6595\xC2AB\
+\\x6596\xC2AC\
+\\x6597\xC2AD\
+\\x6598\xC2AE\
+\\x6599\xC2AF\
+\\x659A\xC2B0\
+\\x659B\xC2B1\
+\\x659C\xC2B2\
+\\x659D\xC2B3\
+\\x659E\xC2B4\
+\\x659F\xC2B5\
+\\x65A0\xC2B6\
+\\x65A1\xC2B7\
+\\x65A2\xC2B8\
+\\x65A3\xC2B9\
+\\x65A4\xC2BA\
+\\x65A5\xC2BB\
+\\x65A6\xC2BC\
+\\x65A7\xC2BD\
+\\x65A8\xC2BE\
+\\x65A9\xC2BF\
+\\x65AA\xC2C0\
+\\x65AB\xC2C1\
+\\x65AC\xC2C2\
+\\x65AD\xC2C3\
+\\x65AE\xC2C4\
+\\x65AF\xC2C5\
+\\x65B0\xC2C6\
+\\x65B1\xC2C7\
+\\x65B2\xC2C8\
+\\x65B3\xC2C9\
+\\x65B4\xC2CA\
+\\x65B5\xC2CB\
+\\x65B6\xC2CC\
+\\x65B7\xC2CD\
+\\x65B8\xC2CE\
+\\x65B9\xC2CF\
+\\x65BA\xC2D0\
+\\x65BB\xC2D1\
+\\x65BC\xC2D2\
+\\x65BD\xC2D3\
+\\x65BE\xC2D4\
+\\x65BF\xC2D5\
+\\x65C0\xC2D6\
+\\x65C1\xC2D7\
+\\x65C2\xC2D8\
+\\x65C3\xC2D9\
+\\x65C4\xC2DA\
+\\x65C5\xC2DB\
+\\x65C6\xC2DC\
+\\x65C7\xC2DD\
+\\x65C8\xC2DE\
+\\x65C9\xC2DF\
+\\x65CA\xC2E0\
+\\x65CB\xC2E1\
+\\x65CC\xC2E2\
+\\x65CD\xC2E3\
+\\x65CE\xC2E4\
+\\x65CF\xC2E5\
+\\x65D0\xC2E6\
+\\x65D1\xC2E7\
+\\x65D2\xC2E8\
+\\x65D3\xC2E9\
+\\x65D4\xC2EA\
+\\x65D5\xC2EB\
+\\x65D6\xC2EC\
+\\x65D7\xC2ED\
+\\x65D8\xC2EE\
+\\x65D9\xC2EF\
+\\x65DA\xC2F0\
+\\x65DB\xC2F1\
+\\x65DC\xC2F2\
+\\x65DD\xC2F3\
+\\x65DE\xC2F4\
+\\x65DF\xC2F5\
+\\x65E0\xC2F6\
+\\x65E1\xC2F7\
+\\x65E2\xC2F8\
+\\x65E3\xC2F9\
+\\x65E4\xC2FA\
+\\x65E5\xC2FB\
+\\x65E6\xC2FC\
+\\x65E7\xC2FD\
+\\x65E8\xC2FE\
+\\x65E9\xC340\
+\\x65EA\xC341\
+\\x65EB\xC342\
+\\x65EC\xC343\
+\\x65ED\xC344\
+\\x65EE\xC345\
+\\x65EF\xC346\
+\\x65F0\xC347\
+\\x65F1\xC348\
+\\x65F2\xC349\
+\\x65F3\xC34A\
+\\x65F4\xC34B\
+\\x65F5\xC34C\
+\\x65F6\xC34D\
+\\x65F7\xC34E\
+\\x65F8\xC34F\
+\\x65F9\xC350\
+\\x65FA\xC351\
+\\x65FB\xC352\
+\\x65FC\xC353\
+\\x65FD\xC354\
+\\x6641\xC355\
+\\x6642\xC356\
+\\x6643\xC357\
+\\x6644\xC358\
+\\x6645\xC359\
+\\x6646\xC35A\
+\\x6647\xC35B\
+\\x6648\xC35C\
+\\x6649\xC35D\
+\\x664A\xC35E\
+\\x664B\xC35F\
+\\x664C\xC360\
+\\x664D\xC361\
+\\x664E\xC362\
+\\x664F\xC363\
+\\x6650\xC364\
+\\x6651\xC365\
+\\x6652\xC366\
+\\x6653\xC367\
+\\x6654\xC368\
+\\x6655\xC369\
+\\x6656\xC36A\
+\\x6657\xC36B\
+\\x6658\xC36C\
+\\x6659\xC36D\
+\\x665A\xC36E\
+\\x665B\xC36F\
+\\x665C\xC370\
+\\x665D\xC371\
+\\x665E\xC372\
+\\x665F\xC373\
+\\x6660\xC374\
+\\x6661\xC375\
+\\x6662\xC376\
+\\x6663\xC377\
+\\x6664\xC378\
+\\x6665\xC379\
+\\x6666\xC37A\
+\\x6667\xC37B\
+\\x6668\xC37C\
+\\x6669\xC37D\
+\\x666A\xC37E\
+\\x666B\xC3A1\
+\\x666C\xC3A2\
+\\x666D\xC3A3\
+\\x666E\xC3A4\
+\\x666F\xC3A5\
+\\x6670\xC3A6\
+\\x6671\xC3A7\
+\\x6672\xC3A8\
+\\x6673\xC3A9\
+\\x6674\xC3AA\
+\\x6675\xC3AB\
+\\x6676\xC3AC\
+\\x6677\xC3AD\
+\\x6678\xC3AE\
+\\x6679\xC3AF\
+\\x667A\xC3B0\
+\\x667B\xC3B1\
+\\x667C\xC3B2\
+\\x667D\xC3B3\
+\\x667E\xC3B4\
+\\x667F\xC3B5\
+\\x6681\xC3B6\
+\\x6682\xC3B7\
+\\x6683\xC3B8\
+\\x6684\xC3B9\
+\\x6685\xC3BA\
+\\x6686\xC3BB\
+\\x6687\xC3BC\
+\\x6688\xC3BD\
+\\x6689\xC3BE\
+\\x668A\xC3BF\
+\\x668B\xC3C0\
+\\x668C\xC3C1\
+\\x668D\xC3C2\
+\\x668E\xC3C3\
+\\x668F\xC3C4\
+\\x6690\xC3C5\
+\\x6691\xC3C6\
+\\x6692\xC3C7\
+\\x6693\xC3C8\
+\\x6694\xC3C9\
+\\x6695\xC3CA\
+\\x6696\xC3CB\
+\\x6697\xC3CC\
+\\x6698\xC3CD\
+\\x6699\xC3CE\
+\\x669A\xC3CF\
+\\x669B\xC3D0\
+\\x669C\xC3D1\
+\\x669D\xC3D2\
+\\x669E\xC3D3\
+\\x669F\xC3D4\
+\\x66A0\xC3D5\
+\\x66A1\xC3D6\
+\\x66A2\xC3D7\
+\\x66A3\xC3D8\
+\\x66A4\xC3D9\
+\\x66A5\xC3DA\
+\\x66A6\xC3DB\
+\\x66A7\xC3DC\
+\\x66A8\xC3DD\
+\\x66A9\xC3DE\
+\\x66AA\xC3DF\
+\\x66AB\xC3E0\
+\\x66AC\xC3E1\
+\\x66AD\xC3E2\
+\\x66AE\xC3E3\
+\\x66AF\xC3E4\
+\\x66B0\xC3E5\
+\\x66B1\xC3E6\
+\\x66B2\xC3E7\
+\\x66B3\xC3E8\
+\\x66B4\xC3E9\
+\\x66B5\xC3EA\
+\\x66B6\xC3EB\
+\\x66B7\xC3EC\
+\\x66B8\xC3ED\
+\\x66B9\xC3EE\
+\\x66BA\xC3EF\
+\\x66BB\xC3F0\
+\\x66BC\xC3F1\
+\\x66BD\xC3F2\
+\\x66BE\xC3F3\
+\\x66BF\xC3F4\
+\\x66C0\xC3F5\
+\\x66C1\xC3F6\
+\\x66C2\xC3F7\
+\\x66C3\xC3F8\
+\\x66C4\xC3F9\
+\\x66C5\xC3FA\
+\\x66C6\xC3FB\
+\\x66C7\xC3FC\
+\\x66C8\xC3FD\
+\\x66C9\xC3FE\
+\\x66CA\xC440\
+\\x66CB\xC441\
+\\x66CC\xC442\
+\\x66CD\xC443\
+\\x66CE\xC444\
+\\x66CF\xC445\
+\\x66D0\xC446\
+\\x66D1\xC447\
+\\x66D2\xC448\
+\\x66D3\xC449\
+\\x66D4\xC44A\
+\\x66D5\xC44B\
+\\x66D6\xC44C\
+\\x66D7\xC44D\
+\\x66D8\xC44E\
+\\x66D9\xC44F\
+\\x66DA\xC450\
+\\x66DB\xC451\
+\\x66DC\xC452\
+\\x66DD\xC453\
+\\x66DE\xC454\
+\\x66DF\xC455\
+\\x66E0\xC456\
+\\x66E1\xC457\
+\\x66E2\xC458\
+\\x66E3\xC459\
+\\x66E4\xC45A\
+\\x66E5\xC45B\
+\\x66E6\xC45C\
+\\x66E7\xC45D\
+\\x66E8\xC45E\
+\\x66E9\xC45F\
+\\x66EA\xC460\
+\\x66EB\xC461\
+\\x66EC\xC462\
+\\x66ED\xC463\
+\\x66EE\xC464\
+\\x66EF\xC465\
+\\x66F0\xC466\
+\\x66F1\xC467\
+\\x66F2\xC468\
+\\x66F3\xC469\
+\\x66F4\xC46A\
+\\x66F5\xC46B\
+\\x66F6\xC46C\
+\\x66F7\xC46D\
+\\x66F8\xC46E\
+\\x66F9\xC46F\
+\\x66FA\xC470\
+\\x66FB\xC471\
+\\x66FC\xC472\
+\\x66FD\xC473\
+\\x6741\xC474\
+\\x6742\xC475\
+\\x6743\xC476\
+\\x6744\xC477\
+\\x6745\xC478\
+\\x6746\xC479\
+\\x6747\xC47A\
+\\x6748\xC47B\
+\\x6749\xC47C\
+\\x674A\xC47D\
+\\x674B\xC47E\
+\\x674C\xC4A1\
+\\x674D\xC4A2\
+\\x674E\xC4A3\
+\\x674F\xC4A4\
+\\x6750\xC4A5\
+\\x6751\xC4A6\
+\\x6752\xC4A7\
+\\x6753\xC4A8\
+\\x6754\xC4A9\
+\\x6755\xC4AA\
+\\x6756\xC4AB\
+\\x6757\xC4AC\
+\\x6758\xC4AD\
+\\x6759\xC4AE\
+\\x675A\xC4AF\
+\\x675B\xC4B0\
+\\x675C\xC4B1\
+\\x675D\xC4B2\
+\\x675E\xC4B3\
+\\x675F\xC4B4\
+\\x6760\xC4B5\
+\\x6761\xC4B6\
+\\x6762\xC4B7\
+\\x6763\xC4B8\
+\\x6764\xC4B9\
+\\x6765\xC4BA\
+\\x6766\xC4BB\
+\\x6767\xC4BC\
+\\x6768\xC4BD\
+\\x6769\xC4BE\
+\\x676A\xC4BF\
+\\x676B\xC4C0\
+\\x676C\xC4C1\
+\\x676D\xC4C2\
+\\x676E\xC4C3\
+\\x676F\xC4C4\
+\\x6770\xC4C5\
+\\x6771\xC4C6\
+\\x6772\xC4C7\
+\\x6773\xC4C8\
+\\x6774\xC4C9\
+\\x6775\xC4CA\
+\\x6776\xC4CB\
+\\x6777\xC4CC\
+\\x6778\xC4CD\
+\\x6779\xC4CE\
+\\x677A\xC4CF\
+\\x677B\xC4D0\
+\\x677C\xC4D1\
+\\x677D\xC4D2\
+\\x677E\xC4D3\
+\\x677F\xC4D4\
+\\x6781\xC4D5\
+\\x6782\xC4D6\
+\\x6783\xC4D7\
+\\x6784\xC4D8\
+\\x6785\xC4D9\
+\\x6786\xC4DA\
+\\x6787\xC4DB\
+\\x6788\xC4DC\
+\\x6789\xC4DD\
+\\x678A\xC4DE\
+\\x678B\xC4DF\
+\\x678C\xC4E0\
+\\x678D\xC4E1\
+\\x678E\xC4E2\
+\\x678F\xC4E3\
+\\x6790\xC4E4\
+\\x6791\xC4E5\
+\\x6792\xC4E6\
+\\x6793\xC4E7\
+\\x6794\xC4E8\
+\\x6795\xC4E9\
+\\x6796\xC4EA\
+\\x6797\xC4EB\
+\\x6798\xC4EC\
+\\x6799\xC4ED\
+\\x679A\xC4EE\
+\\x679B\xC4EF\
+\\x679C\xC4F0\
+\\x679D\xC4F1\
+\\x679E\xC4F2\
+\\x679F\xC4F3\
+\\x67A0\xC4F4\
+\\x67A1\xC4F5\
+\\x67A2\xC4F6\
+\\x67A3\xC4F7\
+\\x67A4\xC4F8\
+\\x67A5\xC4F9\
+\\x67A6\xC4FA\
+\\x67A7\xC4FB\
+\\x67A8\xC4FC\
+\\x67A9\xC4FD\
+\\x67AA\xC4FE\
+\\x67AB\xC540\
+\\x67AC\xC541\
+\\x67AD\xC542\
+\\x67AE\xC543\
+\\x67AF\xC544\
+\\x67B0\xC545\
+\\x67B1\xC546\
+\\x67B2\xC547\
+\\x67B3\xC548\
+\\x67B4\xC549\
+\\x67B5\xC54A\
+\\x67B6\xC54B\
+\\x67B7\xC54C\
+\\x67B8\xC54D\
+\\x67B9\xC54E\
+\\x67BA\xC54F\
+\\x67BB\xC550\
+\\x67BC\xC551\
+\\x67BD\xC552\
+\\x67BE\xC553\
+\\x67BF\xC554\
+\\x67C0\xC555\
+\\x67C1\xC556\
+\\x67C2\xC557\
+\\x67C3\xC558\
+\\x67C4\xC559\
+\\x67C5\xC55A\
+\\x67C6\xC55B\
+\\x67C7\xC55C\
+\\x67C8\xC55D\
+\\x67C9\xC55E\
+\\x67CA\xC55F\
+\\x67CB\xC560\
+\\x67CC\xC561\
+\\x67CD\xC562\
+\\x67CE\xC563\
+\\x67CF\xC564\
+\\x67D0\xC565\
+\\x67D1\xC566\
+\\x67D2\xC567\
+\\x67D3\xC568\
+\\x67D4\xC569\
+\\x67D5\xC56A\
+\\x67D6\xC56B\
+\\x67D7\xC56C\
+\\x67D8\xC56D\
+\\x67D9\xC56E\
+\\x67DA\xC56F\
+\\x67DB\xC570\
+\\x67DC\xC571\
+\\x67DD\xC572\
+\\x67DE\xC573\
+\\x67DF\xC574\
+\\x67E0\xC575\
+\\x67E1\xC576\
+\\x67E2\xC577\
+\\x67E3\xC578\
+\\x67E4\xC579\
+\\x67E5\xC57A\
+\\x67E6\xC57B\
+\\x67E7\xC57C\
+\\x67E8\xC57D\
+\\x67E9\xC57E\
+\\x67EA\xC5A1\
+\\x67EB\xC5A2\
+\\x67EC\xC5A3\
+\\x67ED\xC5A4\
+\\x67EE\xC5A5\
+\\x67EF\xC5A6\
+\\x67F0\xC5A7\
+\\x67F1\xC5A8\
+\\x67F2\xC5A9\
+\\x67F3\xC5AA\
+\\x67F4\xC5AB\
+\\x67F5\xC5AC\
+\\x67F6\xC5AD\
+\\x67F7\xC5AE\
+\\x67F8\xC5AF\
+\\x67F9\xC5B0\
+\\x67FA\xC5B1\
+\\x67FB\xC5B2\
+\\x67FC\xC5B3\
+\\x67FD\xC5B4\
+\\x6841\xC5B5\
+\\x6842\xC5B6\
+\\x6843\xC5B7\
+\\x6844\xC5B8\
+\\x6845\xC5B9\
+\\x6846\xC5BA\
+\\x6847\xC5BB\
+\\x6848\xC5BC\
+\\x6849\xC5BD\
+\\x684A\xC5BE\
+\\x684B\xC5BF\
+\\x684C\xC5C0\
+\\x684D\xC5C1\
+\\x684E\xC5C2\
+\\x684F\xC5C3\
+\\x6850\xC5C4\
+\\x6851\xC5C5\
+\\x6852\xC5C6\
+\\x6853\xC5C7\
+\\x6854\xC5C8\
+\\x6855\xC5C9\
+\\x6856\xC5CA\
+\\x6857\xC5CB\
+\\x6858\xC5CC\
+\\x6859\xC5CD\
+\\x685A\xC5CE\
+\\x685B\xC5CF\
+\\x685C\xC5D0\
+\\x685D\xC5D1\
+\\x685E\xC5D2\
+\\x685F\xC5D3\
+\\x6860\xC5D4\
+\\x6861\xC5D5\
+\\x6862\xC5D6\
+\\x6863\xC5D7\
+\\x6864\xC5D8\
+\\x6865\xC5D9\
+\\x6866\xC5DA\
+\\x6867\xC5DB\
+\\x6868\xC5DC\
+\\x6869\xC5DD\
+\\x686A\xC5DE\
+\\x686B\xC5DF\
+\\x686C\xC5E0\
+\\x686D\xC5E1\
+\\x686E\xC5E2\
+\\x686F\xC5E3\
+\\x6870\xC5E4\
+\\x6871\xC5E5\
+\\x6872\xC5E6\
+\\x6873\xC5E7\
+\\x6874\xC5E8\
+\\x6875\xC5E9\
+\\x6876\xC5EA\
+\\x6877\xC5EB\
+\\x6878\xC5EC\
+\\x6879\xC5ED\
+\\x687A\xC5EE\
+\\x687B\xC5EF\
+\\x687C\xC5F0\
+\\x687D\xC5F1\
+\\x687E\xC5F2\
+\\x687F\xC5F3\
+\\x6881\xC5F4\
+\\x6882\xC5F5\
+\\x6883\xC5F6\
+\\x6884\xC5F7\
+\\x6885\xC5F8\
+\\x6886\xC5F9\
+\\x6887\xC5FA\
+\\x6888\xC5FB\
+\\x6889\xC5FC\
+\\x688A\xC5FD\
+\\x688B\xC5FE\
+\\x688C\xC640\
+\\x688D\xC641\
+\\x688E\xC642\
+\\x688F\xC643\
+\\x6890\xC644\
+\\x6891\xC645\
+\\x6892\xC646\
+\\x6893\xC647\
+\\x6894\xC648\
+\\x6895\xC649\
+\\x6896\xC64A\
+\\x6897\xC64B\
+\\x6898\xC64C\
+\\x6899\xC64D\
+\\x689A\xC64E\
+\\x689B\xC64F\
+\\x689C\xC650\
+\\x689D\xC651\
+\\x689E\xC652\
+\\x689F\xC653\
+\\x68A0\xC654\
+\\x68A1\xC655\
+\\x68A2\xC656\
+\\x68A3\xC657\
+\\x68A4\xC658\
+\\x68A5\xC659\
+\\x68A6\xC65A\
+\\x68A7\xC65B\
+\\x68A8\xC65C\
+\\x68A9\xC65D\
+\\x68AA\xC65E\
+\\x68AB\xC65F\
+\\x68AC\xC660\
+\\x68AD\xC661\
+\\x68AE\xC662\
+\\x68AF\xC663\
+\\x68B0\xC664\
+\\x68B1\xC665\
+\\x68B2\xC666\
+\\x68B3\xC667\
+\\x68B4\xC668\
+\\x68B5\xC669\
+\\x68B6\xC66A\
+\\x68B7\xC66B\
+\\x68B8\xC66C\
+\\x68B9\xC66D\
+\\x68BA\xC66E\
+\\x68BB\xC66F\
+\\x68BC\xC670\
+\\x68BD\xC671\
+\\x68BE\xC672\
+\\x68BF\xC673\
+\\x68C0\xC674\
+\\x68C1\xC675\
+\\x68C2\xC676\
+\\x68C3\xC677\
+\\x68C4\xC678\
+\\x68C5\xC679\
+\\x68C6\xC67A\
+\\x68C7\xC67B\
+\\x68C8\xC67C\
+\\x68C9\xC67D\
+\\x68CA\xC67E\
+\\x68CB\x3F3F\
+\\x6941\xC940\
+\\x6942\xC941\
+\\x6943\xC942\
+\\x6944\xC943\
+\\x6945\xC944\
+\\x6946\xC945\
+\\x6947\xC946\
+\\x6948\xC947\
+\\x6949\xC948\
+\\x694A\xC949\
+\\x694B\xC94A\
+\\x694C\xC94B\
+\\x694D\xC94C\
+\\x694E\xC94D\
+\\x694F\xC94E\
+\\x6950\xC94F\
+\\x6951\xC950\
+\\x6952\xC951\
+\\x6953\xC952\
+\\x6954\xC953\
+\\x6955\xC954\
+\\x6956\xC955\
+\\x6957\xC956\
+\\x6958\xC957\
+\\x6959\xC958\
+\\x695A\xC959\
+\\x695B\xC95A\
+\\x695C\xC95B\
+\\x695D\xC95C\
+\\x695E\xC95D\
+\\x695F\xC95E\
+\\x6960\xC95F\
+\\x6961\xC960\
+\\x6962\xC961\
+\\x6963\xC962\
+\\x6964\xC963\
+\\x6965\xC964\
+\\x6966\xC965\
+\\x6967\xC966\
+\\x6968\xC967\
+\\x6969\xC968\
+\\x696A\xC969\
+\\x696B\xC96A\
+\\x696C\xC96B\
+\\x696D\xC96C\
+\\x696E\xC96D\
+\\x696F\xC96E\
+\\x6970\xC96F\
+\\x6971\xC970\
+\\x6972\xC971\
+\\x6973\xC972\
+\\x6974\xC973\
+\\x6975\xC974\
+\\x6976\xC975\
+\\x6977\xC976\
+\\x6978\xC977\
+\\x6979\xC978\
+\\x697A\xC979\
+\\x697B\xC97A\
+\\x697C\xC97B\
+\\x697D\xC97C\
+\\x697E\xC97D\
+\\x697F\xC97E\
+\\x6981\xC9A1\
+\\x6982\xC9A2\
+\\x6983\xC9A3\
+\\x6984\xC9A4\
+\\x6985\xC9A5\
+\\x6986\xC9A6\
+\\x6987\xC9A7\
+\\x6988\xC9A8\
+\\x6989\xC9A9\
+\\x698A\xC9AA\
+\\x698B\xC9AB\
+\\x698C\xC9AC\
+\\x698D\xC9AD\
+\\x698E\xC9AE\
+\\x698F\xC9AF\
+\\x6990\xC9B0\
+\\x6991\xC9B1\
+\\x6992\xC9B2\
+\\x6993\xC9B3\
+\\x6994\xC9B4\
+\\x6995\xC9B5\
+\\x6996\xC9B6\
+\\x6997\xC9B7\
+\\x6998\xC9B8\
+\\x6999\xC9B9\
+\\x699A\xC9BA\
+\\x699B\xC9BB\
+\\x699C\xC9BC\
+\\x699D\xC9BD\
+\\x699E\xC9BE\
+\\x699F\xC9BF\
+\\x69A0\xC9C0\
+\\x69A1\xC9C1\
+\\x69A2\xC9C2\
+\\x69A3\xC9C3\
+\\x69A4\xC9C4\
+\\x69A5\xC9C5\
+\\x69A6\xC9C6\
+\\x69A7\xC9C7\
+\\x69A8\xC9C8\
+\\x69A9\xC9C9\
+\\x69AA\xC9CA\
+\\x69AB\xC9CB\
+\\x69AC\xC9CC\
+\\x69AD\xC9CD\
+\\x69AE\xC9CE\
+\\x69AF\xC9CF\
+\\x69B0\xC9D0\
+\\x69B1\xC9D1\
+\\x69B2\xC9D2\
+\\x69B3\xC9D3\
+\\x69B4\xC9D4\
+\\x69B5\xC9D5\
+\\x69B6\xC9D6\
+\\x69B7\xC9D7\
+\\x69B8\xC9D8\
+\\x69B9\xC9D9\
+\\x69BA\xC9DA\
+\\x69BB\xC9DB\
+\\x69BC\xC9DC\
+\\x69BD\xC9DD\
+\\x69BE\xC9DE\
+\\x69BF\xC9DF\
+\\x69C0\xC9E0\
+\\x69C1\xC9E1\
+\\x69C2\xC9E2\
+\\x69C3\xC9EC\
+\\x69C4\xC9E3\
+\\x69C5\xC9E4\
+\\x69C6\xC9E5\
+\\x69C7\xC9E6\
+\\x69C8\xC9E7\
+\\x69C9\xC9E8\
+\\x69CA\xC9E9\
+\\x69CB\xC9EA\
+\\x69CC\xC9EB\
+\\x69CD\xC9ED\
+\\x69CE\xC9EE\
+\\x69CF\xC9EF\
+\\x69D0\xC9F0\
+\\x69D1\xC9F1\
+\\x69D2\xC9F2\
+\\x69D3\xC9F3\
+\\x69D4\xC9F4\
+\\x69D5\xC9F5\
+\\x69D6\xC9F6\
+\\x69D7\xC9F7\
+\\x69D8\xC9F8\
+\\x69D9\xC9F9\
+\\x69DA\xC9FA\
+\\x69DB\xC9FB\
+\\x69DC\xC9FC\
+\\x69DD\xC9FD\
+\\x69DE\xC9FE\
+\\x69DF\xCA40\
+\\x69E0\xCA41\
+\\x69E1\xCA42\
+\\x69E2\xCA43\
+\\x69E3\xCA44\
+\\x69E4\xCA45\
+\\x69E5\xCA46\
+\\x69E6\xCA47\
+\\x69E7\xCA48\
+\\x69E8\xCA49\
+\\x69E9\xCA4A\
+\\x69EA\xCA4B\
+\\x69EB\xCA4C\
+\\x69EC\xCA4D\
+\\x69ED\xCA4E\
+\\x69EE\xCA4F\
+\\x69EF\xCA50\
+\\x69F0\xCA51\
+\\x69F1\xCA52\
+\\x69F2\xCA53\
+\\x69F3\xCA54\
+\\x69F4\xCA55\
+\\x69F5\xCA56\
+\\x69F6\xCA57\
+\\x69F7\xCA58\
+\\x69F8\xCA59\
+\\x69F9\xCA5A\
+\\x69FA\xCA5B\
+\\x69FB\xCA5C\
+\\x69FC\xCA5D\
+\\x69FD\xCA5E\
+\\x6A41\xCA5F\
+\\x6A42\xCA60\
+\\x6A43\xCA61\
+\\x6A44\xCA62\
+\\x6A45\xCA63\
+\\x6A46\xCA64\
+\\x6A47\xCA65\
+\\x6A48\xCA66\
+\\x6A49\xCA67\
+\\x6A4A\xCA68\
+\\x6A4B\xCA69\
+\\x6A4C\xCA6A\
+\\x6A4D\xCA6B\
+\\x6A4E\xCA6C\
+\\x6A4F\xCA6D\
+\\x6A50\xCA6E\
+\\x6A51\xCA6F\
+\\x6A52\xCA70\
+\\x6A53\xCA71\
+\\x6A54\xCA72\
+\\x6A55\xCA73\
+\\x6A56\xCA74\
+\\x6A57\xCA75\
+\\x6A58\xCA76\
+\\x6A59\xCA77\
+\\x6A5A\xCA78\
+\\x6A5B\xCA79\
+\\x6A5C\xCA7A\
+\\x6A5D\xCA7B\
+\\x6A5E\xCA7C\
+\\x6A5F\xCA7D\
+\\x6A60\xCA7E\
+\\x6A61\xCAA1\
+\\x6A62\xCAA2\
+\\x6A63\xCAA3\
+\\x6A64\xCAA4\
+\\x6A65\xCAA5\
+\\x6A66\xCAA6\
+\\x6A67\xCAA7\
+\\x6A68\xCAA8\
+\\x6A69\xCAA9\
+\\x6A6A\xCAAA\
+\\x6A6B\xCAAB\
+\\x6A6C\xCAAC\
+\\x6A6D\xCAAD\
+\\x6A6E\xCAAE\
+\\x6A6F\xCAAF\
+\\x6A70\xCAB0\
+\\x6A71\xCAB1\
+\\x6A72\xCAB2\
+\\x6A73\xCAB3\
+\\x6A74\xCAB4\
+\\x6A75\xCAB5\
+\\x6A76\xCAB6\
+\\x6A77\xCAB7\
+\\x6A78\xCAB8\
+\\x6A79\xCAB9\
+\\x6A7A\xCABA\
+\\x6A7B\xCABB\
+\\x6A7C\xCABC\
+\\x6A7D\xCABD\
+\\x6A7E\xCABE\
+\\x6A7F\xCABF\
+\\x6A81\xCAC0\
+\\x6A82\xCAC1\
+\\x6A83\xCAC2\
+\\x6A84\xCAC3\
+\\x6A85\xCAC4\
+\\x6A86\xCAC5\
+\\x6A87\xCAC6\
+\\x6A88\xCAC7\
+\\x6A89\xCAC8\
+\\x6A8A\xCAC9\
+\\x6A8B\xCACA\
+\\x6A8C\xCACB\
+\\x6A8D\xCACC\
+\\x6A8E\xCACD\
+\\x6A8F\xCACE\
+\\x6A90\xCACF\
+\\x6A91\xCAD0\
+\\x6A92\xCAD1\
+\\x6A93\xCAD2\
+\\x6A94\xCAD3\
+\\x6A95\xCAD4\
+\\x6A96\xCAD5\
+\\x6A97\xCAD6\
+\\x6A98\xCAD7\
+\\x6A99\xCAD8\
+\\x6A9A\xCAD9\
+\\x6A9B\xCADA\
+\\x6A9C\xCADB\
+\\x6A9D\xCADC\
+\\x6A9E\xCADD\
+\\x6A9F\xCADE\
+\\x6AA0\xCADF\
+\\x6AA1\xCAE0\
+\\x6AA2\xCAE1\
+\\x6AA3\xCAE2\
+\\x6AA4\xCAE3\
+\\x6AA5\xCAE4\
+\\x6AA6\xCAE5\
+\\x6AA7\xCAE6\
+\\x6AA8\xCAE7\
+\\x6AA9\xCAE8\
+\\x6AAA\xCAE9\
+\\x6AAB\xCAEA\
+\\x6AAC\xCAEB\
+\\x6AAD\xCAEC\
+\\x6AAE\xCAED\
+\\x6AAF\xCAEE\
+\\x6AB0\xCAEF\
+\\x6AB1\xCAF0\
+\\x6AB2\xCAF1\
+\\x6AB3\xCAF2\
+\\x6AB4\xCAF3\
+\\x6AB5\xCAF4\
+\\x6AB6\xCAF5\
+\\x6AB7\xCAF6\
+\\x6AB8\xCAF7\
+\\x6AB9\xCAF8\
+\\x6ABA\xCAF9\
+\\x6ABB\xCAFA\
+\\x6ABC\xCAFB\
+\\x6ABD\xCAFC\
+\\x6ABE\xCAFD\
+\\x6ABF\xCAFE\
+\\x6AC0\xCB40\
+\\x6AC1\xCB41\
+\\x6AC2\xCB42\
+\\x6AC3\xCB43\
+\\x6AC4\xCB44\
+\\x6AC5\xCB45\
+\\x6AC6\xCB46\
+\\x6AC7\xCB47\
+\\x6AC8\xCB48\
+\\x6AC9\xCB49\
+\\x6ACA\xCB4A\
+\\x6ACB\xCB4B\
+\\x6ACC\xCB4C\
+\\x6ACD\xCB4D\
+\\x6ACE\xCB4E\
+\\x6ACF\xCB4F\
+\\x6AD0\xCB50\
+\\x6AD1\xCB51\
+\\x6AD2\xCB52\
+\\x6AD3\xCB53\
+\\x6AD4\xCB54\
+\\x6AD5\xCB55\
+\\x6AD6\xCB56\
+\\x6AD7\xCB57\
+\\x6AD8\xCB58\
+\\x6AD9\xCB59\
+\\x6ADA\xCB5A\
+\\x6ADB\xCB5B\
+\\x6ADC\xCB5C\
+\\x6ADD\xCB5D\
+\\x6ADE\xCB5E\
+\\x6ADF\xCB5F\
+\\x6AE0\xCB60\
+\\x6AE1\xCB61\
+\\x6AE2\xCB62\
+\\x6AE3\xCB63\
+\\x6AE4\xCB64\
+\\x6AE5\xCB65\
+\\x6AE6\xCB66\
+\\x6AE7\xCB67\
+\\x6AE8\xCB68\
+\\x6AE9\xCB69\
+\\x6AEA\xCB6A\
+\\x6AEB\xCB6B\
+\\x6AEC\xCB6C\
+\\x6AED\xCB6D\
+\\x6AEE\xCB6E\
+\\x6AEF\xCB6F\
+\\x6AF0\xCB70\
+\\x6AF1\xCB71\
+\\x6AF2\xCB72\
+\\x6AF3\xCB73\
+\\x6AF4\xCB74\
+\\x6AF5\xCB75\
+\\x6AF6\xCB76\
+\\x6AF7\xCB77\
+\\x6AF8\xCB78\
+\\x6AF9\xCB79\
+\\x6AFA\xCB7A\
+\\x6AFB\xCB7B\
+\\x6AFC\xCB7C\
+\\x6AFD\xCB7D\
+\\x6B41\xCB7E\
+\\x6B42\xCBA1\
+\\x6B43\xCBA2\
+\\x6B44\xCBA3\
+\\x6B45\xCBA4\
+\\x6B46\xCBA5\
+\\x6B47\xCBA6\
+\\x6B48\xCBA7\
+\\x6B49\xCBA8\
+\\x6B4A\xCBA9\
+\\x6B4B\xCBAA\
+\\x6B4C\xCBAB\
+\\x6B4D\xCBAC\
+\\x6B4E\xCBAD\
+\\x6B4F\xCBAE\
+\\x6B50\xCBAF\
+\\x6B51\xCBB0\
+\\x6B52\xCBB1\
+\\x6B53\xCBB2\
+\\x6B54\xCBB3\
+\\x6B55\xCBB4\
+\\x6B56\xCBB5\
+\\x6B57\xCBB6\
+\\x6B58\xCBB7\
+\\x6B59\xCBB8\
+\\x6B5A\xCBB9\
+\\x6B5B\xCBBA\
+\\x6B5C\xCBBB\
+\\x6B5D\xCBBC\
+\\x6B5E\xCBBD\
+\\x6B5F\xCBBE\
+\\x6B60\xCBBF\
+\\x6B61\xCBC0\
+\\x6B62\xCBC1\
+\\x6B63\xCBC2\
+\\x6B64\xCBC3\
+\\x6B65\xCBC4\
+\\x6B66\xCBC5\
+\\x6B67\xCBC6\
+\\x6B68\xCBC7\
+\\x6B69\xCBC8\
+\\x6B6A\xCBC9\
+\\x6B6B\xCBCA\
+\\x6B6C\xCBCB\
+\\x6B6D\xCBCC\
+\\x6B6E\xCBCD\
+\\x6B6F\xCBCE\
+\\x6B70\xCBCF\
+\\x6B71\xCBD0\
+\\x6B72\xCBD1\
+\\x6B73\xCBD2\
+\\x6B74\xCBD3\
+\\x6B75\xCBD4\
+\\x6B76\xCBD5\
+\\x6B77\xCBD6\
+\\x6B78\xCBD7\
+\\x6B79\xCBD8\
+\\x6B7A\xCBD9\
+\\x6B7B\xCBDA\
+\\x6B7C\xCBDB\
+\\x6B7D\xCBDC\
+\\x6B7E\xCBDD\
+\\x6B7F\xCBDE\
+\\x6B81\xCBDF\
+\\x6B82\xCBE0\
+\\x6B83\xCBE1\
+\\x6B84\xCBE2\
+\\x6B85\xCBE3\
+\\x6B86\xCBE4\
+\\x6B87\xCBE5\
+\\x6B88\xCBE6\
+\\x6B89\xCBE7\
+\\x6B8A\xCBE8\
+\\x6B8B\xCBE9\
+\\x6B8C\xCBEA\
+\\x6B8D\xCBEB\
+\\x6B8E\xCBEC\
+\\x6B8F\xCBED\
+\\x6B90\xCBEE\
+\\x6B91\xCBEF\
+\\x6B92\xCBF0\
+\\x6B93\xCBF1\
+\\x6B94\xCBF2\
+\\x6B95\xCBF3\
+\\x6B96\xCBF4\
+\\x6B97\xCBF5\
+\\x6B98\xCBF6\
+\\x6B99\xCBF7\
+\\x6B9A\xCBF8\
+\\x6B9B\xCBF9\
+\\x6B9C\xCBFA\
+\\x6B9D\xCBFB\
+\\x6B9E\xCBFC\
+\\x6B9F\xCBFD\
+\\x6BA0\xCBFE\
+\\x6BA1\xCC40\
+\\x6BA2\xCC41\
+\\x6BA3\xCC42\
+\\x6BA4\xCC43\
+\\x6BA5\xCC44\
+\\x6BA6\xCC45\
+\\x6BA7\xCC46\
+\\x6BA8\xCC47\
+\\x6BA9\xCC48\
+\\x6BAA\xCC49\
+\\x6BAB\xCC4A\
+\\x6BAC\xCC4B\
+\\x6BAD\xCC4C\
+\\x6BAE\xCC4D\
+\\x6BAF\xCC4E\
+\\x6BB0\xCC4F\
+\\x6BB1\xCC50\
+\\x6BB2\xCC51\
+\\x6BB3\xCC52\
+\\x6BB4\xCC53\
+\\x6BB5\xCC54\
+\\x6BB6\xCC55\
+\\x6BB7\xCC56\
+\\x6BB8\xCC57\
+\\x6BB9\xCC58\
+\\x6BBA\xCC59\
+\\x6BBB\xCC5A\
+\\x6BBC\xCC5B\
+\\x6BBD\xCC5C\
+\\x6BBE\xCC5D\
+\\x6BBF\xCC5E\
+\\x6BC0\xCC5F\
+\\x6BC1\xCC60\
+\\x6BC2\xCC61\
+\\x6BC3\xCC62\
+\\x6BC4\xCC63\
+\\x6BC5\xCC64\
+\\x6BC6\xCC65\
+\\x6BC7\xCC66\
+\\x6BC8\xCC67\
+\\x6BC9\xCC68\
+\\x6BCA\xCC69\
+\\x6BCB\xCC6A\
+\\x6BCC\xCC6B\
+\\x6BCD\xCC6C\
+\\x6BCE\xCC6D\
+\\x6BCF\xCC6E\
+\\x6BD0\xCC6F\
+\\x6BD1\xCC70\
+\\x6BD2\xCC71\
+\\x6BD3\xCC72\
+\\x6BD4\xCC73\
+\\x6BD5\xCC74\
+\\x6BD6\xCC75\
+\\x6BD7\xCC76\
+\\x6BD8\xCC77\
+\\x6BD9\xCC78\
+\\x6BDA\xCC79\
+\\x6BDB\xCC7A\
+\\x6BDC\xCC7B\
+\\x6BDD\xCC7C\
+\\x6BDE\xCC7D\
+\\x6BDF\xCC7E\
+\\x6BE0\xCCA1\
+\\x6BE1\xCCA2\
+\\x6BE2\xCCA3\
+\\x6BE3\xCCA4\
+\\x6BE4\xCCA5\
+\\x6BE5\xCCA6\
+\\x6BE6\xCCA7\
+\\x6BE7\xCCA8\
+\\x6BE8\xCCA9\
+\\x6BE9\xCCAA\
+\\x6BEA\xCCAB\
+\\x6BEB\xCCAC\
+\\x6BEC\xCCAD\
+\\x6BED\xCCAE\
+\\x6BEE\xCCAF\
+\\x6BEF\xCCB0\
+\\x6BF0\xCCB1\
+\\x6BF1\xCCB2\
+\\x6BF2\xCCB3\
+\\x6BF3\xCCB4\
+\\x6BF4\xCCB5\
+\\x6BF5\xCCB6\
+\\x6BF6\xCCB7\
+\\x6BF7\xCCB8\
+\\x6BF8\xCCB9\
+\\x6BF9\xCCBA\
+\\x6BFA\xCCBB\
+\\x6BFB\xCCBC\
+\\x6BFC\xCCBD\
+\\x6BFD\xCCBE\
+\\x6C41\xCCBF\
+\\x6C42\xCCC0\
+\\x6C43\xCCC1\
+\\x6C44\xCCC2\
+\\x6C45\xCCC3\
+\\x6C46\xCCC4\
+\\x6C47\xCCC5\
+\\x6C48\xCCC6\
+\\x6C49\xCCC7\
+\\x6C4A\xCCC8\
+\\x6C4B\xCCC9\
+\\x6C4C\xCCCA\
+\\x6C4D\xCCCB\
+\\x6C4E\xCCCC\
+\\x6C4F\xCCCD\
+\\x6C50\xCCCE\
+\\x6C51\xCCCF\
+\\x6C52\xCCD0\
+\\x6C53\xCCD1\
+\\x6C54\xCCD2\
+\\x6C55\xCCD3\
+\\x6C56\xCCD4\
+\\x6C57\xCCD5\
+\\x6C58\xCCD6\
+\\x6C59\xCCD7\
+\\x6C5A\xCCD8\
+\\x6C5B\xCCD9\
+\\x6C5C\xCCDA\
+\\x6C5D\xCCDB\
+\\x6C5E\xCCDC\
+\\x6C5F\xCCDD\
+\\x6C60\xCCDE\
+\\x6C61\xCCDF\
+\\x6C62\xCCE0\
+\\x6C63\xCCE1\
+\\x6C64\xCCE2\
+\\x6C65\xCCE3\
+\\x6C66\xCCE4\
+\\x6C67\xCCE5\
+\\x6C68\xCCE6\
+\\x6C69\xCCE7\
+\\x6C6A\xCCE8\
+\\x6C6B\xCCE9\
+\\x6C6C\xCCEA\
+\\x6C6D\xCCEB\
+\\x6C6E\xCCEC\
+\\x6C6F\xCCED\
+\\x6C70\xCCEE\
+\\x6C71\xCCEF\
+\\x6C72\xCCF0\
+\\x6C73\xCCF1\
+\\x6C74\xCCF2\
+\\x6C75\xCCF3\
+\\x6C76\xCCF4\
+\\x6C77\xCCF5\
+\\x6C78\xCCF6\
+\\x6C79\xCCF7\
+\\x6C7A\xCCF8\
+\\x6C7B\xCCF9\
+\\x6C7C\xCCFA\
+\\x6C7D\xCCFB\
+\\x6C7E\xCCFC\
+\\x6C7F\xCCFD\
+\\x6C81\xCCFE\
+\\x6C82\xCD40\
+\\x6C83\xCD41\
+\\x6C84\xCD42\
+\\x6C85\xCD43\
+\\x6C86\xCD44\
+\\x6C87\xCD45\
+\\x6C88\xCD46\
+\\x6C89\xCD47\
+\\x6C8A\xCD48\
+\\x6C8B\xCD49\
+\\x6C8C\xCD4A\
+\\x6C8D\xCD4B\
+\\x6C8E\xCD4C\
+\\x6C8F\xCD4D\
+\\x6C90\xCD4E\
+\\x6C91\xCD4F\
+\\x6C92\xCD50\
+\\x6C93\xCD51\
+\\x6C94\xCD52\
+\\x6C95\xCD53\
+\\x6C96\xCD54\
+\\x6C97\xCD55\
+\\x6C98\xCD56\
+\\x6C99\xCD57\
+\\x6C9A\xCD58\
+\\x6C9B\xCD59\
+\\x6C9C\xCD5A\
+\\x6C9D\xCD5B\
+\\x6C9E\xCD5C\
+\\x6C9F\xCD5D\
+\\x6CA0\xCD5E\
+\\x6CA1\xCD5F\
+\\x6CA2\xCD60\
+\\x6CA3\xCD61\
+\\x6CA4\xCD62\
+\\x6CA5\xCD63\
+\\x6CA6\xCD64\
+\\x6CA7\xCD65\
+\\x6CA8\xCD66\
+\\x6CA9\xCD67\
+\\x6CAA\xCD68\
+\\x6CAB\xCD69\
+\\x6CAC\xCD6A\
+\\x6CAD\xCD6B\
+\\x6CAE\xCD6C\
+\\x6CAF\xCD6D\
+\\x6CB0\xCD6E\
+\\x6CB1\xCD6F\
+\\x6CB2\xCD70\
+\\x6CB3\xCD71\
+\\x6CB4\xCD72\
+\\x6CB5\xCD73\
+\\x6CB6\xCD74\
+\\x6CB7\xCD75\
+\\x6CB8\xCD76\
+\\x6CB9\xCD77\
+\\x6CBA\xCD78\
+\\x6CBB\xCD79\
+\\x6CBC\xCD7A\
+\\x6CBD\xCD7B\
+\\x6CBE\xCD7C\
+\\x6CBF\xCD7D\
+\\x6CC0\xCD7E\
+\\x6CC1\xCDA1\
+\\x6CC2\xCDA2\
+\\x6CC3\xCDA3\
+\\x6CC4\xCDA4\
+\\x6CC5\xCDA5\
+\\x6CC6\xCDA6\
+\\x6CC7\xCDA7\
+\\x6CC8\xCDA8\
+\\x6CC9\xCDA9\
+\\x6CCA\xCDAA\
+\\x6CCB\xCDAB\
+\\x6CCC\xCDAC\
+\\x6CCD\xCDAD\
+\\x6CCE\xCDAE\
+\\x6CCF\xCDAF\
+\\x6CD0\xCDB0\
+\\x6CD1\xCDB1\
+\\x6CD2\xCDB2\
+\\x6CD3\xCDB3\
+\\x6CD4\xCDB4\
+\\x6CD5\xCDB5\
+\\x6CD6\xCDB6\
+\\x6CD7\xCDB7\
+\\x6CD8\xCDB8\
+\\x6CD9\xCDB9\
+\\x6CDA\xCDBA\
+\\x6CDB\xCDBB\
+\\x6CDC\xCDBC\
+\\x6CDD\xCDBD\
+\\x6CDE\xCDBE\
+\\x6CDF\xCDBF\
+\\x6CE0\xCDC0\
+\\x6CE1\xCDC1\
+\\x6CE2\xCDC2\
+\\x6CE3\xCDC3\
+\\x6CE4\xCDC4\
+\\x6CE5\xCDC5\
+\\x6CE6\xCDC6\
+\\x6CE7\xCDC7\
+\\x6CE8\xCDC8\
+\\x6CE9\xCDC9\
+\\x6CEA\xCDCA\
+\\x6CEB\xCDCB\
+\\x6CEC\xCDCC\
+\\x6CED\xCDCD\
+\\x6CEE\xCDCE\
+\\x6CEF\xCDCF\
+\\x6CF0\xCDD0\
+\\x6CF1\xCDD1\
+\\x6CF2\xCDD2\
+\\x6CF3\xCDD3\
+\\x6CF4\xCDD4\
+\\x6CF5\xCDD5\
+\\x6CF6\xCDD6\
+\\x6CF7\xCDD7\
+\\x6CF8\xCDD8\
+\\x6CF9\xCDD9\
+\\x6CFA\xCDDA\
+\\x6CFB\xCDDB\
+\\x6CFC\xCDDC\
+\\x6CFD\xCDDD\
+\\x6D41\xCDDE\
+\\x6D42\xCDDF\
+\\x6D43\xCDE0\
+\\x6D44\xCDE1\
+\\x6D45\xCDE2\
+\\x6D46\xCDE3\
+\\x6D47\xCDE4\
+\\x6D48\xCDE5\
+\\x6D49\xCDE6\
+\\x6D4A\xCDE7\
+\\x6D4B\xCDE8\
+\\x6D4C\xCDE9\
+\\x6D4D\xCDEA\
+\\x6D4E\xCDEB\
+\\x6D4F\xCDEC\
+\\x6D50\xCDED\
+\\x6D51\xCDEE\
+\\x6D52\xCDEF\
+\\x6D53\xCDF0\
+\\x6D54\xCDF1\
+\\x6D55\xCDF2\
+\\x6D56\xCDF3\
+\\x6D57\xCDF4\
+\\x6D58\xCDF5\
+\\x6D59\xCDF6\
+\\x6D5A\xCDF7\
+\\x6D5B\xCDF8\
+\\x6D5C\xCDF9\
+\\x6D5D\xCDFA\
+\\x6D5E\xCDFB\
+\\x6D5F\xCDFC\
+\\x6D60\xCDFD\
+\\x6D61\xCDFE\
+\\x6D62\xCE40\
+\\x6D63\xCE41\
+\\x6D64\xCE42\
+\\x6D65\xCE43\
+\\x6D66\xCE44\
+\\x6D67\xCE45\
+\\x6D68\xCE46\
+\\x6D69\xCE47\
+\\x6D6A\xCE48\
+\\x6D6B\xCE49\
+\\x6D6C\xCE4A\
+\\x6D6D\xCE4B\
+\\x6D6E\xCE4C\
+\\x6D6F\xCE4D\
+\\x6D70\xCE4E\
+\\x6D71\xCE4F\
+\\x6D72\xCE50\
+\\x6D73\xCE51\
+\\x6D74\xCE52\
+\\x6D75\xCE53\
+\\x6D76\xCE54\
+\\x6D77\xCE55\
+\\x6D78\xCE56\
+\\x6D79\xCE57\
+\\x6D7A\xCE58\
+\\x6D7B\xCE59\
+\\x6D7C\xCE5A\
+\\x6D7D\xCE5B\
+\\x6D7E\xCE5C\
+\\x6D7F\xCE5D\
+\\x6D81\xCE5E\
+\\x6D82\xCE5F\
+\\x6D83\xCE60\
+\\x6D84\xCE61\
+\\x6D85\xCE62\
+\\x6D86\xCE63\
+\\x6D87\xCE64\
+\\x6D88\xCE65\
+\\x6D89\xCE66\
+\\x6D8A\xCE67\
+\\x6D8B\xCE68\
+\\x6D8C\xCE69\
+\\x6D8D\xCE6A\
+\\x6D8E\xCE6B\
+\\x6D8F\xCE6C\
+\\x6D90\xCE6D\
+\\x6D91\xCE6E\
+\\x6D92\xCE6F\
+\\x6D93\xCE70\
+\\x6D94\xCE71\
+\\x6D95\xCE72\
+\\x6D96\xCE73\
+\\x6D97\xCE74\
+\\x6D98\xCE75\
+\\x6D99\xCE76\
+\\x6D9A\xCE77\
+\\x6D9B\xCE78\
+\\x6D9C\xCE79\
+\\x6D9D\xCE7A\
+\\x6D9E\xCE7B\
+\\x6D9F\xCE7C\
+\\x6DA0\xCE7D\
+\\x6DA1\xCE7E\
+\\x6DA2\xCEA1\
+\\x6DA3\xCEA2\
+\\x6DA4\xCEA3\
+\\x6DA5\xCEA4\
+\\x6DA6\xCEA5\
+\\x6DA7\xCEA6\
+\\x6DA8\xCEA7\
+\\x6DA9\xCEA8\
+\\x6DAA\xCEA9\
+\\x6DAB\xCEAA\
+\\x6DAC\xCEAB\
+\\x6DAD\xCEAC\
+\\x6DAE\xCEAD\
+\\x6DAF\xCEAE\
+\\x6DB0\xCEAF\
+\\x6DB1\xCEB0\
+\\x6DB2\xCEB1\
+\\x6DB3\xCEB2\
+\\x6DB4\xCEB3\
+\\x6DB5\xCEB4\
+\\x6DB6\xCEB5\
+\\x6DB7\xCEB6\
+\\x6DB8\xCEB7\
+\\x6DB9\xCEB8\
+\\x6DBA\xCEB9\
+\\x6DBB\xCEBA\
+\\x6DBC\xCEBB\
+\\x6DBD\xCEBC\
+\\x6DBE\xCEBD\
+\\x6DBF\xCEBE\
+\\x6DC0\xCEBF\
+\\x6DC1\xCEC0\
+\\x6DC2\xCEC1\
+\\x6DC3\xCEC2\
+\\x6DC4\xCEC3\
+\\x6DC5\xCEC4\
+\\x6DC6\xCEC5\
+\\x6DC7\xCEC6\
+\\x6DC8\xCEC7\
+\\x6DC9\xCEC8\
+\\x6DCA\xCEC9\
+\\x6DCB\xCECA\
+\\x6DCC\xCECB\
+\\x6DCD\xCECC\
+\\x6DCE\xCECD\
+\\x6DCF\xCECE\
+\\x6DD0\xCECF\
+\\x6DD1\xCED0\
+\\x6DD2\xCED1\
+\\x6DD3\xCED2\
+\\x6DD4\xCED3\
+\\x6DD5\xCED4\
+\\x6DD6\xCED5\
+\\x6DD7\xCED6\
+\\x6DD8\xCED7\
+\\x6DD9\xCED8\
+\\x6DDA\xCED9\
+\\x6DDB\xCEDA\
+\\x6DDC\xCEDB\
+\\x6DDD\xCEDC\
+\\x6DDE\xCEDD\
+\\x6DDF\xCEDE\
+\\x6DE0\xCEDF\
+\\x6DE1\xCEE0\
+\\x6DE2\xCEE1\
+\\x6DE3\xCEE2\
+\\x6DE4\xCEE3\
+\\x6DE5\xCEE4\
+\\x6DE6\xCEE5\
+\\x6DE7\xCEE6\
+\\x6DE8\xCEE7\
+\\x6DE9\xCEE8\
+\\x6DEA\xCEE9\
+\\x6DEB\xCEEA\
+\\x6DEC\xCEEB\
+\\x6DED\xCEEC\
+\\x6DEE\xCEED\
+\\x6DEF\xCEEE\
+\\x6DF0\xCEEF\
+\\x6DF1\xCEF0\
+\\x6DF2\xCEF1\
+\\x6DF3\xCEF2\
+\\x6DF4\xCEF3\
+\\x6DF5\xCEF4\
+\\x6DF6\xCEF5\
+\\x6DF7\xCEF6\
+\\x6DF8\xCEF7\
+\\x6DF9\xCEF8\
+\\x6DFA\xCEF9\
+\\x6DFB\xCEFA\
+\\x6DFC\xCEFB\
+\\x6DFD\xCEFC\
+\\x6E41\xCEFD\
+\\x6E42\xCEFE\
+\\x6E43\xCF40\
+\\x6E44\xCF41\
+\\x6E45\xCF42\
+\\x6E46\xCF43\
+\\x6E47\xCF44\
+\\x6E48\xCF45\
+\\x6E49\xCF46\
+\\x6E4A\xCF47\
+\\x6E4B\xCF48\
+\\x6E4C\xCF49\
+\\x6E4D\xCF4A\
+\\x6E4E\xCF4B\
+\\x6E4F\xCF4C\
+\\x6E50\xCF4D\
+\\x6E51\xCF4E\
+\\x6E52\xCF4F\
+\\x6E53\xCF50\
+\\x6E54\xCF51\
+\\x6E55\xCF52\
+\\x6E56\xCF53\
+\\x6E57\xCF54\
+\\x6E58\xCF55\
+\\x6E59\xCF56\
+\\x6E5A\xCF57\
+\\x6E5B\xCF58\
+\\x6E5C\xCF59\
+\\x6E5D\xCF5A\
+\\x6E5E\xCF5B\
+\\x6E5F\xCF5C\
+\\x6E60\xCF5D\
+\\x6E61\xCF5E\
+\\x6E62\xCF5F\
+\\x6E63\xCF60\
+\\x6E64\xCF61\
+\\x6E65\xCF62\
+\\x6E66\xCF63\
+\\x6E67\xCF64\
+\\x6E68\xCF65\
+\\x6E69\xCF66\
+\\x6E6A\xCF67\
+\\x6E6B\xCF68\
+\\x6E6C\xCF69\
+\\x6E6D\xCF6A\
+\\x6E6E\xCF6B\
+\\x6E6F\xCF6C\
+\\x6E70\xCF6D\
+\\x6E71\xCF6E\
+\\x6E72\xCF6F\
+\\x6E73\xCF70\
+\\x6E74\xCF71\
+\\x6E75\xCF72\
+\\x6E76\xCF73\
+\\x6E77\xCF74\
+\\x6E78\xCF75\
+\\x6E79\xCF76\
+\\x6E7A\xCF77\
+\\x6E7B\xCF78\
+\\x6E7C\xCF79\
+\\x6E7D\xCF7A\
+\\x6E7E\xCF7B\
+\\x6E7F\xCF7C\
+\\x6E81\xCF7D\
+\\x6E82\xCF7E\
+\\x6E83\xCFA1\
+\\x6E84\xCFA2\
+\\x6E85\xCFA3\
+\\x6E86\xCFA4\
+\\x6E87\xCFA5\
+\\x6E88\xCFA6\
+\\x6E89\xCFA7\
+\\x6E8A\xCFA8\
+\\x6E8B\xCFA9\
+\\x6E8C\xCFAA\
+\\x6E8D\xCFAB\
+\\x6E8E\xCFAC\
+\\x6E8F\xCFAD\
+\\x6E90\xCFAE\
+\\x6E91\xCFAF\
+\\x6E92\xCFB0\
+\\x6E93\xCFB1\
+\\x6E94\xCFB2\
+\\x6E95\xCFB3\
+\\x6E96\xCFB4\
+\\x6E97\xCFB5\
+\\x6E98\xCFB6\
+\\x6E99\xCFB7\
+\\x6E9A\xCFB8\
+\\x6E9B\xCFB9\
+\\x6E9C\xCFBA\
+\\x6E9D\xCFBB\
+\\x6E9E\xCFBC\
+\\x6E9F\xCFBD\
+\\x6EA0\xCFBE\
+\\x6EA1\xCFBF\
+\\x6EA2\xCFC0\
+\\x6EA3\xCFC1\
+\\x6EA4\xCFC2\
+\\x6EA5\xCFC3\
+\\x6EA6\xCFC4\
+\\x6EA7\xCFC5\
+\\x6EA8\xCFC6\
+\\x6EA9\xCFC7\
+\\x6EAA\xCFC8\
+\\x6EAB\xCFC9\
+\\x6EAC\xCFCA\
+\\x6EAD\xCFCB\
+\\x6EAE\xCFCC\
+\\x6EAF\xCFCD\
+\\x6EB0\xCFCE\
+\\x6EB1\xCFCF\
+\\x6EB2\xCFD0\
+\\x6EB3\xCFD1\
+\\x6EB4\xCFD2\
+\\x6EB5\xCFD3\
+\\x6EB6\xCFD4\
+\\x6EB7\xCFD5\
+\\x6EB8\xCFD6\
+\\x6EB9\xCFD7\
+\\x6EBA\xCFD8\
+\\x6EBB\xCFD9\
+\\x6EBC\xCFDA\
+\\x6EBD\xCFDB\
+\\x6EBE\xCFDC\
+\\x6EBF\xCFDD\
+\\x6EC0\xCFDE\
+\\x6EC1\xCFDF\
+\\x6EC2\xCFE0\
+\\x6EC3\xCFE1\
+\\x6EC4\xCFE2\
+\\x6EC5\xCFE3\
+\\x6EC6\xCFE4\
+\\x6EC7\xCFE5\
+\\x6EC8\xCFE6\
+\\x6EC9\xCFE7\
+\\x6ECA\xCFE8\
+\\x6ECB\xCFE9\
+\\x6ECC\xCFEA\
+\\x6ECD\xCFEB\
+\\x6ECE\xCFEC\
+\\x6ECF\xCFED\
+\\x6ED0\xCFEE\
+\\x6ED1\xCFEF\
+\\x6ED2\xCFF0\
+\\x6ED3\xCFF1\
+\\x6ED4\xCFF2\
+\\x6ED5\xCFF3\
+\\x6ED6\xCFF4\
+\\x6ED7\xCFF5\
+\\x6ED8\xCFF6\
+\\x6ED9\xCFF7\
+\\x6EDA\xCFF8\
+\\x6EDB\xCFF9\
+\\x6EDC\xCFFA\
+\\x6EDD\xCFFB\
+\\x6EDE\xCFFC\
+\\x6EDF\xCFFD\
+\\x6EE0\xCFFE\
+\\x6EE1\xD040\
+\\x6EE2\xD041\
+\\x6EE3\xD042\
+\\x6EE4\xD043\
+\\x6EE5\xD044\
+\\x6EE6\xD045\
+\\x6EE7\xD046\
+\\x6EE8\xD047\
+\\x6EE9\xD048\
+\\x6EEA\xD049\
+\\x6EEB\xD04A\
+\\x6EEC\xD04B\
+\\x6EED\xD04C\
+\\x6EEE\xD04D\
+\\x6EEF\xD04E\
+\\x6EF0\xD04F\
+\\x6EF1\xD050\
+\\x6EF2\xD051\
+\\x6EF3\xD052\
+\\x6EF4\xD053\
+\\x6EF5\xD054\
+\\x6EF6\xD055\
+\\x6EF7\xD056\
+\\x6EF8\xD057\
+\\x6EF9\xD058\
+\\x6EFA\xD059\
+\\x6EFB\xD05A\
+\\x6EFC\xD05B\
+\\x6EFD\xD05C\
+\\x6F41\xD05D\
+\\x6F42\xD05E\
+\\x6F43\xD05F\
+\\x6F44\xD060\
+\\x6F45\xD061\
+\\x6F46\xD062\
+\\x6F47\xD063\
+\\x6F48\xD064\
+\\x6F49\xD065\
+\\x6F4A\xD066\
+\\x6F4B\xD067\
+\\x6F4C\xD068\
+\\x6F4D\xD069\
+\\x6F4E\xD06A\
+\\x6F4F\xD06B\
+\\x6F50\xD06C\
+\\x6F51\xD06D\
+\\x6F52\xD06E\
+\\x6F53\xD06F\
+\\x6F54\xD070\
+\\x6F55\xD071\
+\\x6F56\xD072\
+\\x6F57\xD073\
+\\x6F58\xD074\
+\\x6F59\xD075\
+\\x6F5A\xD076\
+\\x6F5B\xD077\
+\\x6F5C\xD078\
+\\x6F5D\xD079\
+\\x6F5E\xD07A\
+\\x6F5F\xD07B\
+\\x6F60\xD07C\
+\\x6F61\xD07D\
+\\x6F62\xD07E\
+\\x6F63\xD0A1\
+\\x6F64\xD0A2\
+\\x6F65\xD0A3\
+\\x6F66\xD0A4\
+\\x6F67\xD0A5\
+\\x6F68\xD0A6\
+\\x6F69\xD0A7\
+\\x6F6A\xD0A8\
+\\x6F6B\xD0A9\
+\\x6F6C\xD0AA\
+\\x6F6D\xD0AB\
+\\x6F6E\xD0AC\
+\\x6F6F\xD0AD\
+\\x6F70\xD0AE\
+\\x6F71\xD0AF\
+\\x6F72\xD0B0\
+\\x6F73\xD0B1\
+\\x6F74\xD0B2\
+\\x6F75\xD0B3\
+\\x6F76\xD0B4\
+\\x6F77\xD0B5\
+\\x6F78\xD0B6\
+\\x6F79\xD0B7\
+\\x6F7A\xD0B8\
+\\x6F7B\xD0B9\
+\\x6F7C\xD0BA\
+\\x6F7D\xD0BB\
+\\x6F7E\xD0BC\
+\\x6F7F\xD0BD\
+\\x6F81\xD0BE\
+\\x6F82\xD0BF\
+\\x6F83\xD0C0\
+\\x6F84\xD0C1\
+\\x6F85\xD0C2\
+\\x6F86\xD0C3\
+\\x6F87\xD0C4\
+\\x6F88\xD0C5\
+\\x6F89\xD0C6\
+\\x6F8A\xD0C7\
+\\x6F8B\xD0C8\
+\\x6F8C\xD0C9\
+\\x6F8D\xD0CA\
+\\x6F8E\xD0CB\
+\\x6F8F\xD0CC\
+\\x6F90\xD0CD\
+\\x6F91\xD0CE\
+\\x6F92\xD0CF\
+\\x6F93\xD0D0\
+\\x6F94\xD0D1\
+\\x6F95\xD0D2\
+\\x6F96\xD0D3\
+\\x6F97\xD0D4\
+\\x6F98\xD0D5\
+\\x6F99\xD0D6\
+\\x6F9A\xD0D7\
+\\x6F9B\xD0D8\
+\\x6F9C\xD0D9\
+\\x6F9D\xD0DA\
+\\x6F9E\xD0DB\
+\\x6F9F\xD0DC\
+\\x6FA0\xD0DD\
+\\x6FA1\xD0DE\
+\\x6FA2\xD0DF\
+\\x6FA3\xD0E0\
+\\x6FA4\xD0E1\
+\\x6FA5\xD0E2\
+\\x6FA6\xD0E3\
+\\x6FA7\xD0E4\
+\\x6FA8\xD0E5\
+\\x6FA9\xD0E6\
+\\x6FAA\xD0E7\
+\\x6FAB\xD0E8\
+\\x6FAC\xD0E9\
+\\x6FAD\xD0EA\
+\\x6FAE\xD0EB\
+\\x6FAF\xD0EC\
+\\x6FB0\xD0ED\
+\\x6FB1\xD0EE\
+\\x6FB2\xD0EF\
+\\x6FB3\xD0F0\
+\\x6FB4\xD0F1\
+\\x6FB5\xD0F2\
+\\x6FB6\xD0F3\
+\\x6FB7\xD0F4\
+\\x6FB8\xD0F5\
+\\x6FB9\xD0F6\
+\\x6FBA\xD0F7\
+\\x6FBB\xD0F8\
+\\x6FBC\xD0F9\
+\\x6FBD\xD0FA\
+\\x6FBE\xD0FB\
+\\x6FBF\xD0FC\
+\\x6FC0\xD0FD\
+\\x6FC1\xD0FE\
+\\x6FC2\xD140\
+\\x6FC3\xD141\
+\\x6FC4\xD142\
+\\x6FC5\xD143\
+\\x6FC6\xD144\
+\\x6FC7\xD145\
+\\x6FC8\xD146\
+\\x6FC9\xD147\
+\\x6FCA\xD148\
+\\x6FCB\xD149\
+\\x6FCC\xD14A\
+\\x6FCD\xD14B\
+\\x6FCE\xD14C\
+\\x6FCF\xD14D\
+\\x6FD0\xD14E\
+\\x6FD1\xD14F\
+\\x6FD2\xD150\
+\\x6FD3\xD151\
+\\x6FD4\xD152\
+\\x6FD5\xD153\
+\\x6FD6\xD154\
+\\x6FD7\xD155\
+\\x6FD8\xD156\
+\\x6FD9\xD157\
+\\x6FDA\xD158\
+\\x6FDB\xD159\
+\\x6FDC\xD15A\
+\\x6FDD\xD15B\
+\\x6FDE\xD15C\
+\\x6FDF\xD15D\
+\\x6FE0\xD15E\
+\\x6FE1\xD15F\
+\\x6FE2\xD160\
+\\x6FE3\xD161\
+\\x6FE4\xD162\
+\\x6FE5\xD163\
+\\x6FE6\xD164\
+\\x6FE7\xD165\
+\\x6FE8\xD166\
+\\x6FE9\xD167\
+\\x6FEA\xD168\
+\\x6FEB\xD169\
+\\x6FEC\xD16A\
+\\x6FED\xD16B\
+\\x6FEE\xD16C\
+\\x6FEF\xD16D\
+\\x6FF0\xD16E\
+\\x6FF1\xD16F\
+\\x6FF2\xD170\
+\\x6FF3\xD171\
+\\x6FF4\xD172\
+\\x6FF5\xD173\
+\\x6FF6\xD174\
+\\x6FF7\xD175\
+\\x6FF8\xD176\
+\\x6FF9\xD177\
+\\x6FFA\xD178\
+\\x6FFB\xD179\
+\\x6FFC\xD17A\
+\\x6FFD\xD17B\
+\\x7041\xD17C\
+\\x7042\xD17D\
+\\x7043\xD17E\
+\\x7044\xD1A1\
+\\x7045\xD1A2\
+\\x7046\xD1A3\
+\\x7047\xD1A4\
+\\x7048\xD1A5\
+\\x7049\xD1A6\
+\\x704A\xD1A7\
+\\x704B\xD1A8\
+\\x704C\xD1A9\
+\\x704D\xD1AA\
+\\x704E\xD1AB\
+\\x704F\xD1AC\
+\\x7050\xD1AD\
+\\x7051\xD1AE\
+\\x7052\xD1AF\
+\\x7053\xD1B0\
+\\x7054\xD1B1\
+\\x7055\xD1B2\
+\\x7056\xD1B3\
+\\x7057\xD1B4\
+\\x7058\xD1B5\
+\\x7059\xD1B6\
+\\x705A\xD1B7\
+\\x705B\xD1B8\
+\\x705C\xD1B9\
+\\x705D\xD1BA\
+\\x705E\xD1BB\
+\\x705F\xD1BC\
+\\x7060\xD1BD\
+\\x7061\xD1BE\
+\\x7062\xD1BF\
+\\x7063\xD1C0\
+\\x7064\xD1C1\
+\\x7065\xD1C2\
+\\x7066\xD1C3\
+\\x7067\xD1C4\
+\\x7068\xD1C5\
+\\x7069\xD1C6\
+\\x706A\xD1C7\
+\\x706B\xD1C8\
+\\x706C\xD1C9\
+\\x706D\xD1CA\
+\\x706E\xD1CB\
+\\x706F\xD1CC\
+\\x7070\xD1CD\
+\\x7071\xD1CE\
+\\x7072\xD1CF\
+\\x7073\xD1D0\
+\\x7074\xD1D1\
+\\x7075\xD1D2\
+\\x7076\xD1D3\
+\\x7077\xD1D4\
+\\x7078\xD1D5\
+\\x7079\xD1D6\
+\\x707A\xD1D7\
+\\x707B\xD1D8\
+\\x707C\xD1D9\
+\\x707D\xD1DA\
+\\x707E\xD1DB\
+\\x707F\xD1DC\
+\\x7081\xD1DD\
+\\x7082\xD1DE\
+\\x7083\xD1DF\
+\\x7084\xD1E0\
+\\x7085\xD1E1\
+\\x7086\xD1E2\
+\\x7087\xD1E3\
+\\x7088\xD1E4\
+\\x7089\xD1E5\
+\\x708A\xD1E6\
+\\x708B\xD1E7\
+\\x708C\xD1E8\
+\\x708D\xD1E9\
+\\x708E\xD1EA\
+\\x708F\xD1EB\
+\\x7090\xD1EC\
+\\x7091\xD1ED\
+\\x7092\xD1EE\
+\\x7093\xD1EF\
+\\x7094\xD1F0\
+\\x7095\xD1F1\
+\\x7096\xD1F2\
+\\x7097\xD1F3\
+\\x7098\xD1F4\
+\\x7099\xD1F5\
+\\x709A\xD1F6\
+\\x709B\xD1F7\
+\\x709C\xD1F8\
+\\x709D\xD1F9\
+\\x709E\xD1FA\
+\\x709F\xD1FB\
+\\x70A0\xD1FC\
+\\x70A1\xD1FD\
+\\x70A2\xD1FE\
+\\x70A3\xD240\
+\\x70A4\xD241\
+\\x70A5\xD242\
+\\x70A6\xD243\
+\\x70A7\xD244\
+\\x70A8\xD245\
+\\x70A9\xD246\
+\\x70AA\xD247\
+\\x70AB\xD248\
+\\x70AC\xD249\
+\\x70AD\xD24A\
+\\x70AE\xD24B\
+\\x70AF\xD24C\
+\\x70B0\xD24D\
+\\x70B1\xD24E\
+\\x70B2\xD24F\
+\\x70B3\xD250\
+\\x70B4\xD251\
+\\x70B5\xD252\
+\\x70B6\xD253\
+\\x70B7\xD254\
+\\x70B8\xD255\
+\\x70B9\xD256\
+\\x70BA\xD257\
+\\x70BB\xD258\
+\\x70BC\xD259\
+\\x70BD\xD25A\
+\\x70BE\xD25B\
+\\x70BF\xD25C\
+\\x70C0\xD25D\
+\\x70C1\xD25E\
+\\x70C2\xD25F\
+\\x70C3\xD260\
+\\x70C4\xD261\
+\\x70C5\xD262\
+\\x70C6\xD263\
+\\x70C7\xD264\
+\\x70C8\xD265\
+\\x70C9\xD266\
+\\x70CA\xD267\
+\\x70CB\xD268\
+\\x70CC\xD269\
+\\x70CD\xD26A\
+\\x70CE\xD26B\
+\\x70CF\xD26C\
+\\x70D0\xD26D\
+\\x70D1\xD26E\
+\\x70D2\xD26F\
+\\x70D3\xD270\
+\\x70D4\xD271\
+\\x70D5\xD272\
+\\x70D6\xD273\
+\\x70D7\xD274\
+\\x70D8\xD275\
+\\x70D9\xD276\
+\\x70DA\xD277\
+\\x70DB\xD278\
+\\x70DC\xD279\
+\\x70DD\xD27A\
+\\x70DE\xD27B\
+\\x70DF\xD27C\
+\\x70E0\xD27D\
+\\x70E1\xD27E\
+\\x70E2\xD2A1\
+\\x70E3\xD2A2\
+\\x70E4\xD2A3\
+\\x70E5\xD2A4\
+\\x70E6\xD2A5\
+\\x70E7\xD2A6\
+\\x70E8\xD2A7\
+\\x70E9\xD2A8\
+\\x70EA\xD2A9\
+\\x70EB\xD2AA\
+\\x70EC\xD2AB\
+\\x70ED\xD2AC\
+\\x70EE\xD2AD\
+\\x70EF\xD2AE\
+\\x70F0\xD2AF\
+\\x70F1\xD2B0\
+\\x70F2\xD2B1\
+\\x70F3\xD2B2\
+\\x70F4\xD2B3\
+\\x70F5\xD2B4\
+\\x70F6\xD2B5\
+\\x70F7\xD2B6\
+\\x70F8\xD2B7\
+\\x70F9\xD2B8\
+\\x70FA\xD2B9\
+\\x70FB\xD2BA\
+\\x70FC\xD2BB\
+\\x70FD\xD2BC\
+\\x7141\xD2BD\
+\\x7142\xD2BE\
+\\x7143\xD2BF\
+\\x7144\xD2C0\
+\\x7145\xD2C1\
+\\x7146\xD2C2\
+\\x7147\xD2C3\
+\\x7148\xD2C4\
+\\x7149\xD2C5\
+\\x714A\xD2C6\
+\\x714B\xD2C7\
+\\x714C\xD2C8\
+\\x714D\xD2C9\
+\\x714E\xD2CA\
+\\x714F\xD2CB\
+\\x7150\xD2CC\
+\\x7151\xD2CD\
+\\x7152\xD2CE\
+\\x7153\xD2CF\
+\\x7154\xD2D0\
+\\x7155\xD2D1\
+\\x7156\xD2D2\
+\\x7157\xD2D3\
+\\x7158\xD2D4\
+\\x7159\xD2D5\
+\\x715A\xD2D6\
+\\x715B\xD2D7\
+\\x715C\xD2D8\
+\\x715D\xD2D9\
+\\x715E\xD2DA\
+\\x715F\xD2DB\
+\\x7160\xD2DC\
+\\x7161\xD2DD\
+\\x7162\xD2DE\
+\\x7163\xD2DF\
+\\x7164\xD2E0\
+\\x7165\xD2E1\
+\\x7166\xD2E2\
+\\x7167\xD2E3\
+\\x7168\xD2E4\
+\\x7169\xD2E5\
+\\x716A\xD2E6\
+\\x716B\xD2E7\
+\\x716C\xD2E8\
+\\x716D\xD2E9\
+\\x716E\xD2EA\
+\\x716F\xD2EB\
+\\x7170\xD2EC\
+\\x7171\xD2ED\
+\\x7172\xD2EE\
+\\x7173\xD2EF\
+\\x7174\xD2F0\
+\\x7175\xD2F1\
+\\x7176\xD2F2\
+\\x7177\xD2F3\
+\\x7178\xD2F4\
+\\x7179\xD2F5\
+\\x717A\xD2F6\
+\\x717B\xD2F7\
+\\x717C\xD2F8\
+\\x717D\xD2F9\
+\\x717E\xD2FA\
+\\x717F\xD2FB\
+\\x7181\xD2FC\
+\\x7182\xD2FD\
+\\x7183\xD2FE\
+\\x7184\xD340\
+\\x7185\xD341\
+\\x7186\xD342\
+\\x7187\xD343\
+\\x7188\xD344\
+\\x7189\xD345\
+\\x718A\xD346\
+\\x718B\xD347\
+\\x718C\xD348\
+\\x718D\xD349\
+\\x718E\xD34A\
+\\x718F\xD34B\
+\\x7190\xD34C\
+\\x7191\xD34D\
+\\x7192\xD34E\
+\\x7193\xD34F\
+\\x7194\xD350\
+\\x7195\xD351\
+\\x7196\xD352\
+\\x7197\xD353\
+\\x7198\xD354\
+\\x7199\xD355\
+\\x719A\xD356\
+\\x719B\xD357\
+\\x719C\xD358\
+\\x719D\xD359\
+\\x719E\xD35A\
+\\x719F\xD35B\
+\\x71A0\xD35C\
+\\x71A1\xD35D\
+\\x71A2\xD35E\
+\\x71A3\xD35F\
+\\x71A4\xD360\
+\\x71A5\xD361\
+\\x71A6\xD362\
+\\x71A7\xD363\
+\\x71A8\xD364\
+\\x71A9\xD365\
+\\x71AA\xD366\
+\\x71AB\xD367\
+\\x71AC\xD368\
+\\x71AD\xD369\
+\\x71AE\xD36A\
+\\x71AF\xD36B\
+\\x71B0\xD36C\
+\\x71B1\xD36D\
+\\x71B2\xD36E\
+\\x71B3\xD36F\
+\\x71B4\xD370\
+\\x71B5\xD371\
+\\x71B6\xD372\
+\\x71B7\xD373\
+\\x71B8\xD374\
+\\x71B9\xD375\
+\\x71BA\xD376\
+\\x71BB\xD377\
+\\x71BC\xD378\
+\\x71BD\xD379\
+\\x71BE\xD37A\
+\\x71BF\xD37B\
+\\x71C0\xD37C\
+\\x71C1\xD37D\
+\\x71C2\xD37E\
+\\x71C3\xD3A1\
+\\x71C4\xD3A2\
+\\x71C5\xD3A3\
+\\x71C6\xD3A4\
+\\x71C7\xD3A5\
+\\x71C8\xD3A6\
+\\x71C9\xD3A7\
+\\x71CA\xD3A8\
+\\x71CB\xD3A9\
+\\x71CC\xD3AA\
+\\x71CD\xD3AB\
+\\x71CE\xD3AC\
+\\x71CF\xD3AD\
+\\x71D0\xD3AE\
+\\x71D1\xD3AF\
+\\x71D2\xD3B0\
+\\x71D3\xD3B1\
+\\x71D4\xD3B2\
+\\x71D5\xD3B3\
+\\x71D6\xD3B4\
+\\x71D7\xD3B5\
+\\x71D8\xD3B6\
+\\x71D9\xD3B7\
+\\x71DA\xD3B8\
+\\x71DB\xD3B9\
+\\x71DC\xD3BA\
+\\x71DD\xD3BB\
+\\x71DE\xD3BC\
+\\x71DF\xD3BD\
+\\x71E0\xD3BE\
+\\x71E1\xD3BF\
+\\x71E2\xD3C0\
+\\x71E3\xD3C1\
+\\x71E4\xD3C2\
+\\x71E5\xD3C3\
+\\x71E6\xD3C4\
+\\x71E7\xD3C5\
+\\x71E8\xD3C6\
+\\x71E9\xD3C7\
+\\x71EA\xD3C8\
+\\x71EB\xD3C9\
+\\x71EC\xD3CA\
+\\x71ED\xD3CB\
+\\x71EE\xD3CC\
+\\x71EF\xD3CD\
+\\x71F0\xD3CE\
+\\x71F1\xD3CF\
+\\x71F2\xD3D0\
+\\x71F3\xD3D1\
+\\x71F4\xD3D2\
+\\x71F5\xD3D3\
+\\x71F6\xD3D4\
+\\x71F7\xD3D5\
+\\x71F8\xD3D6\
+\\x71F9\xD3D7\
+\\x71FA\xD3D8\
+\\x71FB\xD3D9\
+\\x71FC\xD3DA\
+\\x71FD\xD3DB\
+\\x7241\xD3DC\
+\\x7242\xD3DD\
+\\x7243\xD3DE\
+\\x7244\xD3DF\
+\\x7245\xD3E0\
+\\x7246\xD3E1\
+\\x7247\xD3E2\
+\\x7248\xD3E3\
+\\x7249\xD3E4\
+\\x724A\xD3E5\
+\\x724B\xD3E6\
+\\x724C\xD3E7\
+\\x724D\xD3E8\
+\\x724E\xD3E9\
+\\x724F\xD3EA\
+\\x7250\xD3EB\
+\\x7251\xD3EC\
+\\x7252\xD3ED\
+\\x7253\xD3EE\
+\\x7254\xD3EF\
+\\x7255\xD3F0\
+\\x7256\xD3F1\
+\\x7257\xD3F2\
+\\x7258\xD3F3\
+\\x7259\xD3F4\
+\\x725A\xD3F5\
+\\x725B\xD3F6\
+\\x725C\xD3F7\
+\\x725D\xD3F8\
+\\x725E\xD3F9\
+\\x725F\xD3FA\
+\\x7260\xD3FB\
+\\x7261\xD3FC\
+\\x7262\xD3FD\
+\\x7263\xD3FE\
+\\x7264\xD440\
+\\x7265\xD441\
+\\x7266\xD442\
+\\x7267\xD443\
+\\x7268\xD444\
+\\x7269\xD445\
+\\x726A\xD446\
+\\x726B\xD447\
+\\x726C\xD448\
+\\x726D\xD449\
+\\x726E\xD44A\
+\\x726F\xD44B\
+\\x7270\xD44C\
+\\x7271\xD44D\
+\\x7272\xD44E\
+\\x7273\xD44F\
+\\x7274\xD450\
+\\x7275\xD451\
+\\x7276\xD452\
+\\x7277\xD453\
+\\x7278\xD454\
+\\x7279\xD455\
+\\x727A\xD456\
+\\x727B\xD457\
+\\x727C\xD458\
+\\x727D\xD459\
+\\x727E\xD45A\
+\\x727F\xD45B\
+\\x7281\xD45C\
+\\x7282\xD45D\
+\\x7283\xD45E\
+\\x7284\xD45F\
+\\x7285\xD460\
+\\x7286\xD461\
+\\x7287\xD462\
+\\x7288\xD463\
+\\x7289\xD464\
+\\x728A\xD465\
+\\x728B\xD466\
+\\x728C\xD467\
+\\x728D\xD468\
+\\x728E\xD469\
+\\x728F\xD46A\
+\\x7290\xD46B\
+\\x7291\xD46C\
+\\x7292\xD46D\
+\\x7293\xD46E\
+\\x7294\xD46F\
+\\x7295\xD470\
+\\x7296\xD471\
+\\x7297\xD472\
+\\x7298\xD473\
+\\x7299\xD474\
+\\x729A\xD475\
+\\x729B\xD476\
+\\x729C\xD477\
+\\x729D\xD478\
+\\x729E\xD479\
+\\x729F\xD47A\
+\\x72A0\xD47B\
+\\x72A1\xD47C\
+\\x72A2\xD47D\
+\\x72A3\xD47E\
+\\x72A4\xD4A1\
+\\x72A5\xD4A2\
+\\x72A6\xD4A3\
+\\x72A7\xD4A4\
+\\x72A8\xD4A5\
+\\x72A9\xD4A6\
+\\x72AA\xD4A7\
+\\x72AB\xD4A8\
+\\x72AC\xD4A9\
+\\x72AD\xD4AA\
+\\x72AE\xD4AB\
+\\x72AF\xD4AC\
+\\x72B0\xD4AD\
+\\x72B1\xD4AE\
+\\x72B2\xD4AF\
+\\x72B3\xD4B0\
+\\x72B4\xD4B1\
+\\x72B5\xD4B2\
+\\x72B6\xD4B3\
+\\x72B7\xD4B4\
+\\x72B8\xD4B5\
+\\x72B9\xD4B6\
+\\x72BA\xD4B7\
+\\x72BB\xD4B8\
+\\x72BC\xD4B9\
+\\x72BD\xD4BA\
+\\x72BE\xD4BB\
+\\x72BF\xD4BC\
+\\x72C0\xD4BD\
+\\x72C1\xD4BE\
+\\x72C2\xD4BF\
+\\x72C3\xD4C0\
+\\x72C4\xD4C1\
+\\x72C5\xD4C2\
+\\x72C6\xD4C3\
+\\x72C7\xD4C4\
+\\x72C8\xD4C5\
+\\x72C9\xD4C6\
+\\x72CA\xD4C7\
+\\x72CB\xD4C8\
+\\x72CC\xD4C9\
+\\x72CD\xD4CA\
+\\x72CE\xD4CB\
+\\x72CF\xD4CC\
+\\x72D0\xD4CD\
+\\x72D1\xD4CE\
+\\x72D2\xD4CF\
+\\x72D3\xD4D0\
+\\x72D4\xD4D1\
+\\x72D5\xD4D2\
+\\x72D6\xD4D3\
+\\x72D7\xD4D4\
+\\x72D8\xD4D5\
+\\x72D9\xD4D6\
+\\x72DA\xD4D7\
+\\x72DB\xD4D8\
+\\x72DC\xD4D9\
+\\x72DD\xD4DA\
+\\x72DE\xD4DB\
+\\x72DF\xD4DC\
+\\x72E0\xD4DD\
+\\x72E1\xD4DE\
+\\x72E2\xD4DF\
+\\x72E3\xD4E0\
+\\x72E4\xD4E1\
+\\x72E5\xD4E2\
+\\x72E6\xD4E3\
+\\x72E7\xD4E4\
+\\x72E8\xD4E5\
+\\x72E9\xD4E6\
+\\x72EA\xD4E7\
+\\x72EB\xD4E8\
+\\x72EC\xD4E9\
+\\x72ED\xD4EA\
+\\x72EE\xD4EB\
+\\x72EF\xD4EC\
+\\x72F0\xD4ED\
+\\x72F1\xD4EE\
+\\x72F2\xD4EF\
+\\x72F3\xD4F0\
+\\x72F4\xD4F1\
+\\x72F5\xD4F2\
+\\x72F6\xD4F3\
+\\x72F7\xD4F4\
+\\x72F8\xD4F5\
+\\x72F9\xD4F6\
+\\x72FA\xD4F7\
+\\x72FB\xD4F8\
+\\x72FC\xD4F9\
+\\x72FD\xD4FA\
+\\x7341\xD4FB\
+\\x7342\xD4FC\
+\\x7343\xD4FD\
+\\x7344\xD4FE\
+\\x7345\xD540\
+\\x7346\xD541\
+\\x7347\xD542\
+\\x7348\xD543\
+\\x7349\xD544\
+\\x734A\xD545\
+\\x734B\xD546\
+\\x734C\xD547\
+\\x734D\xD548\
+\\x734E\xD549\
+\\x734F\xD54A\
+\\x7350\xD54B\
+\\x7351\xD54C\
+\\x7352\xD54D\
+\\x7353\xD54E\
+\\x7354\xD54F\
+\\x7355\xD550\
+\\x7356\xD551\
+\\x7357\xD552\
+\\x7358\xD553\
+\\x7359\xD554\
+\\x735A\xD555\
+\\x735B\xD556\
+\\x735C\xD557\
+\\x735D\xD558\
+\\x735E\xD559\
+\\x735F\xD55A\
+\\x7360\xD55B\
+\\x7361\xD55C\
+\\x7362\xD55D\
+\\x7363\xD55E\
+\\x7364\xD55F\
+\\x7365\xD560\
+\\x7366\xD561\
+\\x7367\xD562\
+\\x7368\xD563\
+\\x7369\xD564\
+\\x736A\xD565\
+\\x736B\xD566\
+\\x736C\xD567\
+\\x736D\xD568\
+\\x736E\xD569\
+\\x736F\xD56A\
+\\x7370\xD56B\
+\\x7371\xD56C\
+\\x7372\xD56D\
+\\x7373\xD56E\
+\\x7374\xD56F\
+\\x7375\xD570\
+\\x7376\xD571\
+\\x7377\xD572\
+\\x7378\xD573\
+\\x7379\xD574\
+\\x737A\xD575\
+\\x737B\xD576\
+\\x737C\xD577\
+\\x737D\xD578\
+\\x737E\xD579\
+\\x737F\xD57A\
+\\x7381\xD57B\
+\\x7382\xD57C\
+\\x7383\xD57D\
+\\x7384\xD57E\
+\\x7385\xD5A1\
+\\x7386\xD5A2\
+\\x7387\xD5A3\
+\\x7388\xD5A4\
+\\x7389\xD5A5\
+\\x738A\xD5A6\
+\\x738B\xD5A7\
+\\x738C\xD5A8\
+\\x738D\xD5A9\
+\\x738E\xD5AA\
+\\x738F\xD5AB\
+\\x7390\xD5AC\
+\\x7391\xD5AD\
+\\x7392\xD5AE\
+\\x7393\xD5AF\
+\\x7394\xD5B0\
+\\x7395\xD5B1\
+\\x7396\xD5B2\
+\\x7397\xD5B3\
+\\x7398\xD5B4\
+\\x7399\xD5B5\
+\\x739A\xD5B6\
+\\x739B\xD5B7\
+\\x739C\xD5B8\
+\\x739D\xD5B9\
+\\x739E\xD5BA\
+\\x739F\xD5BB\
+\\x73A0\xD5BC\
+\\x73A1\xD5BD\
+\\x73A2\xD5BE\
+\\x73A3\xD5BF\
+\\x73A4\xD5C0\
+\\x73A5\xD5C1\
+\\x73A6\xD5C2\
+\\x73A7\xD5C3\
+\\x73A8\xD5C4\
+\\x73A9\xD5C5\
+\\x73AA\xD5C6\
+\\x73AB\xD5C7\
+\\x73AC\xD5C8\
+\\x73AD\xD5C9\
+\\x73AE\xD5CA\
+\\x73AF\xD5CB\
+\\x73B0\xD5CC\
+\\x73B1\xD5CD\
+\\x73B2\xD5CE\
+\\x73B3\xD5CF\
+\\x73B4\xD5D0\
+\\x73B5\xD5D1\
+\\x73B6\xD5D2\
+\\x73B7\xD5D3\
+\\x73B8\xD5D4\
+\\x73B9\xD5D5\
+\\x73BA\xD5D6\
+\\x73BB\xD5D7\
+\\x73BC\xD5D8\
+\\x73BD\xD5D9\
+\\x73BE\xD5DA\
+\\x73BF\xD5DB\
+\\x73C0\xD5DC\
+\\x73C1\xD5DD\
+\\x73C2\xD5DE\
+\\x73C3\xD5DF\
+\\x73C4\xD5E0\
+\\x73C5\xD5E1\
+\\x73C6\xD5E2\
+\\x73C7\xD5E3\
+\\x73C8\xD5E4\
+\\x73C9\xD5E5\
+\\x73CA\xD5E6\
+\\x73CB\xD5E7\
+\\x73CC\xD5E8\
+\\x73CD\xD5E9\
+\\x73CE\xD5EA\
+\\x73CF\xD5EB\
+\\x73D0\xD5EC\
+\\x73D1\xD5ED\
+\\x73D2\xD5EE\
+\\x73D3\xD5EF\
+\\x73D4\xD5F0\
+\\x73D5\xD5F1\
+\\x73D6\xD5F2\
+\\x73D7\xD5F3\
+\\x73D8\xD5F4\
+\\x73D9\xD5F5\
+\\x73DA\xD5F6\
+\\x73DB\xD5F7\
+\\x73DC\xD5F8\
+\\x73DD\xD5F9\
+\\x73DE\xD5FA\
+\\x73DF\xD5FB\
+\\x73E0\xD5FC\
+\\x73E1\xD5FD\
+\\x73E2\xD5FE\
+\\x73E3\xD640\
+\\x73E4\xD641\
+\\x73E5\xD642\
+\\x73E6\xD643\
+\\x73E7\xD644\
+\\x73E8\xD645\
+\\x73E9\xD646\
+\\x73EA\xD647\
+\\x73EB\xD648\
+\\x73EC\xD649\
+\\x73ED\xD64A\
+\\x73EE\xD64B\
+\\x73EF\xD64C\
+\\x73F0\xD64D\
+\\x73F1\xD64E\
+\\x73F2\xD64F\
+\\x73F3\xD650\
+\\x73F4\xD651\
+\\x73F5\xD652\
+\\x73F6\xD653\
+\\x73F7\xD654\
+\\x73F8\xD655\
+\\x73F9\xD656\
+\\x73FA\xD657\
+\\x73FB\xD658\
+\\x73FC\xD659\
+\\x73FD\xD65A\
+\\x7441\xD65B\
+\\x7442\xD65C\
+\\x7443\xD65D\
+\\x7444\xD65E\
+\\x7445\xD65F\
+\\x7446\xD660\
+\\x7447\xD661\
+\\x7448\xD662\
+\\x7449\xD663\
+\\x744A\xD664\
+\\x744B\xD665\
+\\x744C\xD666\
+\\x744D\xD667\
+\\x744E\xD668\
+\\x744F\xD669\
+\\x7450\xD66A\
+\\x7451\xD66B\
+\\x7452\xD66C\
+\\x7453\xD66D\
+\\x7454\xD66E\
+\\x7455\xD66F\
+\\x7456\xD670\
+\\x7457\xD671\
+\\x7458\xD672\
+\\x7459\xD673\
+\\x745A\xD674\
+\\x745B\xD675\
+\\x745C\xD676\
+\\x745D\xD677\
+\\x745E\xD678\
+\\x745F\xD679\
+\\x7460\xD67A\
+\\x7461\xD67B\
+\\x7462\xD67C\
+\\x7463\xD67D\
+\\x7464\xD67E\
+\\x7465\xD6A1\
+\\x7466\xD6A2\
+\\x7467\xD6A3\
+\\x7468\xD6A4\
+\\x7469\xD6A5\
+\\x746A\xD6A6\
+\\x746B\xD6A7\
+\\x746C\xD6A8\
+\\x746D\xD6A9\
+\\x746E\xD6AA\
+\\x746F\xD6AB\
+\\x7470\xD6AC\
+\\x7471\xD6AD\
+\\x7472\xD6AE\
+\\x7473\xD6AF\
+\\x7474\xD6B0\
+\\x7475\xD6B1\
+\\x7476\xD6B2\
+\\x7477\xD6B3\
+\\x7478\xD6B4\
+\\x7479\xD6B5\
+\\x747A\xD6B6\
+\\x747B\xD6B7\
+\\x747C\xD6B8\
+\\x747D\xD6B9\
+\\x747E\xD6BA\
+\\x747F\xD6BB\
+\\x7481\xD6BC\
+\\x7482\xD6BD\
+\\x7483\xD6BE\
+\\x7484\xD6BF\
+\\x7485\xD6C0\
+\\x7486\xD6C1\
+\\x7487\xD6C2\
+\\x7488\xD6C3\
+\\x7489\xD6C4\
+\\x748A\xD6C5\
+\\x748B\xD6C6\
+\\x748C\xD6C7\
+\\x748D\xD6C8\
+\\x748E\xD6C9\
+\\x748F\xD6CA\
+\\x7490\xD6CB\
+\\x7491\xD6CC\
+\\x7492\xD6CD\
+\\x7493\xD6CE\
+\\x7494\xD6CF\
+\\x7495\xD6D0\
+\\x7496\xD6D1\
+\\x7497\xD6D2\
+\\x7498\xD6D3\
+\\x7499\xD6D4\
+\\x749A\xD6D5\
+\\x749B\xD6D6\
+\\x749C\xD6D7\
+\\x749D\xD6D8\
+\\x749E\xD6D9\
+\\x749F\xD6DA\
+\\x74A0\xD6DB\
+\\x74A1\xD6DC\
+\\x74A2\xD6DD\
+\\x74A3\xD6DE\
+\\x74A4\xD6DF\
+\\x74A5\xD6E0\
+\\x74A6\xD6E1\
+\\x74A7\xD6E2\
+\\x74A8\xD6E3\
+\\x74A9\xD6E4\
+\\x74AA\xD6E5\
+\\x74AB\xD6E6\
+\\x74AC\xD6E7\
+\\x74AD\xD6E8\
+\\x74AE\xD6E9\
+\\x74AF\xD6EA\
+\\x74B0\xD6EB\
+\\x74B1\xD6EC\
+\\x74B2\xD6ED\
+\\x74B3\xD6EE\
+\\x74B4\xD6EF\
+\\x74B5\xD6F0\
+\\x74B6\xD6F1\
+\\x74B7\xD6F2\
+\\x74B8\xD6F3\
+\\x74B9\xD6F4\
+\\x74BA\xD6F5\
+\\x74BB\xD6F6\
+\\x74BC\xD6F7\
+\\x74BD\xD6F8\
+\\x74BE\xD6F9\
+\\x74BF\xD6FA\
+\\x74C0\xD6FB\
+\\x74C1\xD6FC\
+\\x74C2\xD6FD\
+\\x74C3\xD6FE\
+\\x74C4\xD740\
+\\x74C5\xD741\
+\\x74C6\xD742\
+\\x74C7\xD743\
+\\x74C8\xD744\
+\\x74C9\xD745\
+\\x74CA\xD746\
+\\x74CB\xD747\
+\\x74CC\xD748\
+\\x74CD\xD749\
+\\x74CE\xD74A\
+\\x74CF\xD74B\
+\\x74D0\xD74C\
+\\x74D1\xD74D\
+\\x74D2\xD74E\
+\\x74D3\xD74F\
+\\x74D4\xD750\
+\\x74D5\xD751\
+\\x74D6\xD752\
+\\x74D7\xD753\
+\\x74D8\xD754\
+\\x74D9\xD755\
+\\x74DA\xD756\
+\\x74DB\xD757\
+\\x74DC\xD758\
+\\x74DD\xD759\
+\\x74DE\xD75A\
+\\x74DF\xD75B\
+\\x74E0\xD75C\
+\\x74E1\xD75D\
+\\x74E2\xD75E\
+\\x74E3\xD75F\
+\\x74E4\xD760\
+\\x74E5\xD761\
+\\x74E6\xD762\
+\\x74E7\xD763\
+\\x74E8\xD764\
+\\x74E9\xD765\
+\\x74EA\xD766\
+\\x74EB\xD767\
+\\x74EC\xD768\
+\\x74ED\xD769\
+\\x74EE\xD76A\
+\\x74EF\xD76B\
+\\x74F0\xD76C\
+\\x74F1\xD76D\
+\\x74F2\xD76E\
+\\x74F3\xD76F\
+\\x74F4\xD770\
+\\x74F5\xD771\
+\\x74F6\xD772\
+\\x74F7\xD773\
+\\x74F8\xD774\
+\\x74F9\xD775\
+\\x74FA\xD776\
+\\x74FB\xD777\
+\\x74FC\xD778\
+\\x74FD\xD779\
+\\x7541\xD77A\
+\\x7542\xD77B\
+\\x7543\xD77C\
+\\x7544\xD77D\
+\\x7545\xD77E\
+\\x7546\xD7A1\
+\\x7547\xD7A2\
+\\x7548\xD7A3\
+\\x7549\xD7A4\
+\\x754A\xD7A5\
+\\x754B\xD7A6\
+\\x754C\xD7A7\
+\\x754D\xD7A8\
+\\x754E\xD7A9\
+\\x754F\xD7AA\
+\\x7550\xD7AB\
+\\x7551\xD7AC\
+\\x7552\xD7AD\
+\\x7553\xD7AE\
+\\x7554\xD7AF\
+\\x7555\xD7B0\
+\\x7556\xD7B1\
+\\x7557\xD7B2\
+\\x7558\xD7B3\
+\\x7559\xD7B4\
+\\x755A\xD7B5\
+\\x755B\xD7B6\
+\\x755C\xD7B7\
+\\x755D\xD7B8\
+\\x755E\xD7B9\
+\\x755F\xD7BA\
+\\x7560\xD7BB\
+\\x7561\xD7BC\
+\\x7562\xD7BD\
+\\x7563\xD7BE\
+\\x7564\xD7BF\
+\\x7565\xD7C0\
+\\x7566\xD7C1\
+\\x7567\xD7C2\
+\\x7568\xD7C3\
+\\x7569\xD7C4\
+\\x756A\xD7C5\
+\\x756B\xD7C6\
+\\x756C\xD7C7\
+\\x756D\xD7C8\
+\\x756E\xD7C9\
+\\x756F\xD7CA\
+\\x7570\xD7CB\
+\\x7571\xD7CC\
+\\x7572\xD7CD\
+\\x7573\xD7CE\
+\\x7574\xD7CF\
+\\x7575\xD7D0\
+\\x7576\xD7D1\
+\\x7577\xD7D2\
+\\x7578\xD7D3\
+\\x7579\xD7D4\
+\\x757A\xD7D5\
+\\x757B\xD7D6\
+\\x757C\xD7D7\
+\\x757D\xD7D8\
+\\x757E\xD7D9\
+\\x757F\xD7DA\
+\\x7581\xD7DB\
+\\x7582\xD7DC\
+\\x7583\xD7DD\
+\\x7584\xD7DE\
+\\x7585\xD7DF\
+\\x7586\xD7E0\
+\\x7587\xD7E1\
+\\x7588\xD7E2\
+\\x7589\xD7E3\
+\\x758A\xD7E4\
+\\x758B\xD7E5\
+\\x758C\xD7E6\
+\\x758D\xD7E7\
+\\x758E\xD7E8\
+\\x758F\xD7E9\
+\\x7590\xD7EA\
+\\x7591\xD7EB\
+\\x7592\xD7EC\
+\\x7593\xD7ED\
+\\x7594\xD7EE\
+\\x7595\xD7EF\
+\\x7596\xD7F0\
+\\x7597\xD7F1\
+\\x7598\xD7F2\
+\\x7599\xD7F3\
+\\x759A\xD7F4\
+\\x759B\xD7F5\
+\\x759C\xD7F6\
+\\x759D\xD7F7\
+\\x759E\xD7F8\
+\\x759F\xD7F9\
+\\x75A0\xD7FA\
+\\x75A1\xD7FB\
+\\x75A2\xD7FC\
+\\x75A3\xD7FD\
+\\x75A4\xD7FE\
+\\x75A5\xD840\
+\\x75A6\xD841\
+\\x75A7\xD842\
+\\x75A8\xD843\
+\\x75A9\xD844\
+\\x75AA\xD845\
+\\x75AB\xD846\
+\\x75AC\xD847\
+\\x75AD\xD848\
+\\x75AE\xD849\
+\\x75AF\xD84A\
+\\x75B0\xD84B\
+\\x75B1\xD84C\
+\\x75B2\xD84D\
+\\x75B3\xD84E\
+\\x75B4\xD84F\
+\\x75B5\xD850\
+\\x75B6\xD851\
+\\x75B7\xD852\
+\\x75B8\xD853\
+\\x75B9\xD854\
+\\x75BA\xD855\
+\\x75BB\xD856\
+\\x75BC\xD857\
+\\x75BD\xD858\
+\\x75BE\xD859\
+\\x75BF\xD85A\
+\\x75C0\xD85B\
+\\x75C1\xD85C\
+\\x75C2\xD85D\
+\\x75C3\xD85E\
+\\x75C4\xD85F\
+\\x75C5\xD860\
+\\x75C6\xD861\
+\\x75C7\xD862\
+\\x75C8\xD863\
+\\x75C9\xD864\
+\\x75CA\xD865\
+\\x75CB\xD866\
+\\x75CC\xD867\
+\\x75CD\xD868\
+\\x75CE\xD869\
+\\x75CF\xD86A\
+\\x75D0\xD86B\
+\\x75D1\xD86C\
+\\x75D2\xD86D\
+\\x75D3\xD86E\
+\\x75D4\xD86F\
+\\x75D5\xD870\
+\\x75D6\xD871\
+\\x75D7\xD872\
+\\x75D8\xD873\
+\\x75D9\xD874\
+\\x75DA\xD875\
+\\x75DB\xD876\
+\\x75DC\xD877\
+\\x75DD\xD878\
+\\x75DE\xD879\
+\\x75DF\xD87A\
+\\x75E0\xD87B\
+\\x75E1\xD87C\
+\\x75E2\xD87D\
+\\x75E3\xD87E\
+\\x75E4\xD8A1\
+\\x75E5\xD8A2\
+\\x75E6\xD8A3\
+\\x75E7\xD8A4\
+\\x75E8\xD8A5\
+\\x75E9\xD8A6\
+\\x75EA\xD8A7\
+\\x75EB\xD8A8\
+\\x75EC\xD8A9\
+\\x75ED\xD8AA\
+\\x75EE\xD8AB\
+\\x75EF\xD8AC\
+\\x75F0\xD8AD\
+\\x75F1\xD8AE\
+\\x75F2\xD8AF\
+\\x75F3\xD8B0\
+\\x75F4\xD8B1\
+\\x75F5\xD8B2\
+\\x75F6\xD8B3\
+\\x75F7\xD8B4\
+\\x75F8\xD8B5\
+\\x75F9\xD8B6\
+\\x75FA\xD8B7\
+\\x75FB\xD8B8\
+\\x75FC\xD8B9\
+\\x75FD\xD8BA\
+\\x7641\xD8BB\
+\\x7642\xD8BC\
+\\x7643\xD8BD\
+\\x7644\xD8BE\
+\\x7645\xD8BF\
+\\x7646\xD8C0\
+\\x7647\xD8C1\
+\\x7648\xD8C2\
+\\x7649\xD8C3\
+\\x764A\xD8C4\
+\\x764B\xD8C5\
+\\x764C\xD8C6\
+\\x764D\xD8C7\
+\\x764E\xD8C8\
+\\x764F\xD8C9\
+\\x7650\xD8CA\
+\\x7651\xD8CB\
+\\x7652\xD8CC\
+\\x7653\xD8CD\
+\\x7654\xD8CE\
+\\x7655\xD8CF\
+\\x7656\xD8D0\
+\\x7657\xD8D1\
+\\x7658\xD8D2\
+\\x7659\xD8D3\
+\\x765A\xD8D4\
+\\x765B\xD8D5\
+\\x765C\xD8D6\
+\\x765D\xD8D7\
+\\x765E\xD8D8\
+\\x765F\xD8D9\
+\\x7660\xD8DA\
+\\x7661\xD8DB\
+\\x7662\xD8DC\
+\\x7663\xD8DD\
+\\x7664\xD8DE\
+\\x7665\xD8DF\
+\\x7666\xD8E0\
+\\x7667\xD8E1\
+\\x7668\xD8E2\
+\\x7669\xD8E3\
+\\x766A\xD8E4\
+\\x766B\xD8E5\
+\\x766C\xD8E6\
+\\x766D\xD8E7\
+\\x766E\xD8E8\
+\\x766F\xD8E9\
+\\x7670\xD8EA\
+\\x7671\xD8EB\
+\\x7672\xD8EC\
+\\x7673\xD8ED\
+\\x7674\xD8EE\
+\\x7675\xD8EF\
+\\x7676\xD8F0\
+\\x7677\xD8F1\
+\\x7678\xD8F2\
+\\x7679\xD8F3\
+\\x767A\xD8F4\
+\\x767B\xD8F5\
+\\x767C\xD8F6\
+\\x767D\xD8F7\
+\\x767E\xD8F8\
+\\x767F\xD8F9\
+\\x7681\xD8FA\
+\\x7682\xD8FB\
+\\x7683\xD8FC\
+\\x7684\xD8FD\
+\\x7685\xD8FE\
+\\x7686\xD940\
+\\x7687\xD941\
+\\x7688\xD942\
+\\x7689\xD943\
+\\x768A\xD944\
+\\x768B\xD945\
+\\x768C\xD946\
+\\x768D\xD947\
+\\x768E\xD948\
+\\x768F\xD949\
+\\x7690\xD94A\
+\\x7691\xD94B\
+\\x7692\xD94C\
+\\x7693\xD94D\
+\\x7694\xD94E\
+\\x7695\xD94F\
+\\x7696\xD950\
+\\x7697\xD951\
+\\x7698\xD952\
+\\x7699\xD953\
+\\x769A\xD954\
+\\x769B\xD955\
+\\x769C\xD956\
+\\x769D\xD957\
+\\x769E\xD958\
+\\x769F\xD959\
+\\x76A0\xD95A\
+\\x76A1\xD95B\
+\\x76A2\xD95C\
+\\x76A3\xD95D\
+\\x76A4\xD95E\
+\\x76A5\xD95F\
+\\x76A6\xD960\
+\\x76A7\xD961\
+\\x76A8\xD962\
+\\x76A9\xD963\
+\\x76AA\xD964\
+\\x76AB\xD965\
+\\x76AC\xD966\
+\\x76AD\xD967\
+\\x76AE\xD968\
+\\x76AF\xD969\
+\\x76B0\xD96A\
+\\x76B1\xD96B\
+\\x76B2\xD96C\
+\\x76B3\xD96D\
+\\x76B4\xD96E\
+\\x76B5\xD96F\
+\\x76B6\xD970\
+\\x76B7\xD971\
+\\x76B8\xD972\
+\\x76B9\xD973\
+\\x76BA\xD974\
+\\x76BB\xD975\
+\\x76BC\xD976\
+\\x76BD\xD977\
+\\x76BE\xD978\
+\\x76BF\xD979\
+\\x76C0\xD97A\
+\\x76C1\xD97B\
+\\x76C2\xD97C\
+\\x76C3\xD97D\
+\\x76C4\xD97E\
+\\x76C5\xD9A1\
+\\x76C6\xD9A2\
+\\x76C7\xD9A3\
+\\x76C8\xD9A4\
+\\x76C9\xD9A5\
+\\x76CA\xD9A6\
+\\x76CB\xD9A7\
+\\x76CC\xD9A8\
+\\x76CD\xD9A9\
+\\x76CE\xD9AA\
+\\x76CF\xD9AB\
+\\x76D0\xD9AC\
+\\x76D1\xD9AD\
+\\x76D2\xD9AE\
+\\x76D3\xD9AF\
+\\x76D4\xD9B0\
+\\x76D5\xD9B1\
+\\x76D6\xD9B2\
+\\x76D7\xD9B3\
+\\x76D8\xD9B4\
+\\x76D9\xD9B5\
+\\x76DA\xD9B6\
+\\x76DB\xD9B7\
+\\x76DC\xD9B8\
+\\x76DD\xD9B9\
+\\x76DE\xD9BA\
+\\x76DF\xD9BB\
+\\x76E0\xD9BC\
+\\x76E1\xD9BD\
+\\x76E2\xD9BE\
+\\x76E3\xD9BF\
+\\x76E4\xD9C0\
+\\x76E5\xD9C1\
+\\x76E6\xD9C2\
+\\x76E7\xD9C3\
+\\x76E8\xD9C4\
+\\x76E9\xD9C5\
+\\x76EA\xD9C6\
+\\x76EB\xD9C7\
+\\x76EC\xD9C8\
+\\x76ED\xD9C9\
+\\x76EE\xD9CA\
+\\x76EF\xD9CB\
+\\x76F0\xD9CC\
+\\x76F1\xD9CD\
+\\x76F2\xD9CE\
+\\x76F3\xD9CF\
+\\x76F4\xD9D0\
+\\x76F5\xD9D1\
+\\x76F6\xD9D2\
+\\x76F7\xD9D3\
+\\x76F8\xD9D4\
+\\x76F9\xD9D5\
+\\x76FA\xD9D6\
+\\x76FB\xD9D7\
+\\x76FC\xD9D8\
+\\x76FD\xD9D9\
+\\x7741\xD9DA\
+\\x7742\xD9DB\
+\\x7743\xD9DC\
+\\x7744\xD9DD\
+\\x7745\xD9DE\
+\\x7746\xD9DF\
+\\x7747\xD9E0\
+\\x7748\xD9E1\
+\\x7749\xD9E2\
+\\x774A\xD9E3\
+\\x774B\xD9E4\
+\\x774C\xD9E5\
+\\x774D\xD9E6\
+\\x774E\xD9E7\
+\\x774F\xD9E8\
+\\x7750\xD9E9\
+\\x7751\xD9EA\
+\\x7752\xD9EB\
+\\x7753\xD9EC\
+\\x7754\xD9ED\
+\\x7755\xD9EE\
+\\x7756\xD9EF\
+\\x7757\xD9F0\
+\\x7758\xD9F1\
+\\x7759\xD9F2\
+\\x775A\xD9F3\
+\\x775B\xD9F4\
+\\x775C\xD9F5\
+\\x775D\xD9F6\
+\\x775E\xD9F7\
+\\x775F\xD9F8\
+\\x7760\xD9F9\
+\\x7761\xD9FA\
+\\x7762\xD9FB\
+\\x7763\xD9FC\
+\\x7764\xD9FD\
+\\x7765\xD9FE\
+\\x7766\xDA40\
+\\x7767\xDA41\
+\\x7768\xDA42\
+\\x7769\xDA43\
+\\x776A\xDA44\
+\\x776B\xDA45\
+\\x776C\xDA46\
+\\x776D\xDA47\
+\\x776E\xDA48\
+\\x776F\xDA49\
+\\x7770\xDA4A\
+\\x7771\xDA4B\
+\\x7772\xDA4C\
+\\x7773\xDA4D\
+\\x7774\xDA4E\
+\\x7775\xDA4F\
+\\x7776\xDA50\
+\\x7777\xDA51\
+\\x7778\xDA52\
+\\x7779\xDA53\
+\\x777A\xDA54\
+\\x777B\xDA55\
+\\x777C\xDA56\
+\\x777D\xDA57\
+\\x777E\xDA58\
+\\x777F\xDA59\
+\\x7781\xDA5A\
+\\x7782\xDA5B\
+\\x7783\xDA5C\
+\\x7784\xDA5D\
+\\x7785\xDA5E\
+\\x7786\xDA5F\
+\\x7787\xDA60\
+\\x7788\xDA61\
+\\x7789\xDA62\
+\\x778A\xDA63\
+\\x778B\xDA64\
+\\x778C\xDA65\
+\\x778D\xDA66\
+\\x778E\xDA67\
+\\x778F\xDA68\
+\\x7790\xDA69\
+\\x7791\xDA6A\
+\\x7792\xDA6B\
+\\x7793\xDA6C\
+\\x7794\xDA6D\
+\\x7795\xDA6E\
+\\x7796\xDA6F\
+\\x7797\xDA70\
+\\x7798\xDA71\
+\\x7799\xDA72\
+\\x779A\xDA73\
+\\x779B\xDA74\
+\\x779C\xDA75\
+\\x779D\xDA76\
+\\x779E\xDA77\
+\\x779F\xDA78\
+\\x77A0\xDA79\
+\\x77A1\xDA7A\
+\\x77A2\xDA7B\
+\\x77A3\xDA7C\
+\\x77A4\xDA7D\
+\\x77A5\xDA7E\
+\\x77A6\xDAA1\
+\\x77A7\xDAA2\
+\\x77A8\xDAA3\
+\\x77A9\xDAA4\
+\\x77AA\xDAA5\
+\\x77AB\xDAA6\
+\\x77AC\xDAA7\
+\\x77AD\xDAA8\
+\\x77AE\xDAA9\
+\\x77AF\xDAAA\
+\\x77B0\xDAAB\
+\\x77B1\xDAAC\
+\\x77B2\xDAAD\
+\\x77B3\xDAAE\
+\\x77B4\xDAAF\
+\\x77B5\xDAB0\
+\\x77B6\xDAB1\
+\\x77B7\xDAB2\
+\\x77B8\xDAB3\
+\\x77B9\xDAB4\
+\\x77BA\xDAB5\
+\\x77BB\xDAB6\
+\\x77BC\xDAB7\
+\\x77BD\xDAB8\
+\\x77BE\xDAB9\
+\\x77BF\xDABA\
+\\x77C0\xDABB\
+\\x77C1\xDABC\
+\\x77C2\xDABD\
+\\x77C3\xDABE\
+\\x77C4\xDABF\
+\\x77C5\xDAC0\
+\\x77C6\xDAC1\
+\\x77C7\xDAC2\
+\\x77C8\xDAC3\
+\\x77C9\xDAC4\
+\\x77CA\xDAC5\
+\\x77CB\xDAC6\
+\\x77CC\xDAC7\
+\\x77CD\xDAC8\
+\\x77CE\xDAC9\
+\\x77CF\xDACA\
+\\x77D0\xDACB\
+\\x77D1\xDACC\
+\\x77D2\xDACD\
+\\x77D3\xDACE\
+\\x77D4\xDACF\
+\\x77D5\xDAD0\
+\\x77D6\xDAD1\
+\\x77D7\xDAD2\
+\\x77D8\xDAD3\
+\\x77D9\xDAD4\
+\\x77DA\xDAD5\
+\\x77DB\xDAD6\
+\\x77DC\xDAD7\
+\\x77DD\xDAD8\
+\\x77DE\xDAD9\
+\\x77DF\xDADA\
+\\x77E0\xDADB\
+\\x77E1\xDADC\
+\\x77E2\xDADD\
+\\x77E3\xDADE\
+\\x77E4\xDADF\
+\\x77E5\xDAE0\
+\\x77E6\xDAE1\
+\\x77E7\xDAE2\
+\\x77E8\xDAE3\
+\\x77E9\xDAE4\
+\\x77EA\xDAE5\
+\\x77EB\xDAE6\
+\\x77EC\xDAE7\
+\\x77ED\xDAE8\
+\\x77EE\xDAE9\
+\\x77EF\xDAEA\
+\\x77F0\xDAEB\
+\\x77F1\xDAEC\
+\\x77F2\xDAED\
+\\x77F3\xDAEE\
+\\x77F4\xDAEF\
+\\x77F5\xDAF0\
+\\x77F6\xDAF1\
+\\x77F7\xDAF2\
+\\x77F8\xDAF3\
+\\x77F9\xDAF4\
+\\x77FA\xDAF5\
+\\x77FB\xDAF6\
+\\x77FC\xDAF7\
+\\x77FD\xDAF8\
+\\x7841\xDAF9\
+\\x7842\xDAFA\
+\\x7843\xDAFB\
+\\x7844\xDAFC\
+\\x7845\xDAFD\
+\\x7846\xDAFE\
+\\x7847\xDB40\
+\\x7848\xDB41\
+\\x7849\xDB42\
+\\x784A\xDB43\
+\\x784B\xDB44\
+\\x784C\xDB45\
+\\x784D\xDB46\
+\\x784E\xDB47\
+\\x784F\xDB48\
+\\x7850\xDB49\
+\\x7851\xDB4A\
+\\x7852\xDB4B\
+\\x7853\xDB4C\
+\\x7854\xDB4D\
+\\x7855\xDB4E\
+\\x7856\xDB4F\
+\\x7857\xDB50\
+\\x7858\xDB51\
+\\x7859\xDB52\
+\\x785A\xDB53\
+\\x785B\xDB54\
+\\x785C\xDB55\
+\\x785D\xDB56\
+\\x785E\xDB57\
+\\x785F\xDB58\
+\\x7860\xDB59\
+\\x7861\xDB5A\
+\\x7862\xDB5B\
+\\x7863\xDB5C\
+\\x7864\xDB5D\
+\\x7865\xDB5E\
+\\x7866\xDB5F\
+\\x7867\xDB60\
+\\x7868\xDB61\
+\\x7869\xDB62\
+\\x786A\xDB63\
+\\x786B\xDB64\
+\\x786C\xDB65\
+\\x786D\xDB66\
+\\x786E\xDB67\
+\\x786F\xDB68\
+\\x7870\xDB69\
+\\x7871\xDB6A\
+\\x7872\xDB6B\
+\\x7873\xDB6C\
+\\x7874\xDB6D\
+\\x7875\xDB6E\
+\\x7876\xDB6F\
+\\x7877\xDB70\
+\\x7878\xDB71\
+\\x7879\xDB72\
+\\x787A\xDB73\
+\\x787B\xDB74\
+\\x787C\xDB75\
+\\x787D\xDB76\
+\\x787E\xDB77\
+\\x787F\xDB78\
+\\x7881\xDB79\
+\\x7882\xDB7A\
+\\x7883\xDB7B\
+\\x7884\xDB7C\
+\\x7885\xDB7D\
+\\x7886\xDB7E\
+\\x7887\xDBA1\
+\\x7888\xDBA2\
+\\x7889\xDBA3\
+\\x788A\xDBA4\
+\\x788B\xDBA5\
+\\x788C\xDBA6\
+\\x788D\xDBA7\
+\\x788E\xDBA8\
+\\x788F\xDBA9\
+\\x7890\xDBAA\
+\\x7891\xDBAB\
+\\x7892\xDBAC\
+\\x7893\xDBAD\
+\\x7894\xDBAE\
+\\x7895\xDBAF\
+\\x7896\xDBB0\
+\\x7897\xDBB1\
+\\x7898\xDBB2\
+\\x7899\xDBB3\
+\\x789A\xDBB4\
+\\x789B\xDBB5\
+\\x789C\xDBB6\
+\\x789D\xDBB7\
+\\x789E\xDBB8\
+\\x789F\xDBB9\
+\\x78A0\xDBBA\
+\\x78A1\xDBBB\
+\\x78A2\xDBBC\
+\\x78A3\xDBBD\
+\\x78A4\xDBBE\
+\\x78A5\xDBBF\
+\\x78A6\xDBC0\
+\\x78A7\xDBC1\
+\\x78A8\xDBC2\
+\\x78A9\xDBC3\
+\\x78AA\xDBC4\
+\\x78AB\xDBC5\
+\\x78AC\xDBC6\
+\\x78AD\xDBC7\
+\\x78AE\xDBC8\
+\\x78AF\xDBC9\
+\\x78B0\xDBCA\
+\\x78B1\xDBCB\
+\\x78B2\xDBCC\
+\\x78B3\xDBCD\
+\\x78B4\xDBCE\
+\\x78B5\xDBCF\
+\\x78B6\xDBD0\
+\\x78B7\xDBD1\
+\\x78B8\xDBD2\
+\\x78B9\xDBD3\
+\\x78BA\xDBD4\
+\\x78BB\xDBD5\
+\\x78BC\xDBD6\
+\\x78BD\xDBD7\
+\\x78BE\xDBD8\
+\\x78BF\xDBD9\
+\\x78C0\xDBDA\
+\\x78C1\xDBDB\
+\\x78C2\xDBDC\
+\\x78C3\xDBDD\
+\\x78C4\xDBDE\
+\\x78C5\xDBDF\
+\\x78C6\xDBE0\
+\\x78C7\xDBE1\
+\\x78C8\xDBE2\
+\\x78C9\xDBE3\
+\\x78CA\xDBE4\
+\\x78CB\xDBE5\
+\\x78CC\xDBE6\
+\\x78CD\xDBE7\
+\\x78CE\xDBE8\
+\\x78CF\xDBE9\
+\\x78D0\xDBEA\
+\\x78D1\xDBEB\
+\\x78D2\xDBEC\
+\\x78D3\xDBED\
+\\x78D4\xDBEE\
+\\x78D5\xDBEF\
+\\x78D6\xDBF0\
+\\x78D7\xDBF1\
+\\x78D8\xDBF2\
+\\x78D9\xDBF3\
+\\x78DA\xDBF4\
+\\x78DB\xDBF5\
+\\x78DC\xDBF6\
+\\x78DD\xDBF7\
+\\x78DE\xDBF8\
+\\x78DF\xDBF9\
+\\x78E0\xDBFA\
+\\x78E1\xDBFB\
+\\x78E2\xDBFC\
+\\x78E3\xDBFD\
+\\x78E4\xDBFE\
+\\x78E5\xDC40\
+\\x78E6\xDC41\
+\\x78E7\xDC42\
+\\x78E8\xDC43\
+\\x78E9\xDC44\
+\\x78EA\xDC45\
+\\x78EB\xDC46\
+\\x78EC\xDC47\
+\\x78ED\xDC48\
+\\x78EE\xDC49\
+\\x78EF\xDC4A\
+\\x78F0\xDC4B\
+\\x78F1\xDC4C\
+\\x78F2\xDC4D\
+\\x78F3\xDC4E\
+\\x78F4\xDC4F\
+\\x78F5\xDC50\
+\\x78F6\xDC51\
+\\x78F7\xDC52\
+\\x78F8\xDC53\
+\\x78F9\xDC54\
+\\x78FA\xDC55\
+\\x78FB\xDC56\
+\\x78FC\xDC57\
+\\x78FD\xDC58\
+\\x7941\xDC59\
+\\x7942\xDC5A\
+\\x7943\xDC5B\
+\\x7944\xDC5C\
+\\x7945\xDC5D\
+\\x7946\xDC5E\
+\\x7947\xDC5F\
+\\x7948\xDC60\
+\\x7949\xDC61\
+\\x794A\xDC62\
+\\x794B\xDC63\
+\\x794C\xDC64\
+\\x794D\xDC65\
+\\x794E\xDC66\
+\\x794F\xDC67\
+\\x7950\xDC68\
+\\x7951\xDC69\
+\\x7952\xDC6A\
+\\x7953\xDC6B\
+\\x7954\xDC6C\
+\\x7955\xDC6D\
+\\x7956\xDC6E\
+\\x7957\xDC6F\
+\\x7958\xDC70\
+\\x7959\xDC71\
+\\x795A\xDC72\
+\\x795B\xDC73\
+\\x795C\xDC74\
+\\x795D\xDC75\
+\\x795E\xDC76\
+\\x795F\xDC77\
+\\x7960\xDC78\
+\\x7961\xDC79\
+\\x7962\xDC7A\
+\\x7963\xDC7B\
+\\x7964\xDC7C\
+\\x7965\xDC7D\
+\\x7966\xDC7E\
+\\x7967\xDCA1\
+\\x7968\xDCA2\
+\\x7969\xDCA3\
+\\x796A\xDCA4\
+\\x796B\xDCA5\
+\\x796C\xDCA6\
+\\x796D\xDCA7\
+\\x796E\xDCA8\
+\\x796F\xDCA9\
+\\x7970\xDCAA\
+\\x7971\xDCAB\
+\\x7972\xDCAC\
+\\x7973\xDCAD\
+\\x7974\xDCAE\
+\\x7975\xDCAF\
+\\x7976\xDCB0\
+\\x7977\xDCB1\
+\\x7978\xDCB2\
+\\x7979\xDCB3\
+\\x797A\xDCB4\
+\\x797B\xDCB5\
+\\x797C\xDCB6\
+\\x797D\xDCB7\
+\\x797E\xDCB8\
+\\x797F\xDCB9\
+\\x7981\xDCBA\
+\\x7982\xDCBB\
+\\x7983\xDCBC\
+\\x7984\xDCBD\
+\\x7985\xDCBE\
+\\x7986\xDCBF\
+\\x7987\xDCC0\
+\\x7988\xDCC1\
+\\x7989\xDCC2\
+\\x798A\xDCC3\
+\\x798B\xDCC4\
+\\x798C\xDCC5\
+\\x798D\xDCC6\
+\\x798E\xDCC7\
+\\x798F\xDCC8\
+\\x7990\xDCC9\
+\\x7991\xDCCA\
+\\x7992\xDCCB\
+\\x7993\xDCCC\
+\\x7994\xDCCD\
+\\x7995\xDCCE\
+\\x7996\xDCCF\
+\\x7997\xDCD0\
+\\x7998\xDCD1\
+\\x7999\xDCD2\
+\\x799A\xDCD3\
+\\x799B\xDCD4\
+\\x799C\xDCD5\
+\\x799D\xDCD6\
+\\x799E\xDCD7\
+\\x799F\xDCD8\
+\\x79A0\xDCD9\
+\\x79A1\xDCDA\
+\\x79A2\xDCDB\
+\\x79A3\xDCDC\
+\\x79A4\xDCDD\
+\\x79A5\xDCDE\
+\\x79A6\xDCDF\
+\\x79A7\xDCE0\
+\\x79A8\xDCE1\
+\\x79A9\xDCE2\
+\\x79AA\xDCE3\
+\\x79AB\xDCE4\
+\\x79AC\xDCE5\
+\\x79AD\xDCE6\
+\\x79AE\xDCE7\
+\\x79AF\xDCE8\
+\\x79B0\xDCE9\
+\\x79B1\xDCEA\
+\\x79B2\xDCEB\
+\\x79B3\xDCEC\
+\\x79B4\xDCED\
+\\x79B5\xDCEE\
+\\x79B6\xDCEF\
+\\x79B7\xDCF0\
+\\x79B8\xDCF1\
+\\x79B9\xDCF2\
+\\x79BA\xDCF3\
+\\x79BB\xDCF4\
+\\x79BC\xDCF5\
+\\x79BD\xDCF6\
+\\x79BE\xDCF7\
+\\x79BF\xDCF8\
+\\x79C0\xDCF9\
+\\x79C1\xDCFA\
+\\x79C2\xDCFB\
+\\x79C3\xDCFC\
+\\x79C4\xDCFD\
+\\x79C5\xDCFE\
+\\x79C6\xDD40\
+\\x79C7\xDD41\
+\\x79C8\xDD42\
+\\x79C9\xDD43\
+\\x79CA\xDD44\
+\\x79CB\xDD45\
+\\x79CC\xDD46\
+\\x79CD\xDD47\
+\\x79CE\xDD48\
+\\x79CF\xDD49\
+\\x79D0\xDD4A\
+\\x79D1\xDD4B\
+\\x79D2\xDD4C\
+\\x79D3\xDD4D\
+\\x79D4\xDD4E\
+\\x79D5\xDD4F\
+\\x79D6\xDD50\
+\\x79D7\xDD51\
+\\x79D8\xDD52\
+\\x79D9\xDD53\
+\\x79DA\xDD54\
+\\x79DB\xDD55\
+\\x79DC\xDD56\
+\\x79DD\xDD57\
+\\x79DE\xDD58\
+\\x79DF\xDD59\
+\\x79E0\xDD5A\
+\\x79E1\xDD5B\
+\\x79E2\xDD5C\
+\\x79E3\xDD5D\
+\\x79E4\xDD5E\
+\\x79E5\xDD5F\
+\\x79E6\xDD60\
+\\x79E7\xDD61\
+\\x79E8\xDD62\
+\\x79E9\xDD63\
+\\x79EA\xDD64\
+\\x79EB\xDD65\
+\\x79EC\xDD66\
+\\x79ED\xDD67\
+\\x79EE\xDD68\
+\\x79EF\xDD69\
+\\x79F0\xDD6A\
+\\x79F1\xDD6B\
+\\x79F2\xDD6C\
+\\x79F3\xDD6D\
+\\x79F4\xDD6E\
+\\x79F5\xDD6F\
+\\x79F6\xDD70\
+\\x79F7\xDD71\
+\\x79F8\xDD72\
+\\x79F9\xDD73\
+\\x79FA\xDD74\
+\\x79FB\xDD75\
+\\x79FC\xDD76\
+\\x79FD\xDD77\
+\\x7A41\xDD78\
+\\x7A42\xDD79\
+\\x7A43\xDD7A\
+\\x7A44\xDD7B\
+\\x7A45\xDD7C\
+\\x7A46\xDD7D\
+\\x7A47\xDD7E\
+\\x7A48\xDDA1\
+\\x7A49\xDDA2\
+\\x7A4A\xDDA3\
+\\x7A4B\xDDA4\
+\\x7A4C\xDDA5\
+\\x7A4D\xDDA6\
+\\x7A4E\xDDA7\
+\\x7A4F\xDDA8\
+\\x7A50\xDDA9\
+\\x7A51\xDDAA\
+\\x7A52\xDDAB\
+\\x7A53\xDDAC\
+\\x7A54\xDDAD\
+\\x7A55\xDDAE\
+\\x7A56\xDDAF\
+\\x7A57\xDDB0\
+\\x7A58\xDDB1\
+\\x7A59\xDDB2\
+\\x7A5A\xDDB3\
+\\x7A5B\xDDB4\
+\\x7A5C\xDDB5\
+\\x7A5D\xDDB6\
+\\x7A5E\xDDB7\
+\\x7A5F\xDDB8\
+\\x7A60\xDDB9\
+\\x7A61\xDDBA\
+\\x7A62\xDDBB\
+\\x7A63\xDDBC\
+\\x7A64\xDDBD\
+\\x7A65\xDDBE\
+\\x7A66\xDDBF\
+\\x7A67\xDDC0\
+\\x7A68\xDDC1\
+\\x7A69\xDDC2\
+\\x7A6A\xDDC3\
+\\x7A6B\xDDC4\
+\\x7A6C\xDDC5\
+\\x7A6D\xDDC6\
+\\x7A6E\xDDC7\
+\\x7A6F\xDDC8\
+\\x7A70\xDDC9\
+\\x7A71\xDDCA\
+\\x7A72\xDDCB\
+\\x7A73\xDDCC\
+\\x7A74\xDDCD\
+\\x7A75\xDDCE\
+\\x7A76\xDDCF\
+\\x7A77\xDDD0\
+\\x7A78\xDDD1\
+\\x7A79\xDDD2\
+\\x7A7A\xDDD3\
+\\x7A7B\xDDD4\
+\\x7A7C\xDDD5\
+\\x7A7D\xDDD6\
+\\x7A7E\xDDD7\
+\\x7A7F\xDDD8\
+\\x7A81\xDDD9\
+\\x7A82\xDDDA\
+\\x7A83\xDDDB\
+\\x7A84\xDDDC\
+\\x7A85\xDDDD\
+\\x7A86\xDDDE\
+\\x7A87\xDDDF\
+\\x7A88\xDDE0\
+\\x7A89\xDDE1\
+\\x7A8A\xDDE2\
+\\x7A8B\xDDE3\
+\\x7A8C\xDDE4\
+\\x7A8D\xDDE5\
+\\x7A8E\xDDE6\
+\\x7A8F\xDDE7\
+\\x7A90\xDDE8\
+\\x7A91\xDDE9\
+\\x7A92\xDDEA\
+\\x7A93\xDDEB\
+\\x7A94\xDDEC\
+\\x7A95\xDDED\
+\\x7A96\xDDEE\
+\\x7A97\xDDEF\
+\\x7A98\xDDF0\
+\\x7A99\xDDF1\
+\\x7A9A\xDDF2\
+\\x7A9B\xDDF3\
+\\x7A9C\xDDF4\
+\\x7A9D\xDDF5\
+\\x7A9E\xDDF6\
+\\x7A9F\xDDF7\
+\\x7AA0\xDDF8\
+\\x7AA1\xDDF9\
+\\x7AA2\xDDFA\
+\\x7AA3\xDDFB\
+\\x7AA4\xDDFC\
+\\x7AA5\xDDFD\
+\\x7AA6\xDDFE\
+\\x7AA7\xDE40\
+\\x7AA8\xDE41\
+\\x7AA9\xDE42\
+\\x7AAA\xDE43\
+\\x7AAB\xDE44\
+\\x7AAC\xDE45\
+\\x7AAD\xDE46\
+\\x7AAE\xDE47\
+\\x7AAF\xDE48\
+\\x7AB0\xDE49\
+\\x7AB1\xDE4A\
+\\x7AB2\xDE4B\
+\\x7AB3\xDE4C\
+\\x7AB4\xDE4D\
+\\x7AB5\xDE4E\
+\\x7AB6\xDE4F\
+\\x7AB7\xDE50\
+\\x7AB8\xDE51\
+\\x7AB9\xDE52\
+\\x7ABA\xDE53\
+\\x7ABB\xDE54\
+\\x7ABC\xDE55\
+\\x7ABD\xDE56\
+\\x7ABE\xDE57\
+\\x7ABF\xDE58\
+\\x7AC0\xDE59\
+\\x7AC1\xDE5A\
+\\x7AC2\xDE5B\
+\\x7AC3\xDE5C\
+\\x7AC4\xDE5D\
+\\x7AC5\xDE5E\
+\\x7AC6\xDE5F\
+\\x7AC7\xDE60\
+\\x7AC8\xDE61\
+\\x7AC9\xDE62\
+\\x7ACA\xDE63\
+\\x7ACB\xDE64\
+\\x7ACC\xDE65\
+\\x7ACD\xDE66\
+\\x7ACE\xDE67\
+\\x7ACF\xDE68\
+\\x7AD0\xDE69\
+\\x7AD1\xDE6A\
+\\x7AD2\xDE6B\
+\\x7AD3\xDE6C\
+\\x7AD4\xDE6D\
+\\x7AD5\xDE6E\
+\\x7AD6\xDE6F\
+\\x7AD7\xDE70\
+\\x7AD8\xDE71\
+\\x7AD9\xDE72\
+\\x7ADA\xDE73\
+\\x7ADB\xDE74\
+\\x7ADC\xDE75\
+\\x7ADD\xDE76\
+\\x7ADE\xDE77\
+\\x7ADF\xDE78\
+\\x7AE0\xDE79\
+\\x7AE1\xDE7A\
+\\x7AE2\xDE7B\
+\\x7AE3\xDE7C\
+\\x7AE4\xDE7D\
+\\x7AE5\xDE7E\
+\\x7AE6\xDEA1\
+\\x7AE7\xDEA2\
+\\x7AE8\xDEA3\
+\\x7AE9\xDEA4\
+\\x7AEA\xDEA5\
+\\x7AEB\xDEA6\
+\\x7AEC\xDEA7\
+\\x7AED\xDEA8\
+\\x7AEE\xDEA9\
+\\x7AEF\xDEAA\
+\\x7AF0\xDEAB\
+\\x7AF1\xDEAC\
+\\x7AF2\xDEAD\
+\\x7AF3\xDEAE\
+\\x7AF4\xDEAF\
+\\x7AF5\xDEB0\
+\\x7AF6\xDEB1\
+\\x7AF7\xDEB2\
+\\x7AF8\xDEB3\
+\\x7AF9\xDEB4\
+\\x7AFA\xDEB5\
+\\x7AFB\xDEB6\
+\\x7AFC\xDEB7\
+\\x7AFD\xDEB8\
+\\x7B41\xDEB9\
+\\x7B42\xDEBA\
+\\x7B43\xDEBB\
+\\x7B44\xDEBC\
+\\x7B45\xDEBD\
+\\x7B46\xDEBE\
+\\x7B47\xDEBF\
+\\x7B48\xDEC0\
+\\x7B49\xDEC1\
+\\x7B4A\xDEC2\
+\\x7B4B\xDEC3\
+\\x7B4C\xDEC4\
+\\x7B4D\xDEC5\
+\\x7B4E\xDEC6\
+\\x7B4F\xDEC7\
+\\x7B50\xDEC8\
+\\x7B51\xDEC9\
+\\x7B52\xDECA\
+\\x7B53\xDECB\
+\\x7B54\xDECC\
+\\x7B55\xDECD\
+\\x7B56\xDECE\
+\\x7B57\xDECF\
+\\x7B58\xDED0\
+\\x7B59\xDED1\
+\\x7B5A\xDED2\
+\\x7B5B\xDED3\
+\\x7B5C\xDED4\
+\\x7B5D\xDED5\
+\\x7B5E\xDED6\
+\\x7B5F\xDED7\
+\\x7B60\xDED8\
+\\x7B61\xDED9\
+\\x7B62\xDEDA\
+\\x7B63\xDEDB\
+\\x7B64\xDEDC\
+\\x7B65\xDEDD\
+\\x7B66\xDEDE\
+\\x7B67\xDEDF\
+\\x7B68\xDEE0\
+\\x7B69\xDEE1\
+\\x7B6A\xDEE2\
+\\x7B6B\xDEE3\
+\\x7B6C\xDEE4\
+\\x7B6D\xDEE5\
+\\x7B6E\xDEE6\
+\\x7B6F\xDEE7\
+\\x7B70\xDEE8\
+\\x7B71\xDEE9\
+\\x7B72\xDEEA\
+\\x7B73\xDEEB\
+\\x7B74\xDEEC\
+\\x7B75\xDEED\
+\\x7B76\xDEEE\
+\\x7B77\xDEEF\
+\\x7B78\xDEF0\
+\\x7B79\xDEF1\
+\\x7B7A\xDEF2\
+\\x7B7B\xDEF3\
+\\x7B7C\xDEF4\
+\\x7B7D\xDEF5\
+\\x7B7E\xDEF6\
+\\x7B7F\xDEF7\
+\\x7B81\xDEF8\
+\\x7B82\xDEF9\
+\\x7B83\xDEFA\
+\\x7B84\xDEFB\
+\\x7B85\xDEFC\
+\\x7B86\xDEFD\
+\\x7B87\xDEFE\
+\\x7B88\xDF40\
+\\x7B89\xDF41\
+\\x7B8A\xDF42\
+\\x7B8B\xDF43\
+\\x7B8C\xDF44\
+\\x7B8D\xDF45\
+\\x7B8E\xDF46\
+\\x7B8F\xDF47\
+\\x7B90\xDF48\
+\\x7B91\xDF49\
+\\x7B92\xDF4A\
+\\x7B93\xDF4B\
+\\x7B94\xDF4C\
+\\x7B95\xDF4D\
+\\x7B96\xDF4E\
+\\x7B97\xDF4F\
+\\x7B98\xDF50\
+\\x7B99\xDF51\
+\\x7B9A\xDF52\
+\\x7B9B\xDF53\
+\\x7B9C\xDF54\
+\\x7B9D\xDF55\
+\\x7B9E\xDF56\
+\\x7B9F\xDF57\
+\\x7BA0\xDF58\
+\\x7BA1\xDF59\
+\\x7BA2\xDF5A\
+\\x7BA3\xDF5B\
+\\x7BA4\xDF5C\
+\\x7BA5\xDF5D\
+\\x7BA6\xDF5E\
+\\x7BA7\xDF5F\
+\\x7BA8\xDF60\
+\\x7BA9\xDF61\
+\\x7BAA\xDF62\
+\\x7BAB\xDF63\
+\\x7BAC\xDF64\
+\\x7BAD\xDF65\
+\\x7BAE\xDF66\
+\\x7BAF\xDF67\
+\\x7BB0\xDF68\
+\\x7BB1\xDF69\
+\\x7BB2\xDF6A\
+\\x7BB3\xDF6B\
+\\x7BB4\xDF6C\
+\\x7BB5\xDF6D\
+\\x7BB6\xDF6E\
+\\x7BB7\xDF6F\
+\\x7BB8\xDF70\
+\\x7BB9\xDF71\
+\\x7BBA\xDF72\
+\\x7BBB\xDF73\
+\\x7BBC\xDF74\
+\\x7BBD\xDF75\
+\\x7BBE\xDF76\
+\\x7BBF\xDF77\
+\\x7BC0\xDF78\
+\\x7BC1\xDF79\
+\\x7BC2\xDF7A\
+\\x7BC3\xDF7B\
+\\x7BC4\xDF7C\
+\\x7BC5\xDF7D\
+\\x7BC6\xDF7E\
+\\x7BC7\xDFA1\
+\\x7BC8\xDFA2\
+\\x7BC9\xDFA3\
+\\x7BCA\xDFA4\
+\\x7BCB\xDFA5\
+\\x7BCC\xDFA6\
+\\x7BCD\xDFA7\
+\\x7BCE\xDFA8\
+\\x7BCF\xDFA9\
+\\x7BD0\xDFAA\
+\\x7BD1\xDFAB\
+\\x7BD2\xDFAC\
+\\x7BD3\xDFAD\
+\\x7BD4\xDFAE\
+\\x7BD5\xDFAF\
+\\x7BD6\xDFB0\
+\\x7BD7\xDFB1\
+\\x7BD8\xDFB2\
+\\x7BD9\xDFB3\
+\\x7BDA\xDFB4\
+\\x7BDB\xDFB5\
+\\x7BDC\xDFB6\
+\\x7BDD\xDFB7\
+\\x7BDE\xDFB8\
+\\x7BDF\xDFB9\
+\\x7BE0\xDFBA\
+\\x7BE1\xDFBB\
+\\x7BE2\xDFBC\
+\\x7BE3\xDFBD\
+\\x7BE4\xDFBE\
+\\x7BE5\xDFBF\
+\\x7BE6\xDFC0\
+\\x7BE7\xDFC1\
+\\x7BE8\xDFC2\
+\\x7BE9\xDFC3\
+\\x7BEA\xDFC4\
+\\x7BEB\xDFC5\
+\\x7BEC\xDFC6\
+\\x7BED\xDFC7\
+\\x7BEE\xDFC8\
+\\x7BEF\xDFC9\
+\\x7BF0\xDFCA\
+\\x7BF1\xDFCB\
+\\x7BF2\xDFCC\
+\\x7BF3\xDFCD\
+\\x7BF4\xDFCE\
+\\x7BF5\xDFCF\
+\\x7BF6\xDFD0\
+\\x7BF7\xDFD1\
+\\x7BF8\xDFD2\
+\\x7BF9\xDFD3\
+\\x7BFA\xDFD4\
+\\x7BFB\xDFD5\
+\\x7BFC\xDFD6\
+\\x7BFD\xDFD7\
+\\x7C41\xDFD8\
+\\x7C42\xDFD9\
+\\x7C43\xDFDA\
+\\x7C44\xDFDB\
+\\x7C45\xDFDC\
+\\x7C46\xDFDD\
+\\x7C47\xDFDE\
+\\x7C48\xDFDF\
+\\x7C49\xDFE0\
+\\x7C4A\xDFE1\
+\\x7C4B\xDFE2\
+\\x7C4C\xDFE3\
+\\x7C4D\xDFE4\
+\\x7C4E\xDFE5\
+\\x7C4F\xDFE6\
+\\x7C50\xDFE7\
+\\x7C51\xDFE8\
+\\x7C52\xDFE9\
+\\x7C53\xDFEA\
+\\x7C54\xDFEB\
+\\x7C55\xDFEC\
+\\x7C56\xDFED\
+\\x7C57\xDFEE\
+\\x7C58\xDFEF\
+\\x7C59\xDFF0\
+\\x7C5A\xDFF1\
+\\x7C5B\xDFF2\
+\\x7C5C\xDFF3\
+\\x7C5D\xDFF4\
+\\x7C5E\xDFF5\
+\\x7C5F\xDFF6\
+\\x7C60\xDFF7\
+\\x7C61\xDFF8\
+\\x7C62\xDFF9\
+\\x7C63\xDFFA\
+\\x7C64\xDFFB\
+\\x7C65\xDFFC\
+\\x7C66\xDFFD\
+\\x7C67\xDFFE\
+\\x7C68\xE040\
+\\x7C69\xE041\
+\\x7C6A\xE042\
+\\x7C6B\xE043\
+\\x7C6C\xE044\
+\\x7C6D\xE045\
+\\x7C6E\xE046\
+\\x7C6F\xE047\
+\\x7C70\xE048\
+\\x7C71\xE049\
+\\x7C72\xE04A\
+\\x7C73\xE04B\
+\\x7C74\xE04C\
+\\x7C75\xE04D\
+\\x7C76\xE04E\
+\\x7C77\xE04F\
+\\x7C78\xE050\
+\\x7C79\xE051\
+\\x7C7A\xE052\
+\\x7C7B\xE053\
+\\x7C7C\xE054\
+\\x7C7D\xE055\
+\\x7C7E\xE056\
+\\x7C7F\xE057\
+\\x7C81\xE058\
+\\x7C82\xE059\
+\\x7C83\xE05A\
+\\x7C84\xE05B\
+\\x7C85\xE05C\
+\\x7C86\xE05D\
+\\x7C87\xE05E\
+\\x7C88\xE05F\
+\\x7C89\xE060\
+\\x7C8A\xE061\
+\\x7C8B\xE062\
+\\x7C8C\xE063\
+\\x7C8D\xE064\
+\\x7C8E\xE065\
+\\x7C8F\xE066\
+\\x7C90\xE067\
+\\x7C91\xE068\
+\\x7C92\xE069\
+\\x7C93\xE06A\
+\\x7C94\xE06B\
+\\x7C95\xE06C\
+\\x7C96\xE06D\
+\\x7C97\xE06E\
+\\x7C98\xE06F\
+\\x7C99\xE070\
+\\x7C9A\xE071\
+\\x7C9B\xE072\
+\\x7C9C\xE073\
+\\x7C9D\xE074\
+\\x7C9E\xE075\
+\\x7C9F\xE076\
+\\x7CA0\xE077\
+\\x7CA1\xE078\
+\\x7CA2\xE079\
+\\x7CA3\xE07A\
+\\x7CA4\xE07B\
+\\x7CA5\xE07C\
+\\x7CA6\xE07D\
+\\x7CA7\xE07E\
+\\x7CA8\xE0A1\
+\\x7CA9\xE0A2\
+\\x7CAA\xE0A3\
+\\x7CAB\xE0A4\
+\\x7CAC\xE0A5\
+\\x7CAD\xE0A6\
+\\x7CAE\xE0A7\
+\\x7CAF\xE0A8\
+\\x7CB0\xE0A9\
+\\x7CB1\xE0AA\
+\\x7CB2\xE0AB\
+\\x7CB3\xE0AC\
+\\x7CB4\xE0AD\
+\\x7CB5\xE0AE\
+\\x7CB6\xE0AF\
+\\x7CB7\xE0B0\
+\\x7CB8\xE0B1\
+\\x7CB9\xE0B2\
+\\x7CBA\xE0B3\
+\\x7CBB\xE0B4\
+\\x7CBC\xE0B5\
+\\x7CBD\xE0B6\
+\\x7CBE\xE0B7\
+\\x7CBF\xE0B8\
+\\x7CC0\xE0B9\
+\\x7CC1\xE0BA\
+\\x7CC2\xE0BB\
+\\x7CC3\xE0BC\
+\\x7CC4\xE0BD\
+\\x7CC5\xE0BE\
+\\x7CC6\xE0BF\
+\\x7CC7\xE0C0\
+\\x7CC8\xE0C1\
+\\x7CC9\xE0C2\
+\\x7CCA\xE0C3\
+\\x7CCB\xE0C4\
+\\x7CCC\xE0C5\
+\\x7CCD\xE0C6\
+\\x7CCE\xE0C7\
+\\x7CCF\xE0C8\
+\\x7CD0\xE0C9\
+\\x7CD1\xE0CA\
+\\x7CD2\xE0CB\
+\\x7CD3\xE0CC\
+\\x7CD4\xE0CD\
+\\x7CD5\xE0CE\
+\\x7CD6\xE0CF\
+\\x7CD7\xE0D0\
+\\x7CD8\xE0D1\
+\\x7CD9\xE0D2\
+\\x7CDA\xE0D3\
+\\x7CDB\xE0D4\
+\\x7CDC\xE0D5\
+\\x7CDD\xE0D6\
+\\x7CDE\xE0D7\
+\\x7CDF\xE0D8\
+\\x7CE0\xE0D9\
+\\x7CE1\xE0DA\
+\\x7CE2\xE0DB\
+\\x7CE3\xE0DC\
+\\x7CE4\xE0DD\
+\\x7CE5\xE0DE\
+\\x7CE6\xE0DF\
+\\x7CE7\xE0E0\
+\\x7CE8\xE0E1\
+\\x7CE9\xE0E2\
+\\x7CEA\xE0E3\
+\\x7CEB\xE0E4\
+\\x7CEC\xE0E5\
+\\x7CED\xE0E6\
+\\x7CEE\xE0E7\
+\\x7CEF\xE0E8\
+\\x7CF0\xE0E9\
+\\x7CF1\xE0EA\
+\\x7CF2\xE0EB\
+\\x7CF3\xE0EC\
+\\x7CF4\xE0ED\
+\\x7CF5\xE0EE\
+\\x7CF6\xE0EF\
+\\x7CF7\xE0F0\
+\\x7CF8\xE0F1\
+\\x7CF9\xE0F2\
+\\x7CFA\xE0F3\
+\\x7CFB\xE0F4\
+\\x7CFC\xE0F5\
+\\x7CFD\xE0F6\
+\\x7D41\xE0F7\
+\\x7D42\xE0F8\
+\\x7D43\xE0F9\
+\\x7D44\xE0FA\
+\\x7D45\xE0FB\
+\\x7D46\xE0FC\
+\\x7D47\xE0FD\
+\\x7D48\xE0FE\
+\\x7D49\xE140\
+\\x7D4A\xE141\
+\\x7D4B\xE142\
+\\x7D4C\xE143\
+\\x7D4D\xE144\
+\\x7D4E\xE145\
+\\x7D4F\xE146\
+\\x7D50\xE147\
+\\x7D51\xE148\
+\\x7D52\xE149\
+\\x7D53\xE14A\
+\\x7D54\xE14B\
+\\x7D55\xE14C\
+\\x7D56\xE14D\
+\\x7D57\xE14E\
+\\x7D58\xE14F\
+\\x7D59\xE150\
+\\x7D5A\xE151\
+\\x7D5B\xE152\
+\\x7D5C\xE153\
+\\x7D5D\xE154\
+\\x7D5E\xE155\
+\\x7D5F\xE156\
+\\x7D60\xE157\
+\\x7D61\xE158\
+\\x7D62\xE159\
+\\x7D63\xE15A\
+\\x7D64\xE15B\
+\\x7D65\xE15C\
+\\x7D66\xE15D\
+\\x7D67\xE15E\
+\\x7D68\xE15F\
+\\x7D69\xE160\
+\\x7D6A\xE161\
+\\x7D6B\xE162\
+\\x7D6C\xE163\
+\\x7D6D\xE164\
+\\x7D6E\xE165\
+\\x7D6F\xE166\
+\\x7D70\xE167\
+\\x7D71\xE168\
+\\x7D72\xE169\
+\\x7D73\xE16A\
+\\x7D74\xE16B\
+\\x7D75\xE16C\
+\\x7D76\xE16D\
+\\x7D77\xE16E\
+\\x7D78\xE16F\
+\\x7D79\xE170\
+\\x7D7A\xE171\
+\\x7D7B\xE172\
+\\x7D7C\xE173\
+\\x7D7D\xE174\
+\\x7D7E\xE175\
+\\x7D7F\xE176\
+\\x7D81\xE177\
+\\x7D82\xE178\
+\\x7D83\xE179\
+\\x7D84\xE17A\
+\\x7D85\xE17B\
+\\x7D86\xE17C\
+\\x7D87\xE17D\
+\\x7D88\xE17E\
+\\x7D89\xE1A1\
+\\x7D8A\xE1A2\
+\\x7D8B\xE1A3\
+\\x7D8C\xE1A4\
+\\x7D8D\xE1A5\
+\\x7D8E\xE1A6\
+\\x7D8F\xE1A7\
+\\x7D90\xE1A8\
+\\x7D91\xE1A9\
+\\x7D92\xE1AA\
+\\x7D93\xE1AB\
+\\x7D94\xE1AC\
+\\x7D95\xE1AD\
+\\x7D96\xE1AE\
+\\x7D97\xE1AF\
+\\x7D98\xE1B0\
+\\x7D99\xE1B1\
+\\x7D9A\xE1B2\
+\\x7D9B\xE1B3\
+\\x7D9C\xE1B4\
+\\x7D9D\xE1B5\
+\\x7D9E\xE1B6\
+\\x7D9F\xE1B7\
+\\x7DA0\xE1B8\
+\\x7DA1\xE1B9\
+\\x7DA2\xE1BA\
+\\x7DA3\xE1BB\
+\\x7DA4\xE1BC\
+\\x7DA5\xE1BD\
+\\x7DA6\xE1BE\
+\\x7DA7\xE1BF\
+\\x7DA8\xE1C0\
+\\x7DA9\xE1C1\
+\\x7DAA\xE1C2\
+\\x7DAB\xE1C3\
+\\x7DAC\xE1C4\
+\\x7DAD\xE1C5\
+\\x7DAE\xE1C6\
+\\x7DAF\xE1C7\
+\\x7DB0\xE1C8\
+\\x7DB1\xE1C9\
+\\x7DB2\xE1CA\
+\\x7DB3\xE1CB\
+\\x7DB4\xE1CC\
+\\x7DB5\xE1CD\
+\\x7DB6\xE1CE\
+\\x7DB7\xE1CF\
+\\x7DB8\xE1D0\
+\\x7DB9\xE1D1\
+\\x7DBA\xE1D2\
+\\x7DBB\xE1D3\
+\\x7DBC\xE1D4\
+\\x7DBD\xE1D5\
+\\x7DBE\xE1D6\
+\\x7DBF\xE1D7\
+\\x7DC0\xE1D8\
+\\x7DC1\xE1D9\
+\\x7DC2\xE1DA\
+\\x7DC3\xE1DB\
+\\x7DC4\xE1DC\
+\\x7DC5\xE1DD\
+\\x7DC6\xE1DE\
+\\x7DC7\xE1DF\
+\\x7DC8\xE1E0\
+\\x7DC9\xE1E1\
+\\x7DCA\xE1E2\
+\\x7DCB\xE1E3\
+\\x7DCC\xE1E4\
+\\x7DCD\xE1E5\
+\\x7DCE\xE1E6\
+\\x7DCF\xE1E7\
+\\x7DD0\xE1E8\
+\\x7DD1\xE1E9\
+\\x7DD2\xE1EA\
+\\x7DD3\xE1EB\
+\\x7DD4\xE1EC\
+\\x7DD5\xE1ED\
+\\x7DD6\xE1EE\
+\\x7DD7\xE1EF\
+\\x7DD8\xE1F0\
+\\x7DD9\xE1F1\
+\\x7DDA\xE1F2\
+\\x7DDB\xE1F3\
+\\x7DDC\xE1F4\
+\\x7DDD\xE1F5\
+\\x7DDE\xE1F6\
+\\x7DDF\xE1F7\
+\\x7DE0\xE1F8\
+\\x7DE1\xE1F9\
+\\x7DE2\xE1FA\
+\\x7DE3\xE1FB\
+\\x7DE4\xE1FC\
+\\x7DE5\xE1FD\
+\\x7DE6\xE1FE\
+\\x7DE7\xE240\
+\\x7DE8\xE241\
+\\x7DE9\xE242\
+\\x7DEA\xE243\
+\\x7DEB\xE244\
+\\x7DEC\xE245\
+\\x7DED\xE246\
+\\x7DEE\xE247\
+\\x7DEF\xE248\
+\\x7DF0\xE249\
+\\x7DF1\xE24A\
+\\x7DF2\xE24B\
+\\x7DF3\xE24C\
+\\x7DF4\xE24D\
+\\x7DF5\xE24E\
+\\x7DF6\xE24F\
+\\x7DF7\xE250\
+\\x7DF8\xE251\
+\\x7DF9\xE252\
+\\x7DFA\xE253\
+\\x7DFB\xE254\
+\\x7DFC\xE255\
+\\x7DFD\xE256\
+\\x7E41\xE257\
+\\x7E42\xE258\
+\\x7E43\xE259\
+\\x7E44\xE25A\
+\\x7E45\xE25B\
+\\x7E46\xE25C\
+\\x7E47\xE25D\
+\\x7E48\xE25E\
+\\x7E49\xE25F\
+\\x7E4A\xE260\
+\\x7E4B\xE261\
+\\x7E4C\xE262\
+\\x7E4D\xE263\
+\\x7E4E\xE264\
+\\x7E4F\xE265\
+\\x7E50\xE266\
+\\x7E51\xE267\
+\\x7E52\xE268\
+\\x7E53\xE269\
+\\x7E54\xE26A\
+\\x7E55\xE26B\
+\\x7E56\xE26C\
+\\x7E57\xE26D\
+\\x7E58\xE26E\
+\\x7E59\xE26F\
+\\x7E5A\xE270\
+\\x7E5B\xE271\
+\\x7E5C\xE272\
+\\x7E5D\xE273\
+\\x7E5E\xE274\
+\\x7E5F\xE275\
+\\x7E60\xE276\
+\\x7E61\xE277\
+\\x7E62\xE278\
+\\x7E63\xE279\
+\\x7E64\xE27A\
+\\x7E65\xE27B\
+\\x7E66\xE27C\
+\\x7E67\xE27D\
+\\x7E68\xE27E\
+\\x7E69\xE2A1\
+\\x7E6A\xE2A2\
+\\x7E6B\xE2A3\
+\\x7E6C\xE2A4\
+\\x7E6D\xE2A5\
+\\x7E6E\xE2A6\
+\\x7E6F\xE2A7\
+\\x7E70\xE2A8\
+\\x7E71\xE2A9\
+\\x7E72\xE2AA\
+\\x7E73\xE2AB\
+\\x7E74\xE2AC\
+\\x7E75\xE2AD\
+\\x7E76\xE2AE\
+\\x7E77\xE2AF\
+\\x7E78\xE2B0\
+\\x7E79\xE2B1\
+\\x7E7A\xE2B2\
+\\x7E7B\xE2B3\
+\\x7E7C\xE2B4\
+\\x7E7D\xE2B5\
+\\x7E7E\xE2B6\
+\\x7E7F\xE2B7\
+\\x7E81\xE2B8\
+\\x7E82\xE2B9\
+\\x7E83\xE2BA\
+\\x7E84\xE2BB\
+\\x7E85\xE2BC\
+\\x7E86\xE2BD\
+\\x7E87\xE2BE\
+\\x7E88\xE2BF\
+\\x7E89\xE2C0\
+\\x7E8A\xE2C1\
+\\x7E8B\xE2C2\
+\\x7E8C\xE2C3\
+\\x7E8D\xE2C4\
+\\x7E8E\xE2C5\
+\\x7E8F\xE2C6\
+\\x7E90\xE2C7\
+\\x7E91\xE2C8\
+\\x7E92\xE2C9\
+\\x7E93\xE2CA\
+\\x7E94\xE2CB\
+\\x7E95\xE2CC\
+\\x7E96\xE2CD\
+\\x7E97\xE2CE\
+\\x7E98\xE2CF\
+\\x7E99\xE2D0\
+\\x7E9A\xE2D1\
+\\x7E9B\xE2D2\
+\\x7E9C\xE2D3\
+\\x7E9D\xE2D4\
+\\x7E9E\xE2D5\
+\\x7E9F\xE2D6\
+\\x7EA0\xE2D7\
+\\x7EA1\xE2D8\
+\\x7EA2\xE2D9\
+\\x7EA3\xE2DA\
+\\x7EA4\xE2DB\
+\\x7EA5\xE2DC\
+\\x7EA6\xE2DD\
+\\x7EA7\xE2DE\
+\\x7EA8\xE2DF\
+\\x7EA9\xE2E0\
+\\x7EAA\xE2E1\
+\\x7EAB\xE2E2\
+\\x7EAC\xE2E3\
+\\x7EAD\xE2E4\
+\\x7EAE\xE2E5\
+\\x7EAF\xE2E6\
+\\x7EB0\xE2E7\
+\\x7EB1\xE2E8\
+\\x7EB2\xE2E9\
+\\x7EB3\xE2EA\
+\\x7EB4\xE2EB\
+\\x7EB5\xE2EC\
+\\x7EB6\xE2ED\
+\\x7EB7\xE2EE\
+\\x7EB8\xE2EF\
+\\x7EB9\xE2F0\
+\\x7EBA\xE2F1\
+\\x7EBB\xE2F2\
+\\x7EBC\xE2F3\
+\\x7EBD\xE2F4\
+\\x7EBE\xE2F5\
+\\x7EBF\xE2F6\
+\\x7EC0\xE2F7\
+\\x7EC1\xE2F8\
+\\x7EC2\xE2F9\
+\\x7EC3\xE2FA\
+\\x7EC4\xE2FB\
+\\x7EC5\xE2FC\
+\\x7EC6\xE2FD\
+\\x7EC7\xE2FE\
+\\x7EC8\xE340\
+\\x7EC9\xE341\
+\\x7ECA\xE342\
+\\x7ECB\xE343\
+\\x7ECC\xE344\
+\\x7ECD\xE345\
+\\x7ECE\xE346\
+\\x7ECF\xE347\
+\\x7ED0\xE348\
+\\x7ED1\xE349\
+\\x7ED2\xE34A\
+\\x7ED3\xE34B\
+\\x7ED4\xE34C\
+\\x7ED5\xE34D\
+\\x7ED6\xE34E\
+\\x7ED7\xE34F\
+\\x7ED8\xE350\
+\\x7ED9\xE351\
+\\x7EDA\xE352\
+\\x7EDB\xE353\
+\\x7EDC\xE354\
+\\x7EDD\xE355\
+\\x7EDE\xE356\
+\\x7EDF\xE357\
+\\x7EE0\xE358\
+\\x7EE1\xE359\
+\\x7EE2\xE35A\
+\\x7EE3\xE35B\
+\\x7EE4\xE35C\
+\\x7EE5\xE35D\
+\\x7EE6\xE35E\
+\\x7EE7\xE35F\
+\\x7EE8\xE360\
+\\x7EE9\xE361\
+\\x7EEA\xE362\
+\\x7EEB\xE363\
+\\x7EEC\xE364\
+\\x7EED\xE365\
+\\x7EEE\xE366\
+\\x7EEF\xE367\
+\\x7EF0\xE368\
+\\x7EF1\xE369\
+\\x7EF2\xE36A\
+\\x7EF3\xE36B\
+\\x7EF4\xE36C\
+\\x7EF5\xE36D\
+\\x7EF6\xE36E\
+\\x7EF7\xE36F\
+\\x7EF8\xE370\
+\\x7EF9\xE371\
+\\x7EFA\xE372\
+\\x7EFB\xE373\
+\\x7EFC\xE374\
+\\x7EFD\xE375\
+\\x7F41\xE376\
+\\x7F42\xE377\
+\\x7F43\xE378\
+\\x7F44\xE379\
+\\x7F45\xE37A\
+\\x7F46\xE37B\
+\\x7F47\xE37C\
+\\x7F48\xE37D\
+\\x7F49\xE37E\
+\\x7F4A\xE3A1\
+\\x7F4B\xE3A2\
+\\x7F4C\xE3A3\
+\\x7F4D\xE3A4\
+\\x7F4E\xE3A5\
+\\x7F4F\xE3A6\
+\\x7F50\xE3A7\
+\\x7F51\xE3A8\
+\\x7F52\xE3A9\
+\\x7F53\xE3AA\
+\\x7F54\xE3AB\
+\\x7F55\xE3AC\
+\\x7F56\xE3AD\
+\\x7F57\xE3AE\
+\\x7F58\xE3AF\
+\\x7F59\xE3B0\
+\\x7F5A\xE3B1\
+\\x7F5B\xE3B2\
+\\x7F5C\xE3B3\
+\\x7F5D\xE3B4\
+\\x7F5E\xE3B5\
+\\x7F5F\xE3B6\
+\\x7F60\xE3B7\
+\\x7F61\xE3B8\
+\\x7F62\xE3B9\
+\\x7F63\xE3BA\
+\\x7F64\xE3BB\
+\\x7F65\xE3BC\
+\\x7F66\xE3BD\
+\\x7F67\xE3BE\
+\\x7F68\xE3BF\
+\\x7F69\xE3C0\
+\\x7F6A\xE3C1\
+\\x7F6B\xE3C2\
+\\x7F6C\xE3C3\
+\\x7F6D\xE3C4\
+\\x7F6E\xE3C5\
+\\x7F6F\xE3C6\
+\\x7F70\xE3C7\
+\\x7F71\xE3C8\
+\\x7F72\xE3C9\
+\\x7F73\xE3CA\
+\\x7F74\xE3CB\
+\\x7F75\xE3CC\
+\\x7F76\xE3CD\
+\\x7F77\xE3CE\
+\\x7F78\xE3CF\
+\\x7F79\xE3D0\
+\\x7F7A\xE3D1\
+\\x7F7B\xE3D2\
+\\x7F7C\xE3D3\
+\\x7F7D\xE3D4\
+\\x7F7E\xE3D5\
+\\x7F7F\xE3D6\
+\\x7F81\xE3D7\
+\\x7F82\xE3D8\
+\\x7F83\xE3D9\
+\\x7F84\xE3DA\
+\\x7F85\xE3DB\
+\\x7F86\xE3DC\
+\\x7F87\xE3DD\
+\\x7F88\xE3DE\
+\\x7F89\xE3DF\
+\\x7F8A\xE3E0\
+\\x7F8B\xE3E1\
+\\x7F8C\xE3E2\
+\\x7F8D\xE3E3\
+\\x7F8E\xE3E4\
+\\x7F8F\xE3E5\
+\\x7F90\xE3E6\
+\\x7F91\xE3E7\
+\\x7F92\xE3E8\
+\\x7F93\xE3E9\
+\\x7F94\xE3EA\
+\\x7F95\xE3EB\
+\\x7F96\xE3EC\
+\\x7F97\xE3ED\
+\\x7F98\xE3EE\
+\\x7F99\xE3EF\
+\\x7F9A\xE3F0\
+\\x7F9B\xE3F1\
+\\x7F9C\xE3F2\
+\\x7F9D\xE3F3\
+\\x7F9E\xE3F4\
+\\x7F9F\xE3F5\
+\\x7FA0\xE3F6\
+\\x7FA1\xE3F7\
+\\x7FA2\xE3F8\
+\\x7FA3\xE3F9\
+\\x7FA4\xE3FA\
+\\x7FA5\xE3FB\
+\\x7FA6\xE3FC\
+\\x7FA7\xE3FD\
+\\x7FA8\xE3FE\
+\\x7FA9\xE440\
+\\x7FAA\xE441\
+\\x7FAB\xE442\
+\\x7FAC\xE443\
+\\x7FAD\xE444\
+\\x7FAE\xE445\
+\\x7FAF\xE446\
+\\x7FB0\xE447\
+\\x7FB1\xE448\
+\\x7FB2\xE449\
+\\x7FB3\xE44A\
+\\x7FB4\xE44B\
+\\x7FB5\xE44C\
+\\x7FB6\xE44D\
+\\x7FB7\xE44E\
+\\x7FB8\xE44F\
+\\x7FB9\xE450\
+\\x7FBA\xE451\
+\\x7FBB\xE452\
+\\x7FBC\xE453\
+\\x7FBD\xE454\
+\\x7FBE\xE455\
+\\x7FBF\xE456\
+\\x7FC0\xE457\
+\\x7FC1\xE458\
+\\x7FC2\xE459\
+\\x7FC3\xE45A\
+\\x7FC4\xE45B\
+\\x7FC5\xE45C\
+\\x7FC6\xE45D\
+\\x7FC7\xE45E\
+\\x7FC8\xE45F\
+\\x7FC9\xE460\
+\\x7FCA\xE461\
+\\x7FCB\xE462\
+\\x7FCC\xE463\
+\\x7FCD\xE464\
+\\x7FCE\xE465\
+\\x7FCF\xE466\
+\\x7FD0\xE467\
+\\x7FD1\xE468\
+\\x7FD2\xE469\
+\\x7FD3\xE46A\
+\\x7FD4\xE46B\
+\\x7FD5\xE46C\
+\\x7FD6\xE46D\
+\\x7FD7\xE46E\
+\\x7FD8\xE46F\
+\\x7FD9\xE470\
+\\x7FDA\xE471\
+\\x7FDB\xE472\
+\\x7FDC\xE473\
+\\x7FDD\xE474\
+\\x7FDE\xE475\
+\\x7FDF\xE476\
+\\x7FE0\xE477\
+\\x7FE1\xE478\
+\\x7FE2\xE479\
+\\x7FE3\xE47A\
+\\x7FE4\xE47B\
+\\x7FE5\xE47C\
+\\x7FE6\xE47D\
+\\x7FE7\xE47E\
+\\x7FE8\xE4A1\
+\\x7FE9\xE4A2\
+\\x7FEA\xE4A3\
+\\x7FEB\xE4A4\
+\\x7FEC\xE4A5\
+\\x7FED\xE4A6\
+\\x7FEE\xE4A7\
+\\x7FEF\xE4A8\
+\\x7FF0\xE4A9\
+\\x7FF1\xE4AA\
+\\x7FF2\xE4AB\
+\\x7FF3\xE4AC\
+\\x7FF4\xE4AD\
+\\x7FF5\xE4AE\
+\\x7FF6\xE4AF\
+\\x7FF7\xE4B0\
+\\x7FF8\xE4B1\
+\\x7FF9\xE4B2\
+\\x7FFA\xE4B3\
+\\x7FFB\xE4B4\
+\\x7FFC\xE4B5\
+\\x7FFD\xE4B6\
+\\x8041\xE4B7\
+\\x8042\xE4B8\
+\\x8043\xE4B9\
+\\x8044\xE4BA\
+\\x8045\xE4BB\
+\\x8046\xE4BC\
+\\x8047\xE4BD\
+\\x8048\xE4BE\
+\\x8049\xE4BF\
+\\x804A\xE4C0\
+\\x804B\xE4C1\
+\\x804C\xE4C2\
+\\x804D\xE4C3\
+\\x804E\xE4C4\
+\\x804F\xE4C5\
+\\x8050\xE4C6\
+\\x8051\xE4C7\
+\\x8052\xE4C8\
+\\x8053\xE4C9\
+\\x8054\xE4CA\
+\\x8055\xE4CB\
+\\x8056\xE4CC\
+\\x8057\xE4CD\
+\\x8058\xE4CE\
+\\x8059\xE4CF\
+\\x805A\xE4D0\
+\\x805B\xE4D1\
+\\x805C\xE4D2\
+\\x805D\xE4D3\
+\\x805E\xE4D4\
+\\x805F\xE4D5\
+\\x8060\xE4D6\
+\\x8061\xE4D7\
+\\x8062\xE4D8\
+\\x8063\xE4D9\
+\\x8064\xE4DA\
+\\x8065\xE4DB\
+\\x8066\xE4DC\
+\\x8067\xE4DD\
+\\x8068\xE4DE\
+\\x8069\xE4DF\
+\\x806A\xE4E0\
+\\x806B\xE4E1\
+\\x806C\xE4E2\
+\\x806D\xE4E3\
+\\x806E\xE4E4\
+\\x806F\xE4E5\
+\\x8070\xE4E6\
+\\x8071\xE4E7\
+\\x8072\xE4E8\
+\\x8073\xE4E9\
+\\x8074\xE4EA\
+\\x8075\xE4EB\
+\\x8076\xE4EC\
+\\x8077\xE4ED\
+\\x8078\xE4EE\
+\\x8079\xE4EF\
+\\x807A\xE4F0\
+\\x807B\xE4F1\
+\\x807C\xE4F2\
+\\x807D\xE4F3\
+\\x807E\xE4F4\
+\\x807F\xE4F5\
+\\x8081\xE4F6\
+\\x8082\xE4F7\
+\\x8083\xE4F8\
+\\x8084\xE4F9\
+\\x8085\xE4FA\
+\\x8086\xE4FB\
+\\x8087\xE4FC\
+\\x8088\xE4FD\
+\\x8089\xE4FE\
+\\x808A\xE540\
+\\x808B\xE541\
+\\x808C\xE542\
+\\x808D\xE543\
+\\x808E\xE544\
+\\x808F\xE545\
+\\x8090\xE546\
+\\x8091\xE547\
+\\x8092\xE548\
+\\x8093\xE549\
+\\x8094\xE54A\
+\\x8095\xE54B\
+\\x8096\xE54C\
+\\x8097\xE54D\
+\\x8098\xE54E\
+\\x8099\xE54F\
+\\x809A\xE550\
+\\x809B\xE551\
+\\x809C\xE552\
+\\x809D\xE553\
+\\x809E\xE554\
+\\x809F\xE555\
+\\x80A0\xE556\
+\\x80A1\xE557\
+\\x80A2\xE558\
+\\x80A3\xE559\
+\\x80A4\xE55A\
+\\x80A5\xE55B\
+\\x80A6\xE55C\
+\\x80A7\xE55D\
+\\x80A8\xE55E\
+\\x80A9\xE55F\
+\\x80AA\xE560\
+\\x80AB\xE561\
+\\x80AC\xE562\
+\\x80AD\xE563\
+\\x80AE\xE564\
+\\x80AF\xE565\
+\\x80B0\xE566\
+\\x80B1\xE567\
+\\x80B2\xE568\
+\\x80B3\xE569\
+\\x80B4\xE56A\
+\\x80B5\xE56B\
+\\x80B6\xE56C\
+\\x80B7\xE56D\
+\\x80B8\xE56E\
+\\x80B9\xE56F\
+\\x80BA\xE570\
+\\x80BB\xE571\
+\\x80BC\xE572\
+\\x80BD\xE573\
+\\x80BE\xE574\
+\\x80BF\xE575\
+\\x80C0\xE576\
+\\x80C1\xE577\
+\\x80C2\xE578\
+\\x80C3\xE579\
+\\x80C4\xE57A\
+\\x80C5\xE57B\
+\\x80C6\xE57C\
+\\x80C7\xE57D\
+\\x80C8\xE57E\
+\\x80C9\xE5A1\
+\\x80CA\xE5A2\
+\\x80CB\xE5A3\
+\\x80CC\xE5A4\
+\\x80CD\xE5A5\
+\\x80CE\xE5A6\
+\\x80CF\xE5A7\
+\\x80D0\xE5A8\
+\\x80D1\xE5A9\
+\\x80D2\xE5AA\
+\\x80D3\xE5AB\
+\\x80D4\xE5AC\
+\\x80D5\xE5AD\
+\\x80D6\xE5AE\
+\\x80D7\xE5AF\
+\\x80D8\xE5B0\
+\\x80D9\xE5B1\
+\\x80DA\xE5B2\
+\\x80DB\xE5B3\
+\\x80DC\xE5B4\
+\\x80DD\xE5B5\
+\\x80DE\xE5B6\
+\\x80DF\xE5B7\
+\\x80E0\xE5B8\
+\\x80E1\xE5B9\
+\\x80E2\xE5BA\
+\\x80E3\xE5BB\
+\\x80E4\xE5BC\
+\\x80E5\xE5BD\
+\\x80E6\xE5BE\
+\\x80E7\xE5BF\
+\\x80E8\xE5C0\
+\\x80E9\xE5C1\
+\\x80EA\xE5C2\
+\\x80EB\xE5C3\
+\\x80EC\xE5C4\
+\\x80ED\xE5C5\
+\\x80EE\xE5C6\
+\\x80EF\xE5C7\
+\\x80F0\xE5C8\
+\\x80F1\xE5C9\
+\\x80F2\xE5CA\
+\\x80F3\xE5CB\
+\\x80F4\xE5CC\
+\\x80F5\xE5CD\
+\\x80F6\xE5CE\
+\\x80F7\xE5CF\
+\\x80F8\xE5D0\
+\\x80F9\xE5D1\
+\\x80FA\xE5D2\
+\\x80FB\xE5D3\
+\\x80FC\xE5D4\
+\\x80FD\xE5D5\
+\\x8141\xE5D6\
+\\x8142\xE5D7\
+\\x8143\xE5D8\
+\\x8144\xE5D9\
+\\x8145\xE5DA\
+\\x8146\xE5DB\
+\\x8147\xE5DC\
+\\x8148\xE5DD\
+\\x8149\xE5DE\
+\\x814A\xE5DF\
+\\x814B\xE5E0\
+\\x814C\xE5E1\
+\\x814D\xE5E2\
+\\x814E\xE5E3\
+\\x814F\xE5E4\
+\\x8150\xE5E5\
+\\x8151\xE5E6\
+\\x8152\xE5E7\
+\\x8153\xE5E8\
+\\x8154\xE5E9\
+\\x8155\xE5EA\
+\\x8156\xE5EB\
+\\x8157\xE5EC\
+\\x8158\xE5ED\
+\\x8159\xE5EE\
+\\x815A\xE5EF\
+\\x815B\xE5F0\
+\\x815C\xE5F1\
+\\x815D\xE5F2\
+\\x815E\xE5F3\
+\\x815F\xE5F4\
+\\x8160\xE5F5\
+\\x8161\xE5F6\
+\\x8162\xE5F7\
+\\x8163\xE5F8\
+\\x8164\xE5F9\
+\\x8165\xE5FA\
+\\x8166\xE5FB\
+\\x8167\xE5FC\
+\\x8168\xE5FD\
+\\x8169\xE5FE\
+\\x816A\xE640\
+\\x816B\xE641\
+\\x816C\xE642\
+\\x816D\xE643\
+\\x816E\xE644\
+\\x816F\xE645\
+\\x8170\xE646\
+\\x8171\xE647\
+\\x8172\xE648\
+\\x8173\xE649\
+\\x8174\xE64A\
+\\x8175\xE64B\
+\\x8176\xE64C\
+\\x8177\xE64D\
+\\x8178\xE64E\
+\\x8179\xE64F\
+\\x817A\xE650\
+\\x817B\xE651\
+\\x817C\xE652\
+\\x817D\xE653\
+\\x817E\xE654\
+\\x817F\xE655\
+\\x8181\xE656\
+\\x8182\xE657\
+\\x8183\xE658\
+\\x8184\xE659\
+\\x8185\xE65A\
+\\x8186\xE65B\
+\\x8187\xE65C\
+\\x8188\xE65D\
+\\x8189\xE65E\
+\\x818A\xE65F\
+\\x818B\xE660\
+\\x818C\xE661\
+\\x818D\xE662\
+\\x818E\xE663\
+\\x818F\xE664\
+\\x8190\xE665\
+\\x8191\xE666\
+\\x8192\xE667\
+\\x8193\xE668\
+\\x8194\xE669\
+\\x8195\xE66A\
+\\x8196\xE66B\
+\\x8197\xE66C\
+\\x8198\xE66D\
+\\x8199\xE66E\
+\\x819A\xE66F\
+\\x819B\xE670\
+\\x819C\xE671\
+\\x819D\xE672\
+\\x819E\xE673\
+\\x819F\xE674\
+\\x81A0\xE675\
+\\x81A1\xE676\
+\\x81A2\xE677\
+\\x81A3\xE678\
+\\x81A4\xE679\
+\\x81A5\xE67A\
+\\x81A6\xE67B\
+\\x81A7\xE67C\
+\\x81A8\xE67D\
+\\x81A9\xE67E\
+\\x81AA\xE6A1\
+\\x81AB\xE6A2\
+\\x81AC\xE6A3\
+\\x81AD\xE6A4\
+\\x81AE\xE6A5\
+\\x81AF\xE6A6\
+\\x81B0\xE6A7\
+\\x81B1\xE6A8\
+\\x81B2\xE6A9\
+\\x81B3\xE6AA\
+\\x81B4\xE6AB\
+\\x81B5\xE6AC\
+\\x81B6\xE6AD\
+\\x81B7\xE6AE\
+\\x81B8\xE6AF\
+\\x81B9\xE6B0\
+\\x81BA\xE6B1\
+\\x81BB\xE6B2\
+\\x81BC\xE6B3\
+\\x81BD\xE6B4\
+\\x81BE\xE6B5\
+\\x81BF\xE6B6\
+\\x81C0\xE6B7\
+\\x81C1\xE6B8\
+\\x81C2\xE6B9\
+\\x81C3\xE6BA\
+\\x81C4\xE6BB\
+\\x81C5\xE6BC\
+\\x81C6\xE6BD\
+\\x81C7\xE6BE\
+\\x81C8\xE6BF\
+\\x81C9\xE6C0\
+\\x81CA\xE6C1\
+\\x81CB\xE6C2\
+\\x81CC\xE6C3\
+\\x81CD\xE6C4\
+\\x81CE\xE6C5\
+\\x81CF\xE6C6\
+\\x81D0\xE6C7\
+\\x81D1\xE6C8\
+\\x81D2\xE6C9\
+\\x81D3\xE6CA\
+\\x81D4\xE6CB\
+\\x81D5\xE6CC\
+\\x81D6\xE6CD\
+\\x81D7\xE6CE\
+\\x81D8\xE6CF\
+\\x81D9\xE6D0\
+\\x81DA\xE6D1\
+\\x81DB\xE6D2\
+\\x81DC\xE6D3\
+\\x81DD\xE6D4\
+\\x81DE\xE6D5\
+\\x81DF\xE6D6\
+\\x81E0\xE6D7\
+\\x81E1\xE6D8\
+\\x81E2\xE6D9\
+\\x81E3\xE6DA\
+\\x81E4\xE6DB\
+\\x81E5\xE6DC\
+\\x81E6\xE6DD\
+\\x81E7\xE6DE\
+\\x81E8\xE6DF\
+\\x81E9\xE6E0\
+\\x81EA\xE6E1\
+\\x81EB\xE6E2\
+\\x81EC\xE6E3\
+\\x81ED\xE6E4\
+\\x81EE\xE6E5\
+\\x81EF\xE6E6\
+\\x81F0\xE6E7\
+\\x81F1\xE6E8\
+\\x81F2\xE6E9\
+\\x81F3\xE6EA\
+\\x81F4\xE6EB\
+\\x81F5\xE6EC\
+\\x81F6\xE6ED\
+\\x81F7\xE6EE\
+\\x81F8\xE6EF\
+\\x81F9\xE6F0\
+\\x81FA\xE6F1\
+\\x81FB\xE6F2\
+\\x81FC\xE6F3\
+\\x81FD\xE6F4\
+\\x8241\xE6F5\
+\\x8242\xE6F6\
+\\x8243\xE6F7\
+\\x8244\xE6F8\
+\\x8245\xE6F9\
+\\x8246\xE6FA\
+\\x8247\xE6FB\
+\\x8248\xE6FC\
+\\x8249\xE6FD\
+\\x824A\xE6FE\
+\\x824B\xE740\
+\\x824C\xE741\
+\\x824D\xE742\
+\\x824E\xE743\
+\\x824F\xE744\
+\\x8250\xE745\
+\\x8251\xE746\
+\\x8252\xE747\
+\\x8253\xE748\
+\\x8254\xE749\
+\\x8255\xE74A\
+\\x8256\xE74B\
+\\x8257\xE74C\
+\\x8258\xE74D\
+\\x8259\xE74E\
+\\x825A\xE74F\
+\\x825B\xE750\
+\\x825C\xE751\
+\\x825D\xE752\
+\\x825E\xE753\
+\\x825F\xE754\
+\\x8260\xE755\
+\\x8261\xE756\
+\\x8262\xE757\
+\\x8263\xE758\
+\\x8264\xE759\
+\\x8265\xE75A\
+\\x8266\xE75B\
+\\x8267\xE75C\
+\\x8268\xE75D\
+\\x8269\xE75E\
+\\x826A\xE75F\
+\\x826B\xE760\
+\\x826C\xE761\
+\\x826D\xE762\
+\\x826E\xE763\
+\\x826F\xE764\
+\\x8270\xE765\
+\\x8271\xE766\
+\\x8272\xE767\
+\\x8273\xE768\
+\\x8274\xE769\
+\\x8275\xE76A\
+\\x8276\xE76B\
+\\x8277\xE76C\
+\\x8278\xE76D\
+\\x8279\xE76E\
+\\x827A\xE76F\
+\\x827B\xE770\
+\\x827C\xE771\
+\\x827D\xE772\
+\\x827E\xE773\
+\\x827F\xE774\
+\\x8281\xE775\
+\\x8282\xE776\
+\\x8283\xE777\
+\\x8284\xE778\
+\\x8285\xE779\
+\\x8286\xE77A\
+\\x8287\xE77B\
+\\x8288\xE77C\
+\\x8289\xE77D\
+\\x828A\xE77E\
+\\x828B\xE7A1\
+\\x828C\xE7A2\
+\\x828D\xE7A3\
+\\x828E\xE7A4\
+\\x828F\xE7A5\
+\\x8290\xE7A6\
+\\x8291\xE7A7\
+\\x8292\xE7A8\
+\\x8293\xE7A9\
+\\x8294\xE7AA\
+\\x8295\xE7AB\
+\\x8296\xE7AC\
+\\x8297\xE7AD\
+\\x8298\xE7AE\
+\\x8299\xE7AF\
+\\x829A\xE7B0\
+\\x829B\xE7B1\
+\\x829C\xE7B2\
+\\x829D\xE7B3\
+\\x829E\xE7B4\
+\\x829F\xE7B5\
+\\x82A0\xE7B6\
+\\x82A1\xE7B7\
+\\x82A2\xE7B8\
+\\x82A3\xE7B9\
+\\x82A4\xE7BA\
+\\x82A5\xE7BB\
+\\x82A6\xE7BC\
+\\x82A7\xE7BD\
+\\x82A8\xE7BE\
+\\x82A9\xE7BF\
+\\x82AA\xE7C0\
+\\x82AB\xE7C1\
+\\x82AC\xE7C2\
+\\x82AD\xE7C3\
+\\x82AE\xE7C4\
+\\x82AF\xE7C5\
+\\x82B0\xE7C6\
+\\x82B1\xE7C7\
+\\x82B2\xE7C8\
+\\x82B3\xE7C9\
+\\x82B4\xE7CA\
+\\x82B5\xE7CB\
+\\x82B6\xE7CC\
+\\x82B7\xE7CD\
+\\x82B8\xE7CE\
+\\x82B9\xE7CF\
+\\x82BA\xE7D0\
+\\x82BB\xE7D1\
+\\x82BC\xE7D2\
+\\x82BD\xE7D3\
+\\x82BE\xE7D4\
+\\x82BF\xE7D5\
+\\x82C0\xE7D6\
+\\x82C1\xE7D7\
+\\x82C2\xE7D8\
+\\x82C3\xE7D9\
+\\x82C4\xE7DA\
+\\x82C5\xE7DB\
+\\x82C6\xE7DC\
+\\x82C7\xE7DD\
+\\x82C8\xE7DE\
+\\x82C9\xE7DF\
+\\x82CA\xE7E0\
+\\x82CB\xE7E1\
+\\x82CC\xE7E2\
+\\x82CD\xE7E3\
+\\x82CE\xE7E4\
+\\x82CF\xE7E5\
+\\x82D0\xE7E6\
+\\x82D1\xE7E7\
+\\x82D2\xE7E8\
+\\x82D3\xE7E9\
+\\x82D4\xE7EA\
+\\x82D5\xE7EB\
+\\x82D6\xE7EC\
+\\x82D7\xE7ED\
+\\x82D8\xE7EE\
+\\x82D9\xE7EF\
+\\x82DA\xE7F0\
+\\x82DB\xE7F1\
+\\x82DC\xE7F2\
+\\x82DD\xE7F3\
+\\x82DE\xE7F4\
+\\x82DF\xE7F5\
+\\x82E0\xE7F6\
+\\x82E1\xE7F7\
+\\x82E2\xE7F8\
+\\x82E3\xE7F9\
+\\x82E4\xE7FA\
+\\x82E5\xE7FB\
+\\x82E6\xE7FC\
+\\x82E7\xE7FD\
+\\x82E8\xE7FE\
+\\x82E9\xE840\
+\\x82EA\xE841\
+\\x82EB\xE842\
+\\x82EC\xE843\
+\\x82ED\xE844\
+\\x82EE\xE845\
+\\x82EF\xE846\
+\\x82F0\xE847\
+\\x82F1\xE848\
+\\x82F2\xE849\
+\\x82F3\xE84A\
+\\x82F4\xE84B\
+\\x82F5\xE84C\
+\\x82F6\xE84D\
+\\x82F7\xE84E\
+\\x82F8\xE84F\
+\\x82F9\xE850\
+\\x82FA\xE851\
+\\x82FB\xE852\
+\\x82FC\xE853\
+\\x82FD\xE854\
+\\x8341\xE855\
+\\x8342\xE856\
+\\x8343\xE857\
+\\x8344\xE858\
+\\x8345\xE859\
+\\x8346\xE85A\
+\\x8347\xE85B\
+\\x8348\xE85C\
+\\x8349\xE85D\
+\\x834A\xE85E\
+\\x834B\xE85F\
+\\x834C\xE860\
+\\x834D\xE861\
+\\x834E\xE862\
+\\x834F\xE863\
+\\x8350\xE864\
+\\x8351\xE865\
+\\x8352\xE866\
+\\x8353\xE867\
+\\x8354\xE868\
+\\x8355\xE869\
+\\x8356\xE86A\
+\\x8357\xE86B\
+\\x8358\xE86C\
+\\x8359\xE86D\
+\\x835A\xE86E\
+\\x835B\xE86F\
+\\x835C\xE870\
+\\x835D\xE871\
+\\x835E\xE872\
+\\x835F\xE873\
+\\x8360\xE874\
+\\x8361\xE875\
+\\x8362\xE876\
+\\x8363\xE877\
+\\x8364\xE878\
+\\x8365\xE879\
+\\x8366\xE87A\
+\\x8367\xE87B\
+\\x8368\xE87C\
+\\x8369\xE87D\
+\\x836A\xE87E\
+\\x836B\xE8A1\
+\\x836C\xE8A2\
+\\x836D\xE8A3\
+\\x836E\xE8A4\
+\\x836F\xE8A5\
+\\x8370\xE8A6\
+\\x8371\xE8A7\
+\\x8372\xE8A8\
+\\x8373\xE8A9\
+\\x8374\xE8AA\
+\\x8375\xE8AB\
+\\x8376\xE8AC\
+\\x8377\xE8AD\
+\\x8378\xE8AE\
+\\x8379\xE8AF\
+\\x837A\xE8B0\
+\\x837B\xE8B1\
+\\x837C\xE8B2\
+\\x837D\xE8B3\
+\\x837E\xE8B4\
+\\x837F\xE8B5\
+\\x8381\xE8B6\
+\\x8382\xE8B7\
+\\x8383\xE8B8\
+\\x8384\xE8B9\
+\\x8385\xE8BA\
+\\x8386\xE8BB\
+\\x8387\xE8BC\
+\\x8388\xE8BD\
+\\x8389\xE8BE\
+\\x838A\xE8BF\
+\\x838B\xE8C0\
+\\x838C\xE8C1\
+\\x838D\xE8C2\
+\\x838E\xE8C3\
+\\x838F\xE8C4\
+\\x8390\xE8C5\
+\\x8391\xE8C6\
+\\x8392\xE8C7\
+\\x8393\xE8C8\
+\\x8394\xE8C9\
+\\x8395\xE8CA\
+\\x8396\xE8CB\
+\\x8397\xE8CC\
+\\x8398\xE8CD\
+\\x8399\xE8CE\
+\\x839A\xE8CF\
+\\x839B\xE8D0\
+\\x839C\xE8D1\
+\\x839D\xE8D2\
+\\x839E\xE8D3\
+\\x839F\xE8D4\
+\\x83A0\xE8D5\
+\\x83A1\xE8D6\
+\\x83A2\xE8D7\
+\\x83A3\xE8D8\
+\\x83A4\xE8D9\
+\\x83A5\xE8DA\
+\\x83A6\xE8DB\
+\\x83A7\xE8DC\
+\\x83A8\xE8DD\
+\\x83A9\xE8DE\
+\\x83AA\xE8DF\
+\\x83AB\xE8E0\
+\\x83AC\xE8E1\
+\\x83AD\xE8E2\
+\\x83AE\xE8E3\
+\\x83AF\xE8E4\
+\\x83B0\xE8E5\
+\\x83B1\xE8E6\
+\\x83B2\xE8E7\
+\\x83B3\xE8E8\
+\\x83B4\xE8E9\
+\\x83B5\xE8EA\
+\\x83B6\xE8EB\
+\\x83B7\xE8EC\
+\\x83B8\xE8ED\
+\\x83B9\xE8EE\
+\\x83BA\xE8EF\
+\\x83BB\xE8F0\
+\\x83BC\xE8F1\
+\\x83BD\xE8F2\
+\\x83BE\xE8F3\
+\\x83BF\xE8F4\
+\\x83C0\xE8F5\
+\\x83C1\xE8F6\
+\\x83C2\xE8F7\
+\\x83C3\xE8F8\
+\\x83C4\xE8F9\
+\\x83C5\xE8FA\
+\\x83C6\xE8FB\
+\\x83C7\xE8FC\
+\\x83C8\xE8FD\
+\\x83C9\xE8FE\
+\\x83CA\xE940\
+\\x83CB\xE941\
+\\x83CC\xE942\
+\\x83CD\xE943\
+\\x83CE\xE944\
+\\x83CF\xE945\
+\\x83D0\xE946\
+\\x83D1\xE947\
+\\x83D2\xE948\
+\\x83D3\xE949\
+\\x83D4\xE94A\
+\\x83D5\xE94B\
+\\x83D6\xE94C\
+\\x83D7\xE94D\
+\\x83D8\xE94E\
+\\x83D9\xE94F\
+\\x83DA\xE950\
+\\x83DB\xE951\
+\\x83DC\xE952\
+\\x83DD\xE953\
+\\x83DE\xE954\
+\\x83DF\xE955\
+\\x83E0\xE956\
+\\x83E1\xE957\
+\\x83E2\xE958\
+\\x83E3\xE959\
+\\x83E4\xE95A\
+\\x83E5\xE95B\
+\\x83E6\xE95C\
+\\x83E7\xE95D\
+\\x83E8\xE95E\
+\\x83E9\xE95F\
+\\x83EA\xE960\
+\\x83EB\xE961\
+\\x83EC\xE962\
+\\x83ED\xE963\
+\\x83EE\xE964\
+\\x83EF\xE965\
+\\x83F0\xE966\
+\\x83F1\xE967\
+\\x83F2\xE968\
+\\x83F3\xE969\
+\\x83F4\xE96A\
+\\x83F5\xE96B\
+\\x83F6\xE96C\
+\\x83F7\xE96D\
+\\x83F8\xE96E\
+\\x83F9\xE96F\
+\\x83FA\xE970\
+\\x83FB\xE971\
+\\x83FC\xE972\
+\\x83FD\xE973\
+\\x8441\xE974\
+\\x8442\xE975\
+\\x8443\xE976\
+\\x8444\xE977\
+\\x8445\xE978\
+\\x8446\xE979\
+\\x8447\xE97A\
+\\x8448\xE97B\
+\\x8449\xE97C\
+\\x844A\xE97D\
+\\x844B\xE97E\
+\\x844C\xE9A1\
+\\x844D\xE9A2\
+\\x844E\xE9A3\
+\\x844F\xE9A4\
+\\x8450\xE9A5\
+\\x8451\xE9A6\
+\\x8452\xE9A7\
+\\x8453\xE9A8\
+\\x8454\xE9A9\
+\\x8455\xE9AA\
+\\x8456\xE9AB\
+\\x8457\xE9AC\
+\\x8458\xE9AD\
+\\x8459\xE9AE\
+\\x845A\xE9AF\
+\\x845B\xE9B0\
+\\x845C\xE9B1\
+\\x845D\xE9B2\
+\\x845E\xE9B3\
+\\x845F\xE9B4\
+\\x8460\xE9B5\
+\\x8461\xE9B6\
+\\x8462\xE9B7\
+\\x8463\xE9B8\
+\\x8464\xE9B9\
+\\x8465\xE9BA\
+\\x8466\xE9BB\
+\\x8467\xE9BC\
+\\x8468\xE9BD\
+\\x8469\xE9BE\
+\\x846A\xE9BF\
+\\x846B\xE9C0\
+\\x846C\xE9C1\
+\\x846D\xE9C2\
+\\x846E\xE9C3\
+\\x846F\xE9C4\
+\\x8470\xE9C5\
+\\x8471\xE9C6\
+\\x8472\xE9C7\
+\\x8473\xE9C8\
+\\x8474\xE9C9\
+\\x8475\xE9CA\
+\\x8476\xE9CB\
+\\x8477\xE9CC\
+\\x8478\xE9CD\
+\\x8479\xE9CE\
+\\x847A\xE9CF\
+\\x847B\xE9D0\
+\\x847C\xE9D1\
+\\x847D\xE9D2\
+\\x847E\xE9D3\
+\\x847F\xE9D4\
+\\x8481\xE9D5\
+\\x8482\xE9D6\
+\\x8483\xE9D7\
+\\x8484\xE9D8\
+\\x8485\xE9D9\
+\\x8486\xE9DA\
+\\x8487\xE9DB\
+\\x8488\xE9DC\
+\\x8489\xE9DD\
+\\x848A\xE9DE\
+\\x848B\xE9DF\
+\\x848C\xE9E0\
+\\x848D\xE9E1\
+\\x848E\xE9E2\
+\\x848F\xE9E3\
+\\x8490\xE9E4\
+\\x8491\xE9E5\
+\\x8492\xE9E6\
+\\x8493\xE9E7\
+\\x8494\xE9E8\
+\\x8495\xE9E9\
+\\x8496\xE9EA\
+\\x8497\xE9EB\
+\\x8498\xE9EC\
+\\x8499\xE9ED\
+\\x849A\xE9EE\
+\\x849B\xE9EF\
+\\x849C\xE9F0\
+\\x849D\xE9F1\
+\\x849E\xE9F2\
+\\x849F\xE9F3\
+\\x84A0\xE9F4\
+\\x84A1\xE9F5\
+\\x84A2\xE9F6\
+\\x84A3\xE9F7\
+\\x84A4\xE9F8\
+\\x84A5\xE9F9\
+\\x84A6\xE9FA\
+\\x84A7\xE9FB\
+\\x84A8\xE9FC\
+\\x84A9\xE9FD\
+\\x84AA\xE9FE\
+\\x84AB\xEA40\
+\\x84AC\xEA41\
+\\x84AD\xEA42\
+\\x84AE\xEA43\
+\\x84AF\xEA44\
+\\x84B0\xEA45\
+\\x84B1\xEA46\
+\\x84B2\xEA47\
+\\x84B3\xEA48\
+\\x84B4\xEA49\
+\\x84B5\xEA4A\
+\\x84B6\xEA4B\
+\\x84B7\xEA4C\
+\\x84B8\xEA4D\
+\\x84B9\xEA4E\
+\\x84BA\xEA4F\
+\\x84BB\xEA50\
+\\x84BC\xEA51\
+\\x84BD\xEA52\
+\\x84BE\xEA53\
+\\x84BF\xEA54\
+\\x84C0\xEA55\
+\\x84C1\xEA56\
+\\x84C2\xEA57\
+\\x84C3\xEA58\
+\\x84C4\xEA59\
+\\x84C5\xEA5A\
+\\x84C6\xEA5B\
+\\x84C7\xEA5C\
+\\x84C8\xEA5D\
+\\x84C9\xEA5E\
+\\x84CA\xEA5F\
+\\x84CB\xEA60\
+\\x84CC\xEA61\
+\\x84CD\xEA62\
+\\x84CE\xEA63\
+\\x84CF\xEA64\
+\\x84D0\xEA65\
+\\x84D1\xEA66\
+\\x84D2\xEA67\
+\\x84D3\xEA68\
+\\x84D4\xEA69\
+\\x84D5\xEA6A\
+\\x84D6\xEA6B\
+\\x84D7\xEA6C\
+\\x84D8\xEA6D\
+\\x84D9\xEA6E\
+\\x84DA\xEA6F\
+\\x84DB\xEA70\
+\\x84DC\xEA71\
+\\x84DD\xEA72\
+\\x84DE\xEA73\
+\\x84DF\xEA74\
+\\x84E0\xEA75\
+\\x84E1\xEA76\
+\\x84E2\xEA77\
+\\x84E3\xEA78\
+\\x84E4\xEA79\
+\\x84E5\xEA7A\
+\\x84E6\xEA7B\
+\\x84E7\xEA7C\
+\\x84E8\xEA7D\
+\\x84E9\xEA7E\
+\\x84EA\xEAA1\
+\\x84EB\xEAA2\
+\\x84EC\xEAA3\
+\\x84ED\xEAA4\
+\\x84EE\xEAA5\
+\\x84EF\xEAA6\
+\\x84F0\xEAA7\
+\\x84F1\xEAA8\
+\\x84F2\xEAA9\
+\\x84F3\xEAAA\
+\\x84F4\xEAAB\
+\\x84F5\xEAAC\
+\\x84F6\xEAAD\
+\\x84F7\xEAAE\
+\\x84F8\xEAAF\
+\\x84F9\xEAB0\
+\\x84FA\xEAB1\
+\\x84FB\xEAB2\
+\\x84FC\xEAB3\
+\\x84FD\xEAB4\
+\\x8541\xEAB5\
+\\x8542\xEAB6\
+\\x8543\xEAB7\
+\\x8544\xEAB8\
+\\x8545\xEAB9\
+\\x8546\xEABA\
+\\x8547\xEABB\
+\\x8548\xEABC\
+\\x8549\xEABD\
+\\x854A\xEABE\
+\\x854B\xEABF\
+\\x854C\xEAC0\
+\\x854D\xEAC1\
+\\x854E\xEAC2\
+\\x854F\xEAC3\
+\\x8550\xEAC4\
+\\x8551\xEAC5\
+\\x8552\xEAC6\
+\\x8553\xEAC7\
+\\x8554\xEAC8\
+\\x8555\xEAC9\
+\\x8556\xEACA\
+\\x8557\xEACB\
+\\x8558\xEACC\
+\\x8559\xEACD\
+\\x855A\xEACE\
+\\x855B\xEACF\
+\\x855C\xEAD0\
+\\x855D\xEAD1\
+\\x855E\xEAD2\
+\\x855F\xEAD3\
+\\x8560\xEAD4\
+\\x8561\xEAD5\
+\\x8562\xEAD6\
+\\x8563\xEAD7\
+\\x8564\xEAD8\
+\\x8565\xEAD9\
+\\x8566\xEADA\
+\\x8567\xEADB\
+\\x8568\xEADC\
+\\x8569\xEADD\
+\\x856A\xEADE\
+\\x856B\xEADF\
+\\x856C\xEAE0\
+\\x856D\xEAE1\
+\\x856E\xEAE2\
+\\x856F\xEAE3\
+\\x8570\xEAE4\
+\\x8571\xEAE5\
+\\x8572\xEAE6\
+\\x8573\xEAE7\
+\\x8574\xEAE8\
+\\x8575\xEAE9\
+\\x8576\xEAEA\
+\\x8577\xEAEB\
+\\x8578\xEAEC\
+\\x8579\xEAED\
+\\x857A\xEAEE\
+\\x857B\xEAEF\
+\\x857C\xEAF0\
+\\x857D\xEAF1\
+\\x857E\xEAF2\
+\\x857F\xEAF3\
+\\x8581\xEAF4\
+\\x8582\xEAF5\
+\\x8583\xEAF6\
+\\x8584\xEAF7\
+\\x8585\xEAF8\
+\\x8586\xEAF9\
+\\x8587\xEAFA\
+\\x8588\xEAFB\
+\\x8589\xEAFC\
+\\x858A\xEAFD\
+\\x858B\xEAFE\
+\\x858C\xEB40\
+\\x858D\xEB41\
+\\x858E\xEB42\
+\\x858F\xEB43\
+\\x8590\xEB44\
+\\x8591\xEB45\
+\\x8592\xEB46\
+\\x8593\xEB47\
+\\x8594\xEB48\
+\\x8595\xEB49\
+\\x8596\xEB4A\
+\\x8597\xEB4B\
+\\x8598\xEB4C\
+\\x8599\xEB4D\
+\\x859A\xEB4E\
+\\x859B\xEB4F\
+\\x859C\xEB50\
+\\x859D\xEB51\
+\\x859E\xEB52\
+\\x859F\xEB53\
+\\x85A0\xEB54\
+\\x85A1\xEB55\
+\\x85A2\xEB56\
+\\x85A3\xEB57\
+\\x85A4\xEB58\
+\\x85A5\xEB59\
+\\x85A6\xEB5A\
+\\x85A7\xEB5B\
+\\x85A8\xEB5C\
+\\x85A9\xEB5D\
+\\x85AA\xEB5E\
+\\x85AB\xEB5F\
+\\x85AC\xEB60\
+\\x85AD\xEB61\
+\\x85AE\xEB62\
+\\x85AF\xEB63\
+\\x85B0\xEB64\
+\\x85B1\xEB65\
+\\x85B2\xEB66\
+\\x85B3\xEB67\
+\\x85B4\xEB68\
+\\x85B5\xEB69\
+\\x85B6\xEB6A\
+\\x85B7\xEB6B\
+\\x85B8\xEB6C\
+\\x85B9\xEB6D\
+\\x85BA\xEB6E\
+\\x85BB\xEB6F\
+\\x85BC\xEB70\
+\\x85BD\xEB71\
+\\x85BE\xEB72\
+\\x85BF\xEB73\
+\\x85C0\xEB74\
+\\x85C1\xEB75\
+\\x85C2\xEB76\
+\\x85C3\xEB77\
+\\x85C4\xEB78\
+\\x85C5\xEB79\
+\\x85C6\xEB7A\
+\\x85C7\xEB7B\
+\\x85C8\xEB7C\
+\\x85C9\xEB7D\
+\\x85CA\xEB7E\
+\\x85CB\xEBA1\
+\\x85CC\xEBA2\
+\\x85CD\xEBA3\
+\\x85CE\xEBA4\
+\\x85CF\xEBA5\
+\\x85D0\xEBA6\
+\\x85D1\xEBA7\
+\\x85D2\xEBA8\
+\\x85D3\xEBA9\
+\\x85D4\xEBAA\
+\\x85D5\xEBAB\
+\\x85D6\xEBAC\
+\\x85D7\xEBAD\
+\\x85D8\xEBAE\
+\\x85D9\xEBAF\
+\\x85DA\xEBB0\
+\\x85DB\xEBB1\
+\\x85DC\xEBB2\
+\\x85DD\xEBB3\
+\\x85DE\xEBB4\
+\\x85DF\xEBB5\
+\\x85E0\xEBB6\
+\\x85E1\xEBB7\
+\\x85E2\xEBB8\
+\\x85E3\xEBB9\
+\\x85E4\xEBBA\
+\\x85E5\xEBBB\
+\\x85E6\xEBBC\
+\\x85E7\xEBBD\
+\\x85E8\xEBBE\
+\\x85E9\xEBBF\
+\\x85EA\xEBC0\
+\\x85EB\xEBC1\
+\\x85EC\xEBC2\
+\\x85ED\xEBC3\
+\\x85EE\xEBC4\
+\\x85EF\xEBC5\
+\\x85F0\xEBC6\
+\\x85F1\xEBC7\
+\\x85F2\xEBC8\
+\\x85F3\xEBC9\
+\\x85F4\xEBCA\
+\\x85F5\xEBCB\
+\\x85F6\xEBCC\
+\\x85F7\xEBCD\
+\\x85F8\xEBCE\
+\\x85F9\xEBCF\
+\\x85FA\xEBD0\
+\\x85FB\xEBD1\
+\\x85FC\xEBD2\
+\\x85FD\xEBD3\
+\\x8641\xEBD4\
+\\x8642\xEBD5\
+\\x8643\xEBD6\
+\\x8644\xEBD7\
+\\x8645\xEBD8\
+\\x8646\xEBD9\
+\\x8647\xEBDA\
+\\x8648\xEBDB\
+\\x8649\xEBDC\
+\\x864A\xEBDD\
+\\x864B\xEBDE\
+\\x864C\xEBDF\
+\\x864D\xEBE0\
+\\x864E\xEBE1\
+\\x864F\xEBE2\
+\\x8650\xEBE3\
+\\x8651\xEBE4\
+\\x8652\xEBE5\
+\\x8653\xEBE6\
+\\x8654\xEBE7\
+\\x8655\xEBE8\
+\\x8656\xEBE9\
+\\x8657\xEBEA\
+\\x8658\xEBEB\
+\\x8659\xEBEC\
+\\x865A\xEBED\
+\\x865B\xEBEE\
+\\x865C\xEBEF\
+\\x865D\xEBF0\
+\\x865E\xEBF1\
+\\x865F\xEBF2\
+\\x8660\xEBF3\
+\\x8661\xEBF4\
+\\x8662\xEBF5\
+\\x8663\xEBF6\
+\\x8664\xEBF7\
+\\x8665\xEBF8\
+\\x8666\xEBF9\
+\\x8667\xEBFA\
+\\x8668\xEBFB\
+\\x8669\xEBFC\
+\\x866A\xEBFD\
+\\x866B\xEBFE\
+\\x866C\xEC40\
+\\x866D\xEC41\
+\\x866E\xEC42\
+\\x866F\xEC43\
+\\x8670\xEC44\
+\\x8671\xEC45\
+\\x8672\xEC46\
+\\x8673\xEC47\
+\\x8674\xEC48\
+\\x8675\xEC49\
+\\x8676\xEC4A\
+\\x8677\xEC4B\
+\\x8678\xEC4C\
+\\x8679\xEC4D\
+\\x867A\xEC4E\
+\\x867B\xEC4F\
+\\x867C\xEC50\
+\\x867D\xEC51\
+\\x867E\xEC52\
+\\x867F\xEC53\
+\\x8681\xEC54\
+\\x8682\xEC55\
+\\x8683\xEC56\
+\\x8684\xEC57\
+\\x8685\xEC58\
+\\x8686\xEC59\
+\\x8687\xEC5A\
+\\x8688\xEC5B\
+\\x8689\xEC5C\
+\\x868A\xEC5D\
+\\x868B\xEC5E\
+\\x868C\xEC5F\
+\\x868D\xEC60\
+\\x868E\xEC61\
+\\x868F\xEC62\
+\\x8690\xEC63\
+\\x8691\xEC64\
+\\x8692\xEC65\
+\\x8693\xEC66\
+\\x8694\xEC67\
+\\x8695\xEC68\
+\\x8696\xEC69\
+\\x8697\xEC6A\
+\\x8698\xEC6B\
+\\x8699\xEC6C\
+\\x869A\xEC6D\
+\\x869B\xEC6E\
+\\x869C\xEC6F\
+\\x869D\xEC70\
+\\x869E\xEC71\
+\\x869F\xEC72\
+\\x86A0\xEC73\
+\\x86A1\xEC74\
+\\x86A2\xEC75\
+\\x86A3\xEC76\
+\\x86A4\xEC77\
+\\x86A5\xEC78\
+\\x86A6\xEC79\
+\\x86A7\xEC7A\
+\\x86A8\xEC7B\
+\\x86A9\xEC7C\
+\\x86AA\xEC7D\
+\\x86AB\xEC7E\
+\\x86AC\xECA1\
+\\x86AD\xECA2\
+\\x86AE\xECA3\
+\\x86AF\xECA4\
+\\x86B0\xECA5\
+\\x86B1\xECA6\
+\\x86B2\xECA7\
+\\x86B3\xECA8\
+\\x86B4\xECA9\
+\\x86B5\xECAA\
+\\x86B6\xECAB\
+\\x86B7\xECAC\
+\\x86B8\xECAD\
+\\x86B9\xECAE\
+\\x86BA\xECAF\
+\\x86BB\xECB0\
+\\x86BC\xECB1\
+\\x86BD\xECB2\
+\\x86BE\xECB3\
+\\x86BF\xECB4\
+\\x86C0\xECB5\
+\\x86C1\xECB6\
+\\x86C2\xECB7\
+\\x86C3\xECB8\
+\\x86C4\xECB9\
+\\x86C5\xECBA\
+\\x86C6\xECBB\
+\\x86C7\xECBC\
+\\x86C8\xECBD\
+\\x86C9\xECBE\
+\\x86CA\xECBF\
+\\x86CB\xECC0\
+\\x86CC\xECC1\
+\\x86CD\xECC2\
+\\x86CE\xECC3\
+\\x86CF\xECC4\
+\\x86D0\xECC5\
+\\x86D1\xECC6\
+\\x86D2\xECC7\
+\\x86D3\xECC8\
+\\x86D4\xECC9\
+\\x86D5\xECCA\
+\\x86D6\xECCB\
+\\x86D7\xECCC\
+\\x86D8\xECCD\
+\\x86D9\xECCE\
+\\x86DA\xECCF\
+\\x86DB\xECD0\
+\\x86DC\xECD1\
+\\x86DD\xECD2\
+\\x86DE\xECD3\
+\\x86DF\xECD4\
+\\x86E0\xECD5\
+\\x86E1\xECD6\
+\\x86E2\xECD7\
+\\x86E3\xECD8\
+\\x86E4\xECD9\
+\\x86E5\xECDA\
+\\x86E6\xECDB\
+\\x86E7\xECDC\
+\\x86E8\xECDD\
+\\x86E9\xECDE\
+\\x86EA\xECDF\
+\\x86EB\xECE0\
+\\x86EC\xECE1\
+\\x86ED\xECE2\
+\\x86EE\xECE3\
+\\x86EF\xECE4\
+\\x86F0\xECE5\
+\\x86F1\xECE6\
+\\x86F2\xECE7\
+\\x86F3\xECE8\
+\\x86F4\xECE9\
+\\x86F5\xECEA\
+\\x86F6\xECEB\
+\\x86F7\xECEC\
+\\x86F8\xECED\
+\\x86F9\xECEE\
+\\x86FA\xECEF\
+\\x86FB\xECF0\
+\\x86FC\xECF1\
+\\x86FD\xECF2\
+\\x8741\xECF3\
+\\x8742\xECF4\
+\\x8743\xECF5\
+\\x8744\xECF6\
+\\x8745\xECF7\
+\\x8746\xECF8\
+\\x8747\xECF9\
+\\x8748\xECFA\
+\\x8749\xECFB\
+\\x874A\xECFC\
+\\x874B\xECFD\
+\\x874C\xECFE\
+\\x874D\xED40\
+\\x874E\xED41\
+\\x874F\xED42\
+\\x8750\xED43\
+\\x8751\xED44\
+\\x8752\xED45\
+\\x8753\xED46\
+\\x8754\xED47\
+\\x8755\xED48\
+\\x8756\xED49\
+\\x8757\xED4A\
+\\x8758\xED4B\
+\\x8759\xED4C\
+\\x875A\xED4D\
+\\x875B\xED4E\
+\\x875C\xED4F\
+\\x875D\xED50\
+\\x875E\xED51\
+\\x875F\xED52\
+\\x8760\xED53\
+\\x8761\xED54\
+\\x8762\xED55\
+\\x8763\xED56\
+\\x8764\xED57\
+\\x8765\xED58\
+\\x8766\xED59\
+\\x8767\xED5A\
+\\x8768\xED5B\
+\\x8769\xED5C\
+\\x876A\xED5D\
+\\x876B\xED5E\
+\\x876C\xED5F\
+\\x876D\xED60\
+\\x876E\xED61\
+\\x876F\xED62\
+\\x8770\xED63\
+\\x8771\xED64\
+\\x8772\xED65\
+\\x8773\xED66\
+\\x8774\xED67\
+\\x8775\xED68\
+\\x8776\xED69\
+\\x8777\xED6A\
+\\x8778\xED6B\
+\\x8779\xED6C\
+\\x877A\xED6D\
+\\x877B\xED6E\
+\\x877C\xED6F\
+\\x877D\xED70\
+\\x877E\xED71\
+\\x877F\xED72\
+\\x8781\xED73\
+\\x8782\xED74\
+\\x8783\xED75\
+\\x8784\xED76\
+\\x8785\xED77\
+\\x8786\xED78\
+\\x8787\xED79\
+\\x8788\xED7A\
+\\x8789\xED7B\
+\\x878A\xED7C\
+\\x878B\xED7D\
+\\x878C\xED7E\
+\\x878D\xEDA1\
+\\x878E\xEDA2\
+\\x878F\xEDA3\
+\\x8790\xEDA4\
+\\x8791\xEDA5\
+\\x8792\xEDA6\
+\\x8793\xEDA7\
+\\x8794\xEDA8\
+\\x8795\xEDA9\
+\\x8796\xEDAA\
+\\x8797\xEDAB\
+\\x8798\xEDAC\
+\\x8799\xEDAD\
+\\x879A\xEDAE\
+\\x879B\xEDAF\
+\\x879C\xEDB0\
+\\x879D\xEDB1\
+\\x879E\xEDB2\
+\\x879F\xEDB3\
+\\x87A0\xEDB4\
+\\x87A1\xEDB5\
+\\x87A2\xEDB6\
+\\x87A3\xEDB7\
+\\x87A4\xEDB8\
+\\x87A5\xEDB9\
+\\x87A6\xEDBA\
+\\x87A7\xEDBB\
+\\x87A8\xEDBC\
+\\x87A9\xEDBD\
+\\x87AA\xEDBE\
+\\x87AB\xEDBF\
+\\x87AC\xEDC0\
+\\x87AD\xEDC1\
+\\x87AE\xEDC2\
+\\x87AF\xEDC3\
+\\x87B0\xEDC4\
+\\x87B1\xEDC5\
+\\x87B2\xEDC6\
+\\x87B3\xEDC7\
+\\x87B4\xEDC8\
+\\x87B5\xEDC9\
+\\x87B6\xEDCA\
+\\x87B7\xEDCB\
+\\x87B8\xEDCC\
+\\x87B9\xEDCD\
+\\x87BA\xEDCE\
+\\x87BB\xEDCF\
+\\x87BC\xEDD0\
+\\x87BD\xEDD1\
+\\x87BE\xEDD2\
+\\x87BF\xEDD3\
+\\x87C0\xEDD4\
+\\x87C1\xEDD5\
+\\x87C2\xEDD6\
+\\x87C3\xEDD7\
+\\x87C4\xEDD8\
+\\x87C5\xEDD9\
+\\x87C6\xEDDA\
+\\x87C7\xEDDB\
+\\x87C8\xEDDC\
+\\x87C9\xEDDD\
+\\x87CA\xEDDE\
+\\x87CB\xEDDF\
+\\x87CC\xEDE0\
+\\x87CD\xEDE1\
+\\x87CE\xEDE2\
+\\x87CF\xEDE3\
+\\x87D0\xEDE4\
+\\x87D1\xEDE5\
+\\x87D2\xEDE6\
+\\x87D3\xEDE7\
+\\x87D4\xEDE8\
+\\x87D5\xEDE9\
+\\x87D6\xEDEA\
+\\x87D7\xEDEB\
+\\x87D8\xEDEC\
+\\x87D9\xEDED\
+\\x87DA\xEDEE\
+\\x87DB\xEDEF\
+\\x87DC\xEDF0\
+\\x87DD\xEDF1\
+\\x87DE\xEDF2\
+\\x87DF\xEDF3\
+\\x87E0\xEDF4\
+\\x87E1\xEDF5\
+\\x87E2\xEDF6\
+\\x87E3\xEDF7\
+\\x87E4\xEDF8\
+\\x87E5\xEDF9\
+\\x87E6\xEDFA\
+\\x87E7\xEDFB\
+\\x87E8\xEDFC\
+\\x87E9\xEDFD\
+\\x87EA\xEDFE\
+\\x87EB\xEE40\
+\\x87EC\xEE41\
+\\x87ED\xEE42\
+\\x87EE\xEE43\
+\\x87EF\xEE44\
+\\x87F0\xEE45\
+\\x87F1\xEE46\
+\\x87F2\xEE47\
+\\x87F3\xEE48\
+\\x87F4\xEE49\
+\\x87F5\xEE4A\
+\\x87F6\xEE4B\
+\\x87F7\xEE4C\
+\\x87F8\xEE4D\
+\\x87F9\xEE4E\
+\\x87FA\xEE4F\
+\\x87FB\xEE50\
+\\x87FC\xEE51\
+\\x87FD\xEE52\
+\\x8841\xEE53\
+\\x8842\xEE54\
+\\x8843\xEE55\
+\\x8844\xEE56\
+\\x8845\xEE57\
+\\x8846\xEE58\
+\\x8847\xEE59\
+\\x8848\xEE5A\
+\\x8849\xEE5B\
+\\x884A\xEE5C\
+\\x884B\xEE5D\
+\\x884C\xEE5E\
+\\x884D\xEE5F\
+\\x884E\xEE60\
+\\x884F\xEE61\
+\\x8850\xEE62\
+\\x8851\xEE63\
+\\x8852\xEE64\
+\\x8853\xEE65\
+\\x8854\xEE66\
+\\x8855\xEE67\
+\\x8856\xEE68\
+\\x8857\xEE69\
+\\x8858\xEE6A\
+\\x8859\xEE6B\
+\\x885A\xEE6C\
+\\x885B\xEE6D\
+\\x885C\xEE6E\
+\\x885D\xEE6F\
+\\x885E\xEE70\
+\\x885F\xEE71\
+\\x8860\xEE72\
+\\x8861\xEE73\
+\\x8862\xEE74\
+\\x8863\xEE75\
+\\x8864\xEE76\
+\\x8865\xEE77\
+\\x8866\xEE78\
+\\x8867\xEE79\
+\\x8868\xEE7A\
+\\x8869\xEE7B\
+\\x886A\xEE7C\
+\\x886B\xEE7D\
+\\x886C\xEE7E\
+\\x886D\xEEA1\
+\\x886E\xEEA2\
+\\x886F\xEEA3\
+\\x8870\xEEA4\
+\\x8871\xEEA5\
+\\x8872\xEEA6\
+\\x8873\xEEA7\
+\\x8874\xEEA8\
+\\x8875\xEEA9\
+\\x8876\xEEAA\
+\\x8877\xEEAB\
+\\x8878\xEEAC\
+\\x8879\xEEAD\
+\\x887A\xEEAE\
+\\x887B\xEEAF\
+\\x887C\xEEB0\
+\\x887D\xEEB1\
+\\x887E\xEEB2\
+\\x887F\xEEB3\
+\\x8881\xEEB4\
+\\x8882\xEEB5\
+\\x8883\xEEB6\
+\\x8884\xEEB7\
+\\x8885\xEEB8\
+\\x8886\xEEB9\
+\\x8887\xEEBA\
+\\x8888\xEEBB\
+\\x8889\xEEBC\
+\\x888A\xEEBD\
+\\x888B\xEEBE\
+\\x888C\xEEBF\
+\\x888D\xEEC0\
+\\x888E\xEEC1\
+\\x888F\xEEC2\
+\\x8890\xEEC3\
+\\x8891\xEEC4\
+\\x8892\xEEC5\
+\\x8893\xEEC6\
+\\x8894\xEEC7\
+\\x8895\xEEC8\
+\\x8896\xEEC9\
+\\x8897\xEECA\
+\\x8898\xEECB\
+\\x8899\xEECC\
+\\x889A\xEECD\
+\\x889B\xEECE\
+\\x889C\xEECF\
+\\x889D\xEED0\
+\\x889E\xEED1\
+\\x889F\xEED2\
+\\x88A0\xEED3\
+\\x88A1\xEED4\
+\\x88A2\xEED5\
+\\x88A3\xEED6\
+\\x88A4\xEED7\
+\\x88A5\xEED8\
+\\x88A6\xEED9\
+\\x88A7\xEEDA\
+\\x88A8\xEEDB\
+\\x88A9\xEEDC\
+\\x88AA\xEEDD\
+\\x88AB\xEEDE\
+\\x88AC\xEEDF\
+\\x88AD\xEEE0\
+\\x88AE\xEEE1\
+\\x88AF\xEEE2\
+\\x88B0\xEEE3\
+\\x88B1\xEEE4\
+\\x88B2\xEEE5\
+\\x88B3\xEEE6\
+\\x88B4\xEEE7\
+\\x88B5\xEEE8\
+\\x88B6\xEEE9\
+\\x88B7\xEEEA\
+\\x88B8\xEEEB\
+\\x88B9\xEEEC\
+\\x88BA\xEEED\
+\\x88BB\xEEEE\
+\\x88BC\xEEEF\
+\\x88BD\xEEF0\
+\\x88BE\xEEF1\
+\\x88BF\xEEF2\
+\\x88C0\xEEF3\
+\\x88C1\xEEF4\
+\\x88C2\xEEF5\
+\\x88C3\xEEF6\
+\\x88C4\xEEF7\
+\\x88C5\xEEF8\
+\\x88C6\xEEF9\
+\\x88C7\xEEFA\
+\\x88C8\xEEFB\
+\\x88C9\xEEFC\
+\\x88CA\xEEFD\
+\\x88CB\xEEFE\
+\\x88CC\xEF40\
+\\x88CD\xEF41\
+\\x88CE\xEF42\
+\\x88CF\xEF43\
+\\x88D0\xEF44\
+\\x88D1\xEF45\
+\\x88D2\xEF46\
+\\x88D3\xEF47\
+\\x88D4\xEF48\
+\\x88D5\xEF49\
+\\x88D6\xEF4A\
+\\x88D7\xEF4B\
+\\x88D8\xEF4C\
+\\x88D9\xEF4D\
+\\x88DA\xEF4E\
+\\x88DB\xEF4F\
+\\x88DC\xEF50\
+\\x88DD\xEF51\
+\\x88DE\xEF52\
+\\x88DF\xEF53\
+\\x88E0\xEF54\
+\\x88E1\xEF55\
+\\x88E2\xEF56\
+\\x88E3\xEF57\
+\\x88E4\xEF58\
+\\x88E5\xEF59\
+\\x88E6\xEF5A\
+\\x88E7\xEF5B\
+\\x88E8\xEF5C\
+\\x88E9\xEF5D\
+\\x88EA\xEF5E\
+\\x88EB\xEF5F\
+\\x88EC\xEF60\
+\\x88ED\xEF61\
+\\x88EE\xEF62\
+\\x88EF\xEF63\
+\\x88F0\xEF64\
+\\x88F1\xEF65\
+\\x88F2\xEF66\
+\\x88F3\xEF67\
+\\x88F4\xEF68\
+\\x88F5\xEF69\
+\\x88F6\xEF6A\
+\\x88F7\xEF6B\
+\\x88F8\xEF6C\
+\\x88F9\xEF6D\
+\\x88FA\xEF6E\
+\\x88FB\xEF6F\
+\\x88FC\xEF70\
+\\x88FD\xEF71\
+\\x8941\xEF72\
+\\x8942\xEF73\
+\\x8943\xEF74\
+\\x8944\xEF75\
+\\x8945\xEF76\
+\\x8946\xEF77\
+\\x8947\xEF78\
+\\x8948\xEF79\
+\\x8949\xEF7A\
+\\x894A\xEF7B\
+\\x894B\xEF7C\
+\\x894C\xEF7D\
+\\x894D\xEF7E\
+\\x894E\xEFA1\
+\\x894F\xEFA2\
+\\x8950\xEFA3\
+\\x8951\xEFA4\
+\\x8952\xEFA5\
+\\x8953\xEFA6\
+\\x8954\xEFA7\
+\\x8955\xEFA8\
+\\x8956\xEFA9\
+\\x8957\xEFAA\
+\\x8958\xEFAB\
+\\x8959\xEFAC\
+\\x895A\xEFAD\
+\\x895B\xEFAE\
+\\x895C\xEFAF\
+\\x895D\xEFB0\
+\\x895E\xEFB1\
+\\x895F\xEFB2\
+\\x8960\xEFB3\
+\\x8961\xEFB4\
+\\x8962\xEFB5\
+\\x8963\xEFB6\
+\\x8964\xEFB7\
+\\x8965\xEFB8\
+\\x8966\xEFB9\
+\\x8967\xEFBA\
+\\x8968\xEFBB\
+\\x8969\xEFBC\
+\\x896A\xEFBD\
+\\x896B\xEFBE\
+\\x896C\xEFBF\
+\\x896D\xEFC0\
+\\x896E\xEFC1\
+\\x896F\xEFC2\
+\\x8970\xEFC3\
+\\x8971\xEFC4\
+\\x8972\xEFC5\
+\\x8973\xEFC6\
+\\x8974\xEFC7\
+\\x8975\xEFC8\
+\\x8976\xEFC9\
+\\x8977\xEFCA\
+\\x8978\xEFCB\
+\\x8979\xEFCC\
+\\x897A\xEFCD\
+\\x897B\xEFCE\
+\\x897C\xEFCF\
+\\x897D\xEFD0\
+\\x897E\xEFD1\
+\\x897F\xEFD2\
+\\x8981\xEFD3\
+\\x8982\xEFD4\
+\\x8983\xEFD5\
+\\x8984\xEFD6\
+\\x8985\xEFD7\
+\\x8986\xEFD8\
+\\x8987\xEFD9\
+\\x8988\xEFDA\
+\\x8989\xEFDB\
+\\x898A\xEFDC\
+\\x898B\xEFDD\
+\\x898C\xEFDE\
+\\x898D\xEFDF\
+\\x898E\xEFE0\
+\\x898F\xEFE1\
+\\x8990\xEFE2\
+\\x8991\xEFE3\
+\\x8992\xEFE4\
+\\x8993\xEFE5\
+\\x8994\xEFE6\
+\\x8995\xEFE7\
+\\x8996\xEFE8\
+\\x8997\xEFE9\
+\\x8998\xEFEA\
+\\x8999\xEFEB\
+\\x899A\xEFEC\
+\\x899B\xEFED\
+\\x899C\xEFEE\
+\\x899D\xEFEF\
+\\x899E\xEFF0\
+\\x899F\xEFF1\
+\\x89A0\xEFF2\
+\\x89A1\xEFF3\
+\\x89A2\xEFF4\
+\\x89A3\xEFF5\
+\\x89A4\xEFF6\
+\\x89A5\xEFF7\
+\\x89A6\xEFF8\
+\\x89A7\xEFF9\
+\\x89A8\xEFFA\
+\\x89A9\xEFFB\
+\\x89AA\xEFFC\
+\\x89AB\xEFFD\
+\\x89AC\xEFFE\
+\\x89AD\xF040\
+\\x89AE\xF041\
+\\x89AF\xF042\
+\\x89B0\xF043\
+\\x89B1\xF044\
+\\x89B2\xF045\
+\\x89B3\xF046\
+\\x89B4\xF047\
+\\x89B5\xF048\
+\\x89B6\xF049\
+\\x89B7\xF04A\
+\\x89B8\xF04B\
+\\x89B9\xF04C\
+\\x89BA\xF04D\
+\\x89BB\xF04E\
+\\x89BC\xF04F\
+\\x89BD\xF050\
+\\x89BE\xF051\
+\\x89BF\xF052\
+\\x89C0\xF053\
+\\x89C1\xF054\
+\\x89C2\xF055\
+\\x89C3\xF056\
+\\x89C4\xF057\
+\\x89C5\xF058\
+\\x89C6\xF059\
+\\x89C7\xF05A\
+\\x89C8\xF05B\
+\\x89C9\xF05C\
+\\x89CA\xF05D\
+\\x89CB\xF05E\
+\\x89CC\xF05F\
+\\x89CD\xF060\
+\\x89CE\xF061\
+\\x89CF\xF062\
+\\x89D0\xF063\
+\\x89D1\xF064\
+\\x89D2\xF065\
+\\x89D3\xF066\
+\\x89D4\xF067\
+\\x89D5\xF068\
+\\x89D6\xF069\
+\\x89D7\xF06A\
+\\x89D8\xF06B\
+\\x89D9\xF06C\
+\\x89DA\xF06D\
+\\x89DB\xF06E\
+\\x89DC\xF06F\
+\\x89DD\xF070\
+\\x89DE\xF071\
+\\x89DF\xF072\
+\\x89E0\xF073\
+\\x89E1\xF074\
+\\x89E2\xF075\
+\\x89E3\xF076\
+\\x89E4\xF077\
+\\x89E5\xF078\
+\\x89E6\xF079\
+\\x89E7\xF07A\
+\\x89E8\xF07B\
+\\x89E9\xF07C\
+\\x89EA\xF07D\
+\\x89EB\xF07E\
+\\x89EC\xF0A1\
+\\x89ED\xF0A2\
+\\x89EE\xF0A3\
+\\x89EF\xF0A4\
+\\x89F0\xF0A5\
+\\x89F1\xF0A6\
+\\x89F2\xF0A7\
+\\x89F3\xF0A8\
+\\x89F4\xF0A9\
+\\x89F5\xF0AA\
+\\x89F6\xF0AB\
+\\x89F7\xF0AC\
+\\x89F8\xF0AD\
+\\x89F9\xF0AE\
+\\x89FA\xF0AF\
+\\x89FB\xF0B0\
+\\x89FC\xF0B1\
+\\x89FD\xF0B2\
+\\x8A41\xF0B3\
+\\x8A42\xF0B4\
+\\x8A43\xF0B5\
+\\x8A44\xF0B6\
+\\x8A45\xF0B7\
+\\x8A46\xF0B8\
+\\x8A47\xF0B9\
+\\x8A48\xF0BA\
+\\x8A49\xF0BB\
+\\x8A4A\xF0BC\
+\\x8A4B\xF0BD\
+\\x8A4C\xF0BE\
+\\x8A4D\xF0BF\
+\\x8A4E\xF0C0\
+\\x8A4F\xF0C1\
+\\x8A50\xF0C2\
+\\x8A51\xF0C3\
+\\x8A52\xF0C4\
+\\x8A53\xF0C5\
+\\x8A54\xF0C6\
+\\x8A55\xF0C7\
+\\x8A56\xF0C8\
+\\x8A57\xF0C9\
+\\x8A58\xF0CA\
+\\x8A59\xF0CB\
+\\x8A5A\xF0CC\
+\\x8A5B\xF0CD\
+\\x8A5C\xF0CE\
+\\x8A5D\xF0CF\
+\\x8A5E\xF0D0\
+\\x8A5F\xF0D1\
+\\x8A60\xF0D2\
+\\x8A61\xF0D3\
+\\x8A62\xF0D4\
+\\x8A63\xF0D5\
+\\x8A64\xF0D6\
+\\x8A65\xF0D7\
+\\x8A66\xF0D8\
+\\x8A67\xF0D9\
+\\x8A68\xF0DA\
+\\x8A69\xF0DB\
+\\x8A6A\xF0DC\
+\\x8A6B\xF0DD\
+\\x8A6C\xF0DE\
+\\x8A6D\xF0DF\
+\\x8A6E\xF0E0\
+\\x8A6F\xF0E1\
+\\x8A70\xF0E2\
+\\x8A71\xF0E3\
+\\x8A72\xF0E4\
+\\x8A73\xF0E5\
+\\x8A74\xF0E6\
+\\x8A75\xF0E7\
+\\x8A76\xF0E8\
+\\x8A77\xF0E9\
+\\x8A78\xF0EA\
+\\x8A79\xF0EB\
+\\x8A7A\xF0EC\
+\\x8A7B\xF0ED\
+\\x8A7C\xF0EE\
+\\x8A7D\xF0EF\
+\\x8A7E\xF0F0\
+\\x8A7F\xF0F1\
+\\x8A81\xF0F2\
+\\x8A82\xF0F3\
+\\x8A83\xF0F4\
+\\x8A84\xF0F5\
+\\x8A85\xF0F6\
+\\x8A86\xF0F7\
+\\x8A87\xF0F8\
+\\x8A88\xF0F9\
+\\x8A89\xF0FA\
+\\x8A8A\xF0FB\
+\\x8A8B\xF0FC\
+\\x8A8C\xF0FD\
+\\x8A8D\xF0FE\
+\\x8A8E\xF140\
+\\x8A8F\xF141\
+\\x8A90\xF142\
+\\x8A91\xF143\
+\\x8A92\xF144\
+\\x8A93\xF145\
+\\x8A94\xF146\
+\\x8A95\xF147\
+\\x8A96\xF148\
+\\x8A97\xF149\
+\\x8A98\xF14A\
+\\x8A99\xF14B\
+\\x8A9A\xF14C\
+\\x8A9B\xF14D\
+\\x8A9C\xF14E\
+\\x8A9D\xF14F\
+\\x8A9E\xF150\
+\\x8A9F\xF151\
+\\x8AA0\xF152\
+\\x8AA1\xF153\
+\\x8AA2\xF154\
+\\x8AA3\xF155\
+\\x8AA4\xF156\
+\\x8AA5\xF157\
+\\x8AA6\xF158\
+\\x8AA7\xF159\
+\\x8AA8\xF15A\
+\\x8AA9\xF15B\
+\\x8AAA\xF15C\
+\\x8AAB\xF15D\
+\\x8AAC\xF15E\
+\\x8AAD\xF15F\
+\\x8AAE\xF160\
+\\x8AAF\xF161\
+\\x8AB0\xF162\
+\\x8AB1\xF163\
+\\x8AB2\xF164\
+\\x8AB3\xF165\
+\\x8AB4\xF166\
+\\x8AB5\xF167\
+\\x8AB6\xF168\
+\\x8AB7\xF169\
+\\x8AB8\xF16A\
+\\x8AB9\xF16B\
+\\x8ABA\xF16C\
+\\x8ABB\xF16D\
+\\x8ABC\xF16E\
+\\x8ABD\xF16F\
+\\x8ABE\xF170\
+\\x8ABF\xF171\
+\\x8AC0\xF172\
+\\x8AC1\xF173\
+\\x8AC2\xF174\
+\\x8AC3\xF175\
+\\x8AC4\xF176\
+\\x8AC5\xF177\
+\\x8AC6\xF178\
+\\x8AC7\xF179\
+\\x8AC8\xF17A\
+\\x8AC9\xF17B\
+\\x8ACA\xF17C\
+\\x8ACB\xF17D\
+\\x8ACC\xF17E\
+\\x8ACD\xF1A1\
+\\x8ACE\xF1A2\
+\\x8ACF\xF1A3\
+\\x8AD0\xF1A4\
+\\x8AD1\xF1A5\
+\\x8AD2\xF1A6\
+\\x8AD3\xF1A7\
+\\x8AD4\xF1A8\
+\\x8AD5\xF1A9\
+\\x8AD6\xF1AA\
+\\x8AD7\xF1AB\
+\\x8AD8\xF1AC\
+\\x8AD9\xF1AD\
+\\x8ADA\xF1AE\
+\\x8ADB\xF1AF\
+\\x8ADC\xF1B0\
+\\x8ADD\xF1B1\
+\\x8ADE\xF1B2\
+\\x8ADF\xF1B3\
+\\x8AE0\xF1B4\
+\\x8AE1\xF1B5\
+\\x8AE2\xF1B6\
+\\x8AE3\xF1B7\
+\\x8AE4\xF1B8\
+\\x8AE5\xF1B9\
+\\x8AE6\xF1BA\
+\\x8AE7\xF1BB\
+\\x8AE8\xF1BC\
+\\x8AE9\xF1BD\
+\\x8AEA\xF1BE\
+\\x8AEB\xF1BF\
+\\x8AEC\xF1C0\
+\\x8AED\xF1C1\
+\\x8AEE\xF1C2\
+\\x8AEF\xF1C3\
+\\x8AF0\xF1C4\
+\\x8AF1\xF1C5\
+\\x8AF2\xF1C6\
+\\x8AF3\xF1C7\
+\\x8AF4\xF1C8\
+\\x8AF5\xF1C9\
+\\x8AF6\xF1CA\
+\\x8AF7\xF1CB\
+\\x8AF8\xF1CC\
+\\x8AF9\xF1CD\
+\\x8AFA\xF1CE\
+\\x8AFB\xF1CF\
+\\x8AFC\xF1D0\
+\\x8AFD\xF1D1\
+\\x8B41\xF1D2\
+\\x8B42\xF1D3\
+\\x8B43\xF1D4\
+\\x8B44\xF1D5\
+\\x8B45\xF1D6\
+\\x8B46\xF1D7\
+\\x8B47\xF1D8\
+\\x8B48\xF1D9\
+\\x8B49\xF1DA\
+\\x8B4A\xF1DB\
+\\x8B4B\xF1DC\
+\\x8B4C\xF1DD\
+\\x8B4D\xF1DE\
+\\x8B4E\xF1DF\
+\\x8B4F\xF1E0\
+\\x8B50\xF1E1\
+\\x8B51\xF1E2\
+\\x8B52\xF1E3\
+\\x8B53\xF1E4\
+\\x8B54\xF1E5\
+\\x8B55\xF1E6\
+\\x8B56\xF1E7\
+\\x8B57\xF1E8\
+\\x8B58\xF1E9\
+\\x8B59\xF1EA\
+\\x8B5A\xF1EB\
+\\x8B5B\xF1EC\
+\\x8B5C\xF1ED\
+\\x8B5D\xF1EE\
+\\x8B5E\xF1EF\
+\\x8B5F\xF1F0\
+\\x8B60\xF1F1\
+\\x8B61\xF1F2\
+\\x8B62\xF1F3\
+\\x8B63\xF1F4\
+\\x8B64\xF1F5\
+\\x8B65\xF1F6\
+\\x8B66\xF1F7\
+\\x8B67\xF1F8\
+\\x8B68\xF1F9\
+\\x8B69\xF1FA\
+\\x8B6A\xF1FB\
+\\x8B6B\xF1FC\
+\\x8B6C\xF1FD\
+\\x8B6D\xF1FE\
+\\x8B6E\xF240\
+\\x8B6F\xF241\
+\\x8B70\xF242\
+\\x8B71\xF243\
+\\x8B72\xF244\
+\\x8B73\xF245\
+\\x8B74\xF246\
+\\x8B75\xF247\
+\\x8B76\xF248\
+\\x8B77\xF249\
+\\x8B78\xF24A\
+\\x8B79\xF24B\
+\\x8B7A\xF24C\
+\\x8B7B\xF24D\
+\\x8B7C\xF24E\
+\\x8B7D\xF24F\
+\\x8B7E\xF250\
+\\x8B7F\xF251\
+\\x8B81\xF252\
+\\x8B82\xF253\
+\\x8B83\xF254\
+\\x8B84\xF255\
+\\x8B85\xF256\
+\\x8B86\xF257\
+\\x8B87\xF258\
+\\x8B88\xF259\
+\\x8B89\xF25A\
+\\x8B8A\xF25B\
+\\x8B8B\xF25C\
+\\x8B8C\xF25D\
+\\x8B8D\xF25E\
+\\x8B8E\xF25F\
+\\x8B8F\xF260\
+\\x8B90\xF261\
+\\x8B91\xF262\
+\\x8B92\xF263\
+\\x8B93\xF264\
+\\x8B94\xF265\
+\\x8B95\xF266\
+\\x8B96\xF267\
+\\x8B97\xF268\
+\\x8B98\xF269\
+\\x8B99\xF26A\
+\\x8B9A\xF26B\
+\\x8B9B\xF26C\
+\\x8B9C\xF26D\
+\\x8B9D\xF26E\
+\\x8B9E\xF26F\
+\\x8B9F\xF270\
+\\x8BA0\xF271\
+\\x8BA1\xF272\
+\\x8BA2\xF273\
+\\x8BA3\xF274\
+\\x8BA4\xF275\
+\\x8BA5\xF276\
+\\x8BA6\xF277\
+\\x8BA7\xF278\
+\\x8BA8\xF279\
+\\x8BA9\xF27A\
+\\x8BAA\xF27B\
+\\x8BAB\xF27C\
+\\x8BAC\xF27D\
+\\x8BAD\xF27E\
+\\x8BAE\xF2A1\
+\\x8BAF\xF2A2\
+\\x8BB0\xF2A3\
+\\x8BB1\xF2A4\
+\\x8BB2\xF2A5\
+\\x8BB3\xF2A6\
+\\x8BB4\xF2A7\
+\\x8BB5\xF2A8\
+\\x8BB6\xF2A9\
+\\x8BB7\xF2AA\
+\\x8BB8\xF2AB\
+\\x8BB9\xF2AC\
+\\x8BBA\xF2AD\
+\\x8BBB\xF2AE\
+\\x8BBC\xF2AF\
+\\x8BBD\xF2B0\
+\\x8BBE\xF2B1\
+\\x8BBF\xF2B2\
+\\x8BC0\xF2B3\
+\\x8BC1\xF2B4\
+\\x8BC2\xF2B5\
+\\x8BC3\xF2B6\
+\\x8BC4\xF2B7\
+\\x8BC5\xF2B8\
+\\x8BC6\xF2B9\
+\\x8BC7\xF2BA\
+\\x8BC8\xF2BB\
+\\x8BC9\xF2BC\
+\\x8BCA\xF2BD\
+\\x8BCB\xF2BE\
+\\x8BCC\xF2BF\
+\\x8BCD\xF2C0\
+\\x8BCE\xF2C1\
+\\x8BCF\xF2C2\
+\\x8BD0\xF2C3\
+\\x8BD1\xF2C4\
+\\x8BD2\xF2C5\
+\\x8BD3\xF2C6\
+\\x8BD4\xF2C7\
+\\x8BD5\xF2C8\
+\\x8BD6\xF2C9\
+\\x8BD7\xF2CA\
+\\x8BD8\xF2CB\
+\\x8BD9\xF2CC\
+\\x8BDA\xF2CD\
+\\x8BDB\xF2CE\
+\\x8BDC\xF2CF\
+\\x8BDD\xF2D0\
+\\x8BDE\xF2D1\
+\\x8BDF\xF2D2\
+\\x8BE0\xF2D3\
+\\x8BE1\xF2D4\
+\\x8BE2\xF2D5\
+\\x8BE3\xF2D6\
+\\x8BE4\xF2D7\
+\\x8BE5\xF2D8\
+\\x8BE6\xF2D9\
+\\x8BE7\xF2DA\
+\\x8BE8\xF2DB\
+\\x8BE9\xF2DC\
+\\x8BEA\xF2DD\
+\\x8BEB\xF2DE\
+\\x8BEC\xF2DF\
+\\x8BED\xF2E0\
+\\x8BEE\xF2E1\
+\\x8BEF\xF2E2\
+\\x8BF0\xF2E3\
+\\x8BF1\xF2E4\
+\\x8BF2\xF2E5\
+\\x8BF3\xF2E6\
+\\x8BF4\xF2E7\
+\\x8BF5\xF2E8\
+\\x8BF6\xF2E9\
+\\x8BF7\xF2EA\
+\\x8BF8\xF2EB\
+\\x8BF9\xF2EC\
+\\x8BFA\xF2ED\
+\\x8BFB\xF2EE\
+\\x8BFC\xF2EF\
+\\x8BFD\xF2F0\
+\\x8C41\xF2F1\
+\\x8C42\xF2F2\
+\\x8C43\xF2F3\
+\\x8C44\xF2F4\
+\\x8C45\xF2F5\
+\\x8C46\xF2F6\
+\\x8C47\xF2F7\
+\\x8C48\xF2F8\
+\\x8C49\xF2F9\
+\\x8C4A\xF2FA\
+\\x8C4B\xF2FB\
+\\x8C4C\xF2FC\
+\\x8C4D\xF2FD\
+\\x8C4E\xF2FE\
+\\x8C4F\xF340\
+\\x8C50\xF341\
+\\x8C51\xF342\
+\\x8C52\xF343\
+\\x8C53\xF344\
+\\x8C54\xF345\
+\\x8C55\xF346\
+\\x8C56\xF347\
+\\x8C57\xF348\
+\\x8C58\xF349\
+\\x8C59\xF34A\
+\\x8C5A\xF34B\
+\\x8C5B\xF34C\
+\\x8C5C\xF34D\
+\\x8C5D\xF34E\
+\\x8C5E\xF34F\
+\\x8C5F\xF350\
+\\x8C60\xF351\
+\\x8C61\xF352\
+\\x8C62\xF353\
+\\x8C63\xF354\
+\\x8C64\xF355\
+\\x8C65\xF356\
+\\x8C66\xF357\
+\\x8C67\xF358\
+\\x8C68\xF359\
+\\x8C69\xF35A\
+\\x8C6A\xF35B\
+\\x8C6B\xF35C\
+\\x8C6C\xF35D\
+\\x8C6D\xF35E\
+\\x8C6E\xF35F\
+\\x8C6F\xF360\
+\\x8C70\xF361\
+\\x8C71\xF362\
+\\x8C72\xF363\
+\\x8C73\xF364\
+\\x8C74\xF365\
+\\x8C75\xF366\
+\\x8C76\xF367\
+\\x8C77\xF368\
+\\x8C78\xF369\
+\\x8C79\xF36A\
+\\x8C7A\xF36B\
+\\x8C7B\xF36C\
+\\x8C7C\xF36D\
+\\x8C7D\xF36E\
+\\x8C7E\xF36F\
+\\x8C7F\xF370\
+\\x8C81\xF371\
+\\x8C82\xF372\
+\\x8C83\xF373\
+\\x8C84\xF374\
+\\x8C85\xF375\
+\\x8C86\xF376\
+\\x8C87\xF377\
+\\x8C88\xF378\
+\\x8C89\xF379\
+\\x8C8A\xF37A\
+\\x8C8B\xF37B\
+\\x8C8C\xF37C\
+\\x8C8D\xF37D\
+\\x8C8E\xF37E\
+\\x8C8F\xF3A1\
+\\x8C90\xF3A2\
+\\x8C91\xF3A3\
+\\x8C92\xF3A4\
+\\x8C93\xF3A5\
+\\x8C94\xF3A6\
+\\x8C95\xF3A7\
+\\x8C96\xF3A8\
+\\x8C97\xF3A9\
+\\x8C98\xF3AA\
+\\x8C99\xF3AB\
+\\x8C9A\xF3AC\
+\\x8C9B\xF3AD\
+\\x8C9C\xF3AE\
+\\x8C9D\xF3AF\
+\\x8C9E\xF3B0\
+\\x8C9F\xF3B1\
+\\x8CA0\xF3B2\
+\\x8CA1\xF3B3\
+\\x8CA2\xF3B4\
+\\x8CA3\xF3B5\
+\\x8CA4\xF3B6\
+\\x8CA5\xF3B7\
+\\x8CA6\xF3B8\
+\\x8CA7\xF3B9\
+\\x8CA8\xF3BA\
+\\x8CA9\xF3BB\
+\\x8CAA\xF3BC\
+\\x8CAB\xF3BD\
+\\x8CAC\xF3BE\
+\\x8CAD\xF3BF\
+\\x8CAE\xF3C0\
+\\x8CAF\xF3C1\
+\\x8CB0\xF3C2\
+\\x8CB1\xF3C3\
+\\x8CB2\xF3C4\
+\\x8CB3\xF3C5\
+\\x8CB4\xF3C6\
+\\x8CB5\xF3C7\
+\\x8CB6\xF3C8\
+\\x8CB7\xF3C9\
+\\x8CB8\xF3CA\
+\\x8CB9\xF3CB\
+\\x8CBA\xF3CC\
+\\x8CBB\xF3CD\
+\\x8CBC\xF3CE\
+\\x8CBD\xF3CF\
+\\x8CBE\xF3D0\
+\\x8CBF\xF3D1\
+\\x8CC0\xF3D2\
+\\x8CC1\xF3D3\
+\\x8CC2\xF3D4\
+\\x8CC3\xF3D5\
+\\x8CC4\xF3D6\
+\\x8CC5\xF3D7\
+\\x8CC6\xF3D8\
+\\x8CC7\xF3D9\
+\\x8CC8\xF3DA\
+\\x8CC9\xF3DB\
+\\x8CCA\xF3DC\
+\\x8CCB\xF3DD\
+\\x8CCC\xF3DE\
+\\x8CCD\xF3DF\
+\\x8CCE\xF3E0\
+\\x8CCF\xF3E1\
+\\x8CD0\xF3E2\
+\\x8CD1\xF3E3\
+\\x8CD2\xF3E4\
+\\x8CD3\xF3E5\
+\\x8CD4\xF3E6\
+\\x8CD5\xF3E7\
+\\x8CD6\xF3E8\
+\\x8CD7\xF3E9\
+\\x8CD8\xF3EA\
+\\x8CD9\xF3EB\
+\\x8CDA\xF3EC\
+\\x8CDB\xF3ED\
+\\x8CDC\xF3EE\
+\\x8CDD\xF3EF\
+\\x8CDE\xF3F0\
+\\x8CDF\xF3F1\
+\\x8CE0\xF3F2\
+\\x8CE1\xF3F3\
+\\x8CE2\xF3F4\
+\\x8CE3\xF3F5\
+\\x8CE4\xF3F6\
+\\x8CE5\xF3F7\
+\\x8CE6\xF3F8\
+\\x8CE7\xF3F9\
+\\x8CE8\xF3FA\
+\\x8CE9\xF3FB\
+\\x8CEA\xF3FC\
+\\x8CEB\xF3FD\
+\\x8CEC\xF3FE\
+\\x8CED\xF440\
+\\x8CEE\xF441\
+\\x8CEF\xF442\
+\\x8CF0\xF443\
+\\x8CF1\xF444\
+\\x8CF2\xF445\
+\\x8CF3\xF446\
+\\x8CF4\xF447\
+\\x8CF5\xF448\
+\\x8CF6\xF449\
+\\x8CF7\xF44A\
+\\x8CF8\xF44B\
+\\x8CF9\xF44C\
+\\x8CFA\xF44D\
+\\x8CFB\xF44E\
+\\x8CFC\xF44F\
+\\x8CFD\xF450\
+\\x8D41\xF451\
+\\x8D42\xF452\
+\\x8D43\xF453\
+\\x8D44\xF454\
+\\x8D45\xF455\
+\\x8D46\xF456\
+\\x8D47\xF457\
+\\x8D48\xF458\
+\\x8D49\xF459\
+\\x8D4A\xF45A\
+\\x8D4B\xF45B\
+\\x8D4C\xF45C\
+\\x8D4D\xF45D\
+\\x8D4E\xF45E\
+\\x8D4F\xF45F\
+\\x8D50\xF460\
+\\x8D51\xF461\
+\\x8D52\xF462\
+\\x8D53\xF463\
+\\x8D54\xF464\
+\\x8D55\xF465\
+\\x8D56\xF466\
+\\x8D57\xF467\
+\\x8D58\xF468\
+\\x8D59\xF469\
+\\x8D5A\xF46A\
+\\x8D5B\xF46B\
+\\x8D5C\xF46C\
+\\x8D5D\xF46D\
+\\x8D5E\xF46E\
+\\x8D5F\xF46F\
+\\x8D60\xF470\
+\\x8D61\xF471\
+\\x8D62\xF472\
+\\x8D63\xF473\
+\\x8D64\xF474\
+\\x8D65\xF475\
+\\x8D66\xF476\
+\\x8D67\xF477\
+\\x8D68\xF478\
+\\x8D69\xF479\
+\\x8D6A\xF47A\
+\\x8D6B\xF47B\
+\\x8D6C\xF47C\
+\\x8D6D\xF47D\
+\\x8D6E\xF47E\
+\\x8D6F\xF4A1\
+\\x8D70\xF4A2\
+\\x8D71\xF4A3\
+\\x8D72\xF4A4\
+\\x8D73\xF4A5\
+\\x8D74\xF4A6\
+\\x8D75\xF4A7\
+\\x8D76\xF4A8\
+\\x8D77\xF4A9\
+\\x8D78\xF4AA\
+\\x8D79\xF4AB\
+\\x8D7A\xF4AC\
+\\x8D7B\xF4AD\
+\\x8D7C\xF4AE\
+\\x8D7D\xF4AF\
+\\x8D7E\xF4B0\
+\\x8D7F\xF4B1\
+\\x8D81\xF4B2\
+\\x8D82\xF4B3\
+\\x8D83\xF4B4\
+\\x8D84\xF4B5\
+\\x8D85\xF4B6\
+\\x8D86\xF4B7\
+\\x8D87\xF4B8\
+\\x8D88\xF4B9\
+\\x8D89\xF4BA\
+\\x8D8A\xF4BB\
+\\x8D8B\xF4BC\
+\\x8D8C\xF4BD\
+\\x8D8D\xF4BE\
+\\x8D8E\xF4BF\
+\\x8D8F\xF4C0\
+\\x8D90\xF4C1\
+\\x8D91\xF4C2\
+\\x8D92\xF4C3\
+\\x8D93\xF4C4\
+\\x8D94\xF4C5\
+\\x8D95\xF4C6\
+\\x8D96\xF4C7\
+\\x8D97\xF4C8\
+\\x8D98\xF4C9\
+\\x8D99\xF4CA\
+\\x8D9A\xF4CB\
+\\x8D9B\xF4CC\
+\\x8D9C\xF4CD\
+\\x8D9D\xF4CE\
+\\x8D9E\xF4CF\
+\\x8D9F\xF4D0\
+\\x8DA0\xF4D1\
+\\x8DA1\xF4D2\
+\\x8DA2\xF4D3\
+\\x8DA3\xF4D4\
+\\x8DA4\xF4D5\
+\\x8DA5\xF4D6\
+\\x8DA6\xF4D7\
+\\x8DA7\xF4D8\
+\\x8DA8\xF4D9\
+\\x8DA9\xF4DA\
+\\x8DAA\xF4DB\
+\\x8DAB\xF4DC\
+\\x8DAC\xF4DD\
+\\x8DAD\xF4DE\
+\\x8DAE\xF4DF\
+\\x8DAF\xF4E0\
+\\x8DB0\xF4E1\
+\\x8DB1\xF4E2\
+\\x8DB2\xF4E3\
+\\x8DB3\xF4E4\
+\\x8DB4\xF4E5\
+\\x8DB5\xF4E6\
+\\x8DB6\xF4E7\
+\\x8DB7\xF4E8\
+\\x8DB8\xF4E9\
+\\x8DB9\xF4EA\
+\\x8DBA\xF4EB\
+\\x8DBB\xF4EC\
+\\x8DBC\xF4ED\
+\\x8DBD\xF4EE\
+\\x8DBE\xF4EF\
+\\x8DBF\xF4F0\
+\\x8DC0\xF4F1\
+\\x8DC1\xF4F2\
+\\x8DC2\xF4F3\
+\\x8DC3\xF4F4\
+\\x8DC4\xF4F5\
+\\x8DC5\xF4F6\
+\\x8DC6\xF4F7\
+\\x8DC7\xF4F8\
+\\x8DC8\xF4F9\
+\\x8DC9\xF4FA\
+\\x8DCA\xF4FB\
+\\x8DCB\xF4FC\
+\\x8DCC\xF4FD\
+\\x8DCD\xF4FE\
+\\x8DCE\xF540\
+\\x8DCF\xF541\
+\\x8DD0\xF542\
+\\x8DD1\xF543\
+\\x8DD2\xF544\
+\\x8DD3\xF545\
+\\x8DD4\xF546\
+\\x8DD5\xF547\
+\\x8DD6\xF548\
+\\x8DD7\xF549\
+\\x8DD8\xF54A\
+\\x8DD9\xF54B\
+\\x8DDA\xF54C\
+\\x8DDB\xF54D\
+\\x8DDC\xF54E\
+\\x8DDD\xF54F\
+\\x8DDE\xF550\
+\\x8DDF\xF551\
+\\x8DE0\xF552\
+\\x8DE1\xF553\
+\\x8DE2\xF554\
+\\x8DE3\xF555\
+\\x8DE4\xF556\
+\\x8DE5\xF557\
+\\x8DE6\xF558\
+\\x8DE7\xF559\
+\\x8DE8\xF55A\
+\\x8DE9\xF55B\
+\\x8DEA\xF55C\
+\\x8DEB\xF55D\
+\\x8DEC\xF55E\
+\\x8DED\xF55F\
+\\x8DEE\xF560\
+\\x8DEF\xF561\
+\\x8DF0\xF562\
+\\x8DF1\xF563\
+\\x8DF2\xF564\
+\\x8DF3\xF565\
+\\x8DF4\xF566\
+\\x8DF5\xF567\
+\\x8DF6\xF568\
+\\x8DF7\xF569\
+\\x8DF8\xF56A\
+\\x8DF9\xF56B\
+\\x8DFA\xF56C\
+\\x8DFB\xF56D\
+\\x8DFC\xF56E\
+\\x8DFD\xF56F\
+\\x8E41\xF570\
+\\x8E42\xF571\
+\\x8E43\xF572\
+\\x8E44\xF573\
+\\x8E45\xF574\
+\\x8E46\xF575\
+\\x8E47\xF576\
+\\x8E48\xF577\
+\\x8E49\xF578\
+\\x8E4A\xF579\
+\\x8E4B\xF57A\
+\\x8E4C\xF57B\
+\\x8E4D\xF57C\
+\\x8E4E\xF57D\
+\\x8E4F\xF57E\
+\\x8E50\xF5A1\
+\\x8E51\xF5A2\
+\\x8E52\xF5A3\
+\\x8E53\xF5A4\
+\\x8E54\xF5A5\
+\\x8E55\xF5A6\
+\\x8E56\xF5A7\
+\\x8E57\xF5A8\
+\\x8E58\xF5A9\
+\\x8E59\xF5AA\
+\\x8E5A\xF5AB\
+\\x8E5B\xF5AC\
+\\x8E5C\xF5AD\
+\\x8E5D\xF5AE\
+\\x8E5E\xF5AF\
+\\x8E5F\xF5B0\
+\\x8E60\xF5B1\
+\\x8E61\xF5B2\
+\\x8E62\xF5B3\
+\\x8E63\xF5B4\
+\\x8E64\xF5B5\
+\\x8E65\xF5B6\
+\\x8E66\xF5B7\
+\\x8E67\xF5B8\
+\\x8E68\xF5B9\
+\\x8E69\xF5BA\
+\\x8E6A\xF5BB\
+\\x8E6B\xF5BC\
+\\x8E6C\xF5BD\
+\\x8E6D\xF5BE\
+\\x8E6E\xF5BF\
+\\x8E6F\xF5C0\
+\\x8E70\xF5C1\
+\\x8E71\xF5C2\
+\\x8E72\xF5C3\
+\\x8E73\xF5C4\
+\\x8E74\xF5C5\
+\\x8E75\xF5C6\
+\\x8E76\xF5C7\
+\\x8E77\xF5C8\
+\\x8E78\xF5C9\
+\\x8E79\xF5CA\
+\\x8E7A\xF5CB\
+\\x8E7B\xF5CC\
+\\x8E7C\xF5CD\
+\\x8E7D\xF5CE\
+\\x8E7E\xF5CF\
+\\x8E7F\xF5D0\
+\\x8E81\xF5D1\
+\\x8E82\xF5D2\
+\\x8E83\xF5D3\
+\\x8E84\xF5D4\
+\\x8E85\xF5D5\
+\\x8E86\xF5D6\
+\\x8E87\xF5D7\
+\\x8E88\xF5D8\
+\\x8E89\xF5D9\
+\\x8E8A\xF5DA\
+\\x8E8B\xF5DB\
+\\x8E8C\xF5DC\
+\\x8E8D\xF5DD\
+\\x8E8E\xF5DE\
+\\x8E8F\xF5DF\
+\\x8E90\xF5E0\
+\\x8E91\xF5E1\
+\\x8E92\xF5E2\
+\\x8E93\xF5E3\
+\\x8E94\xF5E4\
+\\x8E95\xF5E5\
+\\x8E96\xF5E6\
+\\x8E97\xF5E7\
+\\x8E98\xF5E8\
+\\x8E99\xF5E9\
+\\x8E9A\xF5EA\
+\\x8E9B\xF5EB\
+\\x8E9C\xF5EC\
+\\x8E9D\xF5ED\
+\\x8E9E\xF5EE\
+\\x8E9F\xF5EF\
+\\x8EA0\xF5F0\
+\\x8EA1\xF5F1\
+\\x8EA2\xF5F2\
+\\x8EA3\xF5F3\
+\\x8EA4\xF5F4\
+\\x8EA5\xF5F5\
+\\x8EA6\xF5F6\
+\\x8EA7\xF5F7\
+\\x8EA8\xF5F8\
+\\x8EA9\xF5F9\
+\\x8EAA\xF5FA\
+\\x8EAB\xF5FB\
+\\x8EAC\xF5FC\
+\\x8EAD\xF5FD\
+\\x8EAE\xF5FE\
+\\x8EAF\xF640\
+\\x8EB0\xF641\
+\\x8EB1\xF642\
+\\x8EB2\xF643\
+\\x8EB3\xF644\
+\\x8EB4\xF645\
+\\x8EB5\xF646\
+\\x8EB6\xF647\
+\\x8EB7\xF648\
+\\x8EB8\xF649\
+\\x8EB9\xF64A\
+\\x8EBA\xF64B\
+\\x8EBB\xF64C\
+\\x8EBC\xF64D\
+\\x8EBD\xF64E\
+\\x8EBE\xF64F\
+\\x8EBF\xF650\
+\\x8EC0\xF651\
+\\x8EC1\xF652\
+\\x8EC2\xF653\
+\\x8EC3\xF654\
+\\x8EC4\xF655\
+\\x8EC5\xF656\
+\\x8EC6\xF657\
+\\x8EC7\xF658\
+\\x8EC8\xF659\
+\\x8EC9\xF65A\
+\\x8ECA\xF65B\
+\\x8ECB\xF65C\
+\\x8ECC\xF65D\
+\\x8ECD\xF65E\
+\\x8ECE\xF65F\
+\\x8ECF\xF660\
+\\x8ED0\xF661\
+\\x8ED1\xF662\
+\\x8ED2\xF663\
+\\x8ED3\xF664\
+\\x8ED4\xF665\
+\\x8ED5\xF666\
+\\x8ED6\xF667\
+\\x8ED7\xF668\
+\\x8ED8\xF669\
+\\x8ED9\xF66A\
+\\x8EDA\xF66B\
+\\x8EDB\xF66C\
+\\x8EDC\xF66D\
+\\x8EDD\xF66E\
+\\x8EDE\xF66F\
+\\x8EDF\xF670\
+\\x8EE0\xF671\
+\\x8EE1\xF672\
+\\x8EE2\xF673\
+\\x8EE3\xF674\
+\\x8EE4\xF675\
+\\x8EE5\xF676\
+\\x8EE6\xF677\
+\\x8EE7\xF678\
+\\x8EE8\xF679\
+\\x8EE9\xF67A\
+\\x8EEA\xF67B\
+\\x8EEB\xF67C\
+\\x8EEC\xF67D\
+\\x8EED\xF67E\
+\\x8EEE\xF6A1\
+\\x8EEF\xF6A2\
+\\x8EF0\xF6A3\
+\\x8EF1\xF6A4\
+\\x8EF2\xF6A5\
+\\x8EF3\xF6A6\
+\\x8EF4\xF6A7\
+\\x8EF5\xF6A8\
+\\x8EF6\xF6A9\
+\\x8EF7\xF6AA\
+\\x8EF8\xF6AB\
+\\x8EF9\xF6AC\
+\\x8EFA\xF6AD\
+\\x8EFB\xF6AE\
+\\x8EFC\xF6AF\
+\\x8EFD\xF6B0\
+\\x8F41\xF6B1\
+\\x8F42\xF6B2\
+\\x8F43\xF6B3\
+\\x8F44\xF6B4\
+\\x8F45\xF6B5\
+\\x8F46\xF6B6\
+\\x8F47\xF6B7\
+\\x8F48\xF6B8\
+\\x8F49\xF6B9\
+\\x8F4A\xF6BA\
+\\x8F4B\xF6BB\
+\\x8F4C\xF6BC\
+\\x8F4D\xF6BD\
+\\x8F4E\xF6BE\
+\\x8F4F\xF6BF\
+\\x8F50\xF6C0\
+\\x8F51\xF6C1\
+\\x8F52\xF6C2\
+\\x8F53\xF6C3\
+\\x8F54\xF6C4\
+\\x8F55\xF6C5\
+\\x8F56\xF6C6\
+\\x8F57\xF6C7\
+\\x8F58\xF6C8\
+\\x8F59\xF6C9\
+\\x8F5A\xF6CA\
+\\x8F5B\xF6CB\
+\\x8F5C\xF6CC\
+\\x8F5D\xF6CD\
+\\x8F5E\xF6CE\
+\\x8F5F\xF6CF\
+\\x8F60\xF6D0\
+\\x8F61\xF6D1\
+\\x8F62\xF6D2\
+\\x8F63\xF6D3\
+\\x8F64\xF6D4\
+\\x8F65\xF6D5\
+\\x8F66\xF6D6\
+\\x8F67\xF6D7\
+\\x8F68\xF6D8\
+\\x8F69\xF6D9\
+\\x8F6A\xF6DA\
+\\x8F6B\xF6DB\
+\\x8F6C\xF6DC\
+\\x8F6D\xF6DD\
+\\x8F6E\xF6DE\
+\\x8F6F\xF6DF\
+\\x8F70\xF6E0\
+\\x8F71\xF6E1\
+\\x8F72\xF6E2\
+\\x8F73\xF6E3\
+\\x8F74\xF6E4\
+\\x8F75\xF6E5\
+\\x8F76\xF6E6\
+\\x8F77\xF6E7\
+\\x8F78\xF6E8\
+\\x8F79\xF6E9\
+\\x8F7A\xF6EA\
+\\x8F7B\xF6EB\
+\\x8F7C\xF6EC\
+\\x8F7D\xF6ED\
+\\x8F7E\xF6EE\
+\\x8F7F\xF6EF\
+\\x8F81\xF6F0\
+\\x8F82\xF6F1\
+\\x8F83\xF6F2\
+\\x8F84\xF6F3\
+\\x8F85\xF6F4\
+\\x8F86\xF6F5\
+\\x8F87\xF6F6\
+\\x8F88\xF6F7\
+\\x8F89\xF6F8\
+\\x8F8A\xF6F9\
+\\x8F8B\xF6FA\
+\\x8F8C\xF6FB\
+\\x8F8D\xF6FC\
+\\x8F8E\xF6FD\
+\\x8F8F\xF6FE\
+\\x8F90\xF740\
+\\x8F91\xF741\
+\\x8F92\xF742\
+\\x8F93\xF743\
+\\x8F94\xF744\
+\\x8F95\xF745\
+\\x8F96\xF746\
+\\x8F97\xF747\
+\\x8F98\xF748\
+\\x8F99\xF749\
+\\x8F9A\xF74A\
+\\x8F9B\xF74B\
+\\x8F9C\xF74C\
+\\x8F9D\xF74D\
+\\x8F9E\xF74E\
+\\x8F9F\xF74F\
+\\x8FA0\xF750\
+\\x8FA1\xF751\
+\\x8FA2\xF752\
+\\x8FA3\xF753\
+\\x8FA4\xF754\
+\\x8FA5\xF755\
+\\x8FA6\xF756\
+\\x8FA7\xF757\
+\\x8FA8\xF758\
+\\x8FA9\xF759\
+\\x8FAA\xF75A\
+\\x8FAB\xF75B\
+\\x8FAC\xF75C\
+\\x8FAD\xF75D\
+\\x8FAE\xF75E\
+\\x8FAF\xF75F\
+\\x8FB0\xF760\
+\\x8FB1\xF761\
+\\x8FB2\xF762\
+\\x8FB3\xF763\
+\\x8FB4\xF764\
+\\x8FB5\xF765\
+\\x8FB6\xF766\
+\\x8FB7\xF767\
+\\x8FB8\xF768\
+\\x8FB9\xF769\
+\\x8FBA\xF76A\
+\\x8FBB\xF76B\
+\\x8FBC\xF76C\
+\\x8FBD\xF76D\
+\\x8FBE\xF76E\
+\\x8FBF\xF76F\
+\\x8FC0\xF770\
+\\x8FC1\xF771\
+\\x8FC2\xF772\
+\\x8FC3\xF773\
+\\x8FC4\xF774\
+\\x8FC5\xF775\
+\\x8FC6\xF776\
+\\x8FC7\xF777\
+\\x8FC8\xF778\
+\\x8FC9\xF779\
+\\x8FCA\xF77A\
+\\x8FCB\xF77B\
+\\x8FCC\xF77C\
+\\x8FCD\xF77D\
+\\x8FCE\xF77E\
+\\x8FCF\xF7A1\
+\\x8FD0\xF7A2\
+\\x8FD1\xF7A3\
+\\x8FD2\xF7A4\
+\\x8FD3\xF7A5\
+\\x8FD4\xF7A6\
+\\x8FD5\xF7A7\
+\\x8FD6\xF7A8\
+\\x8FD7\xF7A9\
+\\x8FD8\xF7AA\
+\\x8FD9\xF7AB\
+\\x8FDA\xF7AC\
+\\x8FDB\xF7AD\
+\\x8FDC\xF7AE\
+\\x8FDD\xF7AF\
+\\x8FDE\xF7B0\
+\\x8FDF\xF7B1\
+\\x8FE0\xF7B2\
+\\x8FE1\xF7B3\
+\\x8FE2\xF7B4\
+\\x8FE3\xF7B5\
+\\x8FE4\xF7B6\
+\\x8FE5\xF7B7\
+\\x8FE6\xF7B8\
+\\x8FE7\xF7B9\
+\\x8FE8\xF7BA\
+\\x8FE9\xF7BB\
+\\x8FEA\xF7BC\
+\\x8FEB\xF7BD\
+\\x8FEC\xF7BE\
+\\x8FED\xF7BF\
+\\x8FEE\xF7C0\
+\\x8FEF\xF7C1\
+\\x8FF0\xF7C2\
+\\x8FF1\xF7C3\
+\\x8FF2\xF7C4\
+\\x8FF3\xF7C5\
+\\x8FF4\xF7C6\
+\\x8FF5\xF7C7\
+\\x8FF6\xF7C8\
+\\x8FF7\xF7C9\
+\\x8FF8\xF7CA\
+\\x8FF9\xF7CB\
+\\x8FFA\xF7CC\
+\\x8FFB\xF7CD\
+\\x8FFC\xF7CE\
+\\x8FFD\xF7CF\
+\\x9041\xF7D0\
+\\x9042\xF7D1\
+\\x9043\xF7D2\
+\\x9044\xF7D3\
+\\x9045\xF7D4\
+\\x9046\xF7D5\
+\\x9047\xF7D6\
+\\x9048\xF7D7\
+\\x9049\xF7D8\
+\\x904A\xF7D9\
+\\x904B\xF7DA\
+\\x904C\xF7DB\
+\\x904D\xF7DC\
+\\x904E\xF7DD\
+\\x904F\xF7DE\
+\\x9050\xF7DF\
+\\x9051\xF7E0\
+\\x9052\xF7E1\
+\\x9053\xF7E2\
+\\x9054\xF7E3\
+\\x9055\xF7E4\
+\\x9056\xF7E5\
+\\x9057\xF7E6\
+\\x9058\xF7E7\
+\\x9059\xF7E8\
+\\x905A\xF7E9\
+\\x905B\xF7EA\
+\\x905C\xF7EB\
+\\x905D\xF7EC\
+\\x905E\xF7ED\
+\\x905F\xF7EE\
+\\x9060\xF7EF\
+\\x9061\xF7F0\
+\\x9062\xF7F1\
+\\x9063\xF7F2\
+\\x9064\xF7F3\
+\\x9065\xF7F4\
+\\x9066\xF7F5\
+\\x9067\xF7F6\
+\\x9068\xF7F7\
+\\x9069\xF7F8\
+\\x906A\xF7F9\
+\\x906B\xF7FA\
+\\x906C\xF7FB\
+\\x906D\xF7FC\
+\\x906E\xF7FD\
+\\x906F\xF7FE\
+\\x9070\xF840\
+\\x9071\xF841\
+\\x9072\xF842\
+\\x9073\xF843\
+\\x9074\xF844\
+\\x9075\xF845\
+\\x9076\xF846\
+\\x9077\xF847\
+\\x9078\xF848\
+\\x9079\xF849\
+\\x907A\xF84A\
+\\x907B\xF84B\
+\\x907C\xF84C\
+\\x907D\xF84D\
+\\x907E\xF84E\
+\\x907F\xF84F\
+\\x9081\xF850\
+\\x9082\xF851\
+\\x9083\xF852\
+\\x9084\xF853\
+\\x9085\xF854\
+\\x9086\xF855\
+\\x9087\xF856\
+\\x9088\xF857\
+\\x9089\xF858\
+\\x908A\xF859\
+\\x908B\xF85A\
+\\x908C\xF85B\
+\\x908D\xF85C\
+\\x908E\xF85D\
+\\x908F\xF85E\
+\\x9090\xF85F\
+\\x9091\xF860\
+\\x9092\xF861\
+\\x9093\xF862\
+\\x9094\xF863\
+\\x9095\xF864\
+\\x9096\xF865\
+\\x9097\xF866\
+\\x9098\xF867\
+\\x9099\xF868\
+\\x909A\xF869\
+\\x909B\xF86A\
+\\x909C\xF86B\
+\\x909D\xF86C\
+\\x909E\xF86D\
+\\x909F\xF86E\
+\\x90A0\xF86F\
+\\x90A1\xF870\
+\\x90A2\xF871\
+\\x90A3\xF872\
+\\x90A4\xF873\
+\\x90A5\xF874\
+\\x90A6\xF875\
+\\x90A7\xF876\
+\\x90A8\xF877\
+\\x90A9\xF878\
+\\x90AA\xF879\
+\\x90AB\xF87A\
+\\x90AC\xF87B\
+\\x90AD\xF87C\
+\\x90AE\xF87D\
+\\x90AF\xF87E\
+\\x90B0\xF8A1\
+\\x90B1\xF8A2\
+\\x90B2\xF8A3\
+\\x90B3\xF8A4\
+\\x90B4\xF8A5\
+\\x90B5\xF8A6\
+\\x90B6\xF8A7\
+\\x90B7\xF8A8\
+\\x90B8\xF8A9\
+\\x90B9\xF8AA\
+\\x90BA\xF8AB\
+\\x90BB\xF8AC\
+\\x90BC\xF8AD\
+\\x90BD\xF8AE\
+\\x90BE\xF8AF\
+\\x90BF\xF8B0\
+\\x90C0\xF8B1\
+\\x90C1\xF8B2\
+\\x90C2\xF8B3\
+\\x90C3\xF8B4\
+\\x90C4\xF8B5\
+\\x90C5\xF8B6\
+\\x90C6\xF8B7\
+\\x90C7\xF8B8\
+\\x90C8\xF8B9\
+\\x90C9\xF8BA\
+\\x90CA\xF8BB\
+\\x90CB\xF8BC\
+\\x90CC\xF8BD\
+\\x90CD\xF8BE\
+\\x90CE\xF8BF\
+\\x90CF\xF8C0\
+\\x90D0\xF8C1\
+\\x90D1\xF8C2\
+\\x90D2\xF8C3\
+\\x90D3\xF8C4\
+\\x90D4\xF8C5\
+\\x90D5\xF8C6\
+\\x90D6\xF8C7\
+\\x90D7\xF8C8\
+\\x90D8\xF8C9\
+\\x90D9\xF8CA\
+\\x90DA\xF8CB\
+\\x90DB\xF8CC\
+\\x90DC\xF8CD\
+\\x90DD\xF8CE\
+\\x90DE\xF8CF\
+\\x90DF\xF8D0\
+\\x90E0\xF8D1\
+\\x90E1\xF8D2\
+\\x90E2\xF8D3\
+\\x90E3\xF8D4\
+\\x90E4\xF8D5\
+\\x90E5\xF8D6\
+\\x90E6\xF8D7\
+\\x90E7\xF8D8\
+\\x90E8\xF8D9\
+\\x90E9\xF8DA\
+\\x90EA\xF8DB\
+\\x90EB\xF8DC\
+\\x90EC\xF8DD\
+\\x90ED\xF8DE\
+\\x90EE\xF8DF\
+\\x90EF\xF8E0\
+\\x90F0\xF8E1\
+\\x90F1\xF8E2\
+\\x90F2\xF8E3\
+\\x90F3\xF8E4\
+\\x90F4\xF8E5\
+\\x90F5\xF8E6\
+\\x90F6\xF8E7\
+\\x90F7\xF8E8\
+\\x90F8\xF8E9\
+\\x90F9\xF8EA\
+\\x90FA\xF8EB\
+\\x90FB\xF8EC\
+\\x90FC\xF8ED\
+\\x90FD\xF8EE\
+\\x9141\xF8EF\
+\\x9142\xF8F0\
+\\x9143\xF8F1\
+\\x9144\xF8F2\
+\\x9145\xF8F3\
+\\x9146\xF8F4\
+\\x9147\xF8F5\
+\\x9148\xF8F6\
+\\x9149\xF8F7\
+\\x914A\xF8F8\
+\\x914B\xF8F9\
+\\x914C\xF8FA\
+\\x914D\xF8FB\
+\\x914E\xF8FC\
+\\x914F\xF8FD\
+\\x9150\xF8FE\
+\\x9151\xF940\
+\\x9152\xF941\
+\\x9153\xF942\
+\\x9154\xF943\
+\\x9155\xF944\
+\\x9156\xF945\
+\\x9157\xF946\
+\\x9158\xF947\
+\\x9159\xF948\
+\\x915A\xF949\
+\\x915B\xF94A\
+\\x915C\xF94B\
+\\x915D\xF94C\
+\\x915E\xF94D\
+\\x915F\xF94E\
+\\x9160\xF94F\
+\\x9161\xF950\
+\\x9162\xF951\
+\\x9163\xF952\
+\\x9164\xF953\
+\\x9165\xF954\
+\\x9166\xF955\
+\\x9167\xF956\
+\\x9168\xF957\
+\\x9169\xF958\
+\\x916A\xF959\
+\\x916B\xF95A\
+\\x916C\xF95B\
+\\x916D\xF95C\
+\\x916E\xF95D\
+\\x916F\xF95E\
+\\x9170\xF95F\
+\\x9171\xF960\
+\\x9172\xF961\
+\\x9173\xF962\
+\\x9174\xF963\
+\\x9175\xF964\
+\\x9176\xF965\
+\\x9177\xF966\
+\\x9178\xF967\
+\\x9179\xF968\
+\\x917A\xF969\
+\\x917B\xF96A\
+\\x917C\xF96B\
+\\x917D\xF96C\
+\\x917E\xF96D\
+\\x917F\xF96E\
+\\x9181\xF96F\
+\\x9182\xF970\
+\\x9183\xF971\
+\\x9184\xF972\
+\\x9185\xF973\
+\\x9186\xF974\
+\\x9187\xF975\
+\\x9188\xF976\
+\\x9189\xF977\
+\\x918A\xF978\
+\\x918B\xF979\
+\\x918C\xF97A\
+\\x918D\xF97B\
+\\x918E\xF97C\
+\\x918F\xF97D\
+\\x9190\xF97E\
+\\x9191\xF9A1\
+\\x9192\xF9A2\
+\\x9193\xF9A3\
+\\x9194\xF9A4\
+\\x9195\xF9A5\
+\\x9196\xF9A6\
+\\x9197\xF9A7\
+\\x9198\xF9A8\
+\\x9199\xF9A9\
+\\x919A\xF9AA\
+\\x919B\xF9AB\
+\\x919C\xF9AC\
+\\x919D\xF9AD\
+\\x919E\xF9AE\
+\\x919F\xF9AF\
+\\x91A0\xF9B0\
+\\x91A1\xF9B1\
+\\x91A2\xF9B2\
+\\x91A3\xF9B3\
+\\x91A4\xF9B4\
+\\x91A5\xF9B5\
+\\x91A6\xF9B6\
+\\x91A7\xF9B7\
+\\x91A8\xF9B8\
+\\x91A9\xF9B9\
+\\x91AA\xF9BA\
+\\x91AB\xF9BB\
+\\x91AC\xF9BC\
+\\x91AD\xF9BD\
+\\x91AE\xF9BE\
+\\x91AF\xF9BF\
+\\x91B0\xF9C0\
+\\x91B1\xF9C1\
+\\x91B2\xF9C2\
+\\x91B3\xF9C3\
+\\x91B4\xF9C4\
+\\x91B5\xF9C5\
+\\x91B6\xF9C6\
+\\x91B7\xF9C7\
+\\x91B8\xF9C8\
+\\x91B9\xF9C9\
+\\x91BA\xF9CA\
+\\x91BB\xF9CB\
+\\x91BC\xF9CC\
+\\x91BD\xF9CD\
+\\x91BE\xF9CE\
+\\x91BF\xF9CF\
+\\x91C0\xF9D0\
+\\x91C1\xF9D1\
+\\x91C2\xF9D2\
+\\x91C3\xF9D3\
+\\x91C4\xF9D4\
+\\x91C5\xF9D5\
+\\x91C6\x3F3F\
+\\x91C7\x3F3F\
+\\xC241\xFA40\
+\\xC242\xFA41\
+\\xC243\xFA42\
+\\xC244\xFA43\
+\\xC245\xFA44\
+\\xC246\xFA45\
+\\xC247\xFA46\
+\\xC248\xFA47\
+\\xC249\xFA48\
+\\xC24A\xFA49\
+\\xC24B\xFA4A\
+\\xC24C\xFA4B\
+\\xC24D\xFA4C\
+\\xC24E\xFA4D\
+\\xC24F\xFA4E\
+\\xC250\xFA4F\
+\\xC251\xFA50\
+\\xC252\xFA51\
+\\xC253\xFA52\
+\\xC254\xFA53\
+\\xC255\xFA54\
+\\xC256\xFA55\
+\\xC257\xFA56\
+\\xC258\xFA57\
+\\xC259\xFA58\
+\\xC25A\xFA59\
+\\xC25B\xFA5A\
+\\xC25C\xFA5B\
+\\xC25D\xFA5C\
+\\xC25E\xFA5D\
+\\xC25F\xFA5E\
+\\xC260\xFA5F\
+\\xC261\xFA60\
+\\xC262\xFA61\
+\\xC263\xFA62\
+\\xC264\xFA63\
+\\xC265\xFA64\
+\\xC266\xFA65\
+\\xC267\xFA66\
+\\xC268\xFA67\
+\\xC269\xFA68\
+\\xC26A\xFA69\
+\\xC26B\xFA6A\
+\\xC26C\xFA6B\
+\\xC26D\xFA6C\
+\\xC26E\xFA6D\
+\\xC26F\xFA6E\
+\\xC270\xFA6F\
+\\xC271\xFA70\
+\\xC272\xFA71\
+\\xC273\xFA72\
+\\xC274\xFA73\
+\\xC275\xFA74\
+\\xC276\xFA75\
+\\xC277\xFA76\
+\\xC278\xFA77\
+\\xC279\xFA78\
+\\xC27A\xFA79\
+\\xC27B\xFA7A\
+\\xC27C\xFA7B\
+\\xC27D\xFA7C\
+\\xC27E\xFA7D\
+\\xC27F\xFA7E\
+\\xC281\xFAA1\
+\\xC282\xFAA2\
+\\xC283\xFAA3\
+\\xC284\xFAA4\
+\\xC285\xFAA5\
+\\xC286\xFAA6\
+\\xC287\xFAA7\
+\\xC288\xFAA8\
+\\xC289\xFAA9\
+\\xC28A\xFAAA\
+\\xC28B\xFAAB\
+\\xC28C\xFAAC\
+\\xC28D\xFAAD\
+\\xC28E\xFAAE\
+\\xC28F\xFAAF\
+\\xC290\xFAB0\
+\\xC291\xFAB1\
+\\xC292\xFAB2\
+\\xC293\xFAB3\
+\\xC294\xFAB4\
+\\xC295\xFAB5\
+\\xC296\xFAB6\
+\\xC297\xFAB7\
+\\xC298\xFAB8\
+\\xC299\xFAB9\
+\\xC29A\xFABA\
+\\xC29B\xFABB\
+\\xC29C\xFABC\
+\\xC29D\xFABD\
+\\xC29E\xFABE\
+\\xC29F\xFABF\
+\\xC2A0\xFAC0\
+\\xC2A1\xFAC1\
+\\xC2A2\xFAC2\
+\\xC2A3\xFAC3\
+\\xC2A4\xFAC4\
+\\xC2A5\xFAC5\
+\\xC2A6\xFAC6\
+\\xC2A7\xFAC7\
+\\xC2A8\xFAC8\
+\\xC2A9\xFAC9\
+\\xC2AA\xFACA\
+\\xC2AB\xFACB\
+\\xC2AC\xFACC\
+\\xC2AD\xFACD\
+\\xC2AE\xFACE\
+\\xC2AF\xFACF\
+\\xC2B0\xFAD0\
+\\xC2B1\xFAD1\
+\\xC2B2\xFAD2\
+\\xC2B3\xFAD3\
+\\xC2B4\xFAD4\
+\\xC2B5\xFAD5\
+\\xC2B6\xFAD6\
+\\xC2B7\xFAD7\
+\\xC2B8\xFAD8\
+\\xC2B9\xFAD9\
+\\xC2BA\xFADA\
+\\xC2BB\xFADB\
+\\xC2BC\xFADC\
+\\xC2BD\xFADD\
+\\xC2BE\xFADE\
+\\xC2BF\xFADF\
+\\xC2C0\xFAE0\
+\\xC2C1\xFAE1\
+\\xC2C2\xFAE2\
+\\xC2C3\xFAE3\
+\\xC2C4\xFAE4\
+\\xC2C5\xFAE5\
+\\xC2C6\xFAE6\
+\\xC2C7\xFAE7\
+\\xC2C8\xFAE8\
+\\xC2C9\xFAE9\
+\\xC2CA\xFAEA\
+\\xC2CB\xFAEB\
+\\xC2CC\xFAEC\
+\\xC2CD\xFAED\
+\\xC2CE\xFAEE\
+\\xC2CF\xFAEF\
+\\xC2D0\xFAF0\
+\\xC2D1\xFAF1\
+\\xC2D2\xFAF2\
+\\xC2D3\xFAF3\
+\\xC2D4\xFAF4\
+\\xC2D5\xFAF5\
+\\xC2D6\xFAF6\
+\\xC2D7\xFAF7\
+\\xC2D8\xFAF8\
+\\xC2D9\xFAF9\
+\\xC2DA\xFAFA\
+\\xC2DB\xFAFB\
+\\xC2DC\xFAFC\
+\\xC2DD\xFAFD\
+\\xC2DE\xFAFE\
+\\xC2DF\xFB40\
+\\xC2E0\xFB41\
+\\xC2E1\xFB42\
+\\xC2E2\xFB43\
+\\xC2E3\xFB44\
+\\xC2E4\xFB45\
+\\xC2E5\xFB46\
+\\xC2E6\xFB47\
+\\xC2E7\xFB48\
+\\xC2E8\xFB49\
+\\xC2E9\xFB4A\
+\\xC2EA\xFB4B\
+\\xC2EB\xFB4C\
+\\xC2EC\xFB4D\
+\\xC2ED\xFB4E\
+\\xC2EE\xFB4F\
+\\xC2EF\xFB50\
+\\xC2F0\xFB51\
+\\xC2F1\xFB52\
+\\xC2F2\xFB53\
+\\xC2F3\xFB54\
+\\xC2F4\xFB55\
+\\xC2F5\xFB56\
+\\xC2F6\xFB57\
+\\xC2F7\xFB58\
+\\xC2F8\xFB59\
+\\xC2F9\xFB5A\
+\\xC2FA\xFB5B\
+\\xC2FB\xFB5C\
+\\xC2FC\xFB5D\
+\\xC2FD\xFB5E\
+\\xC341\xFB5F\
+\\xC342\xFB60\
+\\xC343\xFB61\
+\\xC344\xFB62\
+\\xC345\xFB63\
+\\xC346\xFB64\
+\\xC347\xFB65\
+\\xC348\xFB66\
+\\xC349\xFB67\
+\\xC34A\xFB68\
+\\xC34B\xFB69\
+\\xC34C\xFB6A\
+\\xC34D\xFB6B\
+\\xC34E\xFB6C\
+\\xC34F\xFB6D\
+\\xC350\xFB6E\
+\\xC351\xFB6F\
+\\xC352\xFB70\
+\\xC353\xFB71\
+\\xC354\xFB72\
+\\xC355\xFB73\
+\\xC356\xFB74\
+\\xC357\xFB75\
+\\xC358\xFB76\
+\\xC359\xFB77\
+\\xC35A\xFB78\
+\\xC35B\xFB79\
+\\xC35C\xFB7A\
+\\xC35D\xFB7B\
+\\xC35E\xFB7C\
+\\xC35F\xFB7D\
+\\xC360\xFB7E\
+\\xC361\xFBA1\
+\\xC362\xFBA2\
+\\xC363\xFBA3\
+\\xC364\xFBA4\
+\\xC365\xFBA5\
+\\xC366\xFBA6\
+\\xC367\xFBA7\
+\\xC368\xFBA8\
+\\xC369\xFBA9\
+\\xC36A\xFBAA\
+\\xC36B\xFBAB\
+\\xC36C\xFBAC\
+\\xC36D\xFBAD\
+\\xC36E\xFBAE\
+\\xC36F\xFBAF\
+\\xC370\xFBB0\
+\\xC371\xFBB1\
+\\xC372\xFBB2\
+\\xC373\xFBB3\
+\\xC374\xFBB4\
+\\xC375\xFBB5\
+\\xC376\xFBB6\
+\\xC377\xFBB7\
+\\xC378\xFBB8\
+\\xC379\xFBB9\
+\\xC37A\xFBBA\
+\\xC37B\xFBBB\
+\\xC37C\xFBBC\
+\\xC37D\xFBBD\
+\\xC37E\xFBBE\
+\\xC37F\xFBBF\
+\\xC381\xFBC0\
+\\xC382\xFBC1\
+\\xC383\xFBC2\
+\\xC384\xFBC3\
+\\xC385\xFBC4\
+\\xC386\xFBC5\
+\\xC387\xFBC6\
+\\xC388\xFBC7\
+\\xC389\xFBC8\
+\\xC38A\xFBC9\
+\\xC38B\xFBCA\
+\\xC38C\xFBCB\
+\\xC38D\xFBCC\
+\\xC38E\xFBCD\
+\\xC38F\xFBCE\
+\\xC390\xFBCF\
+\\xC391\xFBD0\
+\\xC392\xFBD1\
+\\xC393\xFBD2\
+\\xC394\xFBD3\
+\\xC395\xFBD4\
+\\xC396\xFBD5\
+\\xC397\xFBD6\
+\\xC398\xFBD7\
+\\xC399\xFBD8\
+\\xC39A\xFBD9\
+\\xC39B\xFBDA\
+\\xC39C\xFBDB\
+\\xC39D\xFBDC\
+\\xC39E\xFBDD\
+\\xC39F\xFBDE\
+\\xC3A0\xFBDF\
+\\xC3A1\xFBE0\
+\\xC3A2\xFBE1\
+\\xC3A3\xFBE2\
+\\xC3A4\xFBE3\
+\\xC3A5\xFBE4\
+\\xC3A6\xFBE5\
+\\xC3A7\xFBE6\
+\\xC3A8\xFBE7\
+\\xC3A9\xFBE8\
+\\xC3AA\xFBE9\
+\\xC3AB\xFBEA\
+\\xC3AC\xFBEB\
+\\xC3AD\xFBEC\
+\\xC3AE\xFBED\
+\\xC3AF\xFBEE\
+\\xC3B0\xFBEF\
+\\xC3B1\xFBF0\
+\\xC3B2\xFBF1\
+\\xC3B3\xFBF2\
+\\xC3B4\xFBF3\
+\\xC3B5\xFBF4\
+\\xC3B6\xFBF5\
+\\xC3B7\xFBF6\
+\\xC3B8\xFBF7\
+\\xC3B9\xFBF8\
+\\xC3BA\xFBF9\
+\\xC3BB\xFBFA\
+\\xC3BC\xFBFB\
+\\xC3BD\xFBFC\
+\\xC3BE\xFBFD\
+\\xC3BF\xFBFE\
+\\xC3C0\xFC40\
+\\xC3C1\xFC41\
+\\xC3C2\xFC42\
+\\xC3C3\xFC43\
+\\xC3C4\xFC44\
+\\xC3C5\xFC45\
+\\xC3C6\xFC46\
+\\xC3C7\xFC47\
+\\xC3C8\xFC48\
+\\xC3C9\xFC49\
+\\xC3CA\xFC4A\
+\\xC3CB\xFC4B\
+\\xC3CC\xFC4C\
+\\xC3CD\xFC4D\
+\\xC3CE\xFC4E\
+\\xC3CF\xFC4F\
+\\xC3D0\xFC50\
+\\xC3D1\xFC51\
+\\xC3D2\xFC52\
+\\xC3D3\xFC53\
+\\xC3D4\xFC54\
+\\xC3D5\xFC55\
+\\xC3D6\xFC56\
+\\xC3D7\xFC57\
+\\xC3D8\xFC58\
+\\xC3D9\xFC59\
+\\xC3DA\xFC5A\
+\\xC3DB\xFC5B\
+\\xC3DC\xFC5C\
+\\xC3DD\xFC5D\
+\\xC3DE\xFC5E\
+\\xC3DF\xFC5F\
+\\xC3E0\xFC60\
+\\xC3E1\xFC61\
+\\xC3E2\xFC62\
+\\xC3E3\xFC63\
+\\xC3E4\xFC64\
+\\xC3E5\xFC65\
+\\xC3E6\xFC66\
+\\xC3E7\xFC67\
+\\xC3E8\xFC68\
+\\xC3E9\xFC69\
+\\xC3EA\xFC6A\
+\\xC3EB\xFC6B\
+\\xC3EC\xFC6C\
+\\xC3ED\xFC6D\
+\\xC3EE\xFC6E\
+\\xC3EF\xFC6F\
+\\xC3F0\xFC70\
+\\xC3F1\xFC71\
+\\xC3F2\xFC72\
+\\xC3F3\xFC73\
+\\xC3F4\xFC74\
+\\xC3F5\xFC75\
+\\xC3F6\xFC76\
+\\xC3F7\xFC77\
+\\xC3F8\xFC78\
+\\xC3F9\xFC79\
+\\xC3FA\xFC7A\
+\\xC3FB\xFC7B\
+\\xC3FC\xFC7C\
+\\xC3FD\xFC7D\
+\\xC441\xFC7E\
+\\xC442\xFCA1\
+\\xC443\xFCA2\
+\\xC444\xFCA3\
+\\xC445\xFCA4\
+\\xC446\xFCA5\
+\\xC447\xFCA6\
+\\xC448\xFCA7\
+\\xC449\xFCA8\
+\\xC44A\xFCA9\
+\\xC44B\xFCAA\
+\\xC44C\xFCAB\
+\\xC44D\xFCAC\
+\\xC44E\xFCAD\
+\\xC44F\xFCAE\
+\\xC450\xFCAF\
+\\xC451\xFCB0\
+\\xC452\xFCB1\
+\\xC453\xFCB2\
+\\xC454\xFCB3\
+\\xC455\xFCB4\
+\\xC456\xFCB5\
+\\xC457\xFCB6\
+\\xC458\xFCB7\
+\\xC459\xFCB8\
+\\xC45A\xFCB9\
+\\xC45B\xFCBA\
+\\xC45C\xFCBB\
+\\xC45D\xFCBC\
+\\xC45E\xFCBD\
+\\xC45F\xFCBE\
+\\xC460\xFCBF\
+\\xC461\xFCC0\
+\\xC462\xFCC1\
+\\xC463\xFCC2\
+\\xC464\xFCC3\
+\\xC465\xFCC4\
+\\xC466\xFCC5\
+\\xC467\xFCC6\
+\\xC468\xFCC7\
+\\xC469\xFCC8\
+\\xC46A\xFCC9\
+\\xC46B\xFCCA\
+\\xC46C\xFCCB\
+\\xC46D\xFCCC\
+\\xC46E\xFCCD\
+\\xC46F\xFCCE\
+\\xC470\xFCCF\
+\\xC471\xFCD0\
+\\xC472\xFCD1\
+\\xC473\xFCD2\
+\\xC474\xFCD3\
+\\xC475\xFCD4\
+\\xC476\xFCD5\
+\\xC477\xFCD6\
+\\xC478\xFCD7\
+\\xC479\xFCD8\
+\\xC47A\xFCD9\
+\\xC47B\xFCDA\
+\\xC47C\xFCDB\
+\\xC47D\xFCDC\
+\\xC47E\xFCDD\
+\\xC47F\xFCDE\
+\\xC481\xFCDF\
+\\xC482\xFCE0\
+\\xC483\xFCE1\
+\\xC484\xFCE2\
+\\xC485\xFCE3\
+\\xC486\xFCE4\
+\\xC487\xFCE5\
+\\xC488\xFCE6\
+\\xC489\xFCE7\
+\\xC48A\xFCE8\
+\\xC48B\xFCE9\
+\\xC48C\xFCEA\
+\\xC48D\xFCEB\
+\\xC48E\xFCEC\
+\\xC48F\xFCED\
+\\xC490\xFCEE\
+\\xC491\xFCEF\
+\\xC492\xFCF0\
+\\xC493\xFCF1\
+\\xC494\xFCF2\
+\\xC495\xFCF3\
+\\xC496\xFCF4\
+\\xC497\xFCF5\
+\\xC498\xFCF6\
+\\xC499\xFCF7\
+\\xC49A\xFCF8\
+\\xC49B\xFCF9\
+\\xC49C\xFCFA\
+\\xC49D\xFCFB\
+\\xC49E\xFCFC\
+\\xC49F\xFCFD\
+\\xC4A0\xFCFE\
+\\xC4A1\xFD40\
+\\xC4A2\xFD41\
+\\xC4A3\xFD42\
+\\xC4A4\xFD43\
+\\xC4A5\xFD44\
+\\xC4A6\xFD45\
+\\xC4A7\xFD46\
+\\xC4A8\xFD47\
+\\xC4A9\xFD48\
+\\xC4AA\xFD49\
+\\xC4AB\xFD4A\
+\\xC4AC\xFD4B\
+\\xC4AD\xFD4C\
+\\xC4AE\xFD4D\
+\\xC4AF\xFD4E\
+\\xC4B0\xFD4F\
+\\xC4B1\xFD50\
+\\xC4B2\xFD51\
+\\xC4B3\xFD52\
+\\xC4B4\xFD53\
+\\xC4B5\xFD54\
+\\xC4B6\xFD55\
+\\xC4B7\xFD56\
+\\xC4B8\xFD57\
+\\xC4B9\xFD58\
+\\xC4BA\xFD59\
+\\xC4BB\xFD5A\
+\\xC4BC\xFD5B\
+\\xC4BD\xFD5C\
+\\xC4BE\xFD5D\
+\\xC4BF\xFD5E\
+\\xC4C0\xFD5F\
+\\xC4C1\xFD60\
+\\xC4C2\xFD61\
+\\xC4C3\xFD62\
+\\xC4C4\xFD63\
+\\xC4C5\xFD64\
+\\xC4C6\xFD65\
+\\xC4C7\xFD66\
+\\xC4C8\xFD67\
+\\xC4C9\xFD68\
+\\xC4CA\xFD69\
+\\xC4CB\xFD6A\
+\\xC4CC\xFD6B\
+\\xC4CD\xFD6C\
+\\xC4CE\xFD6D\
+\\xC4CF\xFD6E\
+\\xC4D0\xFD6F\
+\\xC4D1\xFD70\
+\\xC4D2\xFD71\
+\\xC4D3\xFD72\
+\\xC4D4\xFD73\
+\\xC4D5\xFD74\
+\\xC4D6\xFD75\
+\\xC4D7\xFD76\
+\\xC4D8\xFD77\
+\\xC4D9\xFD78\
+\\xC4DA\xFD79\
+\\xC4DB\xFD7A\
+\\xC4DC\xFD7B\
+\\xC4DD\xFD7C\
+\\xC4DE\xFD7D\
+\\xC4DF\xFD7E\
+\\xC4E0\xFDA1\
+\\xC4E1\xFDA2\
+\\xC4E2\xFDA3\
+\\xC4E3\xFDA4\
+\\xC4E4\xFDA5\
+\\xC4E5\xFDA6\
+\\xC4E6\xFDA7\
+\\xC4E7\xFDA8\
+\\xC4E8\xFDA9\
+\\xC4E9\xFDAA\
+\\xC4EA\xFDAB\
+\\xC4EB\xFDAC\
+\\xC4EC\xFDAD\
+\\xC4ED\xFDAE\
+\\xC4EE\xFDAF\
+\\xC4EF\xFDB0\
+\\xC4F0\xFDB1\
+\\xC4F1\xFDB2\
+\\xC4F2\xFDB3\
+\\xC4F3\xFDB4\
+\\xC4F4\xFDB5\
+\\xC4F5\xFDB6\
+\\xC4F6\xFDB7\
+\\xC4F7\xFDB8\
+\\xC4F8\xFDB9\
+\\xC4F9\xFDBA\
+\\xC4FA\xFDBB\
+\\xC4FB\xFDBC\
+\\xC4FC\xFDBD\
+\\xC4FD\xFDBE\
+\\xC541\xFDBF\
+\\xC542\xFDC0\
+\\xC543\xFDC1\
+\\xC544\xFDC2\
+\\xC545\xFDC3\
+\\xC546\xFDC4\
+\\xC547\xFDC5\
+\\xC548\xFDC6\
+\\xC549\xFDC7\
+\\xC54A\xFDC8\
+\\xC54B\xFDC9\
+\\xC54C\xFDCA\
+\\xC54D\xFDCB\
+\\xC54E\xFDCC\
+\\xC54F\xFDCD\
+\\xC550\xFDCE\
+\\xC551\xFDCF\
+\\xC552\xFDD0\
+\\xC553\xFDD1\
+\\xC554\xFDD2\
+\\xC555\xFDD3\
+\\xC556\xFDD4\
+\\xC557\xFDD5\
+\\xC558\xFDD6\
+\\xC559\xFDD7\
+\\xC55A\xFDD8\
+\\xC55B\xFDD9\
+\\xC55C\xFDDA\
+\\xC55D\xFDDB\
+\\xC55E\xFDDC\
+\\xC55F\xFDDD\
+\\xC560\xFDDE\
+\\xC561\xFDDF\
+\\xC562\xFDE0\
+\\xC563\xFDE1\
+\\xC564\xFDE2\
+\\xC565\xFDE3\
+\\xC566\xFDE4\
+\\xC567\xFDE5\
+\\xC568\xFDE6\
+\\xC569\xFDE7\
+\\xC56A\xFDE8\
+\\xC56B\xFDE9\
+\\xC56C\xFDEA\
+\\xC56D\xFDEB\
+\\xC56E\xFDEC\
+\\xC56F\xFDED\
+\\xC570\xFDEE\
+\\xC571\xFDEF\
+\\xC572\xFDF0\
+\\xC573\xFDF1\
+\\xC574\xFDF2\
+\\xC575\xFDF3\
+\\xC576\xFDF4\
+\\xC577\xFDF5\
+\\xC578\xFDF6\
+\\xC579\xFDF7\
+\\xC57A\xFDF8\
+\\xC57B\xFDF9\
+\\xC57C\xFDFA\
+\\xC57D\xFDFB\
+\\xC57E\xFDFC\
+\\xC57F\xFDFD\
+\\xC581\xFDFE\
+\\xC582\xFE40\
+\\xC583\xFE41\
+\\xC584\xFE42\
+\\xC585\xFE43\
+\\xC586\xFE44\
+\\xC587\xFE45\
+\\xC588\xFE46\
+\\xC589\xFE47\
+\\xC58A\xFE48\
+\\xC58B\xFE49\
+\\xC58C\xFE4A\
+\\xC58D\xFE4B\
+\\xC58E\xFE4C\
+\\xC58F\xFE4D\
+\\xC590\xFE4E\
+\\xC591\xFE4F\
+\\xC592\xFE50\
+\\xC593\xFE51\
+\\xC594\xFE52\
+\\xC595\xFE53\
+\\xC596\xFE54\
+\\xC597\xFE55\
+\\xC598\xFE56\
+\\xC599\xFE57\
+\\xC59A\xFE58\
+\\xC59B\xFE59\
+\\xC59C\xFE5A\
+\\xC59D\xFE5B\
+\\xC59E\xFE5C\
+\\xC59F\xFE5D\
+\\xC5A0\xFE5E\
+\\xC5A1\xFE5F\
+\\xC5A2\xFE60\
+\\xC5A3\xFE61\
+\\xC5A4\xFE62\
+\\xC5A5\xFE63\
+\\xC5A6\xFE64\
+\\xC5A7\xFE65\
+\\xC5A8\xFE66\
+\\xC5A9\xFE67\
+\\xC5AA\xFE68\
+\\xC5AB\xFE69\
+\\xC5AC\xFE6A\
+\\xC5AD\xFE6B\
+\\xC5AE\xFE6C\
+\\xC5AF\xFE6D\
+\\xC5B0\xFE6E\
+\\xC5B1\xFE6F\
+\\xC5B2\xFE70\
+\\xC5B3\xFE71\
+\\xC5B4\xFE72\
+\\xC5B5\xFE73\
+\\xC5B6\xFE74\
+\\xC5B7\xFE75\
+\\xC5B8\xFE76\
+\\xC5B9\xFE77\
+\\xC5BA\xFE78\
+\\xC5BB\xFE79\
+\\xC5BC\xFE7A\
+\\xC5BD\xFE7B\
+\\xC5BE\xFE7C\
+\\xC5BF\xFE7D\
+\\xC5C0\xFE7E\
+\\xC5C1\xFEA1\
+\\xC5C2\xFEA2\
+\\xC5C3\xFEA3\
+\\xC5C4\xFEA4\
+\\xC5C5\xFEA5\
+\\xC5C6\xFEA6\
+\\xC5C7\xFEA7\
+\\xC5C8\xFEA8\
+\\xC5C9\xFEA9\
+\\xC5CA\xFEAA\
+\\xC5CB\xFEAB\
+\\xC5CC\xFEAC\
+\\xC5CD\xFEAD\
+\\xC5CE\xFEAE\
+\\xC5CF\xFEAF\
+\\xC5D0\xFEB0\
+\\xC5D1\xFEB1\
+\\xC5D2\xFEB2\
+\\xC5D3\xFEB3\
+\\xC5D4\xFEB4\
+\\xC5D5\xFEB5\
+\\xC5D6\xFEB6\
+\\xC5D7\xFEB7\
+\\xC5D8\xFEB8\
+\\xC5D9\xFEB9\
+\\xC5DA\xFEBA\
+\\xC5DB\xFEBB\
+\\xC5DC\xFEBC\
+\\xC5DD\xFEBD\
+\\xC5DE\xFEBE\
+\\xC5DF\xFEBF\
+\\xC5E0\xFEC0\
+\\xC5E1\xFEC1\
+\\xC5E2\xFEC2\
+\\xC5E3\xFEC3\
+\\xC5E4\xFEC4\
+\\xC5E5\xFEC5\
+\\xC5E6\xFEC6\
+\\xC5E7\xFEC7\
+\\xC5E8\xFEC8\
+\\xC5E9\xFEC9\
+\\xC5EA\xFECA\
+\\xC5EB\xFECB\
+\\xC5EC\xFECC\
+\\xC5ED\xFECD\
+\\xC5EE\xFECE\
+\\xC5EF\xFECF\
+\\xC5F0\xFED0\
+\\xC5F1\xFED1\
+\\xC5F2\xFED2\
+\\xC5F3\xFED3\
+\\xC5F4\xFED4\
+\\xC5F5\xFED5\
+\\xC5F6\xFED6\
+\\xC5F7\xFED7\
+\\xC5F8\xFED8\
+\\xC5F9\xFED9\
+\\xC5FA\xFEDA\
+\\xC5FB\xFEDB\
+\\xC5FC\xFEDC\
+\\xC5FD\xFEDD\
+\\xC641\xFEDE\
+\\xC642\xFEDF\
+\\xC643\xFEE0\
+\\xC644\xFEE1\
+\\xC645\xFEE2\
+\\xC646\xFEE3\
+\\xC647\xFEE4\
+\\xC648\xFEE5\
+\\xC649\xFEE6\
+\\xC64A\xFEE7\
+\\xC64B\xFEE8\
+\\xC64C\xFEE9\
+\\xC64D\xFEEA\
+\\xC64E\xFEEB\
+\\xC64F\xFEEC\
+\\xC650\xFEED\
+\\xC651\xFEEE\
+\\xC652\xFEEF\
+\\xC653\xFEF0\
+\\xC654\xFEF1\
+\\xC655\xFEF2\
+\\xC656\xFEF3\
+\\xC657\xFEF4\
+\\xC658\xFEF5\
+\\xC659\xFEF6\
+\\xC65A\xFEF7\
+\\xC65B\xFEF8\
+\\xC65C\xFEF9\
+\\xC65D\xFEFA\
+\\xC65E\xFEFB\
+\\xC65F\xFEFC\
+\\xC660\xFEFD\
+\\xC661\xFEFE\
+\\xC662\x8E40\
+\\xC663\x8E41\
+\\xC664\x8E42\
+\\xC665\x8E43\
+\\xC666\x8E44\
+\\xC667\x8E45\
+\\xC668\x8E46\
+\\xC669\x8E47\
+\\xC66A\x8E48\
+\\xC66B\x8E49\
+\\xC66C\x8E4A\
+\\xC66D\x8E4B\
+\\xC66E\x8E4C\
+\\xC66F\x8E4D\
+\\xC670\x8E4E\
+\\xC671\x8E4F\
+\\xC672\x8E50\
+\\xC673\x8E51\
+\\xC674\x8E52\
+\\xC675\x8E53\
+\\xC676\x8E54\
+\\xC677\x8E55\
+\\xC678\x8E56\
+\\xC679\x8E57\
+\\xC67A\x8E58\
+\\xC67B\x8E59\
+\\xC67C\x8E5A\
+\\xC67D\x8E5B\
+\\xC67E\x8E5C\
+\\xC67F\x8E5D\
+\\xC681\x8E5E\
+\\xC682\x8E5F\
+\\xC683\x8E60\
+\\xC684\x8E61\
+\\xC685\x8E62\
+\\xC686\x8E63\
+\\xC687\x8E64\
+\\xC688\x8E65\
+\\xC689\x8E66\
+\\xC68A\x8E67\
+\\xC68B\x8E68\
+\\xC68C\x8E69\
+\\xC68D\x8E6A\
+\\xC68E\x8E6B\
+\\xC68F\x8E6C\
+\\xC690\x8E6D\
+\\xC691\x8E6E\
+\\xC692\x8E6F\
+\\xC693\x8E70\
+\\xC694\x8E71\
+\\xC695\x8E72\
+\\xC696\x8E73\
+\\xC697\x8E74\
+\\xC698\x8E75\
+\\xC699\x8E76\
+\\xC69A\x8E77\
+\\xC69B\x8E78\
+\\xC69C\x8E79\
+\\xC69D\x8E7A\
+\\xC69E\x8E7B\
+\\xC69F\x8E7C\
+\\xC6A0\x8E7D\
+\\xC6A1\x8E7E\
+\\xC6A2\x8EA1\
+\\xC6A3\x8EA2\
+\\xC6A4\x8EA3\
+\\xC6A5\x8EA4\
+\\xC6A6\x8EA5\
+\\xC6A7\x8EA6\
+\\xC6A8\x8EA7\
+\\xC6A9\x8EA8\
+\\xC6AA\x8EA9\
+\\xC6AB\x8EAA\
+\\xC6AC\x8EAB\
+\\xC6AD\x8EAC\
+\\xC6AE\x8EAD\
+\\xC6AF\x8EAE\
+\\xC6B0\x8EAF\
+\\xC6B1\x8EB0\
+\\xC6B2\x8EB1\
+\\xC6B3\x8EB2\
+\\xC6B4\x8EB3\
+\\xC6B5\x8EB4\
+\\xC6B6\x8EB5\
+\\xC6B7\x8EB6\
+\\xC6B8\x8EB7\
+\\xC6B9\x8EB8\
+\\xC6BA\x8EB9\
+\\xC6BB\x8EBA\
+\\xC6BC\x8EBB\
+\\xC6BD\x8EBC\
+\\xC6BE\x8EBD\
+\\xC6BF\x8EBE\
+\\xC6C0\x8EBF\
+\\xC6C1\x8EC0\
+\\xC6C2\x8EC1\
+\\xC6C3\x8EC2\
+\\xC6C4\x8EC3\
+\\xC6C5\x8EC4\
+\\xC6C6\x8EC5\
+\\xC6C7\x8EC6\
+\\xC6C8\x8EC7\
+\\xC6C9\x8EC8\
+\\xC6CA\x8EC9\
+\\xC6CB\x8ECA\
+\\xC6CC\x8ECB\
+\\xC6CD\x8ECC\
+\\xC6CE\x8ECD\
+\\xC6CF\x8ECE\
+\\xC6D0\x8ECF\
+\\xC6D1\x8ED0\
+\\xC6D2\x8ED1\
+\\xC6D3\x8ED2\
+\\xC6D4\x8ED3\
+\\xC6D5\x8ED4\
+\\xC6D6\x8ED5\
+\\xC6D7\x8ED6\
+\\xC6D8\x8ED7\
+\\xC6D9\x8ED8\
+\\xC6DA\x8ED9\
+\\xC6DB\x8EDA\
+\\xC6DC\x8EDB\
+\\xC6DD\x8EDC\
+\\xC6DE\x8EDD\
+\\xC6DF\x8EDE\
+\\xC6E0\x8EDF\
+\\xC6E1\x8EE0\
+\\xC6E2\x8EE1\
+\\xC6E3\x8EE2\
+\\xC6E4\x8EE3\
+\\xC6E5\x8EE4\
+\\xC6E6\x8EE5\
+\\xC6E7\x8EE6\
+\\xC6E8\x8EE7\
+\\xC6E9\x8EE8\
+\\xC6EA\x8EE9\
+\\xC6EB\x8EEA\
+\\xC6EC\x8EEB\
+\\xC6ED\x8EEC\
+\\xC6EE\x8EED\
+\\xC6EF\x8EEE\
+\\xC6F0\x8EEF\
+\\xC6F1\x8EF0\
+\\xC6F2\x8EF1\
+\\xC6F3\x8EF2\
+\\xC6F4\x8EF3\
+\\xC6F5\x8EF4\
+\\xC6F6\x8EF5\
+\\xC6F7\x8EF6\
+\\xC6F8\x8EF7\
+\\xC6F9\x8EF8\
+\\xC6FA\x8EF9\
+\\xC6FB\x8EFA\
+\\xC6FC\x8EFB\
+\\xC6FD\x8EFC\
+\\xC741\x8EFD\
+\\xC742\x8EFE\
+\\xC743\x8F40\
+\\xC744\x8F41\
+\\xC745\x8F42\
+\\xC746\x8F43\
+\\xC747\x8F44\
+\\xC748\x8F45\
+\\xC749\x8F46\
+\\xC74A\x8F47\
+\\xC74B\x8F48\
+\\xC74C\x8F49\
+\\xC74D\x8F4A\
+\\xC74E\x8F4B\
+\\xC74F\x8F4C\
+\\xC750\x8F4D\
+\\xC751\x8F4E\
+\\xC752\x8F4F\
+\\xC753\x8F50\
+\\xC754\x8F51\
+\\xC755\x8F52\
+\\xC756\x8F53\
+\\xC757\x8F54\
+\\xC758\x8F55\
+\\xC759\x8F56\
+\\xC75A\x8F57\
+\\xC75B\x8F58\
+\\xC75C\x8F59\
+\\xC75D\x8F5A\
+\\xC75E\x8F5B\
+\\xC75F\x8F5C\
+\\xC760\x8F5D\
+\\xC761\x8F5E\
+\\xC762\x8F5F\
+\\xC763\x8F60\
+\\xC764\x8F61\
+\\xC765\x8F62\
+\\xC766\x8F63\
+\\xC767\x8F64\
+\\xC768\x8F65\
+\\xC769\x8F66\
+\\xC76A\x8F67\
+\\xC76B\x8F68\
+\\xC76C\x8F69\
+\\xC76D\x8F6A\
+\\xC76E\x8F6B\
+\\xC76F\x8F6C\
+\\xC770\x8F6D\
+\\xC771\x8F6E\
+\\xC772\x8F6F\
+\\xC773\x8F70\
+\\xC774\x8F71\
+\\xC775\x8F72\
+\\xC776\x8F73\
+\\xC777\x8F74\
+\\xC778\x8F75\
+\\xC779\x8F76\
+\\xC77A\x8F77\
+\\xC77B\x8F78\
+\\xC77C\x8F79\
+\\xC77D\x8F7A\
+\\xC77E\x8F7B\
+\\xC77F\x8F7C\
+\\xC781\x8F7D\
+\\xC782\x8F7E\
+\\xC783\x8FA1\
+\\xC784\x8FA2\
+\\xC785\x8FA3\
+\\xC786\x8FA4\
+\\xC787\x8FA5\
+\\xC788\x8FA6\
+\\xC789\x8FA7\
+\\xC78A\x8FA8\
+\\xC78B\x8FA9\
+\\xC78C\x8FAA\
+\\xC78D\x8FAB\
+\\xC78E\x8FAC\
+\\xC78F\x8FAD\
+\\xC790\x8FAE\
+\\xC791\x8FAF\
+\\xC792\x8FB0\
+\\xC793\x8FB1\
+\\xC794\x8FB2\
+\\xC795\x8FB3\
+\\xC796\x8FB4\
+\\xC797\x8FB5\
+\\xC798\x8FB6\
+\\xC799\x8FB7\
+\\xC79A\x8FB8\
+\\xC79B\x8FB9\
+\\xC79C\x8FBA\
+\\xC79D\x8FBB\
+\\xC79E\x8FBC\
+\\xC79F\x8FBD\
+\\xC7A0\x8FBE\
+\\xC7A1\x8FBF\
+\\xC7A2\x8FC0\
+\\xC7A3\x8FC1\
+\\xC7A4\x8FC2\
+\\xC7A5\x8FC3\
+\\xC7A6\x8FC4\
+\\xC7A7\x8FC5\
+\\xC7A8\x8FC6\
+\\xC7A9\x8FC7\
+\\xC7AA\x8FC8\
+\\xC7AB\x8FC9\
+\\xC7AC\x8FCA\
+\\xC7AD\x8FCB\
+\\xC7AE\x8FCC\
+\\xC7AF\x8FCD\
+\\xC7B0\x8FCE\
+\\xC7B1\x8FCF\
+\\xC7B2\x8FD0\
+\\xC7B3\x8FD1\
+\\xC7B4\x8FD2\
+\\xC7B5\x8FD3\
+\\xC7B6\x8FD4\
+\\xC7B7\x8FD5\
+\\xC7B8\x8FD6\
+\\xC7B9\x8FD7\
+\\xC7BA\x8FD8\
+\\xC7BB\x8FD9\
+\\xC7BC\x8FDA\
+\\xC7BD\x8FDB\
+\\xC7BE\x8FDC\
+\\xC7BF\x8FDD\
+\\xC7C0\x8FDE\
+\\xC7C1\x8FDF\
+\\xC7C2\x8FE0\
+\\xC7C3\x8FE1\
+\\xC7C4\x8FE2\
+\\xC7C5\x8FE3\
+\\xC7C6\x8FE4\
+\\xC7C7\x8FE5\
+\\xC7C8\x8FE6\
+\\xC7C9\x8FE7\
+\\xC7CA\x8FE8\
+\\xC7CB\x8FE9\
+\\xC7CC\x8FEA\
+\\xC7CD\x8FEB\
+\\xC7CE\x8FEC\
+\\xC7CF\x8FED\
+\\xC7D0\x8FEE\
+\\xC7D1\x8FEF\
+\\xC7D2\x8FF0\
+\\xC7D3\x8FF1\
+\\xC7D4\x8FF2\
+\\xC7D5\x8FF3\
+\\xC7D6\x8FF4\
+\\xC7D7\x8FF5\
+\\xC7D8\x8FF6\
+\\xC7D9\x8FF7\
+\\xC7DA\x8FF8\
+\\xC7DB\x8FF9\
+\\xC7DC\x8FFA\
+\\xC7DD\x8FFB\
+\\xC7DE\x8FFC\
+\\xC7DF\x8FFD\
+\\xC7E0\x8FFE\
+\\xC7E1\x9040\
+\\xC7E2\x9041\
+\\xC7E3\x9042\
+\\xC7E4\x9043\
+\\xC7E5\x9044\
+\\xC7E6\x9045\
+\\xC7E7\x9046\
+\\xC7E8\x9047\
+\\xC7E9\x9048\
+\\xC7EA\x9049\
+\\xC7EB\x904A\
+\\xC7EC\x904B\
+\\xC7ED\x904C\
+\\xC7EE\x904D\
+\\xC7EF\x904E\
+\\xC7F0\x904F\
+\\xC7F1\x9050\
+\\xC7F2\x9051\
+\\xC7F3\x9052\
+\\xC7F4\x9053\
+\\xC7F5\x9054\
+\\xC7F6\x9055\
+\\xC7F7\x9056\
+\\xC7F8\x9057\
+\\xC7F9\x9058\
+\\xC7FA\x9059\
+\\xC7FB\x905A\
+\\xC7FC\x905B\
+\\xC7FD\x905C\
+\\xC841\x905D\
+\\xC842\x905E\
+\\xC843\x905F\
+\\xC844\x9060\
+\\xC845\x9061\
+\\xC846\x9062\
+\\xC847\x9063\
+\\xC848\x9064\
+\\xC849\x9065\
+\\xC84A\x9066\
+\\xC84B\x9067\
+\\xC84C\x9068\
+\\xC84D\x9069\
+\\xC84E\x906A\
+\\xC84F\x906B\
+\\xC850\x906C\
+\\xC851\x906D\
+\\xC852\x906E\
+\\xC853\x906F\
+\\xC854\x9070\
+\\xC855\x9071\
+\\xC856\x9072\
+\\xC857\x9073\
+\\xC858\x9074\
+\\xC859\x9075\
+\\xC85A\x9076\
+\\xC85B\x9077\
+\\xC85C\x9078\
+\\xC85D\x9079\
+\\xC85E\x907A\
+\\xC85F\x907B\
+\\xC860\x907C\
+\\xC861\x907D\
+\\xC862\x907E\
+\\xC863\x90A1\
+\\xC864\x90A2\
+\\xC865\x90A3\
+\\xC866\x90A4\
+\\xC867\x90A5\
+\\xC868\x90A6\
+\\xC869\x90A7\
+\\xC86A\x90A8\
+\\xC86B\x90A9\
+\\xC86C\x90AA\
+\\xC86D\x90AB\
+\\xC86E\x90AC\
+\\xC86F\x90AD\
+\\xC870\x90AE\
+\\xC871\x90AF\
+\\xC872\x90B0\
+\\xC873\x90B1\
+\\xC874\x90B2\
+\\xC875\x90B3\
+\\xC876\x90B4\
+\\xC877\x90B5\
+\\xC878\x90B6\
+\\xC879\x90B7\
+\\xC87A\x90B8\
+\\xC87B\x90B9\
+\\xC87C\x90BA\
+\\xC87D\x90BB\
+\\xC87E\x90BC\
+\\xC87F\x90BD\
+\\xC881\x90BE\
+\\xC882\x90BF\
+\\xC883\x90C0\
+\\xC884\x90C1\
+\\xC885\x90C2\
+\\xC886\x90C3\
+\\xC887\x90C4\
+\\xC888\x90C5\
+\\xC889\x90C6\
+\\xC88A\x90C7\
+\\xC88B\x90C8\
+\\xC88C\x90C9\
+\\xC88D\x90CA\
+\\xC88E\x90CB\
+\\xC88F\x90CC\
+\\xC890\x90CD\
+\\xC891\x90CE\
+\\xC892\x90CF\
+\\xC893\x90D0\
+\\xC894\x90D1\
+\\xC895\x90D2\
+\\xC896\x90D3\
+\\xC897\x90D4\
+\\xC898\x90D5\
+\\xC899\x90D6\
+\\xC89A\x90D7\
+\\xC89B\x90D8\
+\\xC89C\x90D9\
+\\xC89D\x90DA\
+\\xC89E\x90DB\
+\\xC89F\x90DC\
+\\xC8A0\x90DD\
+\\xC8A1\x90DE\
+\\xC8A2\x90DF\
+\\xC8A3\x90E0\
+\\xC8A4\x90E1\
+\\xC8A5\x90E2\
+\\xC8A6\x90E3\
+\\xC8A7\x90E4\
+\\xC8A8\x90E5\
+\\xC8A9\x90E6\
+\\xC8AA\x90E7\
+\\xC8AB\x90E8\
+\\xC8AC\x90E9\
+\\xC8AD\x90EA\
+\\xC8AE\x90EB\
+\\xC8AF\x90EC\
+\\xC8B0\x90ED\
+\\xC8B1\x90EE\
+\\xC8B2\x90EF\
+\\xC8B3\x90F0\
+\\xC8B4\x90F1\
+\\xC8B5\x90F2\
+\\xC8B6\x90F3\
+\\xC8B7\x90F4\
+\\xC8B8\x90F5\
+\\xC8B9\x90F6\
+\\xC8BA\x90F7\
+\\xC8BB\x90F8\
+\\xC8BC\x90F9\
+\\xC8BD\x90FA\
+\\xC8BE\x90FB\
+\\xC8BF\x90FC\
+\\xC8C0\x90FD\
+\\xC8C1\x90FE\
+\\xC8C2\x9140\
+\\xC8C3\x9141\
+\\xC8C4\x9142\
+\\xC8C5\x9143\
+\\xC8C6\x9144\
+\\xC8C7\x9145\
+\\xC8C8\x9146\
+\\xC8C9\x9147\
+\\xC8CA\x9148\
+\\xC8CB\x9149\
+\\xC8CC\x914A\
+\\xC8CD\x914B\
+\\xC8CE\x914C\
+\\xC8CF\x914D\
+\\xC8D0\x914E\
+\\xC8D1\x914F\
+\\xC8D2\x9150\
+\\xC8D3\x9151\
+\\xC8D4\x9152\
+\\xC8D5\x9153\
+\\xC8D6\x9154\
+\\xC8D7\x9155\
+\\xC8D8\x9156\
+\\xC8D9\x9157\
+\\xC8DA\x9158\
+\\xC8DB\x9159\
+\\xC8DC\x915A\
+\\xC8DD\x915B\
+\\xC8DE\x915C\
+\\xC8DF\x915D\
+\\xC8E0\x915E\
+\\xC8E1\x915F\
+\\xC8E2\x9160\
+\\xC8E3\x9161\
+\\xC8E4\x9162\
+\\xC8E5\x9163\
+\\xC8E6\x9164\
+\\xC8E7\x9165\
+\\xC8E8\x9166\
+\\xC8E9\x9167\
+\\xC8EA\x9168\
+\\xC8EB\x9169\
+\\xC8EC\x916A\
+\\xC8ED\x916B\
+\\xC8EE\x916C\
+\\xC8EF\x916D\
+\\xC8F0\x916E\
+\\xC8F1\x916F\
+\\xC8F2\x9170\
+\\xC8F3\x9171\
+\\xC8F4\x9172\
+\\xC8F5\x9173\
+\\xC8F6\x9174\
+\\xC8F7\x9175\
+\\xC8F8\x9176\
+\\xC8F9\x9177\
+\\xC8FA\x9178\
+\\xC8FB\x9179\
+\\xC8FC\x917A\
+\\xC8FD\x917B\
+\\xC941\x917C\
+\\xC942\x917D\
+\\xC943\x917E\
+\\xC944\x91A1\
+\\xC945\x91A2\
+\\xC946\x91A3\
+\\xC947\x91A4\
+\\xC948\x91A5\
+\\xC949\x91A6\
+\\xC94A\x91A7\
+\\xC94B\x91A8\
+\\xC94C\x91A9\
+\\xC94D\x91AA\
+\\xC94E\x91AB\
+\\xC94F\x91AC\
+\\xC950\x91AD\
+\\xC951\x91AE\
+\\xC952\x91AF\
+\\xC953\x91B0\
+\\xC954\x91B1\
+\\xC955\x91B2\
+\\xC956\x91B3\
+\\xC957\x91B4\
+\\xC958\x91B5\
+\\xC959\x91B6\
+\\xC95A\x91B7\
+\\xC95B\x91B8\
+\\xC95C\x91B9\
+\\xC95D\x91BA\
+\\xC95E\x91BB\
+\\xC95F\x91BC\
+\\xC960\x91BD\
+\\xC961\x91BE\
+\\xC962\x91BF\
+\\xC963\x91C0\
+\\xC964\x91C1\
+\\xC965\x91C2\
+\\xC966\x91C3\
+\\xC967\x91C4\
+\\xC968\x91C5\
+\\xC969\x91C6\
+\\xC96A\x91C7\
+\\xC96B\x91C8\
+\\xC96C\x91C9\
+\\xC96D\x91CA\
+\\xC96E\x91CB\
+\\xC96F\x91CC\
+\\xC970\x91CD\
+\\xC971\x91CE\
+\\xC972\x91CF\
+\\xC973\x91D0\
+\\xC974\x91D1\
+\\xC975\x91D2\
+\\xC976\x91D3\
+\\xC977\x91D4\
+\\xC978\x91D5\
+\\xC979\x91D6\
+\\xC97A\x91D7\
+\\xC97B\x91D8\
+\\xC97C\x91D9\
+\\xC97D\x91DA\
+\\xC97E\x91DB\
+\\xC97F\x91DC\
+\\xC981\x91DD\
+\\xC982\x91DE\
+\\xC983\x91DF\
+\\xC984\x91E0\
+\\xC985\x91E1\
+\\xC986\x91E2\
+\\xC987\x91E3\
+\\xC988\x91E4\
+\\xC989\x91E5\
+\\xC98A\x91E6\
+\\xC98B\x91E7\
+\\xC98C\x91E8\
+\\xC98D\x91E9\
+\\xC98E\x91EA\
+\\xC98F\x91EB\
+\\xC990\x91EC\
+\\xC991\x91ED\
+\\xC992\x91EE\
+\\xC993\x91EF\
+\\xC994\x91F0\
+\\xC995\x91F1\
+\\xC996\x91F2\
+\\xC997\x91F3\
+\\xC998\x91F4\
+\\xC999\x91F5\
+\\xC99A\x91F6\
+\\xC99B\x91F7\
+\\xC99C\x91F8\
+\\xC99D\x91F9\
+\\xC99E\x91FA\
+\\xC99F\x91FB\
+\\xC9A0\x91FC\
+\\xC9A1\x91FD\
+\\xC9A2\x91FE\
+\\xC9A3\x9240\
+\\xC9A4\x9241\
+\\xC9A5\x9242\
+\\xC9A6\x9243\
+\\xC9A7\x9244\
+\\xC9A8\x9245\
+\\xC9A9\x9246\
+\\xC9AA\x9247\
+\\xC9AB\x9248\
+\\xC9AC\x9249\
+\\xC9AD\x924A\
+\\xC9AE\x924B\
+\\xC9AF\x924C\
+\\xC9B0\x924D\
+\\xC9B1\x924E\
+\\xC9B2\x924F\
+\\xC9B3\x9250\
+\\xC9B4\x9251\
+\\xC9B5\x9252\
+\\xC9B6\x9253\
+\\xC9B7\x9254\
+\\xC9B8\x9255\
+\\xC9B9\x9256\
+\\xC9BA\x9257\
+\\xC9BB\x9258\
+\\xC9BC\x9259\
+\\xC9BD\x925A\
+\\xC9BE\x925B\
+\\xC9BF\x925C\
+\\xC9C0\x925D\
+\\xC9C1\x925E\
+\\xC9C2\x925F\
+\\xC9C3\x9260\
+\\xC9C4\x9261\
+\\xC9C5\x9262\
+\\xC9C6\x9263\
+\\xC9C7\x9264\
+\\xC9C8\x9265\
+\\xC9C9\x9266\
+\\xC9CA\x9267\
+\\xC9CB\x9268\
+\\xC9CC\x9269\
+\\xC9CD\x926A\
+\\xC9CE\x926B\
+\\xC9CF\x926C\
+\\xC9D0\x926D\
+\\xC9D1\x926E\
+\\xC9D2\x926F\
+\\xC9D3\x9270\
+\\xC9D4\x9271\
+\\xC9D5\x9272\
+\\xC9D6\x9273\
+\\xC9D7\x9274\
+\\xC9D8\x9275\
+\\xC9D9\x9276\
+\\xC9DA\x9277\
+\\xC9DB\x9278\
+\\xC9DC\x9279\
+\\xC9DD\x927A\
+\\xC9DE\x927B\
+\\xC9DF\x927C\
+\\xC9E0\x927D\
+\\xC9E1\x927E\
+\\xC9E2\x92A1\
+\\xC9E3\x92A2\
+\\xC9E4\x92A3\
+\\xC9E5\x92A4\
+\\xC9E6\x92A5\
+\\xC9E7\x92A6\
+\\xC9E8\x92A7\
+\\xC9E9\x92A8\
+\\xC9EA\x92A9\
+\\xC9EB\x92AA\
+\\xC9EC\x92AB\
+\\xC9ED\x92AC\
+\\xC9EE\x92AD\
+\\xC9EF\x92AE\
+\\xC9F0\x92AF\
+\\xC9F1\x92B0\
+\\xC9F2\x92B1\
+\\xC9F3\x92B2\
+\\xC9F4\x92B3\
+\\xC9F5\x92B4\
+\\xC9F6\x92B5\
+\\xC9F7\x92B6\
+\\xC9F8\x92B7\
+\\xC9F9\x92B8\
+\\xC9FA\x92B9\
+\\xC9FB\x92BA\
+\\xC9FC\x92BB\
+\\xC9FD\x92BC\
+\\xCA41\x92BD\
+\\xCA42\x92BE\
+\\xCA43\x92BF\
+\\xCA44\x92C0\
+\\xCA45\x92C1\
+\\xCA46\x92C2\
+\\xCA47\x92C3\
+\\xCA48\x92C4\
+\\xCA49\x92C5\
+\\xCA4A\x92C6\
+\\xCA4B\x92C7\
+\\xCA4C\x92C8\
+\\xCA4D\x92C9\
+\\xCA4E\x92CA\
+\\xCA4F\x92CB\
+\\xCA50\x92CC\
+\\xCA51\x92CD\
+\\xCA52\x92CE\
+\\xCA53\x92CF\
+\\xCA54\x92D0\
+\\xCA55\x92D1\
+\\xCA56\x92D2\
+\\xCA57\x92D3\
+\\xCA58\x92D4\
+\\xCA59\x92D5\
+\\xCA5A\x92D6\
+\\xCA5B\x92D7\
+\\xCA5C\x92D8\
+\\xCA5D\x92D9\
+\\xCA5E\x92DA\
+\\xCA5F\x92DB\
+\\xCA60\x92DC\
+\\xCA61\x92DD\
+\\xCA62\x92DE\
+\\xCA63\x92DF\
+\\xCA64\x92E0\
+\\xCA65\x92E1\
+\\xCA66\x92E2\
+\\xCA67\x92E3\
+\\xCA68\x92E4\
+\\xCA69\x92E5\
+\\xCA6A\x92E6\
+\\xCA6B\x92E7\
+\\xCA6C\x92E8\
+\\xCA6D\x92E9\
+\\xCA6E\x92EA\
+\\xCA6F\x92EB\
+\\xCA70\x92EC\
+\\xCA71\x92ED\
+\\xCA72\x92EE\
+\\xCA73\x92EF\
+\\xCA74\x92F0\
+\\xCA75\x92F1\
+\\xCA76\x92F2\
+\\xCA77\x92F3\
+\\xCA78\x92F4\
+\\xCA79\x92F5\
+\\xCA7A\x92F6\
+\\xCA7B\x92F7\
+\\xCA7C\x92F8\
+\\xCA7D\x92F9\
+\\xCA7E\x92FA\
+\\xCA7F\x92FB\
+\\xCA81\x92FC\
+\\xCA82\x92FD\
+\\xCA83\x92FE\
+\\xCA84\x9340\
+\\xCA85\x9341\
+\\xCA86\x9342\
+\\xCA87\x9343\
+\\xCA88\x9344\
+\\xCA89\x9345\
+\\xCA8A\x9346\
+\\xCA8B\x9347\
+\\xCA8C\x9348\
+\\xCA8D\x9349\
+\\xCA8E\x934A\
+\\xCA8F\x934B\
+\\xCA90\x934C\
+\\xCA91\x934D\
+\\xCA92\x934E\
+\\xCA93\x934F\
+\\xCA94\x9350\
+\\xCA95\x9351\
+\\xCA96\x9352\
+\\xCA97\x9353\
+\\xCA98\x9354\
+\\xCA99\x9355\
+\\xCA9A\x9356\
+\\xCA9B\x9357\
+\\xCA9C\x9358\
+\\xCA9D\x9359\
+\\xCA9E\x935A\
+\\xCA9F\x935B\
+\\xCAA0\x935C\
+\\xCAA1\x935D\
+\\xCAA2\x935E\
+\\xCAA3\x935F\
+\\xCAA4\x9360\
+\\xCAA5\x9361\
+\\xCAA6\x9362\
+\\xCAA7\x9363\
+\\xCAA8\x9364\
+\\xCAA9\x9365\
+\\xCAAA\x9366\
+\\xCAAB\x9367\
+\\xCAAC\x9368\
+\\xCAAD\x9369\
+\\xCAAE\x936A\
+\\xCAAF\x936B\
+\\xCAB0\x936C\
+\\xCAB1\x936D\
+\\xCAB2\x936E\
+\\xCAB3\x936F\
+\\xCAB4\x9370\
+\\xCAB5\x9371\
+\\xCAB6\x9372\
+\\xCAB7\x9373\
+\\xCAB8\x9374\
+\\xCAB9\x9375\
+\\xCABA\x9376\
+\\xCABB\x9377\
+\\xCABC\x9378\
+\\xCABD\x9379\
+\\xCABE\x937A\
+\\xCABF\x937B\
+\\xCAC0\x937C\
+\\xCAC1\x937D\
+\\xCAC2\x937E\
+\\xCAC3\x93A1\
+\\xCAC4\x93A2\
+\\xCAC5\x93A3\
+\\xCAC6\x93A4\
+\\xCAC7\x93A5\
+\\xCAC8\x93A6\
+\\xCAC9\x93A7\
+\\xCACA\x93A8\
+\\xCACB\x93A9\
+\\xCACC\x93AA\
+\\xCACD\x93AB\
+\\xCACE\x93AC\
+\\xCACF\x93AD\
+\\xCAD0\x93AE\
+\\xCAD1\x93AF\
+\\xCAD2\x93B0\
+\\xCAD3\x93B1\
+\\xCAD4\x93B2\
+\\xCAD5\x93B3\
+\\xCAD6\x93B4\
+\\xCAD7\x93B5\
+\\xCAD8\x93B6\
+\\xCAD9\x93B7\
+\\xCADA\x93B8\
+\\xCADB\x93B9\
+\\xCADC\x93BA\
+\\xCADD\x93BB\
+\\xCADE\x93BC\
+\\xCADF\x93BD\
+\\xCAE0\x93BE\
+\\xCAE1\x93BF\
+\\xCAE2\x93C0\
+\\xCAE3\x93C1\
+\\xCAE4\x93C2\
+\\xCAE5\x93C3\
+\\xCAE6\x93C4\
+\\xCAE7\x93C5\
+\\xCAE8\x93C6\
+\\xCAE9\x93C7\
+\\xCAEA\x93C8\
+\\xCAEB\x93C9\
+\\xCAEC\x93CA\
+\\xCAED\x93CB\
+\\xCAEE\x93CC\
+\\xCAEF\x93CD\
+\\xCAF0\x93CE\
+\\xCAF1\x93CF\
+\\xCAF2\x93D0\
+\\xCAF3\x93D1\
+\\xCAF4\x93D2\
+\\xCAF5\x93D3\
+\\xCAF6\x93D4\
+\\xCAF7\x93D5\
+\\xCAF8\x93D6\
+\\xCAF9\x93D7\
+\\xCAFA\x93D8\
+\\xCAFB\x93D9\
+\\xCAFC\x93DA\
+\\xCAFD\x93DB\
+\\xCB41\x93DC\
+\\xCB42\x93DD\
+\\xCB43\x93DE\
+\\xCB44\x93DF\
+\\xCB45\x93E0\
+\\xCB46\x93E1\
+\\xCB47\x93E2\
+\\xCB48\x93E3\
+\\xCB49\x93E4\
+\\xCB4A\x93E5\
+\\xCB4B\x93E6\
+\\xCB4C\x93E7\
+\\xCB4D\x93E8\
+\\xCB4E\x93E9\
+\\xCB4F\x93EA\
+\\xCB50\x93EB\
+\\xCB51\x93EC\
+\\xCB52\x93ED\
+\\xCB53\x93EE\
+\\xCB54\x93EF\
+\\xCB55\x93F0\
+\\xCB56\x93F1\
+\\xCB57\x93F2\
+\\xCB58\x93F3\
+\\xCB59\x93F4\
+\\xCB5A\x93F5\
+\\xCB5B\x93F6\
+\\xCB5C\x93F7\
+\\xCB5D\x93F8\
+\\xCB5E\x93F9\
+\\xCB5F\x93FA\
+\\xCB60\x93FB\
+\\xCB61\x93FC\
+\\xCB62\x93FD\
+\\xCB63\x93FE\
+\\xCB64\x9440\
+\\xCB65\x9441\
+\\xCB66\x9442\
+\\xCB67\x9443\
+\\xCB68\x9444\
+\\xCB69\x9445\
+\\xCB6A\x9446\
+\\xCB6B\x9447\
+\\xCB6C\x9448\
+\\xCB6D\x9449\
+\\xCB6E\x944A\
+\\xCB6F\x944B\
+\\xCB70\x944C\
+\\xCB71\x944D\
+\\xCB72\x944E\
+\\xCB73\x944F\
+\\xCB74\x9450\
+\\xCB75\x9451\
+\\xCB76\x9452\
+\\xCB77\x9453\
+\\xCB78\x9454\
+\\xCB79\x9455\
+\\xCB7A\x9456\
+\\xCB7B\x9457\
+\\xCB7C\x9458\
+\\xCB7D\x9459\
+\\xCB7E\x945A\
+\\xCB7F\x945B\
+\\xCB81\x945C\
+\\xCB82\x945D\
+\\xCB83\x945E\
+\\xCB84\x945F\
+\\xCB85\x9460\
+\\xCB86\x9461\
+\\xCB87\x9462\
+\\xCB88\x9463\
+\\xCB89\x9464\
+\\xCB8A\x9465\
+\\xCB8B\x9466\
+\\xCB8C\x9467\
+\\xCB8D\x9468\
+\\xCB8E\x9469\
+\\xCB8F\x946A\
+\\xCB90\x946B\
+\\xCB91\x946C\
+\\xCB92\x946D\
+\\xCB93\x946E\
+\\xCB94\x946F\
+\\xCB95\x9470\
+\\xCB96\x9471\
+\\xCB97\x9472\
+\\xCB98\x9473\
+\\xCB99\x9474\
+\\xCB9A\x9475\
+\\xCB9B\x9476\
+\\xCB9C\x9477\
+\\xCB9D\x9478\
+\\xCB9E\x9479\
+\\xCB9F\x947A\
+\\xCBA0\x947B\
+\\xCBA1\x947C\
+\\xCBA2\x947D\
+\\xCBA3\x947E\
+\\xCBA4\x94A1\
+\\xCBA5\x94A2\
+\\xCBA6\x94A3\
+\\xCBA7\x94A4\
+\\xCBA8\x94A5\
+\\xCBA9\x94A6\
+\\xCBAA\x94A7\
+\\xCBAB\x94A8\
+\\xCBAC\x94A9\
+\\xCBAD\x94AA\
+\\xCBAE\x94AB\
+\\xCBAF\x94AC\
+\\xCBB0\x94AD\
+\\xCBB1\x94AE\
+\\xCBB2\x94AF\
+\\xCBB3\x94B0\
+\\xCBB4\x94B1\
+\\xCBB5\x94B2\
+\\xCBB6\x94B3\
+\\xCBB7\x94B4\
+\\xCBB8\x94B5\
+\\xCBB9\x94B6\
+\\xCBBA\x94B7\
+\\xCBBB\x94B8\
+\\xCBBC\x94B9\
+\\xCBBD\x94BA\
+\\xCBBE\x94BB\
+\\xCBBF\x94BC\
+\\xCBC0\x94BD\
+\\xCBC1\x94BE\
+\\xCBC2\x94BF\
+\\xCBC3\x94C0\
+\\xCBC4\x94C1\
+\\xCBC5\x94C2\
+\\xCBC6\x94C3\
+\\xCBC7\x94C4\
+\\xCBC8\x94C5\
+\\xCBC9\x94C6\
+\\xCBCA\x94C7\
+\\xCBCB\x94C8\
+\\xCBCC\x94C9\
+\\xCBCD\x94CA\
+\\xCBCE\x94CB\
+\\xCBCF\x94CC\
+\\xCBD0\x94CD\
+\\xCBD1\x94CE\
+\\xCBD2\x94CF\
+\\xCBD3\x94D0\
+\\xCBD4\x94D1\
+\\xCBD5\x94D2\
+\\xCBD6\x94D3\
+\\xCBD7\x94D4\
+\\xCBD8\x94D5\
+\\xCBD9\x94D6\
+\\xCBDA\x94D7\
+\\xCBDB\x94D8\
+\\xCBDC\x94D9\
+\\xCBDD\x94DA\
+\\xCBDE\x94DB\
+\\xCBDF\x94DC\
+\\xCBE0\x94DD\
+\\xCBE1\x94DE\
+\\xCBE2\x94DF\
+\\xCBE3\x94E0\
+\\xCBE4\x94E1\
+\\xCBE5\x94E2\
+\\xCBE6\x94E3\
+\\xCBE7\x94E4\
+\\xCBE8\x94E5\
+\\xCBE9\x94E6\
+\\xCBEA\x94E7\
+\\xCBEB\x94E8\
+\\xCBEC\x94E9\
+\\xCBED\x94EA\
+\\xCBEE\x94EB\
+\\xCBEF\x94EC\
+\\xCBF0\x94ED\
+\\xCBF1\x94EE\
+\\xCBF2\x94EF\
+\\xCBF3\x94F0\
+\\xCBF4\x94F1\
+\\xCBF5\x94F2\
+\\xCBF6\x94F3\
+\\xCBF7\x94F4\
+\\xCBF8\x94F5\
+\\xCBF9\x94F6\
+\\xCBFA\x94F7\
+\\xCBFB\x94F8\
+\\xCBFC\x94F9\
+\\xCBFD\x94FA\
+\\xCC41\x94FB\
+\\xCC42\x94FC\
+\\xCC43\x94FD\
+\\xCC44\x94FE\
+\\xCC45\x9540\
+\\xCC46\x9541\
+\\xCC47\x9542\
+\\xCC48\x9543\
+\\xCC49\x9544\
+\\xCC4A\x9545\
+\\xCC4B\x9546\
+\\xCC4C\x9547\
+\\xCC4D\x9548\
+\\xCC4E\x9549\
+\\xCC4F\x954A\
+\\xCC50\x954B\
+\\xCC51\x954C\
+\\xCC52\x954D\
+\\xCC53\x954E\
+\\xCC54\x954F\
+\\xCC55\x9550\
+\\xCC56\x9551\
+\\xCC57\x9552\
+\\xCC58\x9553\
+\\xCC59\x9554\
+\\xCC5A\x9555\
+\\xCC5B\x9556\
+\\xCC5C\x9557\
+\\xCC5D\x9558\
+\\xCC5E\x9559\
+\\xCC5F\x955A\
+\\xCC60\x955B\
+\\xCC61\x955C\
+\\xCC62\x955D\
+\\xCC63\x955E\
+\\xCC64\x955F\
+\\xCC65\x9560\
+\\xCC66\x9561\
+\\xCC67\x9562\
+\\xCC68\x9563\
+\\xCC69\x9564\
+\\xCC6A\x9565\
+\\xCC6B\x9566\
+\\xCC6C\x9567\
+\\xCC6D\x9568\
+\\xCC6E\x9569\
+\\xCC6F\x956A\
+\\xCC70\x956B\
+\\xCC71\x956C\
+\\xCC72\x956D\
+\\xCC73\x956E\
+\\xCC74\x956F\
+\\xCC75\x9570\
+\\xCC76\x9571\
+\\xCC77\x9572\
+\\xCC78\x9573\
+\\xCC79\x9574\
+\\xCC7A\x9575\
+\\xCC7B\x9576\
+\\xCC7C\x9577\
+\\xCC7D\x9578\
+\\xCC7E\x9579\
+\\xCC7F\x957A\
+\\xCC81\x957B\
+\\xCC82\x957C\
+\\xCC83\x957D\
+\\xCC84\x957E\
+\\xCC85\x95A1\
+\\xCC86\x95A2\
+\\xCC87\x95A3\
+\\xCC88\x95A4\
+\\xCC89\x95A5\
+\\xCC8A\x95A6\
+\\xCC8B\x95A7\
+\\xCC8C\x95A8\
+\\xCC8D\x95A9\
+\\xCC8E\x95AA\
+\\xCC8F\x95AB\
+\\xCC90\x95AC\
+\\xCC91\x95AD\
+\\xCC92\x95AE\
+\\xCC93\x95AF\
+\\xCC94\x95B0\
+\\xCC95\x95B1\
+\\xCC96\x95B2\
+\\xCC97\x95B3\
+\\xCC98\x95B4\
+\\xCC99\x95B5\
+\\xCC9A\x95B6\
+\\xCC9B\x95B7\
+\\xCC9C\x95B8\
+\\xCC9D\x95B9\
+\\xCC9E\x95BA\
+\\xCC9F\x95BB\
+\\xCCA0\x95BC\
+\\xCCA1\x95BD\
+\\xCCA2\x95BE\
+\\xCCA3\x95BF\
+\\xCCA4\x95C0\
+\\xCCA5\x95C1\
+\\xCCA6\x95C2\
+\\xCCA7\x95C3\
+\\xCCA8\x95C4\
+\\xCCA9\x95C5\
+\\xCCAA\x95C6\
+\\xCCAB\x95C7\
+\\xCCAC\x95C8\
+\\xCCAD\x95C9\
+\\xCCAE\x95CA\
+\\xCCAF\x95CB\
+\\xCCB0\x95CC\
+\\xCCB1\x95CD\
+\\xCCB2\x95CE\
+\\xCCB3\x95CF\
+\\xCCB4\x95D0\
+\\xCCB5\x95D1\
+\\xCCB6\x95D2\
+\\xCCB7\x95D3\
+\\xCCB8\x95D4\
+\\xCCB9\x95D5\
+\\xCCBA\x95D6\
+\\xCCBB\x95D7\
+\\xCCBC\x95D8\
+\\xCCBD\x95D9\
+\\xCCBE\x95DA\
+\\xCCBF\x95DB\
+\\xCCC0\x95DC\
+\\xCCC1\x95DD\
+\\xCCC2\x95DE\
+\\xCCC3\x95DF\
+\\xCCC4\x95E0\
+\\xCCC5\x95E1\
+\\xCCC6\x95E2\
+\\xCCC7\x95E3\
+\\xCCC8\x95E4\
+\\xCCC9\x95E5\
+\\xCCCA\x95E6\
+\\xCCCB\x95E7\
+\\xCCCC\x95E8\
+\\xCCCD\x95E9\
+\\xCCCE\x95EA\
+\\xCCCF\x95EB\
+\\xCCD0\x95EC\
+\\xCCD1\x95ED\
+\\xCCD2\x95EE\
+\\xCCD3\x95EF\
+\\xCCD4\x95F0\
+\\xCCD5\x95F1\
+\\xCCD6\x95F2\
+\\xCCD7\x95F3\
+\\xCCD8\x95F4\
+\\xCCD9\x95F5\
+\\xCCDA\x95F6\
+\\xCCDB\x95F7\
+\\xCCDC\x95F8\
+\\xCCDD\x95F9\
+\\xCCDE\x95FA\
+\\xCCDF\x95FB\
+\\xCCE0\x95FC\
+\\xCCE1\x95FD\
+\\xCCE2\x95FE\
+\\xCCE3\x9640\
+\\xCCE4\x9641\
+\\xCCE5\x9642\
+\\xCCE6\x9643\
+\\xCCE7\x9644\
+\\xCCE8\x9645\
+\\xCCE9\x9646\
+\\xCCEA\x9647\
+\\xCCEB\x9648\
+\\xCCEC\x9649\
+\\xCCED\x964A\
+\\xCCEE\x964B\
+\\xCCEF\x964C\
+\\xCCF0\x964D\
+\\xCCF1\x964E\
+\\xCCF2\x964F\
+\\xCCF3\x9650\
+\\xCCF4\x9651\
+\\xCCF5\x9652\
+\\xCCF6\x9653\
+\\xCCF7\x9654\
+\\xCCF8\x9655\
+\\xCCF9\x9656\
+\\xCCFA\x9657\
+\\xCCFB\x9658\
+\\xCCFC\x9659\
+\\xCCFD\x965A\
+\\xCD41\x965B\
+\\xCD42\x965C\
+\\xCD43\x965D\
+\\xCD44\x965E\
+\\xCD45\x965F\
+\\xCD46\x9660\
+\\xCD47\x9661\
+\\xCD48\x9662\
+\\xCD49\x9663\
+\\xCD4A\x9664\
+\\xCD4B\x9665\
+\\xCD4C\x9666\
+\\xCD4D\x9667\
+\\xCD4E\x9668\
+\\xCD4F\x9669\
+\\xCD50\x966A\
+\\xCD51\x966B\
+\\xCD52\x966C\
+\\xCD53\x966D\
+\\xCD54\x966E\
+\\xCD55\x966F\
+\\xCD56\x9670\
+\\xCD57\x9671\
+\\xCD58\x9672\
+\\xCD59\x9673\
+\\xCD5A\x9674\
+\\xCD5B\x9675\
+\\xCD5C\x9676\
+\\xCD5D\x9677\
+\\xCD5E\x9678\
+\\xCD5F\x9679\
+\\xCD60\x967A\
+\\xCD61\x967B\
+\\xCD62\x967C\
+\\xCD63\x967D\
+\\xCD64\x967E\
+\\xCD65\x96A1\
+\\xCD66\x96A2\
+\\xCD67\x96A3\
+\\xCD68\x96A4\
+\\xCD69\x96A5\
+\\xCD6A\x96A6\
+\\xCD6B\x96A7\
+\\xCD6C\x96A8\
+\\xCD6D\x96A9\
+\\xCD6E\x96AA\
+\\xCD6F\x96AB\
+\\xCD70\x96AC\
+\\xCD71\x96AD\
+\\xCD72\x96AE\
+\\xCD73\x96AF\
+\\xCD74\x96B0\
+\\xCD75\x96B1\
+\\xCD76\x96B2\
+\\xCD77\x96B3\
+\\xCD78\x96B4\
+\\xCD79\x96B5\
+\\xCD7A\x96B6\
+\\xCD7B\x96B7\
+\\xCD7C\x96B8\
+\\xCD7D\x96B9\
+\\xCD7E\x96BA\
+\\xCD7F\x96BB\
+\\xCD81\x96BC\
+\\xCD82\x96BD\
+\\xCD83\x96BE\
+\\xCD84\x96BF\
+\\xCD85\x96C0\
+\\xCD86\x96C1\
+\\xCD87\x96C2\
+\\xCD88\x96C3\
+\\xCD89\x96C4\
+\\xCD8A\x96C5\
+\\xCD8B\x96C6\
+\\xCD8C\x96C7\
+\\xCD8D\x96C8\
+\\xCD8E\x96C9\
+\\xCD8F\x96CA\
+\\xCD90\x96CB\
+\\xCD91\x96CC\
+\\xCD92\x96CD\
+\\xCD93\x96CE\
+\\xCD94\x96CF\
+\\xCD95\x96D0\
+\\xCD96\x96D1\
+\\xCD97\x96D2\
+\\xCD98\x96D3\
+\\xCD99\x96D4\
+\\xCD9A\x96D5\
+\\xCD9B\x96D6\
+\\xCD9C\x96D7\
+\\xCD9D\x96D8\
+\\xCD9E\x96D9\
+\\xCD9F\x96DA\
+\\xCDA0\x96DB\
+\\xCDA1\x96DC\
+\\xCDA2\x96DD\
+\\xCDA3\x96DE\
+\\xCDA4\x96DF\
+\\xCDA5\x96E0\
+\\xCDA6\x96E1\
+\\xCDA7\x96E2\
+\\xCDA8\x96E3\
+\\xCDA9\x96E4\
+\\xCDAA\x96E5\
+\\xCDAB\x96E6\
+\\xCDAC\x96E7\
+\\xCDAD\x96E8\
+\\xCDAE\x96E9\
+\\xCDAF\x96EA\
+\\xCDB0\x96EB\
+\\xCDB1\x96EC\
+\\xCDB2\x96ED\
+\\xCDB3\x96EE\
+\\xCDB4\x96EF\
+\\xCDB5\x96F0\
+\\xCDB6\x96F1\
+\\xCDB7\x96F2\
+\\xCDB8\x96F3\
+\\xCDB9\x96F4\
+\\xCDBA\x96F5\
+\\xCDBB\x96F6\
+\\xCDBC\x96F7\
+\\xCDBD\x96F8\
+\\xCDBE\x96F9\
+\\xCDBF\x96FA\
+\\xCDC0\x96FB\
+\\xCDC1\x96FC\
+\\xCDC2\x96FD\
+\\xCDC3\x96FE\
+\\xCDC4\x9740\
+\\xCDC5\x9741\
+\\xCDC6\x9742\
+\\xCDC7\x9743\
+\\xCDC8\x9744\
+\\xCDC9\x9745\
+\\xCDCA\x9746\
+\\xCDCB\x9747\
+\\xCDCC\x9748\
+\\xCDCD\x9749\
+\\xCDCE\x974A\
+\\xCDCF\x974B\
+\\xCDD0\x974C\
+\\xCDD1\x974D\
+\\xCDD2\x974E\
+\\xCDD3\x974F\
+\\xCDD4\x9750\
+\\xCDD5\x9751\
+\\xCDD6\x9752\
+\\xCDD7\x9753\
+\\xCDD8\x9754\
+\\xCDD9\x9755\
+\\xCDDA\x9756\
+\\xCDDB\x9757\
+\\xCDDC\x9758\
+\\xCDDD\x9759\
+\\xCDDE\x975A\
+\\xCDDF\x975B\
+\\xCDE0\x975C\
+\\xCDE1\x975D\
+\\xCDE2\x975E\
+\\xCDE3\x975F\
+\\xCDE4\x9760\
+\\xCDE5\x9761\
+\\xCDE6\x9762\
+\\xCDE7\x9763\
+\\xCDE8\x9764\
+\\xCDE9\x9765\
+\\xCDEA\x9766\
+\\xCDEB\x9767\
+\\xCDEC\x9768\
+\\xCDED\x9769\
+\\xCDEE\x976A\
+\\xCDEF\x976B\
+\\xCDF0\x976C\
+\\xCDF1\x976D\
+\\xCDF2\x976E\
+\\xCDF3\x976F\
+\\xCDF4\x9770\
+\\xCDF5\x9771\
+\\xCDF6\x9772\
+\\xCDF7\x9773\
+\\xCDF8\x9774\
+\\xCDF9\x9775\
+\\xCDFA\x9776\
+\\xCDFB\x9777\
+\\xCDFC\x9778\
+\\xCDFD\x9779\
+\\xCE41\x977A\
+\\xCE42\x977B\
+\\xCE43\x977C\
+\\xCE44\x977D\
+\\xCE45\x977E\
+\\xCE46\x97A1\
+\\xCE47\x97A2\
+\\xCE48\x97A3\
+\\xCE49\x97A4\
+\\xCE4A\x97A5\
+\\xCE4B\x97A6\
+\\xCE4C\x97A7\
+\\xCE4D\x97A8\
+\\xCE4E\x97A9\
+\\xCE4F\x97AA\
+\\xCE50\x97AB\
+\\xCE51\x97AC\
+\\xCE52\x97AD\
+\\xCE53\x97AE\
+\\xCE54\x97AF\
+\\xCE55\x97B0\
+\\xCE56\x97B1\
+\\xCE57\x97B2\
+\\xCE58\x97B3\
+\\xCE59\x97B4\
+\\xCE5A\x97B5\
+\\xCE5B\x97B6\
+\\xCE5C\x97B7\
+\\xCE5D\x97B8\
+\\xCE5E\x97B9\
+\\xCE5F\x97BA\
+\\xCE60\x97BB\
+\\xCE61\x97BC\
+\\xCE62\x97BD\
+\\xCE63\x97BE\
+\\xCE64\x97BF\
+\\xCE65\x97C0\
+\\xCE66\x97C1\
+\\xCE67\x97C2\
+\\xCE68\x97C3\
+\\xCE69\x97C4\
+\\xCE6A\x97C5\
+\\xCE6B\x97C6\
+\\xCE6C\x97C7\
+\\xCE6D\x97C8\
+\\xCE6E\x97C9\
+\\xCE6F\x97CA\
+\\xCE70\x97CB\
+\\xCE71\x97CC\
+\\xCE72\x97CD\
+\\xCE73\x97CE\
+\\xCE74\x97CF\
+\\xCE75\x97D0\
+\\xCE76\x97D1\
+\\xCE77\x97D2\
+\\xCE78\x97D3\
+\\xCE79\x97D4\
+\\xCE7A\x97D5\
+\\xCE7B\x97D6\
+\\xCE7C\x97D7\
+\\xCE7D\x97D8\
+\\xCE7E\x97D9\
+\\xCE7F\x97DA\
+\\xCE81\x97DB\
+\\xCE82\x97DC\
+\\xCE83\x97DD\
+\\xCE84\x97DE\
+\\xCE85\x97DF\
+\\xCE86\x97E0\
+\\xCE87\x97E1\
+\\xCE88\x97E2\
+\\xCE89\x97E3\
+\\xCE8A\x97E4\
+\\xCE8B\x97E5\
+\\xCE8C\x97E6\
+\\xCE8D\x97E7\
+\\xCE8E\x97E8\
+\\xCE8F\x97E9\
+\\xCE90\x97EA\
+\\xCE91\x97EB\
+\\xCE92\x97EC\
+\\xCE93\x97ED\
+\\xCE94\x97EE\
+\\xCE95\x97EF\
+\\xCE96\x97F0\
+\\xCE97\x97F1\
+\\xCE98\x97F2\
+\\xCE99\x97F3\
+\\xCE9A\x97F4\
+\\xCE9B\x97F5\
+\\xCE9C\x97F6\
+\\xCE9D\x97F7\
+\\xCE9E\x97F8\
+\\xCE9F\x97F9\
+\\xCEA0\x97FA\
+\\xCEA1\x97FB\
+\\xCEA2\x97FC\
+\\xCEA3\x97FD\
+\\xCEA4\x97FE\
+\\xCEA5\x9840\
+\\xCEA6\x9841\
+\\xCEA7\x9842\
+\\xCEA8\x9843\
+\\xCEA9\x9844\
+\\xCEAA\x9845\
+\\xCEAB\x9846\
+\\xCEAC\x9847\
+\\xCEAD\x9848\
+\\xCEAE\x9849\
+\\xCEAF\x984A\
+\\xCEB0\x984B\
+\\xCEB1\x984C\
+\\xCEB2\x984D\
+\\xCEB3\x984E\
+\\xCEB4\x984F\
+\\xCEB5\x9850\
+\\xCEB6\x9851\
+\\xCEB7\x9852\
+\\xCEB8\x9853\
+\\xCEB9\x9854\
+\\xCEBA\x9855\
+\\xCEBB\x9856\
+\\xCEBC\x9857\
+\\xCEBD\x9858\
+\\xCEBE\x9859\
+\\xCEBF\x985A\
+\\xCEC0\x985B\
+\\xCEC1\x985C\
+\\xCEC2\x985D\
+\\xCEC3\x985E\
+\\xCEC4\x985F\
+\\xCEC5\x9860\
+\\xCEC6\x9861\
+\\xCEC7\x9862\
+\\xCEC8\x9863\
+\\xCEC9\x9864\
+\\xCECA\x9865\
+\\xCECB\x9866\
+\\xCECC\x9867\
+\\xCECD\x9868\
+\\xCECE\x9869\
+\\xCECF\x986A\
+\\xCED0\x986B\
+\\xCED1\x986C\
+\\xCED2\x986D\
+\\xCED3\x986E\
+\\xCED4\x986F\
+\\xCED5\x9870\
+\\xCED6\x9871\
+\\xCED7\x9872\
+\\xCED8\x9873\
+\\xCED9\x9874\
+\\xCEDA\x9875\
+\\xCEDB\x9876\
+\\xCEDC\x9877\
+\\xCEDD\x9878\
+\\xCEDE\x9879\
+\\xCEDF\x987A\
+\\xCEE0\x987B\
+\\xCEE1\x987C\
+\\xCEE2\x987D\
+\\xCEE3\x987E\
+\\xCEE4\x98A1\
+\\xCEE5\x98A2\
+\\xCEE6\x98A3\
+\\xCEE7\x98A4\
+\\xCEE8\x98A5\
+\\xCEE9\x98A6\
+\\xCEEA\x98A7\
+\\xCEEB\x98A8\
+\\xCEEC\x98A9\
+\\xCEED\x98AA\
+\\xCEEE\x98AB\
+\\xCEEF\x98AC\
+\\xCEF0\x98AD\
+\\xCEF1\x98AE\
+\\xCEF2\x98AF\
+\\xCEF3\x98B0\
+\\xCEF4\x98B1\
+\\xCEF5\x98B2\
+\\xCEF6\x98B3\
+\\xCEF7\x98B4\
+\\xCEF8\x98B5\
+\\xCEF9\x98B6\
+\\xCEFA\x98B7\
+\\xCEFB\x98B8\
+\\xCEFC\x98B9\
+\\xCEFD\x98BA\
+\\xCF41\x98BB\
+\\xCF42\x98BC\
+\\xCF43\x98BD\
+\\xCF44\x98BE\
+\\xCF45\x98BF\
+\\xCF46\x98C0\
+\\xCF47\x98C1\
+\\xCF48\x98C2\
+\\xCF49\x98C3\
+\\xCF4A\x98C4\
+\\xCF4B\x98C5\
+\\xCF4C\x98C6\
+\\xCF4D\x98C7\
+\\xCF4E\x98C8\
+\\xCF4F\x98C9\
+\\xCF50\x98CA\
+\\xCF51\x98CB\
+\\xCF52\x98CC\
+\\xCF53\x98CD\
+\\xCF54\x98CE\
+\\xCF55\x98CF\
+\\xCF56\x98D0\
+\\xCF57\x98D1\
+\\xCF58\x98D2\
+\\xCF59\x98D3\
+\\xCF5A\x98D4\
+\\xCF5B\x98D5\
+\\xCF5C\x98D6\
+\\xCF5D\x98D7\
+\\xCF5E\x98D8\
+\\xCF5F\x98D9\
+\\xCF60\x98DA\
+\\xCF61\x98DB\
+\\xCF62\x98DC\
+\\xCF63\x98DD\
+\\xCF64\x98DE\
+\\xCF65\x98DF\
+\\xCF66\x98E0\
+\\xCF67\x98E1\
+\\xCF68\x98E2\
+\\xCF69\x98E3\
+\\xCF6A\x98E4\
+\\xCF6B\x98E5\
+\\xCF6C\x98E6\
+\\xCF6D\x98E7\
+\\xCF6E\x98E8\
+\\xCF6F\x98E9\
+\\xCF70\x98EA\
+\\xCF71\x98EB\
+\\xCF72\x98EC\
+\\xCF73\x98ED\
+\\xCF74\x98EE\
+\\xCF75\x98EF\
+\\xCF76\x98F0\
+\\xCF77\x98F1\
+\\xCF78\x98F2\
+\\xCF79\x98F3\
+\\xCF7A\x98F4\
+\\xCF7B\x98F5\
+\\xCF7C\x98F6\
+\\xCF7D\x98F7\
+\\xCF7E\x98F8\
+\\xCF7F\x98F9\
+\\xCF81\x98FA\
+\\xCF82\x98FB\
+\\xCF83\x98FC\
+\\xCF84\x98FD\
+\\xCF85\x98FE\
+\\xCF86\x9940\
+\\xCF87\x9941\
+\\xCF88\x9942\
+\\xCF89\x9943\
+\\xCF8A\x9944\
+\\xCF8B\x9945\
+\\xCF8C\x9946\
+\\xCF8D\x9947\
+\\xCF8E\x9948\
+\\xCF8F\x9949\
+\\xCF90\x994A\
+\\xCF91\x994B\
+\\xCF92\x994C\
+\\xCF93\x994D\
+\\xCF94\x994E\
+\\xCF95\x994F\
+\\xCF96\x9950\
+\\xCF97\x9951\
+\\xCF98\x9952\
+\\xCF99\x9953\
+\\xCF9A\x9954\
+\\xCF9B\x9955\
+\\xCF9C\x9956\
+\\xCF9D\x9957\
+\\xCF9E\x9958\
+\\xCF9F\x9959\
+\\xCFA0\x995A\
+\\xCFA1\x995B\
+\\xCFA2\x995C\
+\\xCFA3\x995D\
+\\xCFA4\x995E\
+\\xCFA5\x995F\
+\\xCFA6\x9960\
+\\xCFA7\x9961\
+\\xCFA8\x9962\
+\\xCFA9\x9963\
+\\xCFAA\x9964\
+\\xCFAB\x9965\
+\\xCFAC\x9966\
+\\xCFAD\x9967\
+\\xCFAE\x9968\
+\\xCFAF\x9969\
+\\xCFB0\x996A\
+\\xCFB1\x996B\
+\\xCFB2\x996C\
+\\xCFB3\x996D\
+\\xCFB4\x996E\
+\\xCFB5\x996F\
+\\xCFB6\x9970\
+\\xCFB7\x9971\
+\\xCFB8\x9972\
+\\xCFB9\x9973\
+\\xCFBA\x9974\
+\\xCFBB\x9975\
+\\xCFBC\x9976\
+\\xCFBD\x9977\
+\\xCFBE\x9978\
+\\xCFBF\x9979\
+\\xCFC0\x997A\
+\\xCFC1\x997B\
+\\xCFC2\x997C\
+\\xCFC3\x997D\
+\\xCFC4\x997E\
+\\xCFC5\x99A1\
+\\xCFC6\x99A2\
+\\xCFC7\x99A3\
+\\xCFC8\x99A4\
+\\xCFC9\x99A5\
+\\xCFCA\x99A6\
+\\xCFCB\x99A7\
+\\xCFCC\x99A8\
+\\xCFCD\x99A9\
+\\xCFCE\x99AA\
+\\xCFCF\x99AB\
+\\xCFD0\x99AC\
+\\xCFD1\x99AD\
+\\xCFD2\x99AE\
+\\xCFD3\x99AF\
+\\xCFD4\x99B0\
+\\xCFD5\x99B1\
+\\xCFD6\x99B2\
+\\xCFD7\x99B3\
+\\xCFD8\x99B4\
+\\xCFD9\x99B5\
+\\xCFDA\x99B6\
+\\xCFDB\x99B7\
+\\xCFDC\x99B8\
+\\xCFDD\x99B9\
+\\xCFDE\x99BA\
+\\xCFDF\x99BB\
+\\xCFE0\x99BC\
+\\xCFE1\x99BD\
+\\xCFE2\x99BE\
+\\xCFE3\x99BF\
+\\xCFE4\x99C0\
+\\xCFE5\x99C1\
+\\xCFE6\x99C2\
+\\xCFE7\x99C3\
+\\xCFE8\x99C4\
+\\xCFE9\x99C5\
+\\xCFEA\x99C6\
+\\xCFEB\x99C7\
+\\xCFEC\x99C8\
+\\xCFED\x99C9\
+\\xCFEE\x99CA\
+\\xCFEF\x99CB\
+\\xCFF0\x99CC\
+\\xCFF1\x99CD\
+\\xCFF2\x99CE\
+\\xCFF3\x99CF\
+\\xCFF4\x99D0\
+\\xCFF5\x99D1\
+\\xCFF6\x99D2\
+\\xCFF7\x99D3\
+\\xCFF8\x99D4\
+\\xCFF9\x99D5\
+\\xCFFA\x99D6\
+\\xCFFB\x99D7\
+\\xCFFC\x99D8\
+\\xCFFD\x99D9\
+\\xD041\x99DA\
+\\xD042\x99DB\
+\\xD043\x99DC\
+\\xD044\x99DD\
+\\xD045\x99DE\
+\\xD046\x99DF\
+\\xD047\x99E0\
+\\xD048\x99E1\
+\\xD049\x99E2\
+\\xD04A\x99E3\
+\\xD04B\x99E4\
+\\xD04C\x99E5\
+\\xD04D\x99E6\
+\\xD04E\x99E7\
+\\xD04F\x99E8\
+\\xD050\x99E9\
+\\xD051\x99EA\
+\\xD052\x99EB\
+\\xD053\x99EC\
+\\xD054\x99ED\
+\\xD055\x99EE\
+\\xD056\x99EF\
+\\xD057\x99F0\
+\\xD058\x99F1\
+\\xD059\x99F2\
+\\xD05A\x99F3\
+\\xD05B\x99F4\
+\\xD05C\x99F5\
+\\xD05D\x99F6\
+\\xD05E\x99F7\
+\\xD05F\x99F8\
+\\xD060\x99F9\
+\\xD061\x99FA\
+\\xD062\x99FB\
+\\xD063\x99FC\
+\\xD064\x99FD\
+\\xD065\x99FE\
+\\xD066\x9A40\
+\\xD067\x9A41\
+\\xD068\x9A42\
+\\xD069\x9A43\
+\\xD06A\x9A44\
+\\xD06B\x9A45\
+\\xD06C\x9A46\
+\\xD06D\x9A47\
+\\xD06E\x9A48\
+\\xD06F\x9A49\
+\\xD070\x9A4A\
+\\xD071\x9A4B\
+\\xD072\x9A4C\
+\\xD073\x9A4D\
+\\xD074\x9A4E\
+\\xD075\x9A4F\
+\\xD076\x9A50\
+\\xD077\x9A51\
+\\xD078\x9A52\
+\\xD079\x9A53\
+\\xD07A\x9A54\
+\\xD07B\x9A55\
+\\xD07C\x9A56\
+\\xD07D\x9A57\
+\\xD07E\x9A58\
+\\xD07F\x9A59\
+\\xD081\x9A5A\
+\\xD082\x9A5B\
+\\xD083\x9A5C\
+\\xD084\x9A5D\
+\\xD085\x9A5E\
+\\xD086\x9A5F\
+\\xD087\x9A60\
+\\xD088\x9A61\
+\\xD089\x9A62\
+\\xD08A\x9A63\
+\\xD08B\x9A64\
+\\xD08C\x9A65\
+\\xD08D\x9A66\
+\\xD08E\x9A67\
+\\xD08F\x9A68\
+\\xD090\x9A69\
+\\xD091\x9A6A\
+\\xD092\x9A6B\
+\\xD093\x9A6C\
+\\xD094\x9A6D\
+\\xD095\x9A6E\
+\\xD096\x9A6F\
+\\xD097\x9A70\
+\\xD098\x9A71\
+\\xD099\x9A72\
+\\xD09A\x9A73\
+\\xD09B\x9A74\
+\\xD09C\x9A75\
+\\xD09D\x9A76\
+\\xD09E\x9A77\
+\\xD09F\x9A78\
+\\xD0A0\x9A79\
+\\xD0A1\x9A7A\
+\\xD0A2\x9A7B\
+\\xD0A3\x9A7C\
+\\xD0A4\x9A7D\
+\\xD0A5\x9A7E\
+\\xD0A6\x9AA1\
+\\xD0A7\x9AA2\
+\\xD0A8\x9AA3\
+\\xD0A9\x9AA4\
+\\xD0AA\x9AA5\
+\\xD0AB\x9AA6\
+\\xD0AC\x9AA7\
+\\xD0AD\x9AA8\
+\\xD0AE\x9AA9\
+\\xD0AF\x9AAA\
+\\xD0B0\x9AAB\
+\\xD0B1\x9AAC\
+\\xD0B2\x9AAD\
+\\xD0B3\x9AAE\
+\\xD0B4\x9AAF\
+\\xD0B5\x9AB0\
+\\xD0B6\x9AB1\
+\\xD0B7\x9AB2\
+\\xD0B8\x9AB3\
+\\xD0B9\x9AB4\
+\\xD0BA\x9AB5\
+\\xD0BB\x9AB6\
+\\xD0BC\x9AB7\
+\\xD0BD\x9AB8\
+\\xD0BE\x9AB9\
+\\xD0BF\x9ABA\
+\\xD0C0\x9ABB\
+\\xD0C1\x9ABC\
+\\xD0C2\x9ABD\
+\\xD0C3\x9ABE\
+\\xD0C4\x9ABF\
+\\xD0C5\x9AC0\
+\\xD0C6\x9AC1\
+\\xD0C7\x9AC2\
+\\xD0C8\x9AC3\
+\\xD0C9\x9AC4\
+\\xD0CA\x9AC5\
+\\xD0CB\x9AC6\
+\\xD0CC\x9AC7\
+\\xD0CD\x9AC8\
+\\xD0CE\x9AC9\
+\\xD0CF\x9ACA\
+\\xD0D0\x9ACB\
+\\xD0D1\x9ACC\
+\\xD0D2\x9ACD\
+\\xD0D3\x9ACE\
+\\xD0D4\x9ACF\
+\\xD0D5\x9AD0\
+\\xD0D6\x9AD1\
+\\xD0D7\x9AD2\
+\\xD0D8\x9AD3\
+\\xD0D9\x9AD4\
+\\xD0DA\x9AD5\
+\\xD0DB\x9AD6\
+\\xD0DC\x9AD7\
+\\xD0DD\x9AD8\
+\\xD0DE\x9AD9\
+\\xD0DF\x9ADA\
+\\xD0E0\x9ADB\
+\\xD0E1\x9ADC\
+\\xD0E2\x9ADD\
+\\xD0E3\x9ADE\
+\\xD0E4\x9ADF\
+\\xD0E5\x9AE0\
+\\xD0E6\x9AE1\
+\\xD0E7\x9AE2\
+\\xD0E8\x9AE3\
+\\xD0E9\x9AE4\
+\\xD0EA\x9AE5\
+\\xD0EB\x9AE6\
+\\xD0EC\x9AE7\
+\\xD0ED\x9AE8\
+\\xD0EE\x9AE9\
+\\xD0EF\x9AEA\
+\\xD0F0\x9AEB\
+\\xD0F1\x9AEC\
+\\xD0F2\x9AED\
+\\xD0F3\x9AEE\
+\\xD0F4\x9AEF\
+\\xD0F5\x9AF0\
+\\xD0F6\x9AF1\
+\\xD0F7\x9AF2\
+\\xD0F8\x9AF3\
+\\xD0F9\x9AF4\
+\\xD0FA\x9AF5\
+\\xD0FB\x9AF6\
+\\xD0FC\x9AF7\
+\\xD0FD\x9AF8\
+\\xD141\x9AF9\
+\\xD142\x9AFA\
+\\xD143\x9AFB\
+\\xD144\x9AFC\
+\\xD145\x9AFD\
+\\xD146\x9AFE\
+\\xD147\x9B40\
+\\xD148\x9B41\
+\\xD149\x9B42\
+\\xD14A\x9B43\
+\\xD14B\x9B44\
+\\xD14C\x9B45\
+\\xD14D\x9B46\
+\\xD14E\x9B47\
+\\xD14F\x9B48\
+\\xD150\x9B49\
+\\xD151\x9B4A\
+\\xD152\x9B4B\
+\\xD153\x9B4C\
+\\xD154\x9B4D\
+\\xD155\x9B4E\
+\\xD156\x9B4F\
+\\xD157\x9B50\
+\\xD158\x9B51\
+\\xD159\x9B52\
+\\xD15A\x9B53\
+\\xD15B\x9B54\
+\\xD15C\x9B55\
+\\xD15D\x9B56\
+\\xD15E\x9B57\
+\\xD15F\x9B58\
+\\xD160\x9B59\
+\\xD161\x9B5A\
+\\xD162\x9B5B\
+\\xD163\x9B5C\
+\\xD164\x9B5D\
+\\xD165\x9B5E\
+\\xD166\x9B5F\
+\\xD167\x9B60\
+\\xD168\x9B61\
+\\xD169\x9B62\
+\\xD16A\x9B63\
+\\xD16B\x9B64\
+\\xD16C\x9B65\
+\\xD16D\x9B66\
+\\xD16E\x9B67\
+\\xD16F\x9B68\
+\\xD170\x9B69\
+\\xD171\x9B6A\
+\\xD172\x9B6B\
+\\xD173\x9B6C\
+\\xD174\x9B6D\
+\\xD175\x9B6E\
+\\xD176\x9B6F\
+\\xD177\x9B70\
+\\xD178\x9B71\
+\\xD179\x9B72\
+\\xD17A\x9B73\
+\\xD17B\x9B74\
+\\xD17C\x9B75\
+\\xD17D\x9B76\
+\\xD17E\x9B77\
+\\xD17F\x9B78\
+\\xD181\x9B79\
+\\xD182\x9B7A\
+\\xD183\x9B7B\
+\\xD184\x9B7C\
+\\xD185\x9B7D\
+\\xD186\x9B7E\
+\\xD187\x9BA1\
+\\xD188\x9BA2\
+\\xD189\x9BA3\
+\\xD18A\x9BA4\
+\\xD18B\x9BA5\
+\\xD18C\x9BA6\
+\\xD18D\x9BA7\
+\\xD18E\x9BA8\
+\\xD18F\x9BA9\
+\\xD190\x9BAA\
+\\xD191\x9BAB\
+\\xD192\x9BAC\
+\\xD193\x9BAD\
+\\xD194\x9BAE\
+\\xD195\x9BAF\
+\\xD196\x9BB0\
+\\xD197\x9BB1\
+\\xD198\x9BB2\
+\\xD199\x9BB3\
+\\xD19A\x9BB4\
+\\xD19B\x9BB5\
+\\xD19C\x9BB6\
+\\xD19D\x9BB7\
+\\xD19E\x9BB8\
+\\xD19F\x9BB9\
+\\xD1A0\x9BBA\
+\\xD1A1\x9BBB\
+\\xD1A2\x9BBC\
+\\xD1A3\x9BBD\
+\\xD1A4\x9BBE\
+\\xD1A5\x9BBF\
+\\xD1A6\x9BC0\
+\\xD1A7\x9BC1\
+\\xD1A8\x9BC2\
+\\xD1A9\x9BC3\
+\\xD1AA\x9BC4\
+\\xD1AB\x9BC5\
+\\xD1AC\x9BC6\
+\\xD1AD\x9BC7\
+\\xD1AE\x9BC8\
+\\xD1AF\x9BC9\
+\\xD1B0\x9BCA\
+\\xD1B1\x9BCB\
+\\xD1B2\x9BCC\
+\\xD1B3\x9BCD\
+\\xD1B4\x9BCE\
+\\xD1B5\x9BCF\
+\\xD1B6\x9BD0\
+\\xD1B7\x9BD1\
+\\xD1B8\x9BD2\
+\\xD1B9\x9BD3\
+\\xD1BA\x9BD4\
+\\xD1BB\x9BD5\
+\\xD1BC\x9BD6\
+\\xD1BD\x9BD7\
+\\xD1BE\x9BD8\
+\\xD1BF\x9BD9\
+\\xD1C0\x9BDA\
+\\xD1C1\x9BDB\
+\\xD1C2\x9BDC\
+\\xD1C3\x9BDD\
+\\xD1C4\x9BDE\
+\\xD1C5\x9BDF\
+\\xD1C6\x9BE0\
+\\xD1C7\x9BE1\
+\\xD1C8\x9BE2\
+\\xD1C9\x9BE3\
+\\xD1CA\x9BE4\
+\\xD1CB\x9BE5\
+\\xD1CC\x9BE6\
+\\xD1CD\x9BE7\
+\\xD1CE\x9BE8\
+\\xD1CF\x9BE9\
+\\xD1D0\x9BEA\
+\\xD1D1\x9BEB\
+\\xD1D2\x9BEC\
+\\xD1D3\x9BED\
+\\xD1D4\x9BEE\
+\\xD1D5\x9BEF\
+\\xD1D6\x9BF0\
+\\xD1D7\x9BF1\
+\\xD1D8\x9BF2\
+\\xD1D9\x9BF3\
+\\xD1DA\x9BF4\
+\\xD1DB\x9BF5\
+\\xD1DC\x9BF6\
+\\xD1DD\x9BF7\
+\\xD1DE\x9BF8\
+\\xD1DF\x9BF9\
+\\xD1E0\x9BFA\
+\\xD1E1\x9BFB\
+\\xD1E2\x9BFC\
+\\xD1E3\x9BFD\
+\\xD1E4\x9BFE\
+\\xD1E5\x9C40\
+\\xD1E6\x9C41\
+\\xD1E7\x9C42\
+\\xD1E8\x9C43\
+\\xD1E9\x9C44\
+\\xD1EA\x9C45\
+\\xD1EB\x9C46\
+\\xD1EC\x9C47\
+\\xD1ED\x9C48\
+\\xD1EE\x9C49\
+\\xD1EF\x9C4A\
+\\xD1F0\x9C4B\
+\\xD1F1\x9C4C\
+\\xD1F2\x9C4D\
+\\xD1F3\x9C4E\
+\\xD1F4\x9C4F\
+\\xD1F5\x9C50\
+\\xD1F6\x9C51\
+\\xD1F7\x9C52\
+\\xD1F8\x9C53\
+\\xD1F9\x9C54\
+\\xD1FA\x9C55\
+\\xD1FB\x9C56\
+\\xD1FC\x9C57\
+\\xD1FD\x9C58\
+\\xD241\x9C59\
+\\xD242\x9C5A\
+\\xD243\x9C5B\
+\\xD244\x9C5C\
+\\xD245\x9C5D\
+\\xD246\x9C5E\
+\\xD247\x9C5F\
+\\xD248\x9C60\
+\\xD249\x9C61\
+\\xD24A\x9C62\
+\\xD24B\x9C63\
+\\xD24C\x9C64\
+\\xD24D\x9C65\
+\\xD24E\x9C66\
+\\xD24F\x9C67\
+\\xD250\x9C68\
+\\xD251\x9C69\
+\\xD252\x9C6A\
+\\xD253\x9C6B\
+\\xD254\x9C6C\
+\\xD255\x9C6D\
+\\xD256\x9C6E\
+\\xD257\x9C6F\
+\\xD258\x9C70\
+\\xD259\x9C71\
+\\xD25A\x9C72\
+\\xD25B\x9C73\
+\\xD25C\x9C74\
+\\xD25D\x9C75\
+\\xD25E\x9C76\
+\\xD25F\x9C77\
+\\xD260\x9C78\
+\\xD261\x9C79\
+\\xD262\x9C7A\
+\\xD263\x9C7B\
+\\xD264\x9C7C\
+\\xD265\x9C7D\
+\\xD266\x9C7E\
+\\xD267\x9CA1\
+\\xD268\x9CA2\
+\\xD269\x9CA3\
+\\xD26A\x9CA4\
+\\xD26B\x9CA5\
+\\xD26C\x9CA6\
+\\xD26D\x9CA7\
+\\xD26E\x9CA8\
+\\xD26F\x9CA9\
+\\xD270\x9CAA\
+\\xD271\x9CAB\
+\\xD272\x9CAC\
+\\xD273\x9CAD\
+\\xD274\x9CAE\
+\\xD275\x9CAF\
+\\xD276\x9CB0\
+\\xD277\x9CB1\
+\\xD278\x9CB2\
+\\xD279\x9CB3\
+\\xD27A\x9CB4\
+\\xD27B\x9CB5\
+\\xD27C\x9CB6\
+\\xD27D\x9CB7\
+\\xD27E\x9CB8\
+\\xD27F\x9CB9\
+\\xD281\x9CBA\
+\\xD282\x9CBB\
+\\xD283\x9CBC\
+\\xD284\x9CBD\
+\\xD285\x9CBE\
+\\xD286\x9CBF\
+\\xD287\x9CC0\
+\\xD288\x9CC1\
+\\xD289\x9CC2\
+\\xD28A\x9CC3\
+\\xD28B\x9CC4\
+\\xD28C\x9CC5\
+\\xD28D\x9CC6\
+\\xD28E\x9CC7\
+\\xD28F\x9CC8\
+\\xD290\x9CC9\
+\\xD291\x9CCA\
+\\xD292\x9CCB\
+\\xD293\x9CCC\
+\\xD294\x9CCD\
+\\xD295\x9CCE\
+\\xD296\x9CCF\
+\\xD297\x9CD0\
+\\xD298\x9CD1\
+\\xD299\x9CD2\
+\\xD29A\x9CD3\
+\\xD29B\x9CD4\
+\\xD29C\x9CD5\
+\\xD29D\x9CD6\
+\\xD29E\x9CD7\
+\\xD29F\x9CD8\
+\\xD2A0\x9CD9\
+\\xD2A1\x9CDA\
+\\xD2A2\x9CDB\
+\\xD2A3\x9CDC\
+\\xD2A4\x9CDD\
+\\xD2A5\x9CDE\
+\\xD2A6\x9CDF\
+\\xD2A7\x9CE0\
+\\xD2A8\x9CE1\
+\\xD2A9\x9CE2\
+\\xD2AA\x9CE3\
+\\xD2AB\x9CE4\
+\\xD2AC\x9CE5\
+\\xD2AD\x9CE6\
+\\xD2AE\x9CE7\
+\\xD2AF\x9CE8\
+\\xD2B0\x9CE9\
+\\xD2B1\x9CEA\
+\\xD2B2\x9CEB\
+\\xD2B3\x9CEC\
+\\xD2B4\x9CED\
+\\xD2B5\x9CEE\
+\\xD2B6\x9CEF\
+\\xD2B7\x9CF0\
+\\xD2B8\x9CF1\
+\\xD2B9\x9CF2\
+\\xD2BA\x9CF3\
+\\xD2BB\x9CF4\
+\\xD2BC\x9CF5\
+\\xD2BD\x9CF6\
+\\xD2BE\x9CF7\
+\\xD2BF\x9CF8\
+\\xD2C0\x9CF9\
+\\xD2C1\x9CFA\
+\\xD2C2\x9CFB\
+\\xD2C3\x9CFC\
+\\xD2C4\x9CFD\
+\\xD2C5\x9CFE\
+\\xD2C6\x9D40\
+\\xD2C7\x9D41\
+\\xD2C8\x9D42\
+\\xD2C9\x9D43\
+\\xD2CA\x9D44\
+\\xD2CB\x9D45\
+\\xD2CC\x9D46\
+\\xD2CD\x9D47\
+\\xD2CE\x9D48\
+\\xD2CF\x9D49\
+\\xD2D0\x9D4A\
+\\xD2D1\x9D4B\
+\\xD2D2\x9D4C\
+\\xD2D3\x9D4D\
+\\xD2D4\x9D4E\
+\\xD2D5\x9D4F\
+\\xD2D6\x9D50\
+\\xD2D7\x9D51\
+\\xD2D8\x9D52\
+\\xD2D9\x9D53\
+\\xD2DA\x9D54\
+\\xD2DB\x9D55\
+\\xD2DC\x9D56\
+\\xD2DD\x9D57\
+\\xD2DE\x9D58\
+\\xD2DF\x9D59\
+\\xD2E0\x9D5A\
+\\xD2E1\x9D5B\
+\\xD2E2\x9D5C\
+\\xD2E3\x9D5D\
+\\xD2E4\x9D5E\
+\\xD2E5\x9D5F\
+\\xD2E6\x9D60\
+\\xD2E7\x9D61\
+\\xD2E8\x9D62\
+\\xD2E9\x9D63\
+\\xD2EA\x9D64\
+\\xD2EB\x9D65\
+\\xD2EC\x9D66\
+\\xD2ED\x9D67\
+\\xD2EE\x9D68\
+\\xD2EF\x9D69\
+\\xD2F0\x9D6A\
+\\xD2F1\x9D6B\
+\\xD2F2\x9D6C\
+\\xD2F3\x9D6D\
+\\xD2F4\x9D6E\
+\\xD2F5\x9D6F\
+\\xD2F6\x9D70\
+\\xD2F7\x9D71\
+\\xD2F8\x9D72\
+\\xD2F9\x9D73\
+\\xD2FA\x9D74\
+\\xD2FB\x9D75\
+\\xD2FC\x9D76\
+\\xD2FD\x9D77\
+\\xD341\x9D78\
+\\xD342\x9D79\
+\\xD343\x9D7A\
+\\xD344\x9D7B\
+\\xD345\x9D7C\
+\\xD346\x9D7D\
+\\xD347\x9D7E\
+\\xD348\x9DA1\
+\\xD349\x9DA2\
+\\xD34A\x9DA3\
+\\xD34B\x9DA4\
+\\xD34C\x9DA5\
+\\xD34D\x9DA6\
+\\xD34E\x9DA7\
+\\xD34F\x9DA8\
+\\xD350\x9DA9\
+\\xD351\x9DAA\
+\\xD352\x9DAB\
+\\xD353\x9DAC\
+\\xD354\x9DAD\
+\\xD355\x9DAE\
+\\xD356\x9DAF\
+\\xD357\x9DB0\
+\\xD358\x9DB1\
+\\xD359\x9DB2\
+\\xD35A\x9DB3\
+\\xD35B\x9DB4\
+\\xD35C\x9DB5\
+\\xD35D\x9DB6\
+\\xD35E\x9DB7\
+\\xD35F\x9DB8\
+\\xD360\x9DB9\
+\\xD361\x9DBA\
+\\xD362\x9DBB\
+\\xD363\x9DBC\
+\\xD364\x9DBD\
+\\xD365\x9DBE\
+\\xD366\x9DBF\
+\\xD367\x9DC0\
+\\xD368\x9DC1\
+\\xD369\x9DC2\
+\\xD36A\x9DC3\
+\\xD36B\x9DC4\
+\\xD36C\x9DC5\
+\\xD36D\x9DC6\
+\\xD36E\x9DC7\
+\\xD36F\x9DC8\
+\\xD370\x9DC9\
+\\xD371\x9DCA\
+\\xD372\x9DCB\
+\\xD373\x9DCC\
+\\xD374\x9DCD\
+\\xD375\x9DCE\
+\\xD376\x9DCF\
+\\xD377\x9DD0\
+\\xD378\x9DD1\
+\\xD379\x9DD2\
+\\xD37A\x9DD3\
+\\xD37B\x9DD4\
+\\xD37C\x9DD5\
+\\xD37D\x9DD6\
+\\xD37E\x9DD7\
+\\xD37F\x9DD8\
+\\xD381\x9DD9\
+\\xD382\x9DDA\
+\\xD383\x9DDB\
+\\xD384\x9DDC\
+\\xD385\x9DDD\
+\\xD386\x9DDE\
+\\xD387\x9DDF\
+\\xD388\x9DE0\
+\\xD389\x9DE1\
+\\xD38A\x9DE2\
+\\xD38B\x9DE3\
+\\xD38C\x9DE4\
+\\xD38D\x9DE5\
+\\xD38E\x9DE6\
+\\xD38F\x9DE7\
+\\xD390\x9DE8\
+\\xD391\x9DE9\
+\\xD392\x9DEA\
+\\xD393\x9DEB\
+\\xD394\x9DEC\
+\\xD395\x9DED\
+\\xD396\x9DEE\
+\\xD397\x9DEF\
+\\xD398\x9DF0\
+\\xD399\x9DF1\
+\\xD39A\x9DF2\
+\\xD39B\x9DF3\
+\\xD39C\x9DF4\
+\\xD39D\x9DF5\
+\\xD39E\x9DF6\
+\\xD39F\x9DF7\
+\\xD3A0\x9DF8\
+\\xD3A1\x9DF9\
+\\xD3A2\x9DFA\
+\\xD3A3\x9DFB\
+\\xD3A4\x9DFC\
+\\xD3A5\x9DFD\
+\\xD3A6\x9DFE\
+\\xD3A7\x9E40\
+\\xD3A8\x9E41\
+\\xD3A9\x9E42\
+\\xD3AA\x9E43\
+\\xD3AB\x9E44\
+\\xD3AC\x9E45\
+\\xD3AD\x9E46\
+\\xD3AE\x9E47\
+\\xD3AF\x9E48\
+\\xD3B0\x9E49\
+\\xD3B1\x9E4A\
+\\xD3B2\x9E4B\
+\\xD3B3\x9E4C\
+\\xD3B4\x9E4D\
+\\xD3B5\x9E4E\
+\\xD3B6\x9E4F\
+\\xD3B7\x9E50\
+\\xD3B8\x9E51\
+\\xD3B9\x9E52\
+\\xD3BA\x9E53\
+\\xD3BB\x9E54\
+\\xD3BC\x9E55\
+\\xD3BD\x9E56\
+\\xD3BE\x9E57\
+\\xD3BF\x9E58\
+\\xD3C0\x9E59\
+\\xD3C1\x9E5A\
+\\xD3C2\x9E5B\
+\\xD3C3\x9E5C\
+\\xD3C4\x9E5D\
+\\xD3C5\x9E5E\
+\\xD3C6\x9E5F\
+\\xD3C7\x9E60\
+\\xD3C8\x9E61\
+\\xD3C9\x9E62\
+\\xD3CA\x9E63\
+\\xD3CB\x9E64\
+\\xD3CC\x9E65\
+\\xD3CD\x9E66\
+\\xD3CE\x9E67\
+\\xD3CF\x9E68\
+\\xD3D0\x9E69\
+\\xD3D1\x9E6A\
+\\xD3D2\x9E6B\
+\\xD3D3\x9E6C\
+\\xD3D4\x9E6D\
+\\xD3D5\x9E6E\
+\\xD3D6\x9E6F\
+\\xD3D7\x9E70\
+\\xD3D8\x9E71\
+\\xD3D9\x9E72\
+\\xD3DA\x9E73\
+\\xD3DB\x9E74\
+\\xD3DC\x9E75\
+\\xD3DD\x9E76\
+\\xD3DE\x9E77\
+\\xD3DF\x9E78\
+\\xD3E0\x9E79\
+\\xD3E1\x9E7A\
+\\xD3E2\x9E7B\
+\\xD3E3\x9E7C\
+\\xD3E4\x9E7D\
+\\xD3E5\x9E7E\
+\\xD3E6\x9EA1\
+\\xD3E7\x9EA2\
+\\xD3E8\x9EA3\
+\\xD3E9\x9EA4\
+\\xD3EA\x9EA5\
+\\xD3EB\x9EA6\
+\\xD3EC\x9EA7\
+\\xD3ED\x9EA8\
+\\xD3EE\x9EA9\
+\\xD3EF\x9EAA\
+\\xD3F0\x9EAB\
+\\xD3F1\x9EAC\
+\\xD3F2\x9EAD\
+\\xD3F3\x9EAE\
+\\xD3F4\x9EAF\
+\\xD3F5\x9EB0\
+\\xD3F6\x9EB1\
+\\xD3F7\x9EB2\
+\\xD3F8\x9EB3\
+\\xD3F9\x9EB4\
+\\xD3FA\x9EB5\
+\\xD3FB\x9EB6\
+\\xD3FC\x9EB7\
+\\xD3FD\x9EB8\
+\\xD441\x9EB9\
+\\xD442\x9EBA\
+\\xD443\x9EBB\
+\\xD444\x9EBC\
+\\xD445\x9EBD\
+\\xD446\x9EBE\
+\\xD447\x9EBF\
+\\xD448\x9EC0\
+\\xD449\x9EC1\
+\\xD44A\x9EC2\
+\\xD44B\x9EC3\
+\\xD44C\x9EC4\
+\\xD44D\x9EC5\
+\\xD44E\x9EC6\
+\\xD44F\x9EC7\
+\\xD450\x9EC8\
+\\xD451\x9EC9\
+\\xD452\x9ECA\
+\\xD453\x9ECB\
+\\xD454\x9ECC\
+\\xD455\x9ECD\
+\\xD456\x9ECE\
+\\xD457\x9ECF\
+\\xD458\x9ED0\
+\\xD459\x9ED1\
+\\xD45A\x9ED2\
+\\xD45B\x9ED3\
+\\xD45C\x9ED4\
+\\xD45D\x9ED5\
+\\xD45E\x9ED6\
+\\xD45F\x9ED7\
+\\xD460\x9ED8\
+\\xD461\x9ED9\
+\\xD462\x9EDA\
+\\xD463\x9EDB\
+\\xD464\x9EDC\
+\\xD465\x9EDD\
+\\xD466\x9EDE\
+\\xD467\x9EDF\
+\\xD468\x9EE0\
+\\xD469\x9EE1\
+\\xD46A\x9EE2\
+\\xD46B\x9EE3\
+\\xD46C\x9EE4\
+\\xD46D\x9EE5\
+\\xD46E\x9EE6\
+\\xD46F\x9EE7\
+\\xD470\x9EE8\
+\\xD471\x9EE9\
+\\xD472\x9EEA\
+\\xD473\x9EEB\
+\\xD474\x9EEC\
+\\xD475\x9EED\
+\\xD476\x9EEE\
+\\xD477\x9EEF\
+\\xD478\x9EF0\
+\\xD479\x9EF1\
+\\xD47A\x9EF2\
+\\xD47B\x9EF3\
+\\xD47C\x9EF4\
+\\xD47D\x9EF5\
+\\xD47E\x9EF6\
+\\xD47F\x9EF7\
+\\xD481\x9EF8\
+\\xD482\x9EF9\
+\\xD483\x9EFA\
+\\xD484\x9EFB\
+\\xD485\x9EFC\
+\\xD486\x9EFD\
+\\xD487\x9EFE\
+\\xD488\x9F40\
+\\xD489\x9F41\
+\\xD48A\x9F42\
+\\xD48B\x9F43\
+\\xD48C\x9F44\
+\\xD48D\x9F45\
+\\xD48E\x9F46\
+\\xD48F\x9F47\
+\\xD490\x9F48\
+\\xD491\x9F49\
+\\xD492\x9F4A\
+\\xD493\x9F4B\
+\\xD494\x9F4C\
+\\xD495\x9F4D\
+\\xD496\x9F4E\
+\\xD497\x9F4F\
+\\xD498\x9F50\
+\\xD499\x9F51\
+\\xD49A\x9F52\
+\\xD49B\x9F53\
+\\xD49C\x9F54\
+\\xD49D\x9F55\
+\\xD49E\x9F56\
+\\xD49F\x9F57\
+\\xD4A0\x9F58\
+\\xD4A1\x9F59\
+\\xD4A2\x9F5A\
+\\xD4A3\x9F5B\
+\\xD4A4\x9F5C\
+\\xD4A5\x9F5D\
+\\xD4A6\x9F5E\
+\\xD4A7\x9F5F\
+\\xD4A8\x9F60\
+\\xD4A9\x9F61\
+\\xD4AA\x9F62\
+\\xD4AB\x9F63\
+\\xD4AC\x9F64\
+\\xD4AD\x9F65\
+\\xD4AE\x9F66\
+\\xD4AF\x9F67\
+\\xD4B0\x9F68\
+\\xD4B1\x9F69\
+\\xD4B2\x9F6A\
+\\xD4B3\x9F6B\
+\\xD4B4\x9F6C\
+\\xD4B5\x9F6D\
+\\xD4B6\x9F6E\
+\\xD4B7\x9F6F\
+\\xD4B8\x9F70\
+\\xD4B9\x9F71\
+\\xD4BA\x9F72\
+\\xD4BB\x9F73\
+\\xD4BC\x9F74\
+\\xD4BD\x9F75\
+\\xD4BE\x9F76\
+\\xD4BF\x9F77\
+\\xD4C0\x9F78\
+\\xD4C1\x9F79\
+\\xD4C2\x9F7A\
+\\xD4C3\x9F7B\
+\\xD4C4\x9F7C\
+\\xD4C5\x9F7D\
+\\xD4C6\x9F7E\
+\\xD4C7\x9FA1\
+\\xD4C8\x9FA2\
+\\xD4C9\x9FA3\
+\\xD4CA\x9FA4\
+\\xD4CB\x9FA5\
+\\xD4CC\x9FA6\
+\\xD4CD\x9FA7\
+\\xD4CE\x9FA8\
+\\xD4CF\x9FA9\
+\\xD4D0\x9FAA\
+\\xD4D1\x9FAB\
+\\xD4D2\x9FAC\
+\\xD4D3\x9FAD\
+\\xD4D4\x9FAE\
+\\xD4D5\x9FAF\
+\\xD4D6\x9FB0\
+\\xD4D7\x9FB1\
+\\xD4D8\x9FB2\
+\\xD4D9\x9FB3\
+\\xD4DA\x9FB4\
+\\xD4DB\x9FB5\
+\\xD4DC\x9FB6\
+\\xD4DD\x9FB7\
+\\xD4DE\x9FB8\
+\\xD4DF\x9FB9\
+\\xD4E0\x9FBA\
+\\xD4E1\x9FBB\
+\\xD4E2\x9FBC\
+\\xD4E3\x9FBD\
+\\xD4E4\x9FBE\
+\\xD4E5\x9FBF\
+\\xD4E6\x9FC0\
+\\xD4E7\x9FC1\
+\\xD4E8\x9FC2\
+\\xD4E9\x9FC3\
+\\xD4EA\x9FC4\
+\\xD4EB\x9FC5\
+\\xD4EC\x9FC6\
+\\xD4ED\x9FC7\
+\\xD4EE\x9FC8\
+\\xD4EF\x9FC9\
+\\xD4F0\x9FCA\
+\\xD4F1\x9FCB\
+\\xD4F2\x9FCC\
+\\xD4F3\x9FCD\
+\\xD4F4\x9FCE\
+\\xD4F5\x9FCF\
+\\xD4F6\x9FD0\
+\\xD4F7\x9FD1\
+\\xD4F8\x9FD2\
+\\xD4F9\x9FD3\
+\\xD4FA\x9FD4\
+\\xD4FB\x9FD5\
+\\xD4FC\x9FD6\
+\\xD4FD\x9FD7\
+\\xD541\x9FD8\
+\\xD542\x9FD9\
+\\xD543\x9FDA\
+\\xD544\x9FDB\
+\\xD545\x9FDC\
+\\xD546\x9FDD\
+\\xD547\x9FDE\
+\\xD548\x9FDF\
+\\xD549\x9FE0\
+\\xD54A\x9FE1\
+\\xD54B\x9FE2\
+\\xD54C\x9FE3\
+\\xD54D\x9FE4\
+\\xD54E\x9FE5\
+\\xD54F\x9FE6\
+\\xD550\x9FE7\
+\\xD551\x9FE8\
+\\xD552\x9FE9\
+\\xD553\x9FEA\
+\\xD554\x9FEB\
+\\xD555\x9FEC\
+\\xD556\x9FED\
+\\xD557\x9FEE\
+\\xD558\x9FEF\
+\\xD559\x9FF0\
+\\xD55A\x9FF1\
+\\xD55B\x9FF2\
+\\xD55C\x9FF3\
+\\xD55D\x9FF4\
+\\xD55E\x9FF5\
+\\xD55F\x9FF6\
+\\xD560\x9FF7\
+\\xD561\x9FF8\
+\\xD562\x9FF9\
+\\xD563\x9FFA\
+\\xD564\x9FFB\
+\\xD565\x9FFC\
+\\xD566\x9FFD\
+\\xD567\x9FFE\
+\\xD568\xA040\
+\\xD569\xA041\
+\\xD56A\xA042\
+\\xD56B\xA043\
+\\xD56C\xA044\
+\\xD56D\xA045\
+\\xD56E\xA046\
+\\xD56F\xA047\
+\\xD570\xA048\
+\\xD571\xA049\
+\\xD572\xA04A\
+\\xD573\xA04B\
+\\xD574\xA04C\
+\\xD575\xA04D\
+\\xD576\xA04E\
+\\xD577\xA04F\
+\\xD578\xA050\
+\\xD579\xA051\
+\\xD57A\xA052\
+\\xD57B\xA053\
+\\xD57C\xA054\
+\\xD57D\xA055\
+\\xD57E\xA056\
+\\xD57F\xA057\
+\\xD581\xA058\
+\\xD582\xA059\
+\\xD583\xA05A\
+\\xD584\xA05B\
+\\xD585\xA05C\
+\\xD586\xA05D\
+\\xD587\xA05E\
+\\xD588\xA05F\
+\\xD589\xA060\
+\\xD58A\xA061\
+\\xD58B\xA062\
+\\xD58C\xA063\
+\\xD58D\xA064\
+\\xD58E\xA065\
+\\xD58F\xA066\
+\\xD590\xA067\
+\\xD591\xA068\
+\\xD592\xA069\
+\\xD593\xA06A\
+\\xD594\xA06B\
+\\xD595\xA06C\
+\\xD596\xA06D\
+\\xD597\xA06E\
+\\xD598\xA06F\
+\\xD599\xA070\
+\\xD59A\xA071\
+\\xD59B\xA072\
+\\xD59C\xA073\
+\\xD59D\xA074\
+\\xD59E\xA075\
+\\xD59F\xA076\
+\\xD5A0\xA077\
+\\xD5A1\xA078\
+\\xD5A2\xA079\
+\\xD5A3\xA07A\
+\\xD5A4\xA07B\
+\\xD5A5\xA07C\
+\\xD5A6\xA07D\
+\\xD5A7\xA07E\
+\\xD5A8\xA0A1\
+\\xD5A9\xA0A2\
+\\xD5AA\xA0A3\
+\\xD5AB\xA0A4\
+\\xD5AC\xA0A5\
+\\xD5AD\xA0A6\
+\\xD5AE\xA0A7\
+\\xD5AF\xA0A8\
+\\xD5B0\xA0A9\
+\\xD5B1\xA0AA\
+\\xD5B2\xA0AB\
+\\xD5B3\xA0AC\
+\\xD5B4\xA0AD\
+\\xD5B5\xA0AE\
+\\xD5B6\xA0AF\
+\\xD5B7\xA0B0\
+\\xD5B8\xA0B1\
+\\xD5B9\xA0B2\
+\\xD5BA\xA0B3\
+\\xD5BB\xA0B4\
+\\xD5BC\xA0B5\
+\\xD5BD\xA0B6\
+\\xD5BE\xA0B7\
+\\xD5BF\xA0B8\
+\\xD5C0\xA0B9\
+\\xD5C1\xA0BA\
+\\xD5C2\xA0BB\
+\\xD5C3\xA0BC\
+\\xD5C4\xA0BD\
+\\xD5C5\xA0BE\
+\\xD5C6\xA0BF\
+\\xD5C7\xA0C0\
+\\xD5C8\xA0C1\
+\\xD5C9\xA0C2\
+\\xD5CA\xA0C3\
+\\xD5CB\xA0C4\
+\\xD5CC\xA0C5\
+\\xD5CD\xA0C6\
+\\xD5CE\xA0C7\
+\\xD5CF\xA0C8\
+\\xD5D0\xA0C9\
+\\xD5D1\xA0CA\
+\\xD5D2\xA0CB\
+\\xD5D3\xA0CC\
+\\xD5D4\xA0CD\
+\\xD5D5\xA0CE\
+\\xD5D6\xA0CF\
+\\xD5D7\xA0D0\
+\\xD5D8\xA0D1\
+\\xD5D9\xA0D2\
+\\xD5DA\xA0D3\
+\\xD5DB\xA0D4\
+\\xD5DC\xA0D5\
+\\xD5DD\xA0D6\
+\\xD5DE\xA0D7\
+\\xD5DF\xA0D8\
+\\xD5E0\xA0D9\
+\\xD5E1\xA0DA\
+\\xD5E2\xA0DB\
+\\xD5E3\xA0DC\
+\\xD5E4\xA0DD\
+\\xD5E5\xA0DE\
+\\xD5E6\xA0DF\
+\\xD5E7\xA0E0\
+\\xD5E8\xA0E1\
+\\xD5E9\xA0E2\
+\\xD5EA\xA0E3\
+\\xD5EB\xA0E4\
+\\xD5EC\xA0E5\
+\\xD5ED\xA0E6\
+\\xD5EE\xA0E7\
+\\xD5EF\xA0E8\
+\\xD5F0\xA0E9\
+\\xD5F1\xA0EA\
+\\xD5F2\xA0EB\
+\\xD5F3\xA0EC\
+\\xD5F4\xA0ED\
+\\xD5F5\xA0EE\
+\\xD5F6\xA0EF\
+\\xD5F7\xA0F0\
+\\xD5F8\xA0F1\
+\\xD5F9\xA0F2\
+\\xD5FA\xA0F3\
+\\xD5FB\xA0F4\
+\\xD5FC\xA0F5\
+\\xD5FD\xA0F6\
+\\xD641\xA0F7\
+\\xD642\xA0F8\
+\\xD643\xA0F9\
+\\xD644\xA0FA\
+\\xD645\xA0FB\
+\\xD646\xA0FC\
+\\xD647\xA0FD\
+\\xD648\xA0FE\
+\\xD649\x8140\
+\\xD64A\x8141\
+\\xD64B\x8142\
+\\xD64C\x8143\
+\\xD64D\x8144\
+\\xD64E\x8145\
+\\xD64F\x8146\
+\\xD650\x8147\
+\\xD651\x8148\
+\\xD652\x8149\
+\\xD653\x814A\
+\\xD654\x814B\
+\\xD655\x814C\
+\\xD656\x814D\
+\\xD657\x814E\
+\\xD658\x814F\
+\\xD659\x8150\
+\\xD65A\x8151\
+\\xD65B\x8152\
+\\xD65C\x8153\
+\\xD65D\x8154\
+\\xD65E\x8155\
+\\xD65F\x8156\
+\\xD660\x8157\
+\\xD661\x8158\
+\\xD662\x8159\
+\\xD663\x815A\
+\\xD664\x815B\
+\\xD665\x815C\
+\\xD666\x815D\
+\\xD667\x815E\
+\\xD668\x815F\
+\\xD669\x8160\
+\\xD66A\x8161\
+\\xD66B\x8162\
+\\xD66C\x8163\
+\\xD66D\x8164\
+\\xD66E\x8165\
+\\xD66F\x8166\
+\\xD670\x8167\
+\\xD671\x8168\
+\\xD672\x8169\
+\\xD673\x816A\
+\\xD674\x816B\
+\\xD675\x816C\
+\\xD676\x816D\
+\\xD677\x816E\
+\\xD678\x816F\
+\\xD679\x8170\
+\\xD67A\x8171\
+\\xD67B\x8172\
+\\xD67C\x8173\
+\\xD67D\x8174\
+\\xD67E\x8175\
+\\xD67F\x8176\
+\\xD681\x8177\
+\\xD682\x8178\
+\\xD683\x8179\
+\\xD684\x817A\
+\\xD685\x817B\
+\\xD686\x817C\
+\\xD687\x817D\
+\\xD688\x817E\
+\\xD689\x81A1\
+\\xD68A\x81A2\
+\\xD68B\x81A3\
+\\xD68C\x81A4\
+\\xD68D\x81A5\
+\\xD68E\x81A6\
+\\xD68F\x81A7\
+\\xD690\x81A8\
+\\xD691\x81A9\
+\\xD692\x81AA\
+\\xD693\x81AB\
+\\xD694\x81AC\
+\\xD695\x81AD\
+\\xD696\x81AE\
+\\xD697\x81AF\
+\\xD698\x81B0\
+\\xD699\x81B1\
+\\xD69A\x81B2\
+\\xD69B\x81B3\
+\\xD69C\x81B4\
+\\xD69D\x81B5\
+\\xD69E\x81B6\
+\\xD69F\x81B7\
+\\xD6A0\x81B8\
+\\xD6A1\x81B9\
+\\xD6A2\x81BA\
+\\xD6A3\x81BB\
+\\xD6A4\x81BC\
+\\xD6A5\x81BD\
+\\xD6A6\x81BE\
+\\xD6A7\x81BF\
+\\xD6A8\x81C0\
+\\xD6A9\x81C1\
+\\xD6AA\x81C2\
+\\xD6AB\x81C3\
+\\xD6AC\x81C4\
+\\xD6AD\x81C5\
+\\xD6AE\x81C6\
+\\xD6AF\x81C7\
+\\xD6B0\x81C8\
+\\xD6B1\x81C9\
+\\xD6B2\x81CA\
+\\xD6B3\x81CB\
+\\xD6B4\x81CC\
+\\xD6B5\x81CD\
+\\xD6B6\x81CE\
+\\xD6B7\x81CF\
+\\xD6B8\x81D0\
+\\xD6B9\x81D1\
+\\xD6BA\x81D2\
+\\xD6BB\x81D3\
+\\xD6BC\x81D4\
+\\xD6BD\x81D5\
+\\xD6BE\x81D6\
+\\xD6BF\x81D7\
+\\xD6C0\x81D8\
+\\xD6C1\x81D9\
+\\xD6C2\x81DA\
+\\xD6C3\x81DB\
+\\xD6C4\x81DC\
+\\xD6C5\x81DD\
+\\xD6C6\x81DE\
+\\xD6C7\x81DF\
+\\xD6C8\x81E0\
+\\xD6C9\x81E1\
+\\xD6CA\x81E2\
+\\xD6CB\x81E3\
+\\xD6CC\x81E4\
+\\xD6CD\x81E5\
+\\xD6CE\x81E6\
+\\xD6CF\x81E7\
+\\xD6D0\x81E8\
+\\xD6D1\x81E9\
+\\xD6D2\x81EA\
+\\xD6D3\x81EB\
+\\xD6D4\x81EC\
+\\xD6D5\x81ED\
+\\xD6D6\x81EE\
+\\xD6D7\x81EF\
+\\xD6D8\x81F0\
+\\xD6D9\x81F1\
+\\xD6DA\x81F2\
+\\xD6DB\x81F3\
+\\xD6DC\x81F4\
+\\xD6DD\x81F5\
+\\xD6DE\x81F6\
+\\xD6DF\x81F7\
+\\xD6E0\x81F8\
+\\xD6E1\x81F9\
+\\xD6E2\x81FA\
+\\xD6E3\x81FB\
+\\xD6E4\x81FC\
+\\xD6E5\x81FD\
+\\xD6E6\x81FE\
+\\xD6E7\x8240\
+\\xD6E8\x8241\
+\\xD6E9\x8242\
+\\xD6EA\x8243\
+\\xD6EB\x8244\
+\\xD6EC\x8245\
+\\xD6ED\x8246\
+\\xD6EE\x8247\
+\\xD6EF\x8248\
+\\xD6F0\x8249\
+\\xD6F1\x824A\
+\\xD6F2\x824B\
+\\xD6F3\x824C\
+\\xD6F4\x824D\
+\\xD6F5\x824E\
+\\xD6F6\x824F\
+\\xD6F7\x8250\
+\\xD6F8\x8251\
+\\xD6F9\x8252\
+\\xD6FA\x8253\
+\\xD6FB\x8254\
+\\xD6FC\x8255\
+\\xD6FD\x8256\
+\\xD741\x8257\
+\\xD742\x8258\
+\\xD743\x8259\
+\\xD744\x825A\
+\\xD745\x825B\
+\\xD746\x825C\
+\\xD747\x825D\
+\\xD748\x825E\
+\\xD749\x825F\
+\\xD74A\x8260\
+\\xD74B\x8261\
+\\xD74C\x8262\
+\\xD74D\x8263\
+\\xD74E\x8264\
+\\xD74F\x8265\
+\\xD750\x8266\
+\\xD751\x8267\
+\\xD752\x8268\
+\\xD753\x8269\
+\\xD754\x826A\
+\\xD755\x826B\
+\\xD756\x826C\
+\\xD757\x826D\
+\\xD758\x826E\
+\\xD759\x826F\
+\\xD75A\x8270\
+\\xD75B\x8271\
+\\xD75C\x8272\
+\\xD75D\x8273\
+\\xD75E\x8274\
+\\xD75F\x8275\
+\\xD760\x8276\
+\\xD761\x8277\
+\\xD762\x8278\
+\\xD763\x8279\
+\\xD764\x827A\
+\\xD765\x827B\
+\\xD766\x827C\
+\\xD767\x827D\
+\\xD768\x827E\
+\\xD769\x82A1\
+\\xD76A\x82A2\
+\\xD76B\x82A3\
+\\xD76C\x82A4\
+\\xD76D\x82A5\
+\\xD76E\x82A6\
+\\xD76F\x82A7\
+\\xD770\x82A8\
+\\xD771\x82A9\
+\\xD772\x82AA\
+\\xD773\x82AB\
+\\xD774\x82AC\
+\\xD775\x82AD\
+\\xD776\x82AE\
+\\xD777\x82AF\
+\\xD778\x82B0\
+\\xD779\x82B1\
+\\xD77A\x82B2\
+\\xD77B\x82B3\
+\\xD77C\x82B4\
+\\xD77D\x82B5\
+\\xD77E\x82B6\
+\\xD77F\x82B7\
+\\xD781\x82B8\
+\\xD782\x82B9\
+\\xD783\x82BA\
+\\xD784\x82BB\
+\\xD785\x82BC\
+\\xD786\x82BD\
+\\xD787\x82BE\
+\\xD788\x82BF\
+\\xD789\x82C0\
+\\xD78A\x82C1\
+\\xD78B\x82C2\
+\\xD78C\x82C3\
+\\xD78D\x82C4\
+\\xD78E\x82C5\
+\\xD78F\x82C6\
+\\xD790\x82C7\
+\\xD791\x82C8\
+\\xD792\x82C9\
+\\xD793\x82CA\
+\\xD794\x82CB\
+\\xD795\x82CC\
+\\xD796\x82CD\
+\\xD797\x82CE\
+\\xD798\x82CF\
+\\xD799\x82D0\
+\\xD79A\x82D1\
+\\xD79B\x82D2\
+\\xD79C\x82D3\
+\\xD79D\x82D4\
+\\xD79E\x82D5\
+\\xD79F\x82D6\
+\\xD7A0\x82D7\
+\\xD7A1\x82D8\
+\\xD7A2\x82D9\
+\\xD7A3\x82DA\
+\\xD7A4\x82DB\
+\\xD7A5\x82DC\
+\\xD7A6\x82DD\
+\\xD7A7\x82DE\
+\\xD7A8\x82DF\
+\\xD7A9\x82E0\
+\\xD7AA\x82E1\
+\\xD7AB\x82E2\
+\\xD7AC\x82E3\
+\\xD7AD\x82E4\
+\\xD7AE\x82E5\
+\\xD7AF\x82E6\
+\\xD7B0\x82E7\
+\\xD7B1\x82E8\
+\\xD7B2\x82E9\
+\\xD7B3\x82EA\
+\\xD7B4\x82EB\
+\\xD7B5\x82EC\
+\\xD7B6\x82ED\
+\\xD7B7\x82EE\
+\\xD7B8\x82EF\
+\\xD7B9\x82F0\
+\\xD7BA\x82F1\
+\\xD7BB\x82F2\
+\\xD7BC\x82F3\
+\\xD7BD\x82F4\
+\\xD7BE\x82F5\
+\\xD7BF\x82F6\
+\\xD7C0\x82F7\
+\\xD7C1\x82F8\
+\\xD7C2\x82F9\
+\\xD7C3\x82FA\
+\\xD7C4\x82FB\
+\\xD7C5\x82FC\
+\\xD7C6\x82FD\
+\\xD7C7\x82FE\
+\\xD7C8\x8340\
+\\xD7C9\x8341\
+\\xD7CA\x8342\
+\\xD7CB\x8343\
+\\xD7CC\x8344\
+\\xD7CD\x8345\
+\\xD7CE\x8346\
+\\xD7CF\x8347\
+\\xD7D0\x8348\
+\\xD7D1\x8349\
+\\xD7D2\x834A\
+\\xD7D3\x834B\
+\\xD7D4\x834C\
+\\xD7D5\x834D\
+\\xD7D6\x834E\
+\\xD7D7\x834F\
+\\xD7D8\x8350\
+\\xD7D9\x8351\
+\\xD7DA\x8352\
+\\xD7DB\x8353\
+\\xD7DC\x8354\
+\\xD7DD\x8355\
+\\xD7DE\x8356\
+\\xD7DF\x8357\
+\\xD7E0\x8358\
+\\xD7E1\x8359\
+\\xD7E2\x835A\
+\\xD7E3\x835B\
+\\xD7E4\x835C\
+\\xD7E5\x835D\
+\\xD7E6\x835E\
+\\xD7E7\x835F\
+\\xD7E8\x8360\
+\\xD7E9\x8361\
+\\xD7EA\x8362\
+\\xD7EB\x8363\
+\\xD7EC\x8364\
+\\xD7ED\x8365\
+\\xD7EE\x8366\
+\\xD7EF\x8367\
+\\xD7F0\x8368\
+\\xD7F1\x8369\
+\\xD7F2\x836A\
+\\xD7F3\x836B\
+\\xD7F4\x836C\
+\\xD7F5\x836D\
+\\xD7F6\x836E\
+\\xD7F7\x836F\
+\\xD7F8\x8370\
+\\xD7F9\x8371\
+\\xD7FA\x8372\
+\\xD7FB\x8373\
+\\xD7FC\x8374\
+\\xD7FD\x8375\
+\\xD841\x8376\
+\\xD842\x8377\
+\\xD843\x8378\
+\\xD844\x8379\
+\\xD845\x837A\
+\\xD846\x837B\
+\\xD847\x837C\
+\\xD848\x837D\
+\\xD849\x837E\
+\\xD84A\x83A1\
+\\xD84B\x83A2\
+\\xD84C\x83A3\
+\\xD84D\x83A4\
+\\xD84E\x83A5\
+\\xD84F\x83A6\
+\\xD850\x83A7\
+\\xD851\x83A8\
+\\xD852\x83A9\
+\\xD853\x83AA\
+\\xD854\x83AB\
+\\xD855\x83AC\
+\\xD856\x83AD\
+\\xD857\x83AE\
+\\xD858\x83AF\
+\\xD859\x83B0\
+\\xD85A\x83B1\
+\\xD85B\x83B2\
+\\xD85C\x83B3\
+\\xD85D\x83B4\
+\\xD85E\x83B5\
+\\xD85F\x83B6\
+\\xD860\x83B7\
+\\xD861\x83B8\
+\\xD862\x83B9\
+\\xD863\x83BA\
+\\xD864\x83BB\
+\\xD865\x83BC\
+\\xD866\x83BD\
+\\xD867\x83BE\
+\\xD868\x83BF\
+\\xD869\x83C0\
+\\xD86A\x83C1\
+\\xD86B\x83C2\
+\\xD86C\x83C3\
+\\xD86D\x83C4\
+\\xD86E\x83C5\
+\\xD86F\x83C6\
+\\xD870\x83C7\
+\\xD871\x83C8\
+\\xD872\x83C9\
+\\xD873\x83CA\
+\\xD874\x83CB\
+\\xD875\x83CC\
+\\xD876\x83CD\
+\\xD877\x83CE\
+\\xD878\x83CF\
+\\xD879\x83D0\
+\\xD87A\x83D1\
+\\xD87B\x83D2\
+\\xD87C\x83D3\
+\\xD87D\x83D4\
+\\xD87E\x83D5\
+\\xD87F\x83D6\
+\\xD881\x83D7\
+\\xD882\x83D8\
+\\xD883\x83D9\
+\\xD884\x83DA\
+\\xD885\x83DB\
+\\xD886\x83DC\
+\\xD887\x83DD\
+\\xD888\x83DE\
+\\xD889\x83DF\
+\\xD88A\x83E0\
+\\xD88B\x83E1\
+\\xD88C\x83E2\
+\\xD88D\x83E3\
+\\xD88E\x83E4\
+\\xD88F\x83E5\
+\\xD890\x83E6\
+\\xD891\x83E7\
+\\xD892\x83E8\
+\\xD893\x83E9\
+\\xD894\x83EA\
+\\xD895\x83EB\
+\\xD896\x83EC\
+\\xD897\x83ED\
+\\xD898\x83EE\
+\\xD899\x83EF\
+\\xD89A\x83F0\
+\\xD89B\x83F1\
+\\xD89C\x83F2\
+\\xD89D\x83F3\
+\\xD89E\x83F4\
+\\xD89F\x83F5\
+\\xD8A0\x83F6\
+\\xD8A1\x83F7\
+\\xD8A2\x83F8\
+\\xD8A3\x83F9\
+\\xD8A4\x83FA\
+\\xD8A5\x83FB\
+\\xD8A6\x83FC\
+\\xD8A7\x83FD\
+\\xD8A8\x83FE\
+\\xD8A9\x8440\
+\\xD8AA\x8441\
+\\xD8AB\x8442\
+\\xD8AC\x8443\
+\\xD8AD\x8444\
+\\xD8AE\x8445\
+\\xD8AF\x8446\
+\\xD8B0\x8447\
+\\xD8B1\x8448\
+\\xD8B2\x8449\
+\\xD8B3\x844A\
+\\xD8B4\x844B\
+\\xD8B5\x844C\
+\\xD8B6\x844D\
+\\xD8B7\x844E\
+\\xD8B8\x844F\
+\\xD8B9\x8450\
+\\xD8BA\x8451\
+\\xD8BB\x8452\
+\\xD8BC\x8453\
+\\xD8BD\x8454\
+\\xD8BE\x8455\
+\\xD8BF\x8456\
+\\xD8C0\x8457\
+\\xD8C1\x8458\
+\\xD8C2\x8459\
+\\xD8C3\x845A\
+\\xD8C4\x845B\
+\\xD8C5\x845C\
+\\xD8C6\x845D\
+\\xD8C7\x845E\
+\\xD8C8\x845F\
+\\xD8C9\x8460\
+\\xD8CA\x8461\
+\\xD8CB\x8462\
+\\xD8CC\x8463\
+\\xD8CD\x8464\
+\\xD8CE\x8465\
+\\xD8CF\x8466\
+\\xD8D0\x8467\
+\\xD8D1\x8468\
+\\xD8D2\x8469\
+\\xD8D3\x846A\
+\\xD8D4\x846B\
+\\xD8D5\x846C\
+\\xD8D6\x846D\
+\\xD8D7\x846E\
+\\xD8D8\x846F\
+\\xD8D9\x8470\
+\\xD8DA\x8471\
+\\xD8DB\x8472\
+\\xD8DC\x8473\
+\\xD8DD\x8474\
+\\xD8DE\x8475\
+\\xD8DF\x8476\
+\\xD8E0\x8477\
+\\xD8E1\x8478\
+\\xD8E2\x8479\
+\\xD8E3\x847A\
+\\xD8E4\x847B\
+\\xD8E5\x847C\
+\\xD8E6\x847D\
+\\xD8E7\x847E\
+\\xD8E8\x84A1\
+\\xD8E9\x84A2\
+\\xD8EA\x84A3\
+\\xD8EB\x84A4\
+\\xD8EC\x84A5\
+\\xD8ED\x84A6\
+\\xD8EE\x84A7\
+\\xD8EF\x84A8\
+\\xD8F0\x84A9\
+\\xD8F1\x84AA\
+\\xD8F2\x84AB\
+\\xD8F3\x84AC\
+\\xD8F4\x84AD\
+\\xD8F5\x84AE\
+\\xD8F6\x84AF\
+\\xD8F7\x84B0\
+\\xD8F8\x84B1\
+\\xD8F9\x84B2\
+\\xD8FA\x84B3\
+\\xD8FB\x84B4\
+\\xD8FC\x84B5\
+\\xD8FD\x84B6\
+\\xD941\x84B7\
+\\xD942\x84B8\
+\\xD943\x84B9\
+\\xD944\x84BA\
+\\xD945\x84BB\
+\\xD946\x84BC\
+\\xD947\x84BD\
+\\xD948\x84BE\
+\\xD949\x84BF\
+\\xD94A\x84C0\
+\\xD94B\x84C1\
+\\xD94C\x84C2\
+\\xD94D\x84C3\
+\\xD94E\x84C4\
+\\xD94F\x84C5\
+\\xD950\x84C6\
+\\xD951\x84C7\
+\\xD952\x84C8\
+\\xD953\x84C9\
+\\xD954\x84CA\
+\\xD955\x84CB\
+\\xD956\x84CC\
+\\xD957\x84CD\
+\\xD958\x84CE\
+\\xD959\x84CF\
+\\xD95A\x84D0\
+\\xD95B\x84D1\
+\\xD95C\x84D2\
+\\xD95D\x84D3\
+\\xD95E\x84D4\
+\\xD95F\x84D5\
+\\xD960\x84D6\
+\\xD961\x84D7\
+\\xD962\x84D8\
+\\xD963\x84D9\
+\\xD964\x84DA\
+\\xD965\x84DB\
+\\xD966\x84DC\
+\\xD967\x84DD\
+\\xD968\x84DE\
+\\xD969\x84DF\
+\\xD96A\x84E0\
+\\xD96B\x84E1\
+\\xD96C\x84E2\
+\\xD96D\x84E3\
+\\xD96E\x84E4\
+\\xD96F\x84E5\
+\\xD970\x84E6\
+\\xD971\x84E7\
+\\xD972\x84E8\
+\\xD973\x84E9\
+\\xD974\x84EA\
+\\xD975\x84EB\
+\\xD976\x84EC\
+\\xD977\x84ED\
+\\xD978\x84EE\
+\\xD979\x84EF\
+\\xD97A\x84F0\
+\\xD97B\x84F1\
+\\xD97C\x84F2\
+\\xD97D\x84F3\
+\\xD97E\x84F4\
+\\xD97F\x84F5\
+\\xD981\x84F6\
+\\xD982\x84F7\
+\\xD983\x84F8\
+\\xD984\x84F9\
+\\xD985\x84FA\
+\\xD986\x84FB\
+\\xD987\x84FC\
+\\xD988\x84FD\
+\\xD989\x84FE\
+\\xD98A\x8540\
+\\xD98B\x8541\
+\\xD98C\x8542\
+\\xD98D\x8543\
+\\xD98E\x8544\
+\\xD98F\x8545\
+\\xD990\x8546\
+\\xD991\x8547\
+\\xD992\x8548\
+\\xD993\x8549\
+\\xD994\x854A\
+\\xD995\x854B\
+\\xD996\x854C\
+\\xD997\x854D\
+\\xD998\x854E\
+\\xD999\x854F\
+\\xD99A\x8550\
+\\xD99B\x8551\
+\\xD99C\x8552\
+\\xD99D\x8553\
+\\xD99E\x8554\
+\\xD99F\x8555\
+\\xD9A0\x8556\
+\\xD9A1\x8557\
+\\xD9A2\x8558\
+\\xD9A3\x8559\
+\\xD9A4\x855A\
+\\xD9A5\x855B\
+\\xD9A6\x855C\
+\\xD9A7\x855D\
+\\xD9A8\x855E\
+\\xD9A9\x855F\
+\\xD9AA\x8560\
+\\xD9AB\x8561\
+\\xD9AC\x8562\
+\\xD9AD\x8563\
+\\xD9AE\x8564\
+\\xD9AF\x8565\
+\\xD9B0\x8566\
+\\xD9B1\x8567\
+\\xD9B2\x8568\
+\\xD9B3\x8569\
+\\xD9B4\x856A\
+\\xD9B5\x856B\
+\\xD9B6\x856C\
+\\xD9B7\x856D\
+\\xD9B8\x856E\
+\\xD9B9\x856F\
+\\xD9BA\x8570\
+\\xD9BB\x8571\
+\\xD9BC\x8572\
+\\xD9BD\x8573\
+\\xD9BE\x8574\
+\\xD9BF\x8575\
+\\xD9C0\x8576\
+\\xD9C1\x8577\
+\\xD9C2\x8578\
+\\xD9C3\x8579\
+\\xD9C4\x857A\
+\\xD9C5\x857B\
+\\xD9C6\x857C\
+\\xD9C7\x857D\
+\\xD9C8\x857E\
+\\xD9C9\x85A1\
+\\xD9CA\x85A2\
+\\xD9CB\x85A3\
+\\xD9CC\x85A4\
+\\xD9CD\x85A5\
+\\xD9CE\x85A6\
+\\xD9CF\x85A7\
+\\xD9D0\x85A8\
+\\xD9D1\x85A9\
+\\xD9D2\x85AA\
+\\xD9D3\x85AB\
+\\xD9D4\x85AC\
+\\xD9D5\x85AD\
+\\xD9D6\x85AE\
+\\xD9D7\x85AF\
+\\xD9D8\x85B0\
+\\xD9D9\x85B1\
+\\xD9DA\x85B2\
+\\xD9DB\x85B3\
+\\xD9DC\x85B4\
+\\xD9DD\x85B5\
+\\xD9DE\x85B6\
+\\xD9DF\x85B7\
+\\xD9E0\x85B8\
+\\xD9E1\x85B9\
+\\xD9E2\x85BA\
+\\xD9E3\x85BB\
+\\xD9E4\x85BC\
+\\xD9E5\x85BD\
+\\xD9E6\x85BE\
+\\xD9E7\x85BF\
+\\xD9E8\x85C0\
+\\xD9E9\x85C1\
+\\xD9EA\x85C2\
+\\xD9EB\x85C3\
+\\xD9EC\x85C4\
+\\xD9ED\x85C5\
+\\xD9EE\x85C6\
+\\xD9EF\x85C7\
+\\xD9F0\x85C8\
+\\xD9F1\x85C9\
+\\xD9F2\x85CA\
+\\xD9F3\x85CB\
+\\xD9F4\x85CC\
+\\xD9F5\x85CD\
+\\xD9F6\x85CE\
+\\xD9F7\x85CF\
+\\xD9F8\x85D0\
+\\xD9F9\x85D1\
+\\xD9FA\x85D2\
+\\xD9FB\x85D3\
+\\xD9FC\x85D4\
+\\xD9FD\x85D5\
+\\xDA41\x85D6\
+\\xDA42\x85D7\
+\\xDA43\x85D8\
+\\xDA44\x85D9\
+\\xDA45\x85DA\
+\\xDA46\x85DB\
+\\xDA47\x85DC\
+\\xDA48\x85DD\
+\\xDA49\x85DE\
+\\xDA4A\x85DF\
+\\xDA4B\x85E0\
+\\xDA4C\x85E1\
+\\xDA4D\x85E2\
+\\xDA4E\x85E3\
+\\xDA4F\x85E4\
+\\xDA50\x85E5\
+\\xDA51\x85E6\
+\\xDA52\x85E7\
+\\xDA53\x85E8\
+\\xDA54\x85E9\
+\\xDA55\x85EA\
+\\xDA56\x85EB\
+\\xDA57\x85EC\
+\\xDA58\x85ED\
+\\xDA59\x85EE\
+\\xDA5A\x85EF\
+\\xDA5B\x85F0\
+\\xDA5C\x85F1\
+\\xDA5D\x85F2\
+\\xDA5E\x85F3\
+\\xDA5F\x85F4\
+\\xDA60\x85F5\
+\\xDA61\x85F6\
+\\xDA62\x85F7\
+\\xDA63\x85F8\
+\\xDA64\x85F9\
+\\xDA65\x85FA\
+\\xDA66\x85FB\
+\\xDA67\x85FC\
+\\xDA68\x85FD\
+\\xDA69\x85FE\
+\\xDA6A\x8640\
+\\xDA6B\x8641\
+\\xDA6C\x8642\
+\\xDA6D\x8643\
+\\xDA6E\x8644\
+\\xDA6F\x8645\
+\\xDA70\x8646\
+\\xDA71\x8647\
+\\xDA72\x8648\
+\\xDA73\x8649\
+\\xDA74\x864A\
+\\xDA75\x864B\
+\\xDA76\x864C\
+\\xDA77\x864D\
+\\xDA78\x864E\
+\\xDA79\x864F\
+\\xDA7A\x8650\
+\\xDA7B\x8651\
+\\xDA7C\x8652\
+\\xDA7D\x8653\
+\\xDA7E\x8654\
+\\xDA7F\x8655\
+\\xDA81\x8656\
+\\xDA82\x8657\
+\\xDA83\x8658\
+\\xDA84\x8659\
+\\xDA85\x865A\
+\\xDA86\x865B\
+\\xDA87\x865C\
+\\xDA88\x865D\
+\\xDA89\x865E\
+\\xDA8A\x865F\
+\\xDA8B\x8660\
+\\xDA8C\x8661\
+\\xDA8D\x8662\
+\\xDA8E\x8663\
+\\xDA8F\x8664\
+\\xDA90\x8665\
+\\xDA91\x8666\
+\\xDA92\x8667\
+\\xDA93\x8668\
+\\xDA94\x8669\
+\\xDA95\x866A\
+\\xDA96\x866B\
+\\xDA97\x866C\
+\\xDA98\x866D\
+\\xDA99\x866E\
+\\xDA9A\x866F\
+\\xDA9B\x8670\
+\\xDA9C\x8671\
+\\xDA9D\x8672\
+\\xDA9E\x8673\
+\\xDA9F\x8674\
+\\xDAA0\x8675\
+\\xDAA1\x8676\
+\\xDAA2\x8677\
+\\xDAA3\x8678\
+\\xDAA4\x8679\
+\\xDAA5\x867A\
+\\xDAA6\x867B\
+\\xDAA7\x867C\
+\\xDAA8\x867D\
+\\xDAA9\x867E\
+\\xDAAA\x86A1\
+\\xDAAB\x86A2\
+\\xDAAC\x86A3\
+\\xDAAD\x86A4\
+\\xDAAE\x86A5\
+\\xDAAF\x86A6\
+\\xDAB0\x86A7\
+\\xDAB1\x86A8\
+\\xDAB2\x86A9\
+\\xDAB3\x86AA\
+\\xDAB4\x86AB\
+\\xDAB5\x86AC\
+\\xDAB6\x86AD\
+\\xDAB7\x86AE\
+\\xDAB8\x86AF\
+\\xDAB9\x86B0\
+\\xDABA\x86B1\
+\\xDABB\x86B2\
+\\xDABC\x86B3\
+\\xDABD\x86B4\
+\\xDABE\x86B5\
+\\xDABF\x86B6\
+\\xDAC0\x86B7\
+\\xDAC1\x86B8\
+\\xDAC2\x86B9\
+\\xDAC3\x86BA\
+\\xDAC4\x86BB\
+\\xDAC5\x86BC\
+\\xDAC6\x86BD\
+\\xDAC7\x86BE\
+\\xDAC8\x86BF\
+\\xDAC9\x86C0\
+\\xDACA\x86C1\
+\\xDACB\x86C2\
+\\xDACC\x86C3\
+\\xDACD\x86C4\
+\\xDACE\x86C5\
+\\xDACF\x86C6\
+\\xDAD0\x86C7\
+\\xDAD1\x86C8\
+\\xDAD2\x86C9\
+\\xDAD3\x86CA\
+\\xDAD4\x86CB\
+\\xDAD5\x86CC\
+\\xDAD6\x86CD\
+\\xDAD7\x86CE\
+\\xDAD8\x86CF\
+\\xDAD9\x86D0\
+\\xDADA\x86D1\
+\\xDADB\x86D2\
+\\xDADC\x86D3\
+\\xDADD\x86D4\
+\\xDADE\x86D5\
+\\xDADF\x86D6\
+\\xDAE0\x86D7\
+\\xDAE1\x86D8\
+\\xDAE2\x86D9\
+\\xDAE3\x86DA\
+\\xDAE4\x86DB\
+\\xDAE5\x86DC\
+\\xDAE6\x86DD\
+\\xDAE7\x86DE\
+\\xDAE8\x86DF\
+\\xDAE9\x86E0\
+\\xDAEA\x86E1\
+\\xDAEB\x86E2\
+\\xDAEC\x86E3\
+\\xDAED\x86E4\
+\\xDAEE\x86E5\
+\\xDAEF\x86E6\
+\\xDAF0\x86E7\
+\\xDAF1\x86E8\
+\\xDAF2\x86E9\
+\\xDAF3\x86EA\
+\\xDAF4\x86EB\
+\\xDAF5\x86EC\
+\\xDAF6\x86ED\
+\\xDAF7\x86EE\
+\\xDAF8\x86EF\
+\\xDAF9\x86F0\
+\\xDAFA\x86F1\
+\\xDAFB\x86F2\
+\\xDAFC\x86F3\
+\\xDAFD\x86F4\
+\\xDB41\x86F5\
+\\xDB42\x86F6\
+\\xDB43\x86F7\
+\\xDB44\x86F8\
+\\xDB45\x86F9\
+\\xDB46\x86FA\
+\\xDB47\x86FB\
+\\xDB48\x86FC\
+\\xDB49\x86FD\
+\\xDB4A\x86FE\
+\\xDB4B\x8740\
+\\xDB4C\x8741\
+\\xDB4D\x8742\
+\\xDB4E\x8743\
+\\xDB4F\x8744\
+\\xDB50\x8745\
+\\xDB51\x8746\
+\\xDB52\x8747\
+\\xDB53\x8748\
+\\xDB54\x8749\
+\\xDB55\x874A\
+\\xDB56\x874B\
+\\xDB57\x874C\
+\\xDB58\x874D\
+\\xDB59\x874E\
+\\xDB5A\x874F\
+\\xDB5B\x8750\
+\\xDB5C\x8751\
+\\xDB5D\x8752\
+\\xDB5E\x8753\
+\\xDB5F\x8754\
+\\xDB60\x8755\
+\\xDB61\x8756\
+\\xDB62\x8757\
+\\xDB63\x8758\
+\\xDB64\x8759\
+\\xDB65\x875A\
+\\xDB66\x875B\
+\\xDB67\x875C\
+\\xDB68\x875D\
+\\xDB69\x875E\
+\\xDB6A\x875F\
+\\xDB6B\x8760\
+\\xDB6C\x8761\
+\\xDB6D\x8762\
+\\xDB6E\x8763\
+\\xDB6F\x8764\
+\\xDB70\x8765\
+\\xDB71\x8766\
+\\xDB72\x8767\
+\\xDB73\x8768\
+\\xDB74\x8769\
+\\xDB75\x876A\
+\\xDB76\x876B\
+\\xDB77\x876C\
+\\xDB78\x876D\
+\\xDB79\x876E\
+\\xDB7A\x876F\
+\\xDB7B\x8770\
+\\xDB7C\x8771\
+\\xDB7D\x8772\
+\\xDB7E\x8773\
+\\xDB7F\x8774\
+\\xDB81\x8775\
+\\xDB82\x8776\
+\\xDB83\x8777\
+\\xDB84\x8778\
+\\xDB85\x8779\
+\\xDB86\x877A\
+\\xDB87\x877B\
+\\xDB88\x877C\
+\\xDB89\x877D\
+\\xDB8A\x877E\
+\\xDB8B\x87A1\
+\\xDB8C\x87A2\
+\\xDB8D\x87A3\
+\\xDB8E\x87A4\
+\\xDB8F\x87A5\
+\\xDB90\x87A6\
+\\xDB91\x87A7\
+\\xDB92\x87A8\
+\\xDB93\x87A9\
+\\xDB94\x87AA\
+\\xDB95\x87AB\
+\\xDB96\x87AC\
+\\xDB97\x87AD\
+\\xDB98\x87AE\
+\\xDB99\x87AF\
+\\xDB9A\x87B0\
+\\xDB9B\x87B1\
+\\xDB9C\x87B2\
+\\xDB9D\x87B3\
+\\xDB9E\x87B4\
+\\xDB9F\x87B5\
+\\xDBA0\x87B6\
+\\xDBA1\x87B7\
+\\xDBA2\x87B8\
+\\xDBA3\x87B9\
+\\xDBA4\x87BA\
+\\xDBA5\x87BB\
+\\xDBA6\x87BC\
+\\xDBA7\x87BD\
+\\xDBA8\x87BE\
+\\xDBA9\x87BF\
+\\xDBAA\x87C0\
+\\xDBAB\x87C1\
+\\xDBAC\x87C2\
+\\xDBAD\x87C3\
+\\xDBAE\x87C4\
+\\xDBAF\x87C5\
+\\xDBB0\x87C6\
+\\xDBB1\x87C7\
+\\xDBB2\x87C8\
+\\xDBB3\x87C9\
+\\xDBB4\x87CA\
+\\xDBB5\x87CB\
+\\xDBB6\x87CC\
+\\xDBB7\x87CD\
+\\xDBB8\x87CE\
+\\xDBB9\x87CF\
+\\xDBBA\x87D0\
+\\xDBBB\x87D1\
+\\xDBBC\x87D2\
+\\xDBBD\x87D3\
+\\xDBBE\x87D4\
+\\xDBBF\x87D5\
+\\xDBC0\x87D6\
+\\xDBC1\x87D7\
+\\xDBC2\x87D8\
+\\xDBC3\x87D9\
+\\xDBC4\x87DA\
+\\xDBC5\x87DB\
+\\xDBC6\x87DC\
+\\xDBC7\x87DD\
+\\xDBC8\x87DE\
+\\xDBC9\x87DF\
+\\xDBCA\x87E0\
+\\xDBCB\x87E1\
+\\xDBCC\x87E2\
+\\xDBCD\x87E3\
+\\xDBCE\x87E4\
+\\xDBCF\x87E5\
+\\xDBD0\x87E6\
+\\xDBD1\x87E7\
+\\xDBD2\x87E8\
+\\xDBD3\x87E9\
+\\xDBD4\x87EA\
+\\xDBD5\x87EB\
+\\xDBD6\x87EC\
+\\xDBD7\x87ED\
+\\xDBD8\x87EE\
+\\xDBD9\x87EF\
+\\xDBDA\x87F0\
+\\xDBDB\x87F1\
+\\xDBDC\x87F2\
+\\xDBDD\x87F3\
+\\xDBDE\x87F4\
+\\xDBDF\x87F5\
+\\xDBE0\x87F6\
+\\xDBE1\x87F7\
+\\xDBE2\x87F8\
+\\xDBE3\x87F9\
+\\xDBE4\x87FA\
+\\xDBE5\x87FB\
+\\xDBE6\x87FC\
+\\xDBE7\x87FD\
+\\xDBE8\x87FE\
+\\xDBE9\x8840\
+\\xDBEA\x8841\
+\\xDBEB\x8842\
+\\xDBEC\x8843\
+\\xDBED\x8844\
+\\xDBEE\x8845\
+\\xDBEF\x8846\
+\\xDBF0\x8847\
+\\xDBF1\x8848\
+\\xDBF2\x8849\
+\\xDBF3\x884A\
+\\xDBF4\x884B\
+\\xDBF5\x884C\
+\\xDBF6\x884D\
+\\xDBF7\x884E\
+\\xDBF8\x884F\
+\\xDBF9\x8850\
+\\xDBFA\x8851\
+\\xDBFB\x8852\
+\\xDBFC\x8853\
+\\xDBFD\x8854\
+\\xDC41\x8855\
+\\xDC42\x8856\
+\\xDC43\x8857\
+\\xDC44\x8858\
+\\xDC45\x8859\
+\\xDC46\x885A\
+\\xDC47\x885B\
+\\xDC48\x885C\
+\\xDC49\x885D\
+\\xDC4A\x885E\
+\\xDC4B\x885F\
+\\xDC4C\x8860\
+\\xDC4D\x8861\
+\\xDC4E\x8862\
+\\xDC4F\x8863\
+\\xDC50\x8864\
+\\xDC51\x8865\
+\\xDC52\x8866\
+\\xDC53\x8867\
+\\xDC54\x8868\
+\\xDC55\x8869\
+\\xDC56\x886A\
+\\xDC57\x886B\
+\\xDC58\x886C\
+\\xDC59\x886D\
+\\xDC5A\x886E\
+\\xDC5B\x886F\
+\\xDC5C\x8870\
+\\xDC5D\x8871\
+\\xDC5E\x8872\
+\\xDC5F\x8873\
+\\xDC60\x8874\
+\\xDC61\x8875\
+\\xDC62\x8876\
+\\xDC63\x8877\
+\\xDC64\x8878\
+\\xDC65\x8879\
+\\xDC66\x887A\
+\\xDC67\x887B\
+\\xDC68\x887C\
+\\xDC69\x887D\
+\\xDC6A\x887E\
+\\xDC6B\x88A1\
+\\xDC6C\x88A2\
+\\xDC6D\x88A3\
+\\xDC6E\x88A4\
+\\xDC6F\x88A5\
+\\xDC70\x88A6\
+\\xDC71\x88A7\
+\\xDC72\x88A8\
+\\xDC73\x88A9\
+\\xDC74\x88AA\
+\\xDC75\x88AB\
+\\xDC76\x88AC\
+\\xDC77\x88AD\
+\\xDC78\x88AE\
+\\xDC79\x88AF\
+\\xDC7A\x88B0\
+\\xDC7B\x88B1\
+\\xDC7C\x88B2\
+\\xDC7D\x88B3\
+\\xDC7E\x88B4\
+\\xDC7F\x88B5\
+\\xDC81\x88B6\
+\\xDC82\x88B7\
+\\xDC83\x88B8\
+\\xDC84\x88B9\
+\\xDC85\x88BA\
+\\xDC86\x88BB\
+\\xDC87\x88BC\
+\\xDC88\x88BD\
+\\xDC89\x88BE\
+\\xDC8A\x88BF\
+\\xDC8B\x88C0\
+\\xDC8C\x88C1\
+\\xDC8D\x88C2\
+\\xDC8E\x88C3\
+\\xDC8F\x88C4\
+\\xDC90\x88C5\
+\\xDC91\x88C6\
+\\xDC92\x88C7\
+\\xDC93\x88C8\
+\\xDC94\x88C9\
+\\xDC95\x88CA\
+\\xDC96\x88CB\
+\\xDC97\x88CC\
+\\xDC98\x88CD\
+\\xDC99\x88CE\
+\\xDC9A\x88CF\
+\\xDC9B\x88D0\
+\\xDC9C\x88D1\
+\\xDC9D\x88D2\
+\\xDC9E\x88D3\
+\\xDC9F\x88D4\
+\\xDCA0\x88D5\
+\\xDCA1\x88D6\
+\\xDCA2\x88D7\
+\\xDCA3\x88D8\
+\\xDCA4\x88D9\
+\\xDCA5\x88DA\
+\\xDCA6\x88DB\
+\\xDCA7\x88DC\
+\\xDCA8\x88DD\
+\\xDCA9\x88DE\
+\\xDCAA\x88DF\
+\\xDCAB\x88E0\
+\\xDCAC\x88E1\
+\\xDCAD\x88E2\
+\\xDCAE\x88E3\
+\\xDCAF\x88E4\
+\\xDCB0\x88E5\
+\\xDCB1\x88E6\
+\\xDCB2\x88E7\
+\\xDCB3\x88E8\
+\\xDCB4\x88E9\
+\\xDCB5\x88EA\
+\\xDCB6\x88EB\
+\\xDCB7\x88EC\
+\\xDCB8\x88ED\
+\\xDCB9\x88EE\
+\\xDCBA\x88EF\
+\\xDCBB\x88F0\
+\\xDCBC\x88F1\
+\\xDCBD\x88F2\
+\\xDCBE\x88F3\
+\\xDCBF\x88F4\
+\\xDCC0\x88F5\
+\\xDCC1\x88F6\
+\\xDCC2\x88F7\
+\\xDCC3\x88F8\
+\\xDCC4\x88F9\
+\\xDCC5\x88FA\
+\\xDCC6\x88FB\
+\\xDCC7\x88FC\
+\\xDCC8\x88FD\
+\\xDCC9\x88FE\
+\\xDCCA\x8940\
+\\xDCCB\x8941\
+\\xDCCC\x8942\
+\\xDCCD\x8943\
+\\xDCCE\x8944\
+\\xDCCF\x8945\
+\\xDCD0\x8946\
+\\xDCD1\x8947\
+\\xDCD2\x8948\
+\\xDCD3\x8949\
+\\xDCD4\x894A\
+\\xDCD5\x894B\
+\\xDCD6\x894C\
+\\xDCD7\x894D\
+\\xDCD8\x894E\
+\\xDCD9\x894F\
+\\xDCDA\x8950\
+\\xDCDB\x8951\
+\\xDCDC\x8952\
+\\xDCDD\x8953\
+\\xDCDE\x8954\
+\\xDCDF\x8955\
+\\xDCE0\x8956\
+\\xDCE1\x8957\
+\\xDCE2\x8958\
+\\xDCE3\x8959\
+\\xDCE4\x895A\
+\\xDCE5\x895B\
+\\xDCE6\x895C\
+\\xDCE7\x895D\
+\\xDCE8\x895E\
+\\xDCE9\x895F\
+\\xDCEA\x8960\
+\\xDCEB\x8961\
+\\xDCEC\x8962\
+\\xDCED\x8963\
+\\xDCEE\x8964\
+\\xDCEF\x8965\
+\\xDCF0\x8966\
+\\xDCF1\x8967\
+\\xDCF2\x8968\
+\\xDCF3\x8969\
+\\xDCF4\x896A\
+\\xDCF5\x896B\
+\\xDCF6\x896C\
+\\xDCF7\x896D\
+\\xDCF8\x896E\
+\\xDCF9\x896F\
+\\xDCFA\x8970\
+\\xDCFB\x8971\
+\\xDCFC\x8972\
+\\xDCFD\x8973\
+\\xDD41\x8974\
+\\xDD42\x8975\
+\\xDD43\x8976\
+\\xDD44\x8977\
+\\xDD45\x8978\
+\\xDD46\x8979\
+\\xDD47\x897A\
+\\xDD48\x897B\
+\\xDD49\x897C\
+\\xDD4A\x897D\
+\\xDD4B\x897E\
+\\xDD4C\x89A1\
+\\xDD4D\x89A2\
+\\xDD4E\x89A3\
+\\xDD4F\x89A4\
+\\xDD50\x89A5\
+\\xDD51\x89A6\
+\\xDD52\x89A7\
+\\xDD53\x89A8\
+\\xDD54\x89A9\
+\\xDD55\x89AA\
+\\xDD56\x89AB\
+\\xDD57\x89AC\
+\\xDD58\x89AD\
+\\xDD59\x89AE\
+\\xDD5A\x89AF\
+\\xDD5B\x89B0\
+\\xDD5C\x89B1\
+\\xDD5D\x89B2\
+\\xDD5E\x89B3\
+\\xDD5F\x89B4\
+\\xDD60\x89B5\
+\\xDD61\x89B6\
+\\xDD62\x89B7\
+\\xDD63\x89B8\
+\\xDD64\x89B9\
+\\xDD65\x89BA\
+\\xDD66\x89BB\
+\\xDD67\x89BC\
+\\xDD68\x89BD\
+\\xDD69\x89BE\
+\\xDD6A\x89BF\
+\\xDD6B\x89C0\
+\\xDD6C\x89C1\
+\\xDD6D\x89C2\
+\\xDD6E\x89C3\
+\\xDD6F\x89C4\
+\\xDD70\x89C5\
+\\xDD71\x89C6\
+\\xDD72\x89C7\
+\\xDD73\x89C8\
+\\xDD74\x89C9\
+\\xDD75\x89CA\
+\\xDD76\x89CB\
+\\xDD77\x89CC\
+\\xDD78\x89CD\
+\\xDD79\x89CE\
+\\xDD7A\x89CF\
+\\xDD7B\x89D0\
+\\xDD7C\x89D1\
+\\xDD7D\x89D2\
+\\xDD7E\x89D3\
+\\xDD7F\x89D4\
+\\xDD81\x89D5\
+\\xDD82\x89D6\
+\\xDD83\x89D7\
+\\xDD84\x89D8\
+\\xDD85\x89D9\
+\\xDD86\x89DA\
+\\xDD87\x89DB\
+\\xDD88\x89DC\
+\\xDD89\x89DD\
+\\xDD8A\x89DE\
+\\xDD8B\x89DF\
+\\xDD8C\x89E0\
+\\xDD8D\x89E1\
+\\xDD8E\x89E2\
+\\xDD8F\x89E3\
+\\xDD90\x89E4\
+\\xDD91\x89E5\
+\\xDD92\x89E6\
+\\xDD93\x89E7\
+\\xDD94\x89E8\
+\\xDD95\x89E9\
+\\xDD96\x89EA\
+\\xDD97\x89EB\
+\\xDD98\x89EC\
+\\xDD99\x89ED\
+\\xDD9A\x89EE\
+\\xDD9B\x89EF\
+\\xDD9C\x89F0\
+\\xDD9D\x89F1\
+\\xDD9E\x89F2\
+\\xDD9F\x89F3\
+\\xDDA0\x89F4\
+\\xDDA1\x89F5\
+\\xDDA2\x89F6\
+\\xDDA3\x89F7\
+\\xDDA4\x89F8\
+\\xDDA5\x89F9\
+\\xDDA6\x89FA\
+\\xDDA7\x89FB\
+\\xDDA8\x89FC\
+\\xDDA9\x89FD\
+\\xDDAA\x89FE\
+\\xDDAB\x8A40\
+\\xDDAC\x8A41\
+\\xDDAD\x8A42\
+\\xDDAE\x8A43\
+\\xDDAF\x8A44\
+\\xDDB0\x8A45\
+\\xDDB1\x8A46\
+\\xDDB2\x8A47\
+\\xDDB3\x8A48\
+\\xDDB4\x8A49\
+\\xDDB5\x8A4A\
+\\xDDB6\x8A4B\
+\\xDDB7\x8A4C\
+\\xDDB8\x8A4D\
+\\xDDB9\x8A4E\
+\\xDDBA\x8A4F\
+\\xDDBB\x8A50\
+\\xDDBC\x8A51\
+\\xDDBD\x8A52\
+\\xDDBE\x8A53\
+\\xDDBF\x8A54\
+\\xDDC0\x8A55\
+\\xDDC1\x8A56\
+\\xDDC2\x8A57\
+\\xDDC3\x8A58\
+\\xDDC4\x8A59\
+\\xDDC5\x8A5A\
+\\xDDC6\x8A5B\
+\\xDDC7\x8A5C\
+\\xDDC8\x8A5D\
+\\xDDC9\x8A5E\
+\\xDDCA\x8A5F\
+\\xDDCB\x8A60\
+\\xDDCC\x8A61\
+\\xDDCD\x8A62\
+\\xDDCE\x8A63\
+\\xDDCF\x8A64\
+\\xDDD0\x8A65\
+\\xDDD1\x8A66\
+\\xDDD2\x8A67\
+\\xDDD3\x8A68\
+\\xDDD4\x8A69\
+\\xDDD5\x8A6A\
+\\xDDD6\x8A6B\
+\\xDDD7\x8A6C\
+\\xDDD8\x8A6D\
+\\xDDD9\x8A6E\
+\\xDDDA\x8A6F\
+\\xDDDB\x8A70\
+\\xDDDC\x8A71\
+\\xDDDD\x8A72\
+\\xDDDE\x8A73\
+\\xDDDF\x8A74\
+\\xDDE0\x8A75\
+\\xDDE1\x8A76\
+\\xDDE2\x8A77\
+\\xDDE3\x8A78\
+\\xDDE4\x8A79\
+\\xDDE5\x8A7A\
+\\xDDE6\x8A7B\
+\\xDDE7\x8A7C\
+\\xDDE8\x8A7D\
+\\xDDE9\x8A7E\
+\\xDDEA\x8AA1\
+\\xDDEB\x8AA2\
+\\xDDEC\x8AA3\
+\\xDDED\x8AA4\
+\\xDDEE\x8AA5\
+\\xDDEF\x8AA6\
+\\xDDF0\x8AA7\
+\\xDDF1\x8AA8\
+\\xDDF2\x8AA9\
+\\xDDF3\x8AAA\
+\\xDDF4\x8AAB\
+\\xDDF5\x8AAC\
+\\xDDF6\x8AAD\
+\\xDDF7\x8AAE\
+\\xDDF8\x8AAF\
+\\xDDF9\x8AB0\
+\\xDDFA\x8AB1\
+\\xDDFB\x8AB2\
+\\xDDFC\x8AB3\
+\\xDDFD\x8AB4\
+\\xDE41\x8AB5\
+\\xDE42\x8AB6\
+\\xDE43\x8AB7\
+\\xDE44\x8AB8\
+\\xDE45\x8AB9\
+\\xDE46\x8ABA\
+\\xDE47\x8ABB\
+\\xDE48\x8ABC\
+\\xDE49\x8ABD\
+\\xDE4A\x8ABE\
+\\xDE4B\x8ABF\
+\\xDE4C\x8AC0\
+\\xDE4D\x8AC1\
+\\xDE4E\x8AC2\
+\\xDE4F\x8AC3\
+\\xDE50\x8AC4\
+\\xDE51\x8AC5\
+\\xDE52\x8AC6\
+\\xDE53\x8AC7\
+\\xDE54\x8AC8\
+\\xDE55\x8AC9\
+\\xDE56\x8ACA\
+\\xDE57\x8ACB\
+\\xDE58\x8ACC\
+\\xDE59\x8ACD\
+\\xDE5A\x8ACE\
+\\xDE5B\x8ACF\
+\\xDE5C\x8AD0\
+\\xDE5D\x8AD1\
+\\xDE5E\x8AD2\
+\\xDE5F\x8AD3\
+\\xDE60\x8AD4\
+\\xDE61\x8AD5\
+\\xDE62\x8AD6\
+\\xDE63\x8AD7\
+\\xDE64\x8AD8\
+\\xDE65\x8AD9\
+\\xDE66\x8ADA\
+\\xDE67\x8ADB\
+\\xDE68\x8ADC\
+\\xDE69\x8ADD\
+\\xDE6A\x8ADE\
+\\xDE6B\x8ADF\
+\\xDE6C\x8AE0\
+\\xDE6D\x8AE1\
+\\xDE6E\x8AE2\
+\\xDE6F\x8AE3\
+\\xDE70\x8AE4\
+\\xDE71\x8AE5\
+\\xDE72\x8AE6\
+\\xDE73\x8AE7\
+\\xDE74\x8AE8\
+\\xDE75\x8AE9\
+\\xDE76\x8AEA\
+\\xDE77\x8AEB\
+\\xDE78\x8AEC\
+\\xDE79\x8AED\
+\\xDE7A\x8AEE\
+\\xDE7B\x8AEF\
+\\xDE7C\x8AF0\
+\\xDE7D\x8AF1\
+\\xDE7E\x8AF2\
+\\xDE7F\x8AF3\
+\\xDE81\x8AF4\
+\\xDE82\x8AF5\
+\\xDE83\x8AF6\
+\\xDE84\x8AF7\
+\\xDE85\x8AF8\
+\\xDE86\x8AF9\
+\\xDE87\x8AFA\
+\\xDE88\x8AFB\
+\\xDE89\x8AFC\
+\\xDE8A\x8AFD\
+\\xDE8B\x8AFE\
+\\xDE8C\x8B40\
+\\xDE8D\x8B41\
+\\xDE8E\x8B42\
+\\xDE8F\x8B43\
+\\xDE90\x8B44\
+\\xDE91\x8B45\
+\\xDE92\x8B46\
+\\xDE93\x8B47\
+\\xDE94\x8B48\
+\\xDE95\x8B49\
+\\xDE96\x8B4A\
+\\xDE97\x8B4B\
+\\xDE98\x8B4C\
+\\xDE99\x8B4D\
+\\xDE9A\x8B4E\
+\\xDE9B\x8B4F\
+\\xDE9C\x8B50\
+\\xDE9D\x8B51\
+\\xDE9E\x8B52\
+\\xDE9F\x8B53\
+\\xDEA0\x8B54\
+\\xDEA1\x8B55\
+\\xDEA2\x8B56\
+\\xDEA3\x8B57\
+\\xDEA4\x8B58\
+\\xDEA5\x8B59\
+\\xDEA6\x8B5A\
+\\xDEA7\x8B5B\
+\\xDEA8\x8B5C\
+\\xDEA9\x8B5D\
+\\xDEAA\x8B5E\
+\\xDEAB\x8B5F\
+\\xDEAC\x8B60\
+\\xDEAD\x8B61\
+\\xDEAE\x8B62\
+\\xDEAF\x8B63\
+\\xDEB0\x8B64\
+\\xDEB1\x8B65\
+\\xDEB2\x8B66\
+\\xDEB3\x8B67\
+\\xDEB4\x8B68\
+\\xDEB5\x8B69\
+\\xDEB6\x8B6A\
+\\xDEB7\x8B6B\
+\\xDEB8\x8B6C\
+\\xDEB9\x8B6D\
+\\xDEBA\x8B6E\
+\\xDEBB\x8B6F\
+\\xDEBC\x8B70\
+\\xDEBD\x8B71\
+\\xDEBE\x8B72\
+\\xDEBF\x8B73\
+\\xDEC0\x8B74\
+\\xDEC1\x8B75\
+\\xDEC2\x8B76\
+\\xDEC3\x8B77\
+\\xDEC4\x8B78\
+\\xDEC5\x8B79\
+\\xDEC6\x8B7A\
+\\xDEC7\x8B7B\
+\\xDEC8\x8B7C\
+\\xDEC9\x8B7D\
+\\xDECA\x8B7E\
+\\xDECB\x8BA1\
+\\xDECC\x8BA2\
+\\xDECD\x8BA3\
+\\xDECE\x8BA4\
+\\xDECF\x8BA5\
+\\xDED0\x8BA6\
+\\xDED1\x8BA7\
+\\xDED2\x8BA8\
+\\xDED3\x8BA9\
+\\xDED4\x8BAA\
+\\xDED5\x8BAB\
+\\xDED6\x8BAC\
+\\xDED7\x8BAD\
+\\xDED8\x8BAE\
+\\xDED9\x8BAF\
+\\xDEDA\x8BB0\
+\\xDEDB\x8BB1\
+\\xDEDC\x8BB2\
+\\xDEDD\x8BB3\
+\\xDEDE\x8BB4\
+\\xDEDF\x8BB5\
+\\xDEE0\x8BB6\
+\\xDEE1\x8BB7\
+\\xDEE2\x8BB8\
+\\xDEE3\x8BB9\
+\\xDEE4\x8BBA\
+\\xDEE5\x8BBB\
+\\xDEE6\x8BBC\
+\\xDEE7\x8BBD\
+\\xDEE8\x8BBE\
+\\xDEE9\x8BBF\
+\\xDEEA\x8BC0\
+\\xDEEB\x8BC1\
+\\xDEEC\x8BC2\
+\\xDEED\x8BC3\
+\\xDEEE\x8BC4\
+\\xDEEF\x8BC5\
+\\xDEF0\x8BC6\
+\\xDEF1\x8BC7\
+\\xDEF2\x8BC8\
+\\xDEF3\x8BC9\
+\\xDEF4\x8BCA\
+\\xDEF5\x8BCB\
+\\xDEF6\x8BCC\
+\\xDEF7\x8BCD\
+\\xDEF8\x8BCE\
+\\xDEF9\x8BCF\
+\\xDEFA\x8BD0\
+\\xDEFB\x8BD1\
+\\xDEFC\x8BD2\
+\\xDEFD\x8BD3\
+\\xDF41\x8BD4\
+\\xDF42\x8BD5\
+\\xDF43\x8BD6\
+\\xDF44\x8BD7\
+\\xDF45\x8BD8\
+\\xDF46\x8BD9\
+\\xDF47\x8BDA\
+\\xDF48\x8BDB\
+\\xDF49\x8BDC\
+\\xDF4A\x8BDD\
+\\xDF4B\x8BDE\
+\\xDF4C\x8BDF\
+\\xDF4D\x8BE0\
+\\xDF4E\x8BE1\
+\\xDF4F\x8BE2\
+\\xDF50\x8BE3\
+\\xDF51\x8BE4\
+\\xDF52\x8BE5\
+\\xDF53\x8BE6\
+\\xDF54\x8BE7\
+\\xDF55\x8BE8\
+\\xDF56\x8BE9\
+\\xDF57\x8BEA\
+\\xDF58\x8BEB\
+\\xDF59\x8BEC\
+\\xDF5A\x8BED\
+\\xDF5B\x8BEE\
+\\xDF5C\x8BEF\
+\\xDF5D\x8BF0\
+\\xDF5E\x8BF1\
+\\xDF5F\x8BF2\
+\\xDF60\x8BF3\
+\\xDF61\x8BF4\
+\\xDF62\x8BF5\
+\\xDF63\x8BF6\
+\\xDF64\x8BF7\
+\\xDF65\x8BF8\
+\\xDF66\x8BF9\
+\\xDF67\x8BFA\
+\\xDF68\x8BFB\
+\\xDF69\x8BFC\
+\\xDF6A\x8BFD\
+\\xDF6B\x8BFE\
+\\xDF6C\x8C40\
+\\xDF6D\x8C41\
+\\xDF6E\x8C42\
+\\xDF6F\x8C43\
+\\xDF70\x8C44\
+\\xDF71\x8C45\
+\\xDF72\x8C46\
+\\xDF73\x8C47\
+\\xDF74\x8C48\
+\\xDF75\x8C49\
+\\xDF76\x8C4A\
+\\xDF77\x8C4B\
+\\xDF78\x8C4C\
+\\xDF79\x8C4D\
+\\xDF7A\x8C4E\
+\\xDF7B\x8C4F\
+\\xDF7C\x8C50\
+\\xDF7D\x8C51\
+\\xDF7E\x8C52\
+\\xDF7F\x8C53\
+\\xDF81\x8C54\
+\\xDF82\x8C55\
+\\xDF83\x8C56\
+\\xDF84\x8C57\
+\\xDF85\x8C58\
+\\xDF86\x8C59\
+\\xDF87\x8C5A\
+\\xDF88\x8C5B\
+\\xDF89\x8C5C\
+\\xDF8A\x8C5D\
+\\xDF8B\x8C5E\
+\\xDF8C\x8C5F\
+\\xDF8D\x8C60\
+\\xDF8E\x8C61\
+\\xDF8F\x8C62\
+\\xDF90\x8C63\
+\\xDF91\x8C64\
+\\xDF92\x8C65\
+\\xDF93\x8C66\
+\\xDF94\x8C67\
+\\xDF95\x8C68\
+\\xDF96\x8C69\
+\\xDF97\x8C6A\
+\\xDF98\x8C6B\
+\\xDF99\x8C6C\
+\\xDF9A\x8C6D\
+\\xDF9B\x8C6E\
+\\xDF9C\x8C6F\
+\\xDF9D\x8C70\
+\\xDF9E\x8C71\
+\\xDF9F\x8C72\
+\\xDFA0\x8C73\
+\\xDFA1\x8C74\
+\\xDFA2\x8C75\
+\\xDFA3\x8C76\
+\\xDFA4\x8C77\
+\\xDFA5\x8C78\
+\\xDFA6\x8C79\
+\\xDFA7\x8C7A\
+\\xDFA8\x8C7B\
+\\xDFA9\x8C7C\
+\\xDFAA\x8C7D\
+\\xDFAB\x8C7E\
+\\xDFAC\x8CA1\
+\\xDFAD\x8CA2\
+\\xDFAE\x8CA3\
+\\xDFAF\x8CA4\
+\\xDFB0\x8CA5\
+\\xDFB1\x8CA6\
+\\xDFB2\x8CA7\
+\\xDFB3\x8CA8\
+\\xDFB4\x8CA9\
+\\xDFB5\x8CAA\
+\\xDFB6\x8CAB\
+\\xDFB7\x8CAC\
+\\xDFB8\x8CAD\
+\\xDFB9\x8CAE\
+\\xDFBA\x8CAF\
+\\xDFBB\x8CB0\
+\\xDFBC\x8CB1\
+\\xDFBD\x8CB2\
+\\xDFBE\x8CB3\
+\\xDFBF\x8CB4\
+\\xDFC0\x8CB5\
+\\xDFC1\x8CB6\
+\\xDFC2\x8CB7\
+\\xDFC3\x8CB8\
+\\xDFC4\x8CB9\
+\\xDFC5\x8CBA\
+\\xDFC6\x8CBB\
+\\xDFC7\x8CBC\
+\\xDFC8\x8CBD\
+\\xDFC9\x8CBE\
+\\xDFCA\x8CBF\
+\\xDFCB\x8CC0\
+\\xDFCC\x8CC1\
+\\xDFCD\x8CC2\
+\\xDFCE\x8CC3\
+\\xDFCF\x8CC4\
+\\xDFD0\x8CC5\
+\\xDFD1\x8CC6\
+\\xDFD2\x8CC7\
+\\xDFD3\x8CC8\
+\\xDFD4\x8CC9\
+\\xDFD5\x8CCA\
+\\xDFD6\x8CCB\
+\\xDFD7\x8CCC\
+\\xDFD8\x8CCD\
+\\xDFD9\x8CCE\
+\\xDFDA\x8CCF\
+\\xDFDB\x8CD0\
+\\xDFDC\x8CD1\
+\\xDFDD\x8CD2\
+\\xDFDE\x8CD3\
+\\xDFDF\x8CD4\
+\\xDFE0\x8CD5\
+\\xDFE1\x8CD6\
+\\xDFE2\x8CD7\
+\\xDFE3\x8CD8\
+\\xDFE4\x8CD9\
+\\xDFE5\x8CDA\
+\\xDFE6\x8CDB\
+\\xDFE7\x8CDC\
+\\xDFE8\x8CDD\
+\\xDFE9\x8CDE\
+\\xDFEA\x8CDF\
+\\xDFEB\x8CE0\
+\\xDFEC\x8CE1\
+\\xDFED\x8CE2\
+\\xDFEE\x8CE3\
+\\xDFEF\x8CE4\
+\\xDFF0\x8CE5\
+\\xDFF1\x8CE6\
+\\xDFF2\x8CE7\
+\\xDFF3\x8CE8\
+\\xDFF4\x8CE9\
+\\xDFF5\x8CEA\
+\\xDFF6\x8CEB\
+\\xDFF7\x8CEC\
+\\xDFF8\x8CED\
+\\xDFF9\x8CEE\
+\\xDFFA\x8CEF\
+\\xDFFB\x8CF0\
+\\xDFFC\x8CF1\
+\\xDFFD\x8CF2\
+\\xE041\x8CF3\
+\\xE042\x8CF4\
+\\xE043\x8CF5\
+\\xE044\x8CF6\
+\\xE045\x8CF7\
+\\xE046\x8CF8\
+\\xE047\x8CF9\
+\\xE048\x8CFA\
+\\xE049\x8CFB\
+\\xE04A\x8CFC\
+\\xE04B\x8CFD\
+\\xE04C\x8CFE\
+\\xE04D\x8D40\
+\\xE04E\x8D41\
+\\xE04F\x8D42\
+\\xE050\x8D43\
+\\xE051\x8D44\
+\\xE052\x8D45\
+\\xE053\x8D46\
+\\xE054\x8D47\
+\\xE055\x8D48\
+\\xE056\x8D49\
+\\xE057\x8D4A\
+\\xE058\x8D4B\
+\\xE059\x8D4C\
+\\xE05A\x8D4D\
+\\xE05B\x8D4E\
+\\xE05C\x8D4F\
+\\xE05D\x8D50\
+\\xE05E\x8D51\
+\\xE05F\x8D52\
+\\xE060\x8D53\
+\\xE061\x8D54\
+\\xE062\x8D55\
+\\xE063\x8D56\
+\\xE064\x8D57\
+\\xE065\x8D58\
+\\xE066\x8D59\
+\\xE067\x8D5A\
+\\xE068\x8D5B\
+\\xE069\x8D5C\
+\\xE06A\x8D5D\
+\\xE06B\x8D5E\
+\\xE06C\x8D5F\
+\\xE06D\x8D60\
+\\xE06E\x8D61\
+\\xE06F\x8D62\
+\\xE070\x8D63\
+\\xE071\x8D64\
+\\xE072\x8D65\
+\\xE073\x8D66\
+\\xE074\x8D67\
+\\xE075\x8D68\
+\\xE076\x8D69\
+\\xE077\x8D6A\
+\\xE078\x8D6B\
+\\xE079\x8D6C\
+\\xE07A\x8D6D\
+\\xE07B\x8D6E\
+\\xE07C\x8D6F\
+\\xE07D\x8D70\
+\\xE07E\x8D71\
+\\xE07F\x8D72\
+\\xE081\x8D73\
+\\xE082\x8D74\
+\\xE083\x8D75\
+\\xE084\x8D76\
+\\xE085\x8D77\
+\\xE086\x8D78\
+\\xE087\x8D79\
+\\xE088\x8D7A\
+\\xE089\x8D7B\
+\\xE08A\x8D7C\
+\\xE08B\x8D7D\
+\\xE08C\x8D7E\
+\\xE08D\x8DA1\
+\\xE08E\x8DA2\
+\\xE08F\x8DA3\
+\\xE090\x8DA4\
+\\xE091\x8DA5\
+\\xE092\x8DA6\
+\\xE093\x8DA7\
+\\xE094\x8DA8\
+\\xE095\x8DA9\
+\\xE096\x8DAA\
+\\xE097\x8DAB\
+\\xE098\x8DAC\
+\\xE099\x8DAD\
+\\xE09A\x8DAE\
+\\xE09B\x8DAF\
+\\xE09C\x8DB0\
+\\xE09D\x8DB1\
+\\xE09E\x8DB2\
+\\xE09F\x8DB3\
+\\xE0A0\x8DB4\
+\\xE0A1\x8DB5\
+\\xE0A2\x8DB6\
+\\xE0A3\x8DB7\
+\\xE0A4\x8DB8\
+\\xE0A5\x8DB9\
+\\xE0A6\x8DBA\
+\\xE0A7\x8DBB\
+\\xE0A8\x8DBC\
+\\xE0A9\x8DBD\
+\\xE0AA\x8DBE\
+\\xE0AB\x8DBF\
+\\xE0AC\x8DC0\
+\\xE0AD\x8DC1\
+\\xE0AE\x8DC2\
+\\xE0AF\x8DC3\
+\\xE0B0\x8DC4\
+\\xE0B1\x8DC5\
+\\xE0B2\x8DC6\
+\\xE0B3\x8DC7\
+\\xE0B4\x8DC8\
+\\xE0B5\x8DC9\
+\\xE0B6\x8DCA\
+\\xE0B7\x8DCB\
+\\xE0B8\x8DCC\
+\\xE0B9\x8DCD\
+\\xE0BA\x8DCE\
+\\xE0BB\x8DCF\
+\\xE0BC\x8DD0\
+\\xE0BD\x8DD1\
+\\xE0BE\x8DD2\
+\\xE0BF\x8DD3\
+\\xE0C0\x8DD4\
+\\xE0C1\x8DD5\
+\\xE0C2\x8DD6\
+\\xE0C3\x8DD7\
+\\xE0C4\x8DD8\
+\\xE0C5\x8DD9\
+\\xE0C6\x8DDA\
+\\xE0C7\x8DDB\
+\\xE0C8\x8DDC\
+\\xE0C9\x8DDD\
+\\xE0CA\x8DDE\
+\\xE0CB\x8DDF\
+\\xE0CC\x8DE0\
+\\xE0CD\x8DE1\
+\\xE0CE\x8DE2\
+\\xE0CF\x8DE3\
+\\xE0D0\x8DE4\
+\\xE0D1\x8DE5\
+\\xE0D2\x8DE6\
+\\xE0D3\x8DE7\
+\\xE0D4\x8DE8\
+\\xE0D5\x8DE9\
+\\xE0D6\x8DEA\
+\\xE0D7\x8DEB\
+\\xE0D8\x8DEC\
+\\xE0D9\x8DED\
+\\xE0DA\x8DEE\
+\\xE0DB\x8DEF\
+\\xE0DC\x8DF0\
+\\xE0DD\x8DF1\
+\\xE0DE\x8DF2\
+\\xE0DF\x8DF3\
+\\xE0E0\x8DF4\
+\\xE0E1\x8DF5\
+\\xE0E2\x8DF6\
+\\xE0E3\x8DF7\
+\\xE0E4\x8DF8\
+\\xE0E5\x8DF9\
+\\xE0E6\x8DFA\
+\\xE0E7\x8DFB\
+\\xE0E8\x8DFC\
+\\xE0E9\x8DFD\
+\\xE0EA\x8DFE\
+\\xE0EB\xC6A1\
+\\xE0EC\xC6A2\
+\\xE0ED\xC6A3\
+\\xE0EE\xC6A4\
+\\xE0EF\xC6A5\
+\\xE0F0\xC6A6\
+\\xE0F1\xC6A7\
+\\xE0F2\xC6A8\
+\\xE0F3\xC6A9\
+\\xE0F4\xC6AA\
+\\xE0F5\xC6AB\
+\\xE0F6\xC6AC\
+\\xE0F7\xC6AD\
+\\xE0F8\xC6AE\
+\\xE0F9\xC6AF\
+\\xE0FA\xC6B0\
+\\xE0FB\xC6B1\
+\\xE0FC\xC6B2\
+\\xE0FD\xC6B3\
+\\xE141\xC6B4\
+\\xE142\xC6B5\
+\\xE143\xC6B6\
+\\xE144\xC6B7\
+\\xE145\xC6B8\
+\\xE146\xC6B9\
+\\xE147\xC6BA\
+\\xE148\xC6BB\
+\\xE149\xC6BC\
+\\xE14A\xC6BD\
+\\xE14B\xC6BE\
+\\xE14C\xC6BF\
+\\xE14D\xC6C0\
+\\xE14E\xC6C1\
+\\xE14F\xC6C2\
+\\xE150\xC6C3\
+\\xE151\xC6C4\
+\\xE152\xC6C5\
+\\xE153\xC6C6\
+\\xE154\xC6C7\
+\\xE155\xC6C8\
+\\xE156\xC6C9\
+\\xE157\xC6CA\
+\\xE158\xC6CB\
+\\xE159\xC6CC\
+\\xE15A\xC6CD\
+\\xE15B\xC6CE\
+\\xE15C\xC6CF\
+\\xE15D\xC6D0\
+\\xE15E\xC6D1\
+\\xE15F\xC6D2\
+\\xE160\xC6D3\
+\\xE161\xC6D4\
+\\xE162\xC6D5\
+\\xE163\xC6D6\
+\\xE164\xC6D7\
+\\xE165\xC6D8\
+\\xE166\xC6D9\
+\\xE167\xC6DA\
+\\xE168\xC6DB\
+\\xE169\xC6DC\
+\\xE16A\xC6DD\
+\\xE16B\xC6DE\
+\\xE16C\xC6DF\
+\\xE16D\xC6E0\
+\\xE16E\xC6E1\
+\\xE16F\xC6E2\
+\\xE170\xC6E3\
+\\xE171\xC6E4\
+\\xE172\xC6E5\
+\\xE173\xC6E6\
+\\xE174\xC6E7\
+\\xE175\xC6E8\
+\\xE176\xC6E9\
+\\xE177\xC6EA\
+\\xE178\xC6EB\
+\\xE179\xC6EC\
+\\xE17A\xC6ED\
+\\xE17B\xC6EE\
+\\xE17C\xC6EF\
+\\xE17D\xC6F0\
+\\xE17E\xC6F1\
+\\xE17F\xC6F2\
+\\xE181\xC6F3\
+\\xE182\xC6F4\
+\\xE183\xC6F5\
+\\xE184\xC6F6\
+\\xE185\xC6F7\
+\\xE186\xC6F8\
+\\xE187\xC6F9\
+\\xE188\xC6FA\
+\\xE189\xC6FB\
+\\xE18A\xC6FC\
+\\xE18B\xC6FD\
+\\xE18C\xC6FE\
+\\xE18D\xC740\
+\\xE18E\xC741\
+\\xE18F\xC742\
+\\xE190\xC743\
+\\xE191\xC744\
+\\xE192\xC745\
+\\xE193\xC746\
+\\xE194\xC747\
+\\xE195\xC748\
+\\xE196\xC749\
+\\xE197\xC74A\
+\\xE198\xC74B\
+\\xE199\xC74C\
+\\xE19A\xC74D\
+\\xE19B\xC74E\
+\\xE19C\xC74F\
+\\xE19D\xC750\
+\\xE19E\xC751\
+\\xE19F\xC752\
+\\xE1A0\xC753\
+\\xE1A1\xC754\
+\\xE1A2\xC755\
+\\xE1A3\xC756\
+\\xE1A4\xC757\
+\\xE1A5\xC758\
+\\xE1A6\xC759\
+\\xE1A7\xC75A\
+\\xE1A8\xC75B\
+\\xE1A9\xC75C\
+\\xE1AA\xC75D\
+\\xE1AB\xC75E\
+\\xE1AC\xC75F\
+\\xE1AD\xC760\
+\\xE1AE\xC761\
+\\xE1AF\xC762\
+\\xE1B0\xC763\
+\\xE1B1\xC764\
+\\xE1B2\xC765\
+\\xE1B3\xC766\
+\\xE1B4\xC767\
+\\xE1B5\xC768\
+\\xE1B6\xC769\
+\\xE1B7\xC76A\
+\\xE1B8\xC76B\
+\\xE1B9\xC76C\
+\\xE1BA\xC76D\
+\\xE1BB\xC76E\
+\\xE1BC\xC76F\
+\\xE1BD\xC770\
+\\xE1BE\xC771\
+\\xE1BF\xC772\
+\\xE1C0\xC773\
+\\xE1C1\xC774\
+\\xE1C2\xC775\
+\\xE1C3\xC776\
+\\xE1C4\xC777\
+\\xE1C5\xC778\
+\\xE1C6\xC779\
+\\xE1C7\xC77A\
+\\xE1C8\xC77B\
+\\xE1C9\xC77C\
+\\xE1CA\xC77D\
+\\xE1CB\xC77E\
+\\xE1CC\xC7A1\
+\\xE1CD\xC7A2\
+\\xE1CE\xC7A3\
+\\xE1CF\xC7A4\
+\\xE1D0\xC7A5\
+\\xE1D1\xC7A6\
+\\xE1D2\xC7A7\
+\\xE1D3\xC7A8\
+\\xE1D4\xC7A9\
+\\xE1D5\xC7AA\
+\\xE1D6\xC7AB\
+\\xE1D7\xC7AC\
+\\xE1D8\xC7AD\
+\\xE1D9\xC7AE\
+\\xE1DA\xC7AF\
+\\xE1DB\xC7B0\
+\\xE1DC\xC7B1\
+\\xE1DD\xC7B2\
+\\xE1DE\xC7B3\
+\\xE1DF\xC7B4\
+\\xE1E0\xC7B5\
+\\xE1E1\xC7B6\
+\\xE1E2\xC7B7\
+\\xE1E3\xC7B8\
+\\xE1E4\xC7B9\
+\\xE1E5\xC7BA\
+\\xE1E6\xC7BB\
+\\xE1E7\xC7BC\
+\\xE1E8\xC7BD\
+\\xE1E9\xC7BE\
+\\xE1EA\xC7BF\
+\\xE1EB\xC7C0\
+\\xE1EC\xC7C1\
+\\xE1ED\xC7C2\
+\\xE1EE\xC7C3\
+\\xE1EF\xC7C4\
+\\xE1F0\xC7C5\
+\\xE1F1\xC7C6\
+\\xE1F2\xC7C7\
+\\xE1F3\xC7C8\
+\\xE1F4\xC7C9\
+\\xE1F5\xC7CA\
+\\xE1F6\xC7CB\
+\\xE1F7\xC7CC\
+\\xE1F8\xC7CD\
+\\xE1F9\xC7CE\
+\\xE1FA\xC7CF\
+\\xE1FB\xC7D0\
+\\xE1FC\xC7D1\
+\\xE1FD\xC7D2\
+\\xE241\xC7D3\
+\\xE242\xC7D4\
+\\xE243\xC7D5\
+\\xE244\xC7D6\
+\\xE245\xC7D7\
+\\xE246\xC7D8\
+\\xE247\xC7D9\
+\\xE248\xC7DA\
+\\xE249\xC7DB\
+\\xE24A\xC7DC\
+\\xE24B\xC7DD\
+\\xE24C\xC7DE\
+\\xE24D\xC7DF\
+\\xE24E\xC7E0\
+\\xE24F\xC7E1\
+\\xE250\xC7E2\
+\\xE251\xC7E3\
+\\xE252\xC7E4\
+\\xE253\xC7E5\
+\\xE254\xC7E6\
+\\xE255\xC7E7\
+\\xE256\xC7E8\
+\\xE257\xC7E9\
+\\xE258\xC7EA\
+\\xE259\xC7EB\
+\\xE25A\xC7EC\
+\\xE25B\xC7ED\
+\\xE25C\xC7EE\
+\\xE25D\xC7EF\
+\\xE25E\xC7F0\
+\\xE25F\xC7F1\
+\\xE260\xC7F2\
+\\xE261\xC7F3\
+\\xE262\xC7F4\
+\\xE263\xC7F5\
+\\xE264\xC7F6\
+\\xE265\xC7F7\
+\\xE266\xC7F8\
+\\xE267\xC7F9\
+\\xE268\xC7FA\
+\\xE269\xC7FB\
+\\xE26A\xC7FC\
+\\xE26B\xC7FD\
+\\xE26C\xC7FE\
+\\xE26D\xC840\
+\\xE26E\xC841\
+\\xE26F\xC842\
+\\xE270\xC843\
+\\xE271\xC844\
+\\xE272\xC845\
+\\xE273\xC846\
+\\xE274\xC847\
+\\xE275\xC848\
+\\xE276\xC849\
+\\xE277\xC84A\
+\\xE278\xC84B\
+\\xE279\xC84C\
+\\xE27A\xC84D\
+\\xE27B\xC84E\
+\\xE27C\xC84F\
+\\xE27D\xC850\
+\\xE27E\xC851\
+\\xE27F\xC852\
+\\xE281\xC853\
+\\xE282\xC854\
+\\xE283\xC855\
+\\xE284\xC856\
+\\xE285\xC857\
+\\xE286\xC858\
+\\xE287\xC859\
+\\xE288\xC85A\
+\\xE289\xC85B\
+\\xE28A\xC85C\
+\\xE28B\xC85D\
+\\xE28C\xC85E\
+\\xE28D\xC85F\
+\\xE28E\xC860\
+\\xE28F\xC861\
+\\xE290\xC862\
+\\xE291\xC863\
+\\xE292\xC864\
+\\xE293\xC865\
+\\xE294\xC866\
+\\xE295\xC867\
+\\xE296\xC868\
+\\xE297\xC869\
+\\xE298\xC86A\
+\\xE299\xC86B\
+\\xE29A\xC86C\
+\\xE29B\xC86D\
+\\xE29C\xC86E\
+\\xE29D\xC86F\
+\\xE29E\xC870\
+\\xE29F\xC871\
+\\xE2A0\xC872\
+\\xE2A1\xC873\
+\\xE2A2\xC874\
+\\xE2A3\xC875\
+\\xE2A4\xC876\
+\\xE2A5\xC877\
+\\xE2A6\xC878\
+\\xE2A7\xC879\
+\\xE2A8\xC87A\
+\\xE2A9\xC87B\
+\\xE2AA\xC87C\
+\\xE2AB\xC87D\
+\\xE2AC\xC87E\
+\\xE2AD\xC8A1\
+\\xE2AE\xC8A2\
+\\xE2AF\xC8A3\
+\\xE2B0\xC8A4\
+\\xE2B1\xC8A5\
+\\xE2B2\xC8A6\
+\\xE2B3\xC8A7\
+\\xE2B4\xC8A8\
+\\xE2B5\xC8A9\
+\\xE2B6\xC8AA\
+\\xE2B7\xC8AB\
+\\xE2B8\xC8AC\
+\\xE2B9\xC8AD\
+\\xE2BA\xC8AE\
+\\xE2BB\xC8AF\
+\\xE2BC\xC8B0\
+\\xE2BD\xC8B1\
+\\xE2BE\xC8B2\
+\\xE2BF\xC8B3\
+\\xE2C0\xC8B4\
+\\xE2C1\xC8B5\
+\\xE2C2\xC8B6\
+\\xE2C3\xC8B7\
+\\xE2C4\xC8B8\
+\\xE2C5\xC8B9\
+\\xE2C6\xC8BA\
+\\xE2C7\xC8BB\
+\\xE2C8\xC8BC\
+\\xE2C9\xC8BD\
+\\xE2CA\xC8BE\
+\\xE2CB\xC8BF\
+\\xE2CC\xC8C0\
+\\xE2CD\xC8C1\
+\\xE2CE\xC8C2\
+\\xE2CF\xC8C3\
+\\xE2D0\xC8C4\
+\\xE2D1\xC8C5\
+\\xE2D2\xC8C6\
+\\xE2D3\xC8C7\
+\\xE2D4\xC8C8\
+\\xE2D5\xC8C9\
+\\xE2D6\xC8CA\
+\\xE2D7\xC8CB\
+\\xE2D8\xC8CC\
+\\xE2D9\xC8CD\
+\\xE2DA\xC8CE\
+\\xE2DB\xC8CF\
+\\xE2DC\xC8D0\
+\\xE2DD\xC8D1\
+\\xE2DE\xC8D2\
+\\xE2DF\xC8D3\
+\\xE2E0\xC8D4\
+\\xE2E1\xC8D5\
+\\xE2E2\xC8D6\
+\\xE2E3\xC8D7\
+\\xE2E4\xC8D8\
+\\xE2E5\xC8D9\
+\\xE2E6\xC8DA\
+\\xE2E7\xC8DB\
+\\xE2E8\xC8DC\
+\\xE2E9\xC8DD\
+\\xE2EA\xC8DE\
+\\xE2EB\xC8DF\
+\\xE2EC\xC8E0\
+\\xE2ED\xC8E1\
+\\xE2EE\xC8E2\
+\\xE2EF\xC8E3\
+\\xE2F0\xC8E4\
+\\xE2F1\xC8E5\
+\\xE2F2\xC8E6\
+\\xE2F3\xC8E7\
+\\xE2F4\xC8E8\
+\\xE2F5\xC8E9\
+\\xE2F6\xC8EA\
+\\xE2F7\xC8EB\
+\\xE2F8\xC8EC\
+\\xE2F9\xC8ED\
+\\xE2FA\xC8EE\
+\\xE2FB\xC8EF\
+\\xE2FC\xC8F0\
+\\xE2FD\xC8F1"
diff --git a/src/OpenAFP/Internals/UConv.hs b/src/OpenAFP/Internals/UConv.hs
deleted file mode 100644
--- a/src/OpenAFP/Internals/UConv.hs
+++ /dev/null
@@ -1,67 +0,0 @@
-{-# OPTIONS -#include #-}
-{-# OPTIONS -fglasgow-exts #-}
-
------------------------------------------------------------------------------
--- |
--- Module : OpenAFP.Internals.UConv
--- Copyright : Audrey Tang
--- License : BSD-style
---
--- Maintainer : audreyt@audreyt.org
--- Stability : experimental
--- Portability : non-portable (FFI extensions, UNIX98)
---
--- This module provides an interface to IBM ICU's uconv functionality
---
------------------------------------------------------------------------------
-
--- Make with: ghc --make main.hs -L/usr/local/lib -licuuc -O -I/usr/local/include
-
-module OpenAFP.Internals.UConv where
-
-import Foreign
-import Foreign.C
-import Foreign.Ptr
-import OpenAFP.Internals.Binary
-import System.IO.Unsafe(unsafePerformIO)
-
--- |
--- Convert a sequence of bytes from one encoding to another.
-uconv :: String -- ^ The encoding to convert from
- -> String -- ^ The encoding to convert to
- -> [N1] -- ^ The byte sequence to convert
- -> Maybe String -- ^ The byte sequence converted
-uconv fromcode tocode bytes = unsafePerformIO $ do
- -- Create a conversion descriptor
- withCString fromcode $ \fromcode_c -> do
- withCString tocode $ \tocode_c -> do
- allocaBytes in_len $ \in_c -> do
- pokeArray in_c bytes
- allocaBytes out_len $ \out_c -> do
- alloca $ \err -> do
- poke err (0 :: Word8)
- len <- ucnv_convert tocode_c
- fromcode_c
- (castPtr out_c)
- (toEnum out_len)
- (castPtr in_c)
- (toEnum in_len)
- err
- errCode <- peek err :: IO Word8
- if (errCode == 0) then
- return . Just =<< peekCStringLen (out_c, fromEnum len)
- else
- return Nothing -- ("<>")
- where
- out_len = (4 * in_len)
- in_len = (length bytes)
-
-foreign import ccall "ucnv_convert_3_4" ucnv_convert ::
- CString -> -- toConverterName
- CString -> -- fromConverterName
- Ptr CChar -> -- target
- Int32 -> -- targetCapacity
- Ptr CChar -> -- source
- Int32 -> -- sourceLength
- Ptr Word8 -> -- pErrorCode
- IO Int32 -- return: targetLength
diff --git a/src/OpenAFP/Prelude/Exts.hs b/src/OpenAFP/Prelude/Exts.hs
deleted file mode 100644
--- a/src/OpenAFP/Prelude/Exts.hs
+++ /dev/null
@@ -1,104 +0,0 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields -cpp #-}
-
------------------------------------------------------------------------------
--- |
--- Module : OpenAFP.Prelude.Exts
--- Copyright : (c) Audrey Tang 2004, 2006
--- License : BSD-style
---
--- Maintainer : audreyt@audreyt.org
--- Stability : experimental
--- Portability : non-portable (GHC-only)
---
--- PreludeExts from the Haskell Wiki under the BSD license.
---
------------------------------------------------------------------------------
-
-module OpenAFP.Prelude.Exts where
-import OpenAFP.Internals
-
--- | Applies a bunch of functions to a value.
-rmap :: [a -> b] -> a -> [b]
-rmap fs x = map ($ x) fs
-
--- Catch user errors, but let others through
-onUserError :: IO a -> (String -> IO a) -> IO a
-m `onUserError` h
- = m `catchError` \e ->
- if isUserError e
- then h (ioeGetErrorString e)
- else throwError e
-
-type RE = String
-(=~) :: String -> String -> Bool
-s =~ p = isJust $ matchRegex (mkRegexWithOpts p False True) s
-
-splitRegexWithMatches :: RE -> String -> ([String], [String])
-splitRegexWithMatches regexpr src = splitRegex' src
- where
- regex = mkRegex regexpr
- splitRegex' :: String -> ([String], [String])
- splitRegex' s =
- case matchRegexAll regex s of
- Just (before, match, after, _) ->
- case splitRegex' after of (text, matches) -> (before : text, match : matches)
- Nothing -> ([s], [])
-
-splitBy :: (a -> Bool) -> [a] -> [[a]]
-splitBy _ [] = []
-splitBy f list = first : splitBy f (dropWhile f rest)
- where
- (first, rest) = break f list
-
-lower :: String -> String
-lower = map toLower
-
-upper :: String -> String
-upper = map toUpper
-
----------------------------------------------------------------------------------
--- Tom Moertel - from lambdabot's Util module
-
--- | Join lists with the given glue elements. Example:
---
--- > joinList ", " ["one","two","three"] ===> "one, two, three"
-
-joinList :: [a] -- ^ Glue to join with
- -> [[a]] -- ^ Elements to glue together
- -> [a] -- ^ Result: glued-together list
-
-joinList glue xs = (concat . intersperse glue) xs
-
--- | Split a list into pieces that were held together by glue. Example:
---
--- > split ", " "one, two, three" ===> ["one","two","three"]
-
-split :: Eq a => [a] -- ^ Glue that holds pieces together
- -> [a] -- ^ List to break into pieces
- -> [[a]] -- ^ Result: list of pieces
-
-split glue xs = split' xs
- where
- split' [] = []
- split' xs = piece : split' (dropGlue rest)
- where (piece, rest) = breakOnGlue glue xs
- dropGlue = drop (length glue)
-
--- | Break off the first piece of a list held together by glue,
--- leaving the glue attached to the remainder of the list. Example:
---
--- > breakOnGlue ", " "one, two, three" ===> ("one", ", two, three")
-
-breakOnGlue :: (Eq a) => [a] -- ^ Glue that holds pieces together
- -> [a] -- ^ List from which to break off a piece
- -> ([a],[a]) -- ^ Result: (first piece, glue ++ rest of list)
-
-breakOnGlue _ [] = ([],[])
-breakOnGlue glue rest@(x:xs)
- | glue `isPrefixOf` rest = ([], rest)
- | otherwise = (x:piece, rest') where (piece, rest') = breakOnGlue glue xs
-
-split_first_word :: String -> (String, String)
-split_first_word xs = (w, dropWhile isSpace xs')
- where (w, xs') = break isSpace xs
-
diff --git a/src/OpenAFP/Prelude/InstanceAFP.hs b/src/OpenAFP/Prelude/InstanceAFP.hs
--- a/src/OpenAFP/Prelude/InstanceAFP.hs
+++ b/src/OpenAFP/Prelude/InstanceAFP.hs
@@ -1,736 +1,11 @@
-{-# OPTIONS -fglasgow-exts #-}
module OpenAFP.Prelude.InstanceAFP () where
-import OpenAFP.Types
-import OpenAFP.Records
-import OpenAFP.Internals
-
-recOf :: (ChunkBuf c n b, Binary (Record r)) => c -> IO r
-recOf c = return . fromRecord =<< chunkToRecord c
-
-apply :: (MonadIO m) => (t -> IO a) -> t -> (a -> m b) -> m b
-apply ctr c f = f =<< (liftIO $ ctr c)
-
-instance Rec BAG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BAG a01 a02 a03
- recPut bh r = do put bh $ bag_Type r; put bh $ bag_ r; put bh $ bag r; return ()
- recSizeOf r = sum [ sizeOf $ bag_Type r, sizeOf $ bag_ r, sizeOf $ bag r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bag_Type r), viewField "_" (viewNumber $ bag_ r), viewField "" (viewNStr $ bag r) ]
- recType = fromEnum . bag_Type
-
-instance Rec BBC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BBC a01 a02 a03
- recPut bh r = do put bh $ bbc_Type r; put bh $ bbc_ r; put bh $ bbc r; return ()
- recSizeOf r = sum [ sizeOf $ bbc_Type r, sizeOf $ bbc_ r, sizeOf $ bbc r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bbc_Type r), viewField "_" (viewNumber $ bbc_ r), viewField "" (viewNStr $ bbc r) ]
- recType = fromEnum . bbc_Type
-
-instance Rec BCA where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BCA a01 a02 a03
- recPut bh r = do put bh $ bca_Type r; put bh $ bca_ r; put bh $ bca r; return ()
- recSizeOf r = sum [ sizeOf $ bca_Type r, sizeOf $ bca_ r, sizeOf $ bca r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bca_Type r), viewField "_" (viewNumber $ bca_ r), viewField "" (viewNStr $ bca r) ]
- recType = fromEnum . bca_Type
-
-instance Rec BCF where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BCF a01 a02 a03
- recPut bh r = do put bh $ bcf_Type r; put bh $ bcf_ r; put bh $ bcf r; return ()
- recSizeOf r = sum [ sizeOf $ bcf_Type r, sizeOf $ bcf_ r, sizeOf $ bcf r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bcf_Type r), viewField "_" (viewNumber $ bcf_ r), viewField "" (viewNStr $ bcf r) ]
- recType = fromEnum . bcf_Type
-
-instance Rec BCP where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BCP a01 a02 a03
- recPut bh r = do put bh $ bcp_Type r; put bh $ bcp_ r; put bh $ bcp r; return ()
- recSizeOf r = sum [ sizeOf $ bcp_Type r, sizeOf $ bcp_ r, sizeOf $ bcp r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bcp_Type r), viewField "_" (viewNumber $ bcp_ r), viewField "" (viewNStr $ bcp r) ]
- recType = fromEnum . bcp_Type
-
-instance Rec BDA where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BDA a01 a02 a03
- recPut bh r = do put bh $ bda_Type r; put bh $ bda_ r; put bh $ bda r; return ()
- recSizeOf r = sum [ sizeOf $ bda_Type r, sizeOf $ bda_ r, sizeOf $ bda r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bda_Type r), viewField "_" (viewNumber $ bda_ r), viewField "" (viewNStr $ bda r) ]
- recType = fromEnum . bda_Type
-
-instance Rec BDD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BDD a01 a02 a03
- recPut bh r = do put bh $ bdd_Type r; put bh $ bdd_ r; put bh $ bdd r; return ()
- recSizeOf r = sum [ sizeOf $ bdd_Type r, sizeOf $ bdd_ r, sizeOf $ bdd r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bdd_Type r), viewField "_" (viewNumber $ bdd_ r), viewField "" (viewNStr $ bdd r) ]
- recType = fromEnum . bdd_Type
-
-instance Rec BDG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BDG a01 a02 a03
- recPut bh r = do put bh $ bdg_Type r; put bh $ bdg_ r; put bh $ bdg r; return ()
- recSizeOf r = sum [ sizeOf $ bdg_Type r, sizeOf $ bdg_ r, sizeOf $ bdg r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bdg_Type r), viewField "_" (viewNumber $ bdg_ r), viewField "" (viewNStr $ bdg r) ]
- recType = fromEnum . bdg_Type
-
-instance Rec BDI where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BDI a01 a02 a03
- recPut bh r = do put bh $ bdi_Type r; put bh $ bdi_ r; put bh $ bdi r; return ()
- recSizeOf r = sum [ sizeOf $ bdi_Type r, sizeOf $ bdi_ r, sizeOf $ bdi r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bdi_Type r), viewField "_" (viewNumber $ bdi_ r), viewField "" (viewNStr $ bdi r) ]
- recType = fromEnum . bdi_Type
-
-instance Rec BDM where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BDM a01 a02 a03
- recPut bh r = do put bh $ bdm_Type r; put bh $ bdm_ r; put bh $ bdm r; return ()
- recSizeOf r = sum [ sizeOf $ bdm_Type r, sizeOf $ bdm_ r, sizeOf $ bdm r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bdm_Type r), viewField "_" (viewNumber $ bdm_ r), viewField "" (viewNStr $ bdm r) ]
- recType = fromEnum . bdm_Type
-
-instance Rec BDT where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BDT a01 a02 a03
- recPut bh r = do put bh $ bdt_Type r; put bh $ bdt_ r; put bh $ bdt r; return ()
- recSizeOf r = sum [ sizeOf $ bdt_Type r, sizeOf $ bdt_ r, sizeOf $ bdt r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bdt_Type r), viewField "_" (viewNumber $ bdt_ r), viewField "" (viewNStr $ bdt r) ]
- recType = fromEnum . bdt_Type
-
-instance Rec BDX where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BDX a01 a02 a03
- recPut bh r = do put bh $ bdx_Type r; put bh $ bdx_ r; put bh $ bdx r; return ()
- recSizeOf r = sum [ sizeOf $ bdx_Type r, sizeOf $ bdx_ r, sizeOf $ bdx r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bdx_Type r), viewField "_" (viewNumber $ bdx_ r), viewField "" (viewNStr $ bdx r) ]
- recType = fromEnum . bdx_Type
-
-instance Rec BFG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BFG a01 a02 a03
- recPut bh r = do put bh $ bfg_Type r; put bh $ bfg_ r; put bh $ bfg r; return ()
- recSizeOf r = sum [ sizeOf $ bfg_Type r, sizeOf $ bfg_ r, sizeOf $ bfg r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bfg_Type r), viewField "_" (viewNumber $ bfg_ r), viewField "" (viewNStr $ bfg r) ]
- recType = fromEnum . bfg_Type
-
-instance Rec BFM where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BFM a01 a02 a03
- recPut bh r = do put bh $ bfm_Type r; put bh $ bfm_ r; put bh $ bfm r; return ()
- recSizeOf r = sum [ sizeOf $ bfm_Type r, sizeOf $ bfm_ r, sizeOf $ bfm r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bfm_Type r), viewField "_" (viewNumber $ bfm_ r), viewField "" (viewNStr $ bfm r) ]
- recType = fromEnum . bfm_Type
-
-instance Rec BFN where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BFN a01 a02 a03
- recPut bh r = do put bh $ bfn_Type r; put bh $ bfn_ r; put bh $ bfn r; return ()
- recSizeOf r = sum [ sizeOf $ bfn_Type r, sizeOf $ bfn_ r, sizeOf $ bfn r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bfn_Type r), viewField "_" (viewNumber $ bfn_ r), viewField "" (viewNStr $ bfn r) ]
- recType = fromEnum . bfn_Type
-
-instance Rec BGR where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BGR a01 a02 a03
- recPut bh r = do put bh $ bgr_Type r; put bh $ bgr_ r; put bh $ bgr r; return ()
- recSizeOf r = sum [ sizeOf $ bgr_Type r, sizeOf $ bgr_ r, sizeOf $ bgr r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bgr_Type r), viewField "_" (viewNumber $ bgr_ r), viewField "" (viewNStr $ bgr r) ]
- recType = fromEnum . bgr_Type
-
-instance Rec BII where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BII a01 a02 a03
- recPut bh r = do put bh $ bii_Type r; put bh $ bii_ r; put bh $ bii_ImageObjectName r; return ()
- recSizeOf r = sum [ sizeOf $ bii_Type r, sizeOf $ bii_ r, sizeOf $ bii_ImageObjectName r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bii_Type r), viewField "_" (viewNumber $ bii_ r), viewField "ImageObjectName" (viewString $ bii_ImageObjectName r) ]
- recType = fromEnum . bii_Type
-
-instance Rec BIM where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BIM a01 a02 a03
- recPut bh r = do put bh $ bim_Type r; put bh $ bim_ r; put bh $ bim r; return ()
- recSizeOf r = sum [ sizeOf $ bim_Type r, sizeOf $ bim_ r, sizeOf $ bim r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bim_Type r), viewField "_" (viewNumber $ bim_ r), viewField "" (viewNStr $ bim r) ]
- recType = fromEnum . bim_Type
-
-instance Rec BMM where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BMM a01 a02 a03
- recPut bh r = do put bh $ bmm_Type r; put bh $ bmm_ r; put bh $ bmm r; return ()
- recSizeOf r = sum [ sizeOf $ bmm_Type r, sizeOf $ bmm_ r, sizeOf $ bmm r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bmm_Type r), viewField "_" (viewNumber $ bmm_ r), viewField "" (viewNStr $ bmm r) ]
- recType = fromEnum . bmm_Type
-
-instance Rec BMO where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BMO a01 a02 a03
- recPut bh r = do put bh $ bmo_Type r; put bh $ bmo_ r; put bh $ bmo r; return ()
- recSizeOf r = sum [ sizeOf $ bmo_Type r, sizeOf $ bmo_ r, sizeOf $ bmo r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bmo_Type r), viewField "_" (viewNumber $ bmo_ r), viewField "" (viewNStr $ bmo r) ]
- recType = fromEnum . bmo_Type
-
-instance Rec BNG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BNG a01 a02 a03
- recPut bh r = do put bh $ bng_Type r; put bh $ bng_ r; put bh $ bng r; return ()
- recSizeOf r = sum [ sizeOf $ bng_Type r, sizeOf $ bng_ r, sizeOf $ bng r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bng_Type r), viewField "_" (viewNumber $ bng_ r), viewField "" (viewNStr $ bng r) ]
- recType = fromEnum . bng_Type
-
-instance Rec BOC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BOC a01 a02 a03
- recPut bh r = do put bh $ boc_Type r; put bh $ boc_ r; put bh $ boc r; return ()
- recSizeOf r = sum [ sizeOf $ boc_Type r, sizeOf $ boc_ r, sizeOf $ boc r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ boc_Type r), viewField "_" (viewNumber $ boc_ r), viewField "" (viewNStr $ boc r) ]
- recType = fromEnum . boc_Type
-
-instance Rec BOG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BOG a01 a02 a03
- recPut bh r = do put bh $ bog_Type r; put bh $ bog_ r; put bh $ bog r; return ()
- recSizeOf r = sum [ sizeOf $ bog_Type r, sizeOf $ bog_ r, sizeOf $ bog r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bog_Type r), viewField "_" (viewNumber $ bog_ r), viewField "" (viewNStr $ bog r) ]
- recType = fromEnum . bog_Type
-
-instance Rec BPG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BPG a01 a02 a03
- recPut bh r = do put bh $ bpg_Type r; put bh $ bpg_ r; put bh $ bpg r; return ()
- recSizeOf r = sum [ sizeOf $ bpg_Type r, sizeOf $ bpg_ r, sizeOf $ bpg r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bpg_Type r), viewField "_" (viewNumber $ bpg_ r), viewField "" (viewNStr $ bpg r) ]
- recType = fromEnum . bpg_Type
-
-instance Rec BPM where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BPM a01 a02 a03
- recPut bh r = do put bh $ bpm_Type r; put bh $ bpm_ r; put bh $ bpm r; return ()
- recSizeOf r = sum [ sizeOf $ bpm_Type r, sizeOf $ bpm_ r, sizeOf $ bpm r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bpm_Type r), viewField "_" (viewNumber $ bpm_ r), viewField "" (viewNStr $ bpm r) ]
- recType = fromEnum . bpm_Type
-
-instance Rec BPS where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BPS a01 a02 a03
- recPut bh r = do put bh $ bps_Type r; put bh $ bps_ r; put bh $ bps r; return ()
- recSizeOf r = sum [ sizeOf $ bps_Type r, sizeOf $ bps_ r, sizeOf $ bps r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bps_Type r), viewField "_" (viewNumber $ bps_ r), viewField "" (viewNStr $ bps r) ]
- recType = fromEnum . bps_Type
-
-instance Rec BPT where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BPT a01 a02 a03
- recPut bh r = do put bh $ bpt_Type r; put bh $ bpt_ r; put bh $ bpt r; return ()
- recSizeOf r = sum [ sizeOf $ bpt_Type r, sizeOf $ bpt_ r, sizeOf $ bpt r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bpt_Type r), viewField "_" (viewNumber $ bpt_ r), viewField "" (viewNStr $ bpt r) ]
- recType = fromEnum . bpt_Type
-
-instance Rec BR where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BR a01 a02 a03
- recPut bh r = do put bh $ br_Type r; put bh $ br_ r; put bh $ br r; return ()
- recSizeOf r = sum [ sizeOf $ br_Type r, sizeOf $ br_ r, sizeOf $ br r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ br_Type r), viewField "_" (viewNumber $ br_ r), viewField "" (viewNStr $ br r) ]
- recType = fromEnum . br_Type
-
-instance Rec BRG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BRG a01 a02 a03
- recPut bh r = do put bh $ brg_Type r; put bh $ brg_ r; put bh $ brg r; return ()
- recSizeOf r = sum [ sizeOf $ brg_Type r, sizeOf $ brg_ r, sizeOf $ brg r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ brg_Type r), viewField "_" (viewNumber $ brg_ r), viewField "" (viewNStr $ brg r) ]
- recType = fromEnum . brg_Type
-
-instance Rec BSG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ BSG a01 a02 a03
- recPut bh r = do put bh $ bsg_Type r; put bh $ bsg_ r; put bh $ bsg r; return ()
- recSizeOf r = sum [ sizeOf $ bsg_Type r, sizeOf $ bsg_ r, sizeOf $ bsg r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bsg_Type r), viewField "_" (viewNumber $ bsg_ r), viewField "" (viewNStr $ bsg r) ]
- recType = fromEnum . bsg_Type
-
-instance Rec CAT where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ CAT a01 a02 a03
- recPut bh r = do put bh $ cat_Type r; put bh $ cat_ r; put bh $ cat r; return ()
- recSizeOf r = sum [ sizeOf $ cat_Type r, sizeOf $ cat_ r, sizeOf $ cat r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cat_Type r), viewField "_" (viewNumber $ cat_ r), viewField "" (viewNStr $ cat r) ]
- recType = fromEnum . cat_Type
-
-instance Rec CDD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ CDD a01 a02 a03
- recPut bh r = do put bh $ cdd_Type r; put bh $ cdd_ r; put bh $ cdd r; return ()
- recSizeOf r = sum [ sizeOf $ cdd_Type r, sizeOf $ cdd_ r, sizeOf $ cdd r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cdd_Type r), viewField "_" (viewNumber $ cdd_ r), viewField "" (viewNStr $ cdd r) ]
- recType = fromEnum . cdd_Type
-
-instance Rec CFC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; return $ CFC a01 a02 a03 a04
- recPut bh r = do put bh $ cfc_Type r; put bh $ cfc_ r; put bh $ cfc_CFIRepeatingGroupLength r; put bh $ cfc r; return ()
- recSizeOf r = sum [ sizeOf $ cfc_Type r, sizeOf $ cfc_ r, sizeOf $ cfc_CFIRepeatingGroupLength r, sizeOf $ cfc r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cfc_Type r), viewField "_" (viewNumber $ cfc_ r), viewField "CFIRepeatingGroupLength" (viewNumber $ cfc_CFIRepeatingGroupLength r), viewField "" (viewNStr $ cfc r) ]
- recType = fromEnum . cfc_Type
-
-instance Rec CFI where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ CFI a01 a02 a03
- recPut bh r = do put bh $ cfi_Type r; put bh $ cfi_ r; put bh $ cfi_Data r; return ()
- recSizeOf r = sum [ sizeOf $ cfi_Type r, sizeOf $ cfi_ r, sizeOf $ cfi_Data r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cfi_Type r), viewField "_" (viewNumber $ cfi_ r), viewField "Data" (viewData $ cfi_Data r) ]
- recType = fromEnum . cfi_Type
-
-instance Rec CFI_Data where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; return $ CFI_Data a01 a02 a03 a04
- recPut bh r = do put bh $ cfi_FontCharacterSetName r; put bh $ cfi_CodePageName r; put bh $ cfi_CodedFontName r; put bh $ cfi_Section r; return ()
- recSizeOf r = sum [ sizeOf $ cfi_FontCharacterSetName r, sizeOf $ cfi_CodePageName r, sizeOf $ cfi_CodedFontName r, sizeOf $ cfi_Section r ]
- recView r = viewRecord (typeOf r) [ viewField "FontCharacterSetName" (viewString $ cfi_FontCharacterSetName r), viewField "CodePageName" (viewString $ cfi_CodePageName r), viewField "CodedFontName" (viewString $ cfi_CodedFontName r), viewField "Section" (viewNumber $ cfi_Section r) ]
- recType r = 0
-
-instance RecData CFI CFI_Data where
- readData r = cfi_Data r
- writeData r cs = r { cfi_Data = cs }
-
-instance Rec CPC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; a05 <- get bh; a06 <- get bh; a07 <- get bh; a08 <- get bh; return $ CPC a01 a02 a03 a04 a05 a06 a07 a08
- recPut bh r = do put bh $ cpc_Type r; put bh $ cpc_ r; put bh $ cpc_GCGID r; put bh $ cpc_UseFlags r; put bh $ cpc_CPIRepeatingGroupLength r; put bh $ cpc_SpaceCharacterSection r; put bh $ cpc_UseFlags2 r; put bh $ cpc r; return ()
- recSizeOf r = sum [ sizeOf $ cpc_Type r, sizeOf $ cpc_ r, sizeOf $ cpc_GCGID r, sizeOf $ cpc_UseFlags r, sizeOf $ cpc_CPIRepeatingGroupLength r, sizeOf $ cpc_SpaceCharacterSection r, sizeOf $ cpc_UseFlags2 r, sizeOf $ cpc r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cpc_Type r), viewField "_" (viewNumber $ cpc_ r), viewField "GCGID" (viewString $ cpc_GCGID r), viewField "UseFlags" (viewNumber $ cpc_UseFlags r), viewField "CPIRepeatingGroupLength" (viewNumber $ cpc_CPIRepeatingGroupLength r), viewField "SpaceCharacterSection" (viewNumber $ cpc_SpaceCharacterSection r), viewField "UseFlags2" (viewNumber $ cpc_UseFlags2 r), viewField "" (viewNStr $ cpc r) ]
- recType = fromEnum . cpc_Type
-
-instance Rec CPD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ CPD a01 a02 a03
- recPut bh r = do put bh $ cpd_Type r; put bh $ cpd_ r; put bh $ cpd r; return ()
- recSizeOf r = sum [ sizeOf $ cpd_Type r, sizeOf $ cpd_ r, sizeOf $ cpd r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cpd_Type r), viewField "_" (viewNumber $ cpd_ r), viewField "" (viewNStr $ cpd r) ]
- recType = fromEnum . cpd_Type
-
-instance Rec CPI where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ CPI a01 a02 a03
- recPut bh r = do put bh $ cpi_Type r; put bh $ cpi_ r; put bh $ cpi_Data r; return ()
- recSizeOf r = sum [ sizeOf $ cpi_Type r, sizeOf $ cpi_ r, sizeOf $ cpi_Data r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cpi_Type r), viewField "_" (viewNumber $ cpi_ r), viewField "Data" (viewData $ cpi_Data r) ]
- recType = fromEnum . cpi_Type
-
-instance Rec CPI_Data where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ CPI_Data a01 a02 a03
- recPut bh r = do put bh $ cpi_GCGID r; put bh $ cpi_Section r; put bh $ cpi_CodePoint r; return ()
- recSizeOf r = sum [ sizeOf $ cpi_GCGID r, sizeOf $ cpi_Section r, sizeOf $ cpi_CodePoint r ]
- recView r = viewRecord (typeOf r) [ viewField "GCGID" (viewString $ cpi_GCGID r), viewField "Section" (viewNumber $ cpi_Section r), viewField "CodePoint" (viewNumber $ cpi_CodePoint r) ]
- recType r = 0
-
-instance RecData CPI CPI_Data where
- readData r = cpi_Data r
- writeData r cs = r { cpi_Data = cs }
-
-instance Rec CTC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ CTC a01 a02 a03
- recPut bh r = do put bh $ ctc_Type r; put bh $ ctc_ r; put bh $ ctc r; return ()
- recSizeOf r = sum [ sizeOf $ ctc_Type r, sizeOf $ ctc_ r, sizeOf $ ctc r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ctc_Type r), viewField "_" (viewNumber $ ctc_ r), viewField "" (viewNStr $ ctc r) ]
- recType = fromEnum . ctc_Type
-
-instance Rec DXD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ DXD a01 a02 a03
- recPut bh r = do put bh $ dxd_Type r; put bh $ dxd_ r; put bh $ dxd r; return ()
- recSizeOf r = sum [ sizeOf $ dxd_Type r, sizeOf $ dxd_ r, sizeOf $ dxd r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ dxd_Type r), viewField "_" (viewNumber $ dxd_ r), viewField "" (viewNStr $ dxd r) ]
- recType = fromEnum . dxd_Type
-
-instance Rec EAG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EAG a01 a02 a03
- recPut bh r = do put bh $ eag_Type r; put bh $ eag_ r; put bh $ eag r; return ()
- recSizeOf r = sum [ sizeOf $ eag_Type r, sizeOf $ eag_ r, sizeOf $ eag r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eag_Type r), viewField "_" (viewNumber $ eag_ r), viewField "" (viewNStr $ eag r) ]
- recType = fromEnum . eag_Type
-
-instance Rec EBC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EBC a01 a02 a03
- recPut bh r = do put bh $ ebc_Type r; put bh $ ebc_ r; put bh $ ebc r; return ()
- recSizeOf r = sum [ sizeOf $ ebc_Type r, sizeOf $ ebc_ r, sizeOf $ ebc r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ebc_Type r), viewField "_" (viewNumber $ ebc_ r), viewField "" (viewNStr $ ebc r) ]
- recType = fromEnum . ebc_Type
-
-instance Rec ECA where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ ECA a01 a02 a03
- recPut bh r = do put bh $ eca_Type r; put bh $ eca_ r; put bh $ eca r; return ()
- recSizeOf r = sum [ sizeOf $ eca_Type r, sizeOf $ eca_ r, sizeOf $ eca r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eca_Type r), viewField "_" (viewNumber $ eca_ r), viewField "" (viewNStr $ eca r) ]
- recType = fromEnum . eca_Type
-
-instance Rec ECF where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ ECF a01 a02 a03
- recPut bh r = do put bh $ ecf_Type r; put bh $ ecf_ r; put bh $ ecf r; return ()
- recSizeOf r = sum [ sizeOf $ ecf_Type r, sizeOf $ ecf_ r, sizeOf $ ecf r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ecf_Type r), viewField "_" (viewNumber $ ecf_ r), viewField "" (viewNStr $ ecf r) ]
- recType = fromEnum . ecf_Type
-
-instance Rec ECP where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ ECP a01 a02 a03
- recPut bh r = do put bh $ ecp_Type r; put bh $ ecp_ r; put bh $ ecp r; return ()
- recSizeOf r = sum [ sizeOf $ ecp_Type r, sizeOf $ ecp_ r, sizeOf $ ecp r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ecp_Type r), viewField "_" (viewNumber $ ecp_ r), viewField "" (viewNStr $ ecp r) ]
- recType = fromEnum . ecp_Type
-
-instance Rec EDG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EDG a01 a02 a03
- recPut bh r = do put bh $ edg_Type r; put bh $ edg_ r; put bh $ edg r; return ()
- recSizeOf r = sum [ sizeOf $ edg_Type r, sizeOf $ edg_ r, sizeOf $ edg r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ edg_Type r), viewField "_" (viewNumber $ edg_ r), viewField "" (viewNStr $ edg r) ]
- recType = fromEnum . edg_Type
-
-instance Rec EDI where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EDI a01 a02 a03
- recPut bh r = do put bh $ edi_Type r; put bh $ edi_ r; put bh $ edi r; return ()
- recSizeOf r = sum [ sizeOf $ edi_Type r, sizeOf $ edi_ r, sizeOf $ edi r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ edi_Type r), viewField "_" (viewNumber $ edi_ r), viewField "" (viewNStr $ edi r) ]
- recType = fromEnum . edi_Type
-
-instance Rec EDM where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EDM a01 a02 a03
- recPut bh r = do put bh $ edm_Type r; put bh $ edm_ r; put bh $ edm r; return ()
- recSizeOf r = sum [ sizeOf $ edm_Type r, sizeOf $ edm_ r, sizeOf $ edm r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ edm_Type r), viewField "_" (viewNumber $ edm_ r), viewField "" (viewNStr $ edm r) ]
- recType = fromEnum . edm_Type
-
-instance Rec EDT where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EDT a01 a02 a03
- recPut bh r = do put bh $ edt_Type r; put bh $ edt_ r; put bh $ edt r; return ()
- recSizeOf r = sum [ sizeOf $ edt_Type r, sizeOf $ edt_ r, sizeOf $ edt r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ edt_Type r), viewField "_" (viewNumber $ edt_ r), viewField "" (viewNStr $ edt r) ]
- recType = fromEnum . edt_Type
-
-instance Rec EDX where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EDX a01 a02 a03
- recPut bh r = do put bh $ edx_Type r; put bh $ edx_ r; put bh $ edx r; return ()
- recSizeOf r = sum [ sizeOf $ edx_Type r, sizeOf $ edx_ r, sizeOf $ edx r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ edx_Type r), viewField "_" (viewNumber $ edx_ r), viewField "" (viewNStr $ edx r) ]
- recType = fromEnum . edx_Type
-
-instance Rec EFG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EFG a01 a02 a03
- recPut bh r = do put bh $ efg_Type r; put bh $ efg_ r; put bh $ efg r; return ()
- recSizeOf r = sum [ sizeOf $ efg_Type r, sizeOf $ efg_ r, sizeOf $ efg r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ efg_Type r), viewField "_" (viewNumber $ efg_ r), viewField "" (viewNStr $ efg r) ]
- recType = fromEnum . efg_Type
-
-instance Rec EFM where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EFM a01 a02 a03
- recPut bh r = do put bh $ efm_Type r; put bh $ efm_ r; put bh $ efm r; return ()
- recSizeOf r = sum [ sizeOf $ efm_Type r, sizeOf $ efm_ r, sizeOf $ efm r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ efm_Type r), viewField "_" (viewNumber $ efm_ r), viewField "" (viewNStr $ efm r) ]
- recType = fromEnum . efm_Type
-
-instance Rec EFN where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EFN a01 a02 a03
- recPut bh r = do put bh $ efn_Type r; put bh $ efn_ r; put bh $ efn r; return ()
- recSizeOf r = sum [ sizeOf $ efn_Type r, sizeOf $ efn_ r, sizeOf $ efn r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ efn_Type r), viewField "_" (viewNumber $ efn_ r), viewField "" (viewNStr $ efn r) ]
- recType = fromEnum . efn_Type
-
-instance Rec EGR where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EGR a01 a02 a03
- recPut bh r = do put bh $ egr_Type r; put bh $ egr_ r; put bh $ egr r; return ()
- recSizeOf r = sum [ sizeOf $ egr_Type r, sizeOf $ egr_ r, sizeOf $ egr r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ egr_Type r), viewField "_" (viewNumber $ egr_ r), viewField "" (viewNStr $ egr r) ]
- recType = fromEnum . egr_Type
-
-instance Rec EII where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EII a01 a02 a03
- recPut bh r = do put bh $ eii_Type r; put bh $ eii_ r; put bh $ eii_ImageObjectName r; return ()
- recSizeOf r = sum [ sizeOf $ eii_Type r, sizeOf $ eii_ r, sizeOf $ eii_ImageObjectName r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eii_Type r), viewField "_" (viewNumber $ eii_ r), viewField "ImageObjectName" (viewString $ eii_ImageObjectName r) ]
- recType = fromEnum . eii_Type
-
-instance Rec EIM where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EIM a01 a02 a03
- recPut bh r = do put bh $ eim_Type r; put bh $ eim_ r; put bh $ eim r; return ()
- recSizeOf r = sum [ sizeOf $ eim_Type r, sizeOf $ eim_ r, sizeOf $ eim r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eim_Type r), viewField "_" (viewNumber $ eim_ r), viewField "" (viewNStr $ eim r) ]
- recType = fromEnum . eim_Type
-
-instance Rec EMM where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EMM a01 a02 a03
- recPut bh r = do put bh $ emm_Type r; put bh $ emm_ r; put bh $ emm r; return ()
- recSizeOf r = sum [ sizeOf $ emm_Type r, sizeOf $ emm_ r, sizeOf $ emm r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ emm_Type r), viewField "_" (viewNumber $ emm_ r), viewField "" (viewNStr $ emm r) ]
- recType = fromEnum . emm_Type
-
-instance Rec EMO where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EMO a01 a02 a03
- recPut bh r = do put bh $ emo_Type r; put bh $ emo_ r; put bh $ emo r; return ()
- recSizeOf r = sum [ sizeOf $ emo_Type r, sizeOf $ emo_ r, sizeOf $ emo r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ emo_Type r), viewField "_" (viewNumber $ emo_ r), viewField "" (viewNStr $ emo r) ]
- recType = fromEnum . emo_Type
-
-instance Rec ENG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ ENG a01 a02 a03
- recPut bh r = do put bh $ eng_Type r; put bh $ eng_ r; put bh $ eng r; return ()
- recSizeOf r = sum [ sizeOf $ eng_Type r, sizeOf $ eng_ r, sizeOf $ eng r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eng_Type r), viewField "_" (viewNumber $ eng_ r), viewField "" (viewNStr $ eng r) ]
- recType = fromEnum . eng_Type
-
-instance Rec EOC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EOC a01 a02 a03
- recPut bh r = do put bh $ eoc_Type r; put bh $ eoc_ r; put bh $ eoc r; return ()
- recSizeOf r = sum [ sizeOf $ eoc_Type r, sizeOf $ eoc_ r, sizeOf $ eoc r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eoc_Type r), viewField "_" (viewNumber $ eoc_ r), viewField "" (viewNStr $ eoc r) ]
- recType = fromEnum . eoc_Type
-
-instance Rec EOG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EOG a01 a02 a03
- recPut bh r = do put bh $ eog_Type r; put bh $ eog_ r; put bh $ eog r; return ()
- recSizeOf r = sum [ sizeOf $ eog_Type r, sizeOf $ eog_ r, sizeOf $ eog r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eog_Type r), viewField "_" (viewNumber $ eog_ r), viewField "" (viewNStr $ eog r) ]
- recType = fromEnum . eog_Type
-
-instance Rec EPG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EPG a01 a02 a03
- recPut bh r = do put bh $ epg_Type r; put bh $ epg_ r; put bh $ epg r; return ()
- recSizeOf r = sum [ sizeOf $ epg_Type r, sizeOf $ epg_ r, sizeOf $ epg r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ epg_Type r), viewField "_" (viewNumber $ epg_ r), viewField "" (viewNStr $ epg r) ]
- recType = fromEnum . epg_Type
-
-instance Rec EPM where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EPM a01 a02 a03
- recPut bh r = do put bh $ epm_Type r; put bh $ epm_ r; put bh $ epm r; return ()
- recSizeOf r = sum [ sizeOf $ epm_Type r, sizeOf $ epm_ r, sizeOf $ epm r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ epm_Type r), viewField "_" (viewNumber $ epm_ r), viewField "" (viewNStr $ epm r) ]
- recType = fromEnum . epm_Type
-
-instance Rec EPS where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EPS a01 a02 a03
- recPut bh r = do put bh $ eps_Type r; put bh $ eps_ r; put bh $ eps r; return ()
- recSizeOf r = sum [ sizeOf $ eps_Type r, sizeOf $ eps_ r, sizeOf $ eps r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eps_Type r), viewField "_" (viewNumber $ eps_ r), viewField "" (viewNStr $ eps r) ]
- recType = fromEnum . eps_Type
-
-instance Rec EPT where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ EPT a01 a02 a03
- recPut bh r = do put bh $ ept_Type r; put bh $ ept_ r; put bh $ ept r; return ()
- recSizeOf r = sum [ sizeOf $ ept_Type r, sizeOf $ ept_ r, sizeOf $ ept r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ept_Type r), viewField "_" (viewNumber $ ept_ r), viewField "" (viewNStr $ ept r) ]
- recType = fromEnum . ept_Type
-
-instance Rec ER where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ ER a01 a02 a03
- recPut bh r = do put bh $ er_Type r; put bh $ er_ r; put bh $ er r; return ()
- recSizeOf r = sum [ sizeOf $ er_Type r, sizeOf $ er_ r, sizeOf $ er r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ er_Type r), viewField "_" (viewNumber $ er_ r), viewField "" (viewNStr $ er r) ]
- recType = fromEnum . er_Type
-
-instance Rec ERG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ ERG a01 a02 a03
- recPut bh r = do put bh $ erg_Type r; put bh $ erg_ r; put bh $ erg r; return ()
- recSizeOf r = sum [ sizeOf $ erg_Type r, sizeOf $ erg_ r, sizeOf $ erg r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ erg_Type r), viewField "_" (viewNumber $ erg_ r), viewField "" (viewNStr $ erg r) ]
- recType = fromEnum . erg_Type
-
-instance Rec ESG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ ESG a01 a02 a03
- recPut bh r = do put bh $ esg_Type r; put bh $ esg_ r; put bh $ esg r; return ()
- recSizeOf r = sum [ sizeOf $ esg_Type r, sizeOf $ esg_ r, sizeOf $ esg r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ esg_Type r), viewField "_" (viewNumber $ esg_ r), viewField "" (viewNStr $ esg r) ]
- recType = fromEnum . esg_Type
-
-instance Rec FGD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ FGD a01 a02 a03
- recPut bh r = do put bh $ fgd_Type r; put bh $ fgd_ r; put bh $ fgd r; return ()
- recSizeOf r = sum [ sizeOf $ fgd_Type r, sizeOf $ fgd_ r, sizeOf $ fgd r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fgd_Type r), viewField "_" (viewNumber $ fgd_ r), viewField "" (viewNStr $ fgd r) ]
- recType = fromEnum . fgd_Type
-
-instance Rec FNC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; a05 <- get bh; a06 <- get bh; a07 <- get bh; a08 <- get bh; a09 <- get bh; a10 <- get bh; a11 <- get bh; a12 <- get bh; a13 <- get bh; a14 <- get bh; a15 <- get bh; a16 <- get bh; a17 <- get bh; a18 <- get bh; a19 <- get bh; return $ FNC a01 a02 a03 a04 a05 a06 a07 a08 a09 a10 a11 a12 a13 a14 a15 a16 a17 a18 a19
- recPut bh r = do put bh $ fnc_Type r; put bh $ fnc_ r; put bh $ fnc_Constant r; put bh $ fnc_PatternTechnologyIdentifier r; put bh $ fnc_FNCReserved1 r; put bh $ fnc_UseFlags r; put bh $ fnc_UnitXBase r; put bh $ fnc_UnitYBase r; put bh $ fnc_UnitXValue r; put bh $ fnc_UnitYValue r; put bh $ fnc_MaxWidth r; put bh $ fnc_MaxHeight r; put bh $ fnc_FNORepeatingGroupLength r; put bh $ fnc_FNIRepeatingGroupLength r; put bh $ fnc_PatternDataAlignmentCode r; put bh $ fnc_PatternDataCount1 r; put bh $ fnc_FNPRepeatingGroupLength r; put bh $ fnc_FNMRepeatingGroupLength r; put bh $ fnc r; return ()
- recSizeOf r = sum [ sizeOf $ fnc_Type r, sizeOf $ fnc_ r, sizeOf $ fnc_Constant r, sizeOf $ fnc_PatternTechnologyIdentifier r, sizeOf $ fnc_FNCReserved1 r, sizeOf $ fnc_UseFlags r, sizeOf $ fnc_UnitXBase r, sizeOf $ fnc_UnitYBase r, sizeOf $ fnc_UnitXValue r, sizeOf $ fnc_UnitYValue r, sizeOf $ fnc_MaxWidth r, sizeOf $ fnc_MaxHeight r, sizeOf $ fnc_FNORepeatingGroupLength r, sizeOf $ fnc_FNIRepeatingGroupLength r, sizeOf $ fnc_PatternDataAlignmentCode r, sizeOf $ fnc_PatternDataCount1 r, sizeOf $ fnc_FNPRepeatingGroupLength r, sizeOf $ fnc_FNMRepeatingGroupLength r, sizeOf $ fnc r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fnc_Type r), viewField "_" (viewNumber $ fnc_ r), viewField "Constant" (viewString $ fnc_Constant r), viewField "PatternTechnologyIdentifier" (viewNumber $ fnc_PatternTechnologyIdentifier r), viewField "FNCReserved1" (viewString $ fnc_FNCReserved1 r), viewField "UseFlags" (viewNumber $ fnc_UseFlags r), viewField "UnitXBase" (viewNumber $ fnc_UnitXBase r), viewField "UnitYBase" (viewNumber $ fnc_UnitYBase r), viewField "UnitXValue" (viewNumber $ fnc_UnitXValue r), viewField "UnitYValue" (viewNumber $ fnc_UnitYValue r), viewField "MaxWidth" (viewNumber $ fnc_MaxWidth r), viewField "MaxHeight" (viewNumber $ fnc_MaxHeight r), viewField "FNORepeatingGroupLength" (viewNumber $ fnc_FNORepeatingGroupLength r), viewField "FNIRepeatingGroupLength" (viewNumber $ fnc_FNIRepeatingGroupLength r), viewField "PatternDataAlignmentCode" (viewNumber $ fnc_PatternDataAlignmentCode r), viewField "PatternDataCount1" (viewString $ fnc_PatternDataCount1 r), viewField "FNPRepeatingGroupLength" (viewNumber $ fnc_FNPRepeatingGroupLength r), viewField "FNMRepeatingGroupLength" (viewNumber $ fnc_FNMRepeatingGroupLength r), viewField "" (viewNStr $ fnc r) ]
- recType = fromEnum . fnc_Type
-
-instance Rec FND where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ FND a01 a02 a03
- recPut bh r = do put bh $ fnd_Type r; put bh $ fnd_ r; put bh $ fnd r; return ()
- recSizeOf r = sum [ sizeOf $ fnd_Type r, sizeOf $ fnd_ r, sizeOf $ fnd r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fnd_Type r), viewField "_" (viewNumber $ fnd_ r), viewField "" (viewNStr $ fnd r) ]
- recType = fromEnum . fnd_Type
-
-instance Rec FNG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ FNG a01 a02 a03
- recPut bh r = do put bh $ fng_Type r; put bh $ fng_ r; put bh $ fng r; return ()
- recSizeOf r = sum [ sizeOf $ fng_Type r, sizeOf $ fng_ r, sizeOf $ fng r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fng_Type r), viewField "_" (viewNumber $ fng_ r), viewField "" (viewNStr $ fng r) ]
- recType = fromEnum . fng_Type
-
-instance Rec FNI where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ FNI a01 a02 a03
- recPut bh r = do put bh $ fni_Type r; put bh $ fni_ r; put bh $ fni_Data r; return ()
- recSizeOf r = sum [ sizeOf $ fni_Type r, sizeOf $ fni_ r, sizeOf $ fni_Data r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fni_Type r), viewField "_" (viewNumber $ fni_ r), viewField "Data" (viewData $ fni_Data r) ]
- recType = fromEnum . fni_Type
-
-instance Rec FNI_Data where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; a05 <- get bh; a06 <- get bh; a07 <- get bh; a08 <- get bh; a09 <- get bh; a10 <- get bh; a11 <- get bh; return $ FNI_Data a01 a02 a03 a04 a05 a06 a07 a08 a09 a10 a11
- recPut bh r = do put bh $ fni_GCGID r; put bh $ fni_CharacterIncrement r; put bh $ fni_AscendHeight r; put bh $ fni_DescendDepth r; put bh $ fni_Reserved1 r; put bh $ fni_FNMCount r; put bh $ fni_ASpace r; put bh $ fni_BSpace r; put bh $ fni_CSpace r; put bh $ fni_Reserved2 r; put bh $ fni_BaseOffset r; return ()
- recSizeOf r = sum [ sizeOf $ fni_GCGID r, sizeOf $ fni_CharacterIncrement r, sizeOf $ fni_AscendHeight r, sizeOf $ fni_DescendDepth r, sizeOf $ fni_Reserved1 r, sizeOf $ fni_FNMCount r, sizeOf $ fni_ASpace r, sizeOf $ fni_BSpace r, sizeOf $ fni_CSpace r, sizeOf $ fni_Reserved2 r, sizeOf $ fni_BaseOffset r ]
- recView r = viewRecord (typeOf r) [ viewField "GCGID" (viewString $ fni_GCGID r), viewField "CharacterIncrement" (viewNumber $ fni_CharacterIncrement r), viewField "AscendHeight" (viewNumber $ fni_AscendHeight r), viewField "DescendDepth" (viewNumber $ fni_DescendDepth r), viewField "Reserved1" (viewNumber $ fni_Reserved1 r), viewField "FNMCount" (viewNumber $ fni_FNMCount r), viewField "ASpace" (viewNumber $ fni_ASpace r), viewField "BSpace" (viewNumber $ fni_BSpace r), viewField "CSpace" (viewNumber $ fni_CSpace r), viewField "Reserved2" (viewNumber $ fni_Reserved2 r), viewField "BaseOffset" (viewNumber $ fni_BaseOffset r) ]
- recType r = 0
-
-instance RecData FNI FNI_Data where
- readData r = fni_Data r
- writeData r cs = r { fni_Data = cs }
-
-instance Rec FNM where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ FNM a01 a02 a03
- recPut bh r = do put bh $ fnm_Type r; put bh $ fnm_ r; put bh $ fnm_Data r; return ()
- recSizeOf r = sum [ sizeOf $ fnm_Type r, sizeOf $ fnm_ r, sizeOf $ fnm_Data r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fnm_Type r), viewField "_" (viewNumber $ fnm_ r), viewField "Data" (viewData $ fnm_Data r) ]
- recType = fromEnum . fnm_Type
-
-instance Rec FNM_Data where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ FNM_Data a01 a02 a03
- recPut bh r = do put bh $ fnm_Width r; put bh $ fnm_Height r; put bh $ fnm_Offset r; return ()
- recSizeOf r = sum [ sizeOf $ fnm_Width r, sizeOf $ fnm_Height r, sizeOf $ fnm_Offset r ]
- recView r = viewRecord (typeOf r) [ viewField "Width" (viewNumber $ fnm_Width r), viewField "Height" (viewNumber $ fnm_Height r), viewField "Offset" (viewNumber $ fnm_Offset r) ]
- recType r = 0
-
-instance RecData FNM FNM_Data where
- readData r = fnm_Data r
- writeData r cs = r { fnm_Data = cs }
-
-instance Rec FNN where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ FNN a01 a02 a03
- recPut bh r = do put bh $ fnn_Type r; put bh $ fnn_ r; put bh $ fnn r; return ()
- recSizeOf r = sum [ sizeOf $ fnn_Type r, sizeOf $ fnn_ r, sizeOf $ fnn r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fnn_Type r), viewField "_" (viewNumber $ fnn_ r), viewField "" (viewNStr $ fnn r) ]
- recType = fromEnum . fnn_Type
-
-instance Rec FNO where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; a05 <- get bh; a06 <- get bh; a07 <- get bh; a08 <- get bh; return $ FNO a01 a02 a03 a04 a05 a06 a07 a08
- recPut bh r = do put bh $ fno_Type r; put bh $ fno_ r; put bh $ fno_Reserved r; put bh $ fno_CharacterRotation r; put bh $ fno_MaxBaseOffset r; put bh $ fno_MaxCharacterIncrement r; put bh $ fno_SpaceCharacterIncrement r; put bh $ fno r; return ()
- recSizeOf r = sum [ sizeOf $ fno_Type r, sizeOf $ fno_ r, sizeOf $ fno_Reserved r, sizeOf $ fno_CharacterRotation r, sizeOf $ fno_MaxBaseOffset r, sizeOf $ fno_MaxCharacterIncrement r, sizeOf $ fno_SpaceCharacterIncrement r, sizeOf $ fno r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fno_Type r), viewField "_" (viewNumber $ fno_ r), viewField "Reserved" (viewNumber $ fno_Reserved r), viewField "CharacterRotation" (viewNumber $ fno_CharacterRotation r), viewField "MaxBaseOffset" (viewNumber $ fno_MaxBaseOffset r), viewField "MaxCharacterIncrement" (viewNumber $ fno_MaxCharacterIncrement r), viewField "SpaceCharacterIncrement" (viewNumber $ fno_SpaceCharacterIncrement r), viewField "" (viewNStr $ fno r) ]
- recType = fromEnum . fno_Type
-
-instance Rec FNP where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ FNP a01 a02 a03
- recPut bh r = do put bh $ fnp_Type r; put bh $ fnp_ r; put bh $ fnp r; return ()
- recSizeOf r = sum [ sizeOf $ fnp_Type r, sizeOf $ fnp_ r, sizeOf $ fnp r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fnp_Type r), viewField "_" (viewNumber $ fnp_ r), viewField "" (viewNStr $ fnp r) ]
- recType = fromEnum . fnp_Type
-
-instance Rec GAD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ GAD a01 a02 a03
- recPut bh r = do put bh $ gad_Type r; put bh $ gad_ r; put bh $ gad r; return ()
- recSizeOf r = sum [ sizeOf $ gad_Type r, sizeOf $ gad_ r, sizeOf $ gad r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ gad_Type r), viewField "_" (viewNumber $ gad_ r), viewField "" (viewNStr $ gad r) ]
- recType = fromEnum . gad_Type
-
-instance Rec GDD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ GDD a01 a02 a03
- recPut bh r = do put bh $ gdd_Type r; put bh $ gdd_ r; put bh $ gdd r; return ()
- recSizeOf r = sum [ sizeOf $ gdd_Type r, sizeOf $ gdd_ r, sizeOf $ gdd r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ gdd_Type r), viewField "_" (viewNumber $ gdd_ r), viewField "" (viewNStr $ gdd r) ]
- recType = fromEnum . gdd_Type
-
-instance Rec ICP where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; a05 <- get bh; a06 <- get bh; a07 <- get bh; a08 <- get bh; return $ ICP a01 a02 a03 a04 a05 a06 a07 a08
- recPut bh r = do put bh $ icp_Type r; put bh $ icp_ r; put bh $ icp_XCellOffset r; put bh $ icp_YCellOffset r; put bh $ icp_XCellSize r; put bh $ icp_YCellSize r; put bh $ icp_XFillSize r; put bh $ icp_YFillSize r; return ()
- recSizeOf r = sum [ sizeOf $ icp_Type r, sizeOf $ icp_ r, sizeOf $ icp_XCellOffset r, sizeOf $ icp_YCellOffset r, sizeOf $ icp_XCellSize r, sizeOf $ icp_YCellSize r, sizeOf $ icp_XFillSize r, sizeOf $ icp_YFillSize r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ icp_Type r), viewField "_" (viewNumber $ icp_ r), viewField "XCellOffset" (viewNumber $ icp_XCellOffset r), viewField "YCellOffset" (viewNumber $ icp_YCellOffset r), viewField "XCellSize" (viewNumber $ icp_XCellSize r), viewField "YCellSize" (viewNumber $ icp_YCellSize r), viewField "XFillSize" (viewNumber $ icp_XFillSize r), viewField "YFillSize" (viewNumber $ icp_YFillSize r) ]
- recType = fromEnum . icp_Type
-
-instance Rec IDD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ IDD a01 a02 a03
- recPut bh r = do put bh $ idd_Type r; put bh $ idd_ r; put bh $ idd r; return ()
- recSizeOf r = sum [ sizeOf $ idd_Type r, sizeOf $ idd_ r, sizeOf $ idd r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ idd_Type r), viewField "_" (viewNumber $ idd_ r), viewField "" (viewNStr $ idd r) ]
- recType = fromEnum . idd_Type
-
-instance Rec IEL where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ IEL a01 a02 a03
- recPut bh r = do put bh $ iel_Type r; put bh $ iel_ r; put bh $ iel r; return ()
- recSizeOf r = sum [ sizeOf $ iel_Type r, sizeOf $ iel_ r, sizeOf $ iel r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ iel_Type r), viewField "_" (viewNumber $ iel_ r), viewField "" (viewNStr $ iel r) ]
- recType = fromEnum . iel_Type
-
-instance Rec IID where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; a05 <- get bh; a06 <- get bh; a07 <- get bh; a08 <- get bh; a09 <- get bh; a10 <- get bh; a11 <- get bh; a12 <- get bh; a13 <- get bh; a14 <- get bh; return $ IID a01 a02 a03 a04 a05 a06 a07 a08 a09 a10 a11 a12 a13 a14
- recPut bh r = do put bh $ iid_Type r; put bh $ iid_ r; put bh $ iid_ConstantData1 r; put bh $ iid_XBase r; put bh $ iid_YBase r; put bh $ iid_XUnits r; put bh $ iid_YUnits r; put bh $ iid_XSize r; put bh $ iid_YSize r; put bh $ iid_ConstantData2 r; put bh $ iid_XCellSizeDefault r; put bh $ iid_YCellSizeDefault r; put bh $ iid_ConstantData3 r; put bh $ iid_Color r; return ()
- recSizeOf r = sum [ sizeOf $ iid_Type r, sizeOf $ iid_ r, sizeOf $ iid_ConstantData1 r, sizeOf $ iid_XBase r, sizeOf $ iid_YBase r, sizeOf $ iid_XUnits r, sizeOf $ iid_YUnits r, sizeOf $ iid_XSize r, sizeOf $ iid_YSize r, sizeOf $ iid_ConstantData2 r, sizeOf $ iid_XCellSizeDefault r, sizeOf $ iid_YCellSizeDefault r, sizeOf $ iid_ConstantData3 r, sizeOf $ iid_Color r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ iid_Type r), viewField "_" (viewNumber $ iid_ r), viewField "ConstantData1" (viewString $ iid_ConstantData1 r), viewField "XBase" (viewNumber $ iid_XBase r), viewField "YBase" (viewNumber $ iid_YBase r), viewField "XUnits" (viewNumber $ iid_XUnits r), viewField "YUnits" (viewNumber $ iid_YUnits r), viewField "XSize" (viewNumber $ iid_XSize r), viewField "YSize" (viewNumber $ iid_YSize r), viewField "ConstantData2" (viewString $ iid_ConstantData2 r), viewField "XCellSizeDefault" (viewNumber $ iid_XCellSizeDefault r), viewField "YCellSizeDefault" (viewNumber $ iid_YCellSizeDefault r), viewField "ConstantData3" (viewString $ iid_ConstantData3 r), viewField "Color" (viewNumber $ iid_Color r) ]
- recType = fromEnum . iid_Type
-
-instance Rec IMM where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ IMM a01 a02 a03
- recPut bh r = do put bh $ imm_Type r; put bh $ imm_ r; put bh $ imm r; return ()
- recSizeOf r = sum [ sizeOf $ imm_Type r, sizeOf $ imm_ r, sizeOf $ imm r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ imm_Type r), viewField "_" (viewNumber $ imm_ r), viewField "" (viewNStr $ imm r) ]
- recType = fromEnum . imm_Type
-
-instance Rec IOB where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ IOB a01 a02 a03
- recPut bh r = do put bh $ iob_Type r; put bh $ iob_ r; put bh $ iob r; return ()
- recSizeOf r = sum [ sizeOf $ iob_Type r, sizeOf $ iob_ r, sizeOf $ iob r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ iob_Type r), viewField "_" (viewNumber $ iob_ r), viewField "" (viewNStr $ iob r) ]
- recType = fromEnum . iob_Type
-
-instance Rec IOC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; a05 <- get bh; a06 <- get bh; a07 <- get bh; a08 <- get bh; a09 <- get bh; a10 <- get bh; a11 <- get bh; a12 <- get bh; return $ IOC a01 a02 a03 a04 a05 a06 a07 a08 a09 a10 a11 a12
- recPut bh r = do put bh $ ioc_Type r; put bh $ ioc_ r; put bh $ ioc_Reserved1 r; put bh $ ioc_XOffset r; put bh $ ioc_Reserved2 r; put bh $ ioc_YOffset r; put bh $ ioc_XOrientation r; put bh $ ioc_YOrientation r; put bh $ ioc_ConstantData1 r; put bh $ ioc_XMap r; put bh $ ioc_YMap r; put bh $ ioc_ConstantData2 r; return ()
- recSizeOf r = sum [ sizeOf $ ioc_Type r, sizeOf $ ioc_ r, sizeOf $ ioc_Reserved1 r, sizeOf $ ioc_XOffset r, sizeOf $ ioc_Reserved2 r, sizeOf $ ioc_YOffset r, sizeOf $ ioc_XOrientation r, sizeOf $ ioc_YOrientation r, sizeOf $ ioc_ConstantData1 r, sizeOf $ ioc_XMap r, sizeOf $ ioc_YMap r, sizeOf $ ioc_ConstantData2 r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ioc_Type r), viewField "_" (viewNumber $ ioc_ r), viewField "Reserved1" (viewString $ ioc_Reserved1 r), viewField "XOffset" (viewNumber $ ioc_XOffset r), viewField "Reserved2" (viewString $ ioc_Reserved2 r), viewField "YOffset" (viewNumber $ ioc_YOffset r), viewField "XOrientation" (viewNumber $ ioc_XOrientation r), viewField "YOrientation" (viewNumber $ ioc_YOrientation r), viewField "ConstantData1" (viewString $ ioc_ConstantData1 r), viewField "XMap" (viewNumber $ ioc_XMap r), viewField "YMap" (viewNumber $ ioc_YMap r), viewField "ConstantData2" (viewString $ ioc_ConstantData2 r) ]
- recType = fromEnum . ioc_Type
-
-instance Rec IPD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ IPD a01 a02 a03
- recPut bh r = do put bh $ ipd_Type r; put bh $ ipd_ r; put bh $ ipd r; return ()
- recSizeOf r = sum [ sizeOf $ ipd_Type r, sizeOf $ ipd_ r, sizeOf $ ipd r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ipd_Type r), viewField "_" (viewNumber $ ipd_ r), viewField "" (viewNStr $ ipd r) ]
- recType = fromEnum . ipd_Type
-
-instance Rec IPG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ IPG a01 a02 a03
- recPut bh r = do put bh $ ipg_Type r; put bh $ ipg_ r; put bh $ ipg r; return ()
- recSizeOf r = sum [ sizeOf $ ipg_Type r, sizeOf $ ipg_ r, sizeOf $ ipg r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ipg_Type r), viewField "_" (viewNumber $ ipg_ r), viewField "" (viewNStr $ ipg r) ]
- recType = fromEnum . ipg_Type
-
-instance Rec IPO where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ IPO a01 a02 a03
- recPut bh r = do put bh $ ipo_Type r; put bh $ ipo_ r; put bh $ ipo r; return ()
- recSizeOf r = sum [ sizeOf $ ipo_Type r, sizeOf $ ipo_ r, sizeOf $ ipo r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ipo_Type r), viewField "_" (viewNumber $ ipo_ r), viewField "" (viewNStr $ ipo r) ]
- recType = fromEnum . ipo_Type
-
-instance Rec IPS where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ IPS a01 a02 a03
- recPut bh r = do put bh $ ips_Type r; put bh $ ips_ r; put bh $ ips r; return ()
- recSizeOf r = sum [ sizeOf $ ips_Type r, sizeOf $ ips_ r, sizeOf $ ips r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ips_Type r), viewField "_" (viewNumber $ ips_ r), viewField "" (viewNStr $ ips r) ]
- recType = fromEnum . ips_Type
-
-instance Rec IRD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ IRD a01 a02 a03
- recPut bh r = do put bh $ ird_Type r; put bh $ ird_ r; put bh $ ird_ImageData r; return ()
- recSizeOf r = sum [ sizeOf $ ird_Type r, sizeOf $ ird_ r, sizeOf $ ird_ImageData r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ird_Type r), viewField "_" (viewNumber $ ird_ r), viewField "ImageData" (viewNStr $ ird_ImageData r) ]
- recType = fromEnum . ird_Type
-
-instance Rec LLE where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ LLE a01 a02 a03
- recPut bh r = do put bh $ lle_Type r; put bh $ lle_ r; put bh $ lle r; return ()
- recSizeOf r = sum [ sizeOf $ lle_Type r, sizeOf $ lle_ r, sizeOf $ lle r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ lle_Type r), viewField "_" (viewNumber $ lle_ r), viewField "" (viewNStr $ lle r) ]
- recType = fromEnum . lle_Type
-
-instance Rec LNC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ LNC a01 a02 a03
- recPut bh r = do put bh $ lnc_Type r; put bh $ lnc_ r; put bh $ lnc r; return ()
- recSizeOf r = sum [ sizeOf $ lnc_Type r, sizeOf $ lnc_ r, sizeOf $ lnc r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ lnc_Type r), viewField "_" (viewNumber $ lnc_ r), viewField "" (viewNStr $ lnc r) ]
- recType = fromEnum . lnc_Type
-
-instance Rec LND where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ LND a01 a02 a03
- recPut bh r = do put bh $ lnd_Type r; put bh $ lnd_ r; put bh $ lnd r; return ()
- recSizeOf r = sum [ sizeOf $ lnd_Type r, sizeOf $ lnd_ r, sizeOf $ lnd r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ lnd_Type r), viewField "_" (viewNumber $ lnd_ r), viewField "" (viewNStr $ lnd r) ]
- recType = fromEnum . lnd_Type
-
-instance Rec MBC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MBC a01 a02 a03
- recPut bh r = do put bh $ mbc_Type r; put bh $ mbc_ r; put bh $ mbc r; return ()
- recSizeOf r = sum [ sizeOf $ mbc_Type r, sizeOf $ mbc_ r, sizeOf $ mbc r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mbc_Type r), viewField "_" (viewNumber $ mbc_ r), viewField "" (viewNStr $ mbc r) ]
- recType = fromEnum . mbc_Type
-
-instance Rec MCA where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MCA a01 a02 a03
- recPut bh r = do put bh $ mca_Type r; put bh $ mca_ r; put bh $ mca r; return ()
- recSizeOf r = sum [ sizeOf $ mca_Type r, sizeOf $ mca_ r, sizeOf $ mca r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mca_Type r), viewField "_" (viewNumber $ mca_ r), viewField "" (viewNStr $ mca r) ]
- recType = fromEnum . mca_Type
-
-instance Rec MCC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MCC a01 a02 a03
- recPut bh r = do put bh $ mcc_Type r; put bh $ mcc_ r; put bh $ mcc r; return ()
- recSizeOf r = sum [ sizeOf $ mcc_Type r, sizeOf $ mcc_ r, sizeOf $ mcc r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mcc_Type r), viewField "_" (viewNumber $ mcc_ r), viewField "" (viewNStr $ mcc r) ]
- recType = fromEnum . mcc_Type
-
-instance Rec MCD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MCD a01 a02 a03
- recPut bh r = do put bh $ mcd_Type r; put bh $ mcd_ r; put bh $ mcd r; return ()
- recSizeOf r = sum [ sizeOf $ mcd_Type r, sizeOf $ mcd_ r, sizeOf $ mcd r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mcd_Type r), viewField "_" (viewNumber $ mcd_ r), viewField "" (viewNStr $ mcd r) ]
- recType = fromEnum . mcd_Type
-
+import OpenAFP.Prelude.InstanceAFP.B ()
+import OpenAFP.Prelude.InstanceAFP.C ()
+import OpenAFP.Prelude.InstanceAFP.D ()
+import OpenAFP.Prelude.InstanceAFP.E ()
+import OpenAFP.Prelude.InstanceAFP.F ()
+import OpenAFP.Prelude.InstanceAFP.G ()
+import OpenAFP.Prelude.InstanceAFP.I ()
+import OpenAFP.Prelude.InstanceAFP.L ()
+import OpenAFP.Prelude.InstanceAFP.M ()
diff --git a/src/OpenAFP/Prelude/InstanceAFP/B.hs b/src/OpenAFP/Prelude/InstanceAFP/B.hs
new file mode 100644
--- /dev/null
+++ b/src/OpenAFP/Prelude/InstanceAFP/B.hs
@@ -0,0 +1,216 @@
+
+module OpenAFP.Prelude.InstanceAFP.B () where
+import OpenAFP.Types
+import OpenAFP.Records
+import OpenAFP.Internals
+
+instance Rec BAG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BAG a01 a02 a03
+ recPut r = do put $ bag_Type r; put $ bag_ r; put $ bag r; return ()
+ recSizeOf r = sum [ sizeOf $ bag_Type r, sizeOf $ bag_ r, sizeOf $ bag r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bag_Type r), viewField "_" (viewNumber $ bag_ r), viewField "" (viewNStr $ bag r) ]
+ recType = fromEnum . bag_Type
+
+instance Rec BBC where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BBC a01 a02 a03
+ recPut r = do put $ bbc_Type r; put $ bbc_ r; put $ bbc r; return ()
+ recSizeOf r = sum [ sizeOf $ bbc_Type r, sizeOf $ bbc_ r, sizeOf $ bbc r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bbc_Type r), viewField "_" (viewNumber $ bbc_ r), viewField "" (viewNStr $ bbc r) ]
+ recType = fromEnum . bbc_Type
+
+instance Rec BCA where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BCA a01 a02 a03
+ recPut r = do put $ bca_Type r; put $ bca_ r; put $ bca r; return ()
+ recSizeOf r = sum [ sizeOf $ bca_Type r, sizeOf $ bca_ r, sizeOf $ bca r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bca_Type r), viewField "_" (viewNumber $ bca_ r), viewField "" (viewNStr $ bca r) ]
+ recType = fromEnum . bca_Type
+
+instance Rec BCF where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BCF a01 a02 a03
+ recPut r = do put $ bcf_Type r; put $ bcf_ r; put $ bcf r; return ()
+ recSizeOf r = sum [ sizeOf $ bcf_Type r, sizeOf $ bcf_ r, sizeOf $ bcf r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bcf_Type r), viewField "_" (viewNumber $ bcf_ r), viewField "" (viewNStr $ bcf r) ]
+ recType = fromEnum . bcf_Type
+
+instance Rec BCP where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BCP a01 a02 a03
+ recPut r = do put $ bcp_Type r; put $ bcp_ r; put $ bcp r; return ()
+ recSizeOf r = sum [ sizeOf $ bcp_Type r, sizeOf $ bcp_ r, sizeOf $ bcp r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bcp_Type r), viewField "_" (viewNumber $ bcp_ r), viewField "" (viewNStr $ bcp r) ]
+ recType = fromEnum . bcp_Type
+
+instance Rec BDA where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BDA a01 a02 a03
+ recPut r = do put $ bda_Type r; put $ bda_ r; put $ bda r; return ()
+ recSizeOf r = sum [ sizeOf $ bda_Type r, sizeOf $ bda_ r, sizeOf $ bda r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bda_Type r), viewField "_" (viewNumber $ bda_ r), viewField "" (viewNStr $ bda r) ]
+ recType = fromEnum . bda_Type
+
+instance Rec BDD where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BDD a01 a02 a03
+ recPut r = do put $ bdd_Type r; put $ bdd_ r; put $ bdd r; return ()
+ recSizeOf r = sum [ sizeOf $ bdd_Type r, sizeOf $ bdd_ r, sizeOf $ bdd r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bdd_Type r), viewField "_" (viewNumber $ bdd_ r), viewField "" (viewNStr $ bdd r) ]
+ recType = fromEnum . bdd_Type
+
+instance Rec BDG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BDG a01 a02 a03
+ recPut r = do put $ bdg_Type r; put $ bdg_ r; put $ bdg r; return ()
+ recSizeOf r = sum [ sizeOf $ bdg_Type r, sizeOf $ bdg_ r, sizeOf $ bdg r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bdg_Type r), viewField "_" (viewNumber $ bdg_ r), viewField "" (viewNStr $ bdg r) ]
+ recType = fromEnum . bdg_Type
+
+instance Rec BDI where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BDI a01 a02 a03
+ recPut r = do put $ bdi_Type r; put $ bdi_ r; put $ bdi r; return ()
+ recSizeOf r = sum [ sizeOf $ bdi_Type r, sizeOf $ bdi_ r, sizeOf $ bdi r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bdi_Type r), viewField "_" (viewNumber $ bdi_ r), viewField "" (viewNStr $ bdi r) ]
+ recType = fromEnum . bdi_Type
+
+instance Rec BDM where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BDM a01 a02 a03
+ recPut r = do put $ bdm_Type r; put $ bdm_ r; put $ bdm r; return ()
+ recSizeOf r = sum [ sizeOf $ bdm_Type r, sizeOf $ bdm_ r, sizeOf $ bdm r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bdm_Type r), viewField "_" (viewNumber $ bdm_ r), viewField "" (viewNStr $ bdm r) ]
+ recType = fromEnum . bdm_Type
+
+instance Rec BDT where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BDT a01 a02 a03
+ recPut r = do put $ bdt_Type r; put $ bdt_ r; put $ bdt r; return ()
+ recSizeOf r = sum [ sizeOf $ bdt_Type r, sizeOf $ bdt_ r, sizeOf $ bdt r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bdt_Type r), viewField "_" (viewNumber $ bdt_ r), viewField "" (viewNStr $ bdt r) ]
+ recType = fromEnum . bdt_Type
+
+instance Rec BDX where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BDX a01 a02 a03
+ recPut r = do put $ bdx_Type r; put $ bdx_ r; put $ bdx r; return ()
+ recSizeOf r = sum [ sizeOf $ bdx_Type r, sizeOf $ bdx_ r, sizeOf $ bdx r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bdx_Type r), viewField "_" (viewNumber $ bdx_ r), viewField "" (viewNStr $ bdx r) ]
+ recType = fromEnum . bdx_Type
+
+instance Rec BFG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BFG a01 a02 a03
+ recPut r = do put $ bfg_Type r; put $ bfg_ r; put $ bfg r; return ()
+ recSizeOf r = sum [ sizeOf $ bfg_Type r, sizeOf $ bfg_ r, sizeOf $ bfg r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bfg_Type r), viewField "_" (viewNumber $ bfg_ r), viewField "" (viewNStr $ bfg r) ]
+ recType = fromEnum . bfg_Type
+
+instance Rec BFM where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BFM a01 a02 a03
+ recPut r = do put $ bfm_Type r; put $ bfm_ r; put $ bfm r; return ()
+ recSizeOf r = sum [ sizeOf $ bfm_Type r, sizeOf $ bfm_ r, sizeOf $ bfm r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bfm_Type r), viewField "_" (viewNumber $ bfm_ r), viewField "" (viewNStr $ bfm r) ]
+ recType = fromEnum . bfm_Type
+
+instance Rec BFN where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BFN a01 a02 a03
+ recPut r = do put $ bfn_Type r; put $ bfn_ r; put $ bfn r; return ()
+ recSizeOf r = sum [ sizeOf $ bfn_Type r, sizeOf $ bfn_ r, sizeOf $ bfn r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bfn_Type r), viewField "_" (viewNumber $ bfn_ r), viewField "" (viewNStr $ bfn r) ]
+ recType = fromEnum . bfn_Type
+
+instance Rec BGR where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BGR a01 a02 a03
+ recPut r = do put $ bgr_Type r; put $ bgr_ r; put $ bgr r; return ()
+ recSizeOf r = sum [ sizeOf $ bgr_Type r, sizeOf $ bgr_ r, sizeOf $ bgr r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bgr_Type r), viewField "_" (viewNumber $ bgr_ r), viewField "" (viewNStr $ bgr r) ]
+ recType = fromEnum . bgr_Type
+
+instance Rec BII where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BII a01 a02 a03
+ recPut r = do put $ bii_Type r; put $ bii_ r; put $ bii_ImageObjectName r; return ()
+ recSizeOf r = sum [ sizeOf $ bii_Type r, sizeOf $ bii_ r, sizeOf $ bii_ImageObjectName r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bii_Type r), viewField "_" (viewNumber $ bii_ r), viewField "ImageObjectName" (viewAStr $ bii_ImageObjectName r) ]
+ recType = fromEnum . bii_Type
+
+instance Rec BIM where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BIM a01 a02 a03
+ recPut r = do put $ bim_Type r; put $ bim_ r; put $ bim r; return ()
+ recSizeOf r = sum [ sizeOf $ bim_Type r, sizeOf $ bim_ r, sizeOf $ bim r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bim_Type r), viewField "_" (viewNumber $ bim_ r), viewField "" (viewAStr $ bim r) ]
+ recType = fromEnum . bim_Type
+
+instance Rec BMM where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BMM a01 a02 a03
+ recPut r = do put $ bmm_Type r; put $ bmm_ r; put $ bmm r; return ()
+ recSizeOf r = sum [ sizeOf $ bmm_Type r, sizeOf $ bmm_ r, sizeOf $ bmm r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bmm_Type r), viewField "_" (viewNumber $ bmm_ r), viewField "" (viewNStr $ bmm r) ]
+ recType = fromEnum . bmm_Type
+
+instance Rec BMO where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BMO a01 a02 a03
+ recPut r = do put $ bmo_Type r; put $ bmo_ r; put $ bmo r; return ()
+ recSizeOf r = sum [ sizeOf $ bmo_Type r, sizeOf $ bmo_ r, sizeOf $ bmo r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bmo_Type r), viewField "_" (viewNumber $ bmo_ r), viewField "" (viewNStr $ bmo r) ]
+ recType = fromEnum . bmo_Type
+
+instance Rec BNG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BNG a01 a02 a03
+ recPut r = do put $ bng_Type r; put $ bng_ r; put $ bng r; return ()
+ recSizeOf r = sum [ sizeOf $ bng_Type r, sizeOf $ bng_ r, sizeOf $ bng r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bng_Type r), viewField "_" (viewNumber $ bng_ r), viewField "" (viewNStr $ bng r) ]
+ recType = fromEnum . bng_Type
+
+instance Rec BOC where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BOC a01 a02 a03
+ recPut r = do put $ boc_Type r; put $ boc_ r; put $ boc r; return ()
+ recSizeOf r = sum [ sizeOf $ boc_Type r, sizeOf $ boc_ r, sizeOf $ boc r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ boc_Type r), viewField "_" (viewNumber $ boc_ r), viewField "" (viewNStr $ boc r) ]
+ recType = fromEnum . boc_Type
+
+instance Rec BOG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BOG a01 a02 a03
+ recPut r = do put $ bog_Type r; put $ bog_ r; put $ bog r; return ()
+ recSizeOf r = sum [ sizeOf $ bog_Type r, sizeOf $ bog_ r, sizeOf $ bog r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bog_Type r), viewField "_" (viewNumber $ bog_ r), viewField "" (viewNStr $ bog r) ]
+ recType = fromEnum . bog_Type
+
+instance Rec BPG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BPG a01 a02 a03
+ recPut r = do put $ bpg_Type r; put $ bpg_ r; put $ bpg r; return ()
+ recSizeOf r = sum [ sizeOf $ bpg_Type r, sizeOf $ bpg_ r, sizeOf $ bpg r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bpg_Type r), viewField "_" (viewNumber $ bpg_ r), viewField "" (viewNStr $ bpg r) ]
+ recType = fromEnum . bpg_Type
+
+instance Rec BPM where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BPM a01 a02 a03
+ recPut r = do put $ bpm_Type r; put $ bpm_ r; put $ bpm r; return ()
+ recSizeOf r = sum [ sizeOf $ bpm_Type r, sizeOf $ bpm_ r, sizeOf $ bpm r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bpm_Type r), viewField "_" (viewNumber $ bpm_ r), viewField "" (viewNStr $ bpm r) ]
+ recType = fromEnum . bpm_Type
+
+instance Rec BPS where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BPS a01 a02 a03
+ recPut r = do put $ bps_Type r; put $ bps_ r; put $ bps r; return ()
+ recSizeOf r = sum [ sizeOf $ bps_Type r, sizeOf $ bps_ r, sizeOf $ bps r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bps_Type r), viewField "_" (viewNumber $ bps_ r), viewField "" (viewAStr $ bps r) ]
+ recType = fromEnum . bps_Type
+
+instance Rec BPT where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BPT a01 a02 a03
+ recPut r = do put $ bpt_Type r; put $ bpt_ r; put $ bpt r; return ()
+ recSizeOf r = sum [ sizeOf $ bpt_Type r, sizeOf $ bpt_ r, sizeOf $ bpt r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bpt_Type r), viewField "_" (viewNumber $ bpt_ r), viewField "" (viewAStr $ bpt r) ]
+ recType = fromEnum . bpt_Type
+
+instance Rec BR where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BR a01 a02 a03
+ recPut r = do put $ br_Type r; put $ br_ r; put $ br r; return ()
+ recSizeOf r = sum [ sizeOf $ br_Type r, sizeOf $ br_ r, sizeOf $ br r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ br_Type r), viewField "_" (viewNumber $ br_ r), viewField "" (viewAStr $ br r) ]
+ recType = fromEnum . br_Type
+
+instance Rec BRG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BRG a01 a02 a03
+ recPut r = do put $ brg_Type r; put $ brg_ r; put $ brg r; return ()
+ recSizeOf r = sum [ sizeOf $ brg_Type r, sizeOf $ brg_ r, sizeOf $ brg r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ brg_Type r), viewField "_" (viewNumber $ brg_ r), viewField "" (viewNStr $ brg r) ]
+ recType = fromEnum . brg_Type
+
+instance Rec BSG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ BSG a01 a02 a03
+ recPut r = do put $ bsg_Type r; put $ bsg_ r; put $ bsg r; return ()
+ recSizeOf r = sum [ sizeOf $ bsg_Type r, sizeOf $ bsg_ r, sizeOf $ bsg r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ bsg_Type r), viewField "_" (viewNumber $ bsg_ r), viewField "" (viewNStr $ bsg r) ]
+ recType = fromEnum . bsg_Type
+
diff --git a/src/OpenAFP/Prelude/InstanceAFP/C.hs b/src/OpenAFP/Prelude/InstanceAFP/C.hs
new file mode 100644
--- /dev/null
+++ b/src/OpenAFP/Prelude/InstanceAFP/C.hs
@@ -0,0 +1,88 @@
+
+module OpenAFP.Prelude.InstanceAFP.C () where
+import OpenAFP.Types
+import OpenAFP.Records
+import OpenAFP.Internals
+
+instance Rec CAT where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ CAT a01 a02 a03
+ recPut r = do put $ cat_Type r; put $ cat_ r; put $ cat r; return ()
+ recSizeOf r = sum [ sizeOf $ cat_Type r, sizeOf $ cat_ r, sizeOf $ cat r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cat_Type r), viewField "_" (viewNumber $ cat_ r), viewField "" (viewNStr $ cat r) ]
+ recType = fromEnum . cat_Type
+
+instance Rec CDD where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ CDD a01 a02 a03
+ recPut r = do put $ cdd_Type r; put $ cdd_ r; put $ cdd r; return ()
+ recSizeOf r = sum [ sizeOf $ cdd_Type r, sizeOf $ cdd_ r, sizeOf $ cdd r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cdd_Type r), viewField "_" (viewNumber $ cdd_ r), viewField "" (viewNStr $ cdd r) ]
+ recType = fromEnum . cdd_Type
+
+instance Rec CFC where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; return $ CFC a01 a02 a03 a04
+ recPut r = do put $ cfc_Type r; put $ cfc_ r; put $ cfc_CFIRepeatingGroupLength r; put $ cfc r; return ()
+ recSizeOf r = sum [ sizeOf $ cfc_Type r, sizeOf $ cfc_ r, sizeOf $ cfc_CFIRepeatingGroupLength r, sizeOf $ cfc r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cfc_Type r), viewField "_" (viewNumber $ cfc_ r), viewField "CFIRepeatingGroupLength" (viewNumber $ cfc_CFIRepeatingGroupLength r), viewField "" (viewNStr $ cfc r) ]
+ recType = fromEnum . cfc_Type
+
+instance Rec CFI where
+ recGet = do a01 <- get; a02 <- get; a03 <- getList; return $ CFI a01 a02 a03
+ recPut r = do put $ cfi_Type r; put $ cfi_ r; putList $ cfi_Data r; return ()
+ recSizeOf r = sum [ sizeOf $ cfi_Type r, sizeOf $ cfi_ r, sizeOf $ cfi_Data r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cfi_Type r), viewField "_" (viewNumber $ cfi_ r), viewField "Data" (viewData $ cfi_Data r) ]
+ recType = fromEnum . cfi_Type
+
+instance Rec CFI_Data where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; return $ CFI_Data a01 a02 a03 a04
+ recPut r = do put $ cfi_FontCharacterSetName r; put $ cfi_CodePageName r; put $ cfi_CodedFontName r; put $ cfi_Section r; return ()
+ recSizeOf r = sum [ sizeOf $ cfi_FontCharacterSetName r, sizeOf $ cfi_CodePageName r, sizeOf $ cfi_CodedFontName r, sizeOf $ cfi_Section r ]
+ recView r = viewRecord (typeOf r) [ viewField "FontCharacterSetName" (viewString $ cfi_FontCharacterSetName r), viewField "CodePageName" (viewString $ cfi_CodePageName r), viewField "CodedFontName" (viewString $ cfi_CodedFontName r), viewField "Section" (viewNumber $ cfi_Section r) ]
+ recType r = 0
+
+instance RecData CFI CFI_Data where
+ type RecOf CFI_Data = CFI
+ type DataOf CFI = CFI_Data
+ readData = cfi_Data
+ writeData r cs = r { cfi_Data = cs }
+
+instance Rec CPC where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; a05 <- get; a06 <- get; a07 <- get; a08 <- get; return $ CPC a01 a02 a03 a04 a05 a06 a07 a08
+ recPut r = do put $ cpc_Type r; put $ cpc_ r; put $ cpc_GCGID r; put $ cpc_UseFlags r; put $ cpc_CPIRepeatingGroupLength r; put $ cpc_SpaceCharacterSection r; put $ cpc_UseFlags2 r; put $ cpc r; return ()
+ recSizeOf r = sum [ sizeOf $ cpc_Type r, sizeOf $ cpc_ r, sizeOf $ cpc_GCGID r, sizeOf $ cpc_UseFlags r, sizeOf $ cpc_CPIRepeatingGroupLength r, sizeOf $ cpc_SpaceCharacterSection r, sizeOf $ cpc_UseFlags2 r, sizeOf $ cpc r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cpc_Type r), viewField "_" (viewNumber $ cpc_ r), viewField "GCGID" (viewString $ cpc_GCGID r), viewField "UseFlags" (viewNumber $ cpc_UseFlags r), viewField "CPIRepeatingGroupLength" (viewNumber $ cpc_CPIRepeatingGroupLength r), viewField "SpaceCharacterSection" (viewNumber $ cpc_SpaceCharacterSection r), viewField "UseFlags2" (viewNumber $ cpc_UseFlags2 r), viewField "" (viewNStr $ cpc r) ]
+ recType = fromEnum . cpc_Type
+
+instance Rec CPD where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ CPD a01 a02 a03
+ recPut r = do put $ cpd_Type r; put $ cpd_ r; put $ cpd r; return ()
+ recSizeOf r = sum [ sizeOf $ cpd_Type r, sizeOf $ cpd_ r, sizeOf $ cpd r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cpd_Type r), viewField "_" (viewNumber $ cpd_ r), viewField "" (viewNStr $ cpd r) ]
+ recType = fromEnum . cpd_Type
+
+instance Rec CPI where
+ recGet = do a01 <- get; a02 <- get; a03 <- getList; return $ CPI a01 a02 a03
+ recPut r = do put $ cpi_Type r; put $ cpi_ r; putList $ cpi_Data r; return ()
+ recSizeOf r = sum [ sizeOf $ cpi_Type r, sizeOf $ cpi_ r, sizeOf $ cpi_Data r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ cpi_Type r), viewField "_" (viewNumber $ cpi_ r), viewField "Data" (viewData $ cpi_Data r) ]
+ recType = fromEnum . cpi_Type
+
+instance Rec CPI_Data where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ CPI_Data a01 a02 a03
+ recPut r = do put $ cpi_GCGID r; put $ cpi_Section r; put $ cpi_CodePoint r; return ()
+ recSizeOf r = sum [ sizeOf $ cpi_GCGID r, sizeOf $ cpi_Section r, sizeOf $ cpi_CodePoint r ]
+ recView r = viewRecord (typeOf r) [ viewField "GCGID" (viewString $ cpi_GCGID r), viewField "Section" (viewNumber $ cpi_Section r), viewField "CodePoint" (viewNumber $ cpi_CodePoint r) ]
+ recType r = 0
+
+instance RecData CPI CPI_Data where
+ type RecOf CPI_Data = CPI
+ type DataOf CPI = CPI_Data
+ readData = cpi_Data
+ writeData r cs = r { cpi_Data = cs }
+
+instance Rec CTC where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ CTC a01 a02 a03
+ recPut r = do put $ ctc_Type r; put $ ctc_ r; put $ ctc r; return ()
+ recSizeOf r = sum [ sizeOf $ ctc_Type r, sizeOf $ ctc_ r, sizeOf $ ctc r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ctc_Type r), viewField "_" (viewNumber $ ctc_ r), viewField "" (viewNStr $ ctc r) ]
+ recType = fromEnum . ctc_Type
+
diff --git a/src/OpenAFP/Prelude/InstanceAFP/D.hs b/src/OpenAFP/Prelude/InstanceAFP/D.hs
new file mode 100644
--- /dev/null
+++ b/src/OpenAFP/Prelude/InstanceAFP/D.hs
@@ -0,0 +1,13 @@
+
+module OpenAFP.Prelude.InstanceAFP.D () where
+import OpenAFP.Types
+import OpenAFP.Records
+import OpenAFP.Internals
+
+instance Rec DXD where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ DXD a01 a02 a03
+ recPut r = do put $ dxd_Type r; put $ dxd_ r; put $ dxd r; return ()
+ recSizeOf r = sum [ sizeOf $ dxd_Type r, sizeOf $ dxd_ r, sizeOf $ dxd r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ dxd_Type r), viewField "_" (viewNumber $ dxd_ r), viewField "" (viewNStr $ dxd r) ]
+ recType = fromEnum . dxd_Type
+
diff --git a/src/OpenAFP/Prelude/InstanceAFP/E.hs b/src/OpenAFP/Prelude/InstanceAFP/E.hs
new file mode 100644
--- /dev/null
+++ b/src/OpenAFP/Prelude/InstanceAFP/E.hs
@@ -0,0 +1,202 @@
+
+module OpenAFP.Prelude.InstanceAFP.E () where
+import OpenAFP.Types
+import OpenAFP.Records
+import OpenAFP.Internals
+
+instance Rec EAG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EAG a01 a02 a03
+ recPut r = do put $ eag_Type r; put $ eag_ r; put $ eag r; return ()
+ recSizeOf r = sum [ sizeOf $ eag_Type r, sizeOf $ eag_ r, sizeOf $ eag r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eag_Type r), viewField "_" (viewNumber $ eag_ r), viewField "" (viewNStr $ eag r) ]
+ recType = fromEnum . eag_Type
+
+instance Rec EBC where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EBC a01 a02 a03
+ recPut r = do put $ ebc_Type r; put $ ebc_ r; put $ ebc r; return ()
+ recSizeOf r = sum [ sizeOf $ ebc_Type r, sizeOf $ ebc_ r, sizeOf $ ebc r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ebc_Type r), viewField "_" (viewNumber $ ebc_ r), viewField "" (viewNStr $ ebc r) ]
+ recType = fromEnum . ebc_Type
+
+instance Rec ECA where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ ECA a01 a02 a03
+ recPut r = do put $ eca_Type r; put $ eca_ r; put $ eca r; return ()
+ recSizeOf r = sum [ sizeOf $ eca_Type r, sizeOf $ eca_ r, sizeOf $ eca r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eca_Type r), viewField "_" (viewNumber $ eca_ r), viewField "" (viewNStr $ eca r) ]
+ recType = fromEnum . eca_Type
+
+instance Rec ECF where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ ECF a01 a02 a03
+ recPut r = do put $ ecf_Type r; put $ ecf_ r; put $ ecf r; return ()
+ recSizeOf r = sum [ sizeOf $ ecf_Type r, sizeOf $ ecf_ r, sizeOf $ ecf r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ecf_Type r), viewField "_" (viewNumber $ ecf_ r), viewField "" (viewNStr $ ecf r) ]
+ recType = fromEnum . ecf_Type
+
+instance Rec ECP where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ ECP a01 a02 a03
+ recPut r = do put $ ecp_Type r; put $ ecp_ r; put $ ecp r; return ()
+ recSizeOf r = sum [ sizeOf $ ecp_Type r, sizeOf $ ecp_ r, sizeOf $ ecp r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ecp_Type r), viewField "_" (viewNumber $ ecp_ r), viewField "" (viewNStr $ ecp r) ]
+ recType = fromEnum . ecp_Type
+
+instance Rec EDG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EDG a01 a02 a03
+ recPut r = do put $ edg_Type r; put $ edg_ r; put $ edg r; return ()
+ recSizeOf r = sum [ sizeOf $ edg_Type r, sizeOf $ edg_ r, sizeOf $ edg r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ edg_Type r), viewField "_" (viewNumber $ edg_ r), viewField "" (viewNStr $ edg r) ]
+ recType = fromEnum . edg_Type
+
+instance Rec EDI where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EDI a01 a02 a03
+ recPut r = do put $ edi_Type r; put $ edi_ r; put $ edi r; return ()
+ recSizeOf r = sum [ sizeOf $ edi_Type r, sizeOf $ edi_ r, sizeOf $ edi r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ edi_Type r), viewField "_" (viewNumber $ edi_ r), viewField "" (viewNStr $ edi r) ]
+ recType = fromEnum . edi_Type
+
+instance Rec EDM where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EDM a01 a02 a03
+ recPut r = do put $ edm_Type r; put $ edm_ r; put $ edm r; return ()
+ recSizeOf r = sum [ sizeOf $ edm_Type r, sizeOf $ edm_ r, sizeOf $ edm r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ edm_Type r), viewField "_" (viewNumber $ edm_ r), viewField "" (viewNStr $ edm r) ]
+ recType = fromEnum . edm_Type
+
+instance Rec EDT where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EDT a01 a02 a03
+ recPut r = do put $ edt_Type r; put $ edt_ r; put $ edt r; return ()
+ recSizeOf r = sum [ sizeOf $ edt_Type r, sizeOf $ edt_ r, sizeOf $ edt r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ edt_Type r), viewField "_" (viewNumber $ edt_ r), viewField "" (viewNStr $ edt r) ]
+ recType = fromEnum . edt_Type
+
+instance Rec EDX where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EDX a01 a02 a03
+ recPut r = do put $ edx_Type r; put $ edx_ r; put $ edx r; return ()
+ recSizeOf r = sum [ sizeOf $ edx_Type r, sizeOf $ edx_ r, sizeOf $ edx r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ edx_Type r), viewField "_" (viewNumber $ edx_ r), viewField "" (viewNStr $ edx r) ]
+ recType = fromEnum . edx_Type
+
+instance Rec EFG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EFG a01 a02 a03
+ recPut r = do put $ efg_Type r; put $ efg_ r; put $ efg r; return ()
+ recSizeOf r = sum [ sizeOf $ efg_Type r, sizeOf $ efg_ r, sizeOf $ efg r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ efg_Type r), viewField "_" (viewNumber $ efg_ r), viewField "" (viewNStr $ efg r) ]
+ recType = fromEnum . efg_Type
+
+instance Rec EFM where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EFM a01 a02 a03
+ recPut r = do put $ efm_Type r; put $ efm_ r; put $ efm r; return ()
+ recSizeOf r = sum [ sizeOf $ efm_Type r, sizeOf $ efm_ r, sizeOf $ efm r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ efm_Type r), viewField "_" (viewNumber $ efm_ r), viewField "" (viewNStr $ efm r) ]
+ recType = fromEnum . efm_Type
+
+instance Rec EFN where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EFN a01 a02 a03
+ recPut r = do put $ efn_Type r; put $ efn_ r; put $ efn r; return ()
+ recSizeOf r = sum [ sizeOf $ efn_Type r, sizeOf $ efn_ r, sizeOf $ efn r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ efn_Type r), viewField "_" (viewNumber $ efn_ r), viewField "" (viewNStr $ efn r) ]
+ recType = fromEnum . efn_Type
+
+instance Rec EGR where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EGR a01 a02 a03
+ recPut r = do put $ egr_Type r; put $ egr_ r; put $ egr r; return ()
+ recSizeOf r = sum [ sizeOf $ egr_Type r, sizeOf $ egr_ r, sizeOf $ egr r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ egr_Type r), viewField "_" (viewNumber $ egr_ r), viewField "" (viewNStr $ egr r) ]
+ recType = fromEnum . egr_Type
+
+instance Rec EII where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EII a01 a02 a03
+ recPut r = do put $ eii_Type r; put $ eii_ r; put $ eii_ImageObjectName r; return ()
+ recSizeOf r = sum [ sizeOf $ eii_Type r, sizeOf $ eii_ r, sizeOf $ eii_ImageObjectName r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eii_Type r), viewField "_" (viewNumber $ eii_ r), viewField "ImageObjectName" (viewAStr $ eii_ImageObjectName r) ]
+ recType = fromEnum . eii_Type
+
+instance Rec EIM where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EIM a01 a02 a03
+ recPut r = do put $ eim_Type r; put $ eim_ r; put $ eim r; return ()
+ recSizeOf r = sum [ sizeOf $ eim_Type r, sizeOf $ eim_ r, sizeOf $ eim r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eim_Type r), viewField "_" (viewNumber $ eim_ r), viewField "" (viewAStr $ eim r) ]
+ recType = fromEnum . eim_Type
+
+instance Rec EMM where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EMM a01 a02 a03
+ recPut r = do put $ emm_Type r; put $ emm_ r; put $ emm r; return ()
+ recSizeOf r = sum [ sizeOf $ emm_Type r, sizeOf $ emm_ r, sizeOf $ emm r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ emm_Type r), viewField "_" (viewNumber $ emm_ r), viewField "" (viewNStr $ emm r) ]
+ recType = fromEnum . emm_Type
+
+instance Rec EMO where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EMO a01 a02 a03
+ recPut r = do put $ emo_Type r; put $ emo_ r; put $ emo r; return ()
+ recSizeOf r = sum [ sizeOf $ emo_Type r, sizeOf $ emo_ r, sizeOf $ emo r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ emo_Type r), viewField "_" (viewNumber $ emo_ r), viewField "" (viewNStr $ emo r) ]
+ recType = fromEnum . emo_Type
+
+instance Rec ENG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ ENG a01 a02 a03
+ recPut r = do put $ eng_Type r; put $ eng_ r; put $ eng r; return ()
+ recSizeOf r = sum [ sizeOf $ eng_Type r, sizeOf $ eng_ r, sizeOf $ eng r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eng_Type r), viewField "_" (viewNumber $ eng_ r), viewField "" (viewAStr $ eng r) ]
+ recType = fromEnum . eng_Type
+
+instance Rec EOC where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EOC a01 a02 a03
+ recPut r = do put $ eoc_Type r; put $ eoc_ r; put $ eoc r; return ()
+ recSizeOf r = sum [ sizeOf $ eoc_Type r, sizeOf $ eoc_ r, sizeOf $ eoc r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eoc_Type r), viewField "_" (viewNumber $ eoc_ r), viewField "" (viewNStr $ eoc r) ]
+ recType = fromEnum . eoc_Type
+
+instance Rec EOG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EOG a01 a02 a03
+ recPut r = do put $ eog_Type r; put $ eog_ r; put $ eog r; return ()
+ recSizeOf r = sum [ sizeOf $ eog_Type r, sizeOf $ eog_ r, sizeOf $ eog r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eog_Type r), viewField "_" (viewNumber $ eog_ r), viewField "" (viewAStr $ eog r) ]
+ recType = fromEnum . eog_Type
+
+instance Rec EPG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EPG a01 a02 a03
+ recPut r = do put $ epg_Type r; put $ epg_ r; put $ epg r; return ()
+ recSizeOf r = sum [ sizeOf $ epg_Type r, sizeOf $ epg_ r, sizeOf $ epg r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ epg_Type r), viewField "_" (viewNumber $ epg_ r), viewField "" (viewAStr $ epg r) ]
+ recType = fromEnum . epg_Type
+
+instance Rec EPM where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EPM a01 a02 a03
+ recPut r = do put $ epm_Type r; put $ epm_ r; put $ epm r; return ()
+ recSizeOf r = sum [ sizeOf $ epm_Type r, sizeOf $ epm_ r, sizeOf $ epm r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ epm_Type r), viewField "_" (viewNumber $ epm_ r), viewField "" (viewNStr $ epm r) ]
+ recType = fromEnum . epm_Type
+
+instance Rec EPS where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EPS a01 a02 a03
+ recPut r = do put $ eps_Type r; put $ eps_ r; put $ eps r; return ()
+ recSizeOf r = sum [ sizeOf $ eps_Type r, sizeOf $ eps_ r, sizeOf $ eps r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ eps_Type r), viewField "_" (viewNumber $ eps_ r), viewField "" (viewAStr $ eps r) ]
+ recType = fromEnum . eps_Type
+
+instance Rec EPT where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ EPT a01 a02 a03
+ recPut r = do put $ ept_Type r; put $ ept_ r; put $ ept r; return ()
+ recSizeOf r = sum [ sizeOf $ ept_Type r, sizeOf $ ept_ r, sizeOf $ ept r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ept_Type r), viewField "_" (viewNumber $ ept_ r), viewField "" (viewNStr $ ept r) ]
+ recType = fromEnum . ept_Type
+
+instance Rec ER where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ ER a01 a02 a03
+ recPut r = do put $ er_Type r; put $ er_ r; put $ er r; return ()
+ recSizeOf r = sum [ sizeOf $ er_Type r, sizeOf $ er_ r, sizeOf $ er r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ er_Type r), viewField "_" (viewNumber $ er_ r), viewField "" (viewAStr $ er r) ]
+ recType = fromEnum . er_Type
+
+instance Rec ERG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ ERG a01 a02 a03
+ recPut r = do put $ erg_Type r; put $ erg_ r; put $ erg r; return ()
+ recSizeOf r = sum [ sizeOf $ erg_Type r, sizeOf $ erg_ r, sizeOf $ erg r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ erg_Type r), viewField "_" (viewNumber $ erg_ r), viewField "" (viewNStr $ erg r) ]
+ recType = fromEnum . erg_Type
+
+instance Rec ESG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ ESG a01 a02 a03
+ recPut r = do put $ esg_Type r; put $ esg_ r; put $ esg r; return ()
+ recSizeOf r = sum [ sizeOf $ esg_Type r, sizeOf $ esg_ r, sizeOf $ esg r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ esg_Type r), viewField "_" (viewNumber $ esg_ r), viewField "" (viewNStr $ esg r) ]
+ recType = fromEnum . esg_Type
+
diff --git a/src/OpenAFP/Prelude/InstanceAFP/F.hs b/src/OpenAFP/Prelude/InstanceAFP/F.hs
new file mode 100644
--- /dev/null
+++ b/src/OpenAFP/Prelude/InstanceAFP/F.hs
@@ -0,0 +1,96 @@
+
+module OpenAFP.Prelude.InstanceAFP.F () where
+import OpenAFP.Types
+import OpenAFP.Records
+import OpenAFP.Internals
+
+instance Rec FGD where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ FGD a01 a02 a03
+ recPut r = do put $ fgd_Type r; put $ fgd_ r; put $ fgd r; return ()
+ recSizeOf r = sum [ sizeOf $ fgd_Type r, sizeOf $ fgd_ r, sizeOf $ fgd r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fgd_Type r), viewField "_" (viewNumber $ fgd_ r), viewField "" (viewNStr $ fgd r) ]
+ recType = fromEnum . fgd_Type
+
+instance Rec FNC where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; a05 <- get; a06 <- get; a07 <- get; a08 <- get; a09 <- get; a10 <- get; a11 <- get; a12 <- get; a13 <- get; a14 <- get; a15 <- get; a16 <- get; a17 <- get; a18 <- get; a19 <- get; return $ FNC a01 a02 a03 a04 a05 a06 a07 a08 a09 a10 a11 a12 a13 a14 a15 a16 a17 a18 a19
+ recPut r = do put $ fnc_Type r; put $ fnc_ r; put $ fnc_Constant r; put $ fnc_PatternTechnologyIdentifier r; put $ fnc_FNCReserved1 r; put $ fnc_UseFlags r; put $ fnc_UnitXBase r; put $ fnc_UnitYBase r; put $ fnc_UnitXValue r; put $ fnc_UnitYValue r; put $ fnc_MaxWidth r; put $ fnc_MaxHeight r; put $ fnc_FNORepeatingGroupLength r; put $ fnc_FNIRepeatingGroupLength r; put $ fnc_PatternDataAlignmentCode r; put $ fnc_PatternDataCount1 r; put $ fnc_FNPRepeatingGroupLength r; put $ fnc_FNMRepeatingGroupLength r; put $ fnc r; return ()
+ recSizeOf r = sum [ sizeOf $ fnc_Type r, sizeOf $ fnc_ r, sizeOf $ fnc_Constant r, sizeOf $ fnc_PatternTechnologyIdentifier r, sizeOf $ fnc_FNCReserved1 r, sizeOf $ fnc_UseFlags r, sizeOf $ fnc_UnitXBase r, sizeOf $ fnc_UnitYBase r, sizeOf $ fnc_UnitXValue r, sizeOf $ fnc_UnitYValue r, sizeOf $ fnc_MaxWidth r, sizeOf $ fnc_MaxHeight r, sizeOf $ fnc_FNORepeatingGroupLength r, sizeOf $ fnc_FNIRepeatingGroupLength r, sizeOf $ fnc_PatternDataAlignmentCode r, sizeOf $ fnc_PatternDataCount1 r, sizeOf $ fnc_FNPRepeatingGroupLength r, sizeOf $ fnc_FNMRepeatingGroupLength r, sizeOf $ fnc r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fnc_Type r), viewField "_" (viewNumber $ fnc_ r), viewField "Constant" (viewString $ fnc_Constant r), viewField "PatternTechnologyIdentifier" (viewNumber $ fnc_PatternTechnologyIdentifier r), viewField "FNCReserved1" (viewString $ fnc_FNCReserved1 r), viewField "UseFlags" (viewNumber $ fnc_UseFlags r), viewField "UnitXBase" (viewNumber $ fnc_UnitXBase r), viewField "UnitYBase" (viewNumber $ fnc_UnitYBase r), viewField "UnitXValue" (viewNumber $ fnc_UnitXValue r), viewField "UnitYValue" (viewNumber $ fnc_UnitYValue r), viewField "MaxWidth" (viewNumber $ fnc_MaxWidth r), viewField "MaxHeight" (viewNumber $ fnc_MaxHeight r), viewField "FNORepeatingGroupLength" (viewNumber $ fnc_FNORepeatingGroupLength r), viewField "FNIRepeatingGroupLength" (viewNumber $ fnc_FNIRepeatingGroupLength r), viewField "PatternDataAlignmentCode" (viewNumber $ fnc_PatternDataAlignmentCode r), viewField "PatternDataCount1" (viewString $ fnc_PatternDataCount1 r), viewField "FNPRepeatingGroupLength" (viewNumber $ fnc_FNPRepeatingGroupLength r), viewField "FNMRepeatingGroupLength" (viewNumber $ fnc_FNMRepeatingGroupLength r), viewField "" (viewNStr $ fnc r) ]
+ recType = fromEnum . fnc_Type
+
+instance Rec FND where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ FND a01 a02 a03
+ recPut r = do put $ fnd_Type r; put $ fnd_ r; put $ fnd r; return ()
+ recSizeOf r = sum [ sizeOf $ fnd_Type r, sizeOf $ fnd_ r, sizeOf $ fnd r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fnd_Type r), viewField "_" (viewNumber $ fnd_ r), viewField "" (viewNStr $ fnd r) ]
+ recType = fromEnum . fnd_Type
+
+instance Rec FNG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ FNG a01 a02 a03
+ recPut r = do put $ fng_Type r; put $ fng_ r; put $ fng r; return ()
+ recSizeOf r = sum [ sizeOf $ fng_Type r, sizeOf $ fng_ r, sizeOf $ fng r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fng_Type r), viewField "_" (viewNumber $ fng_ r), viewField "" (viewNStr $ fng r) ]
+ recType = fromEnum . fng_Type
+
+instance Rec FNI where
+ recGet = do a01 <- get; a02 <- get; a03 <- getList; return $ FNI a01 a02 a03
+ recPut r = do put $ fni_Type r; put $ fni_ r; putList $ fni_Data r; return ()
+ recSizeOf r = sum [ sizeOf $ fni_Type r, sizeOf $ fni_ r, sizeOf $ fni_Data r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fni_Type r), viewField "_" (viewNumber $ fni_ r), viewField "Data" (viewData $ fni_Data r) ]
+ recType = fromEnum . fni_Type
+
+instance Rec FNI_Data where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; a05 <- get; a06 <- get; a07 <- get; a08 <- get; a09 <- get; a10 <- get; a11 <- get; return $ FNI_Data a01 a02 a03 a04 a05 a06 a07 a08 a09 a10 a11
+ recPut r = do put $ fni_GCGID r; put $ fni_CharacterIncrement r; put $ fni_AscendHeight r; put $ fni_DescendDepth r; put $ fni_Reserved1 r; put $ fni_FNMCount r; put $ fni_ASpace r; put $ fni_BSpace r; put $ fni_CSpace r; put $ fni_Reserved2 r; put $ fni_BaseOffset r; return ()
+ recSizeOf r = sum [ sizeOf $ fni_GCGID r, sizeOf $ fni_CharacterIncrement r, sizeOf $ fni_AscendHeight r, sizeOf $ fni_DescendDepth r, sizeOf $ fni_Reserved1 r, sizeOf $ fni_FNMCount r, sizeOf $ fni_ASpace r, sizeOf $ fni_BSpace r, sizeOf $ fni_CSpace r, sizeOf $ fni_Reserved2 r, sizeOf $ fni_BaseOffset r ]
+ recView r = viewRecord (typeOf r) [ viewField "GCGID" (viewString $ fni_GCGID r), viewField "CharacterIncrement" (viewNumber $ fni_CharacterIncrement r), viewField "AscendHeight" (viewNumber $ fni_AscendHeight r), viewField "DescendDepth" (viewNumber $ fni_DescendDepth r), viewField "Reserved1" (viewNumber $ fni_Reserved1 r), viewField "FNMCount" (viewNumber $ fni_FNMCount r), viewField "ASpace" (viewNumber $ fni_ASpace r), viewField "BSpace" (viewNumber $ fni_BSpace r), viewField "CSpace" (viewNumber $ fni_CSpace r), viewField "Reserved2" (viewNumber $ fni_Reserved2 r), viewField "BaseOffset" (viewNumber $ fni_BaseOffset r) ]
+ recType r = 0
+
+instance RecData FNI FNI_Data where
+ type RecOf FNI_Data = FNI
+ type DataOf FNI = FNI_Data
+ readData = fni_Data
+ writeData r cs = r { fni_Data = cs }
+
+
+instance Rec FNM where
+ recGet = do a01 <- get; a02 <- get; a03 <- getList; return $ FNM a01 a02 a03
+ recPut r = do put $ fnm_Type r; put $ fnm_ r; putList $ fnm_Data r; return ()
+ recSizeOf r = sum [ sizeOf $ fnm_Type r, sizeOf $ fnm_ r, sizeOf $ fnm_Data r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fnm_Type r), viewField "_" (viewNumber $ fnm_ r), viewField "Data" (viewData $ fnm_Data r) ]
+ recType = fromEnum . fnm_Type
+
+instance Rec FNM_Data where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ FNM_Data a01 a02 a03
+ recPut r = do put $ fnm_Width r; put $ fnm_Height r; put $ fnm_Offset r; return ()
+ recSizeOf r = sum [ sizeOf $ fnm_Width r, sizeOf $ fnm_Height r, sizeOf $ fnm_Offset r ]
+ recView r = viewRecord (typeOf r) [ viewField "Width" (viewNumber $ fnm_Width r), viewField "Height" (viewNumber $ fnm_Height r), viewField "Offset" (viewNumber $ fnm_Offset r) ]
+ recType r = 0
+
+instance RecData FNM FNM_Data where
+ type RecOf FNM_Data = FNM
+ type DataOf FNM = FNM_Data
+ readData = fnm_Data
+ writeData r cs = r { fnm_Data = cs }
+
+instance Rec FNN where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ FNN a01 a02 a03
+ recPut r = do put $ fnn_Type r; put $ fnn_ r; put $ fnn r; return ()
+ recSizeOf r = sum [ sizeOf $ fnn_Type r, sizeOf $ fnn_ r, sizeOf $ fnn r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fnn_Type r), viewField "_" (viewNumber $ fnn_ r), viewField "" (viewNStr $ fnn r) ]
+ recType = fromEnum . fnn_Type
+
+instance Rec FNO where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; a05 <- get; a06 <- get; a07 <- get; a08 <- get; return $ FNO a01 a02 a03 a04 a05 a06 a07 a08
+ recPut r = do put $ fno_Type r; put $ fno_ r; put $ fno_Reserved r; put $ fno_CharacterRotation r; put $ fno_MaxBaseOffset r; put $ fno_MaxCharacterIncrement r; put $ fno_SpaceCharacterIncrement r; put $ fno r; return ()
+ recSizeOf r = sum [ sizeOf $ fno_Type r, sizeOf $ fno_ r, sizeOf $ fno_Reserved r, sizeOf $ fno_CharacterRotation r, sizeOf $ fno_MaxBaseOffset r, sizeOf $ fno_MaxCharacterIncrement r, sizeOf $ fno_SpaceCharacterIncrement r, sizeOf $ fno r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fno_Type r), viewField "_" (viewNumber $ fno_ r), viewField "Reserved" (viewNumber $ fno_Reserved r), viewField "CharacterRotation" (viewNumber $ fno_CharacterRotation r), viewField "MaxBaseOffset" (viewNumber $ fno_MaxBaseOffset r), viewField "MaxCharacterIncrement" (viewNumber $ fno_MaxCharacterIncrement r), viewField "SpaceCharacterIncrement" (viewNumber $ fno_SpaceCharacterIncrement r), viewField "" (viewNStr $ fno r) ]
+ recType = fromEnum . fno_Type
+
+instance Rec FNP where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ FNP a01 a02 a03
+ recPut r = do put $ fnp_Type r; put $ fnp_ r; put $ fnp r; return ()
+ recSizeOf r = sum [ sizeOf $ fnp_Type r, sizeOf $ fnp_ r, sizeOf $ fnp r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ fnp_Type r), viewField "_" (viewNumber $ fnp_ r), viewField "" (viewNStr $ fnp r) ]
+ recType = fromEnum . fnp_Type
+
diff --git a/src/OpenAFP/Prelude/InstanceAFP/G.hs b/src/OpenAFP/Prelude/InstanceAFP/G.hs
new file mode 100644
--- /dev/null
+++ b/src/OpenAFP/Prelude/InstanceAFP/G.hs
@@ -0,0 +1,20 @@
+
+module OpenAFP.Prelude.InstanceAFP.G () where
+import OpenAFP.Types
+import OpenAFP.Records
+import OpenAFP.Internals
+
+instance Rec GAD where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ GAD a01 a02 a03
+ recPut r = do put $ gad_Type r; put $ gad_ r; put $ gad r; return ()
+ recSizeOf r = sum [ sizeOf $ gad_Type r, sizeOf $ gad_ r, sizeOf $ gad r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ gad_Type r), viewField "_" (viewNumber $ gad_ r), viewField "" (viewNStr $ gad r) ]
+ recType = fromEnum . gad_Type
+
+instance Rec GDD where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ GDD a01 a02 a03
+ recPut r = do put $ gdd_Type r; put $ gdd_ r; put $ gdd r; return ()
+ recSizeOf r = sum [ sizeOf $ gdd_Type r, sizeOf $ gdd_ r, sizeOf $ gdd r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ gdd_Type r), viewField "_" (viewNumber $ gdd_ r), viewField "" (viewNStr $ gdd r) ]
+ recType = fromEnum . gdd_Type
+
diff --git a/src/OpenAFP/Prelude/InstanceAFP/I.hs b/src/OpenAFP/Prelude/InstanceAFP/I.hs
new file mode 100644
--- /dev/null
+++ b/src/OpenAFP/Prelude/InstanceAFP/I.hs
@@ -0,0 +1,90 @@
+
+module OpenAFP.Prelude.InstanceAFP.I () where
+import OpenAFP.Types
+import OpenAFP.Records
+import OpenAFP.Internals
+
+instance Rec ICP where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; a05 <- get; a06 <- get; a07 <- get; a08 <- get; return $ ICP a01 a02 a03 a04 a05 a06 a07 a08
+ recPut r = do put $ icp_Type r; put $ icp_ r; put $ icp_XCellOffset r; put $ icp_YCellOffset r; put $ icp_XCellSize r; put $ icp_YCellSize r; put $ icp_XFillSize r; put $ icp_YFillSize r; return ()
+ recSizeOf r = sum [ sizeOf $ icp_Type r, sizeOf $ icp_ r, sizeOf $ icp_XCellOffset r, sizeOf $ icp_YCellOffset r, sizeOf $ icp_XCellSize r, sizeOf $ icp_YCellSize r, sizeOf $ icp_XFillSize r, sizeOf $ icp_YFillSize r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ icp_Type r), viewField "_" (viewNumber $ icp_ r), viewField "XCellOffset" (viewNumber $ icp_XCellOffset r), viewField "YCellOffset" (viewNumber $ icp_YCellOffset r), viewField "XCellSize" (viewNumber $ icp_XCellSize r), viewField "YCellSize" (viewNumber $ icp_YCellSize r), viewField "XFillSize" (viewNumber $ icp_XFillSize r), viewField "YFillSize" (viewNumber $ icp_YFillSize r) ]
+ recType = fromEnum . icp_Type
+
+instance Rec IDD where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ IDD a01 a02 a03
+ recPut r = do put $ idd_Type r; put $ idd_ r; put $ idd r; return ()
+ recSizeOf r = sum [ sizeOf $ idd_Type r, sizeOf $ idd_ r, sizeOf $ idd r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ idd_Type r), viewField "_" (viewNumber $ idd_ r), viewField "" (viewNStr $ idd r) ]
+ recType = fromEnum . idd_Type
+
+instance Rec IEL where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ IEL a01 a02 a03
+ recPut r = do put $ iel_Type r; put $ iel_ r; put $ iel r; return ()
+ recSizeOf r = sum [ sizeOf $ iel_Type r, sizeOf $ iel_ r, sizeOf $ iel r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ iel_Type r), viewField "_" (viewNumber $ iel_ r), viewField "" (viewNStr $ iel r) ]
+ recType = fromEnum . iel_Type
+
+instance Rec IID where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; a05 <- get; a06 <- get; a07 <- get; a08 <- get; a09 <- get; a10 <- get; a11 <- get; a12 <- get; a13 <- get; a14 <- get; return $ IID a01 a02 a03 a04 a05 a06 a07 a08 a09 a10 a11 a12 a13 a14
+ recPut r = do put $ iid_Type r; put $ iid_ r; put $ iid_ConstantData1 r; put $ iid_XBase r; put $ iid_YBase r; put $ iid_XUnits r; put $ iid_YUnits r; put $ iid_XSize r; put $ iid_YSize r; put $ iid_ConstantData2 r; put $ iid_XCellSizeDefault r; put $ iid_YCellSizeDefault r; put $ iid_ConstantData3 r; put $ iid_Color r; return ()
+ recSizeOf r = sum [ sizeOf $ iid_Type r, sizeOf $ iid_ r, sizeOf $ iid_ConstantData1 r, sizeOf $ iid_XBase r, sizeOf $ iid_YBase r, sizeOf $ iid_XUnits r, sizeOf $ iid_YUnits r, sizeOf $ iid_XSize r, sizeOf $ iid_YSize r, sizeOf $ iid_ConstantData2 r, sizeOf $ iid_XCellSizeDefault r, sizeOf $ iid_YCellSizeDefault r, sizeOf $ iid_ConstantData3 r, sizeOf $ iid_Color r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ iid_Type r), viewField "_" (viewNumber $ iid_ r), viewField "ConstantData1" (viewString $ iid_ConstantData1 r), viewField "XBase" (viewNumber $ iid_XBase r), viewField "YBase" (viewNumber $ iid_YBase r), viewField "XUnits" (viewNumber $ iid_XUnits r), viewField "YUnits" (viewNumber $ iid_YUnits r), viewField "XSize" (viewNumber $ iid_XSize r), viewField "YSize" (viewNumber $ iid_YSize r), viewField "ConstantData2" (viewString $ iid_ConstantData2 r), viewField "XCellSizeDefault" (viewNumber $ iid_XCellSizeDefault r), viewField "YCellSizeDefault" (viewNumber $ iid_YCellSizeDefault r), viewField "ConstantData3" (viewString $ iid_ConstantData3 r), viewField "Color" (viewNumber $ iid_Color r) ]
+ recType = fromEnum . iid_Type
+
+instance Rec IMM where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ IMM a01 a02 a03
+ recPut r = do put $ imm_Type r; put $ imm_ r; put $ imm r; return ()
+ recSizeOf r = sum [ sizeOf $ imm_Type r, sizeOf $ imm_ r, sizeOf $ imm r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ imm_Type r), viewField "_" (viewNumber $ imm_ r), viewField "" (viewNStr $ imm r) ]
+ recType = fromEnum . imm_Type
+
+instance Rec IOB where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ IOB a01 a02 a03
+ recPut r = do put $ iob_Type r; put $ iob_ r; put $ iob r; return ()
+ recSizeOf r = sum [ sizeOf $ iob_Type r, sizeOf $ iob_ r, sizeOf $ iob r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ iob_Type r), viewField "_" (viewNumber $ iob_ r), viewField "" (viewNStr $ iob r) ]
+ recType = fromEnum . iob_Type
+
+instance Rec IOC where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; a05 <- get; a06 <- get; a07 <- get; a08 <- get; a09 <- get; a10 <- get; a11 <- get; a12 <- get; return $ IOC a01 a02 a03 a04 a05 a06 a07 a08 a09 a10 a11 a12
+ recPut r = do put $ ioc_Type r; put $ ioc_ r; put $ ioc_Reserved1 r; put $ ioc_XOffset r; put $ ioc_Reserved2 r; put $ ioc_YOffset r; put $ ioc_XOrientation r; put $ ioc_YOrientation r; put $ ioc_ConstantData1 r; put $ ioc_XMap r; put $ ioc_YMap r; put $ ioc_ConstantData2 r; return ()
+ recSizeOf r = sum [ sizeOf $ ioc_Type r, sizeOf $ ioc_ r, sizeOf $ ioc_Reserved1 r, sizeOf $ ioc_XOffset r, sizeOf $ ioc_Reserved2 r, sizeOf $ ioc_YOffset r, sizeOf $ ioc_XOrientation r, sizeOf $ ioc_YOrientation r, sizeOf $ ioc_ConstantData1 r, sizeOf $ ioc_XMap r, sizeOf $ ioc_YMap r, sizeOf $ ioc_ConstantData2 r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ioc_Type r), viewField "_" (viewNumber $ ioc_ r), viewField "Reserved1" (viewString $ ioc_Reserved1 r), viewField "XOffset" (viewNumber $ ioc_XOffset r), viewField "Reserved2" (viewString $ ioc_Reserved2 r), viewField "YOffset" (viewNumber $ ioc_YOffset r), viewField "XOrientation" (viewNumber $ ioc_XOrientation r), viewField "YOrientation" (viewNumber $ ioc_YOrientation r), viewField "ConstantData1" (viewString $ ioc_ConstantData1 r), viewField "XMap" (viewNumber $ ioc_XMap r), viewField "YMap" (viewNumber $ ioc_YMap r), viewField "ConstantData2" (viewString $ ioc_ConstantData2 r) ]
+ recType = fromEnum . ioc_Type
+
+instance Rec IPD where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ IPD a01 a02 a03
+ recPut r = do put $ ipd_Type r; put $ ipd_ r; put $ ipd r; return ()
+ recSizeOf r = sum [ sizeOf $ ipd_Type r, sizeOf $ ipd_ r, sizeOf $ ipd r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ipd_Type r), viewField "_" (viewNumber $ ipd_ r), viewField "" (viewNStr $ ipd r) ]
+ recType = fromEnum . ipd_Type
+
+instance Rec IPG where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ IPG a01 a02 a03
+ recPut r = do put $ ipg_Type r; put $ ipg_ r; put $ ipg r; return ()
+ recSizeOf r = sum [ sizeOf $ ipg_Type r, sizeOf $ ipg_ r, sizeOf $ ipg r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ipg_Type r), viewField "_" (viewNumber $ ipg_ r), viewField "" (viewNStr $ ipg r) ]
+ recType = fromEnum . ipg_Type
+
+instance Rec IPO where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ IPO a01 a02 a03
+ recPut r = do put $ ipo_Type r; put $ ipo_ r; put $ ipo r; return ()
+ recSizeOf r = sum [ sizeOf $ ipo_Type r, sizeOf $ ipo_ r, sizeOf $ ipo r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ipo_Type r), viewField "_" (viewNumber $ ipo_ r), viewField "" (viewNStr $ ipo r) ]
+ recType = fromEnum . ipo_Type
+
+instance Rec IPS where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ IPS a01 a02 a03
+ recPut r = do put $ ips_Type r; put $ ips_ r; put $ ips r; return ()
+ recSizeOf r = sum [ sizeOf $ ips_Type r, sizeOf $ ips_ r, sizeOf $ ips r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ips_Type r), viewField "_" (viewNumber $ ips_ r), viewField "" (viewAStr $ ips r) ]
+ recType = fromEnum . ips_Type
+
+instance Rec IRD where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ IRD a01 a02 a03
+ recPut r = do put $ ird_Type r; put $ ird_ r; put $ ird_ImageData r; return ()
+ recSizeOf r = sum [ sizeOf $ ird_Type r, sizeOf $ ird_ r, sizeOf $ ird_ImageData r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ird_Type r), viewField "_" (viewNumber $ ird_ r), viewField "ImageData" (viewNStr $ ird_ImageData r) ]
+ recType = fromEnum . ird_Type
+
diff --git a/src/OpenAFP/Prelude/InstanceAFP/L.hs b/src/OpenAFP/Prelude/InstanceAFP/L.hs
new file mode 100644
--- /dev/null
+++ b/src/OpenAFP/Prelude/InstanceAFP/L.hs
@@ -0,0 +1,27 @@
+
+module OpenAFP.Prelude.InstanceAFP.L () where
+import OpenAFP.Types
+import OpenAFP.Records
+import OpenAFP.Internals
+
+instance Rec LLE where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ LLE a01 a02 a03
+ recPut r = do put $ lle_Type r; put $ lle_ r; put $ lle r; return ()
+ recSizeOf r = sum [ sizeOf $ lle_Type r, sizeOf $ lle_ r, sizeOf $ lle r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ lle_Type r), viewField "_" (viewNumber $ lle_ r), viewField "" (viewNStr $ lle r) ]
+ recType = fromEnum . lle_Type
+
+instance Rec LNC where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ LNC a01 a02 a03
+ recPut r = do put $ lnc_Type r; put $ lnc_ r; put $ lnc r; return ()
+ recSizeOf r = sum [ sizeOf $ lnc_Type r, sizeOf $ lnc_ r, sizeOf $ lnc r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ lnc_Type r), viewField "_" (viewNumber $ lnc_ r), viewField "" (viewNStr $ lnc r) ]
+ recType = fromEnum . lnc_Type
+
+instance Rec LND where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ LND a01 a02 a03
+ recPut r = do put $ lnd_Type r; put $ lnd_ r; put $ lnd r; return ()
+ recSizeOf r = sum [ sizeOf $ lnd_Type r, sizeOf $ lnd_ r, sizeOf $ lnd r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ lnd_Type r), viewField "_" (viewNumber $ lnd_ r), viewField "" (viewNStr $ lnd r) ]
+ recType = fromEnum . lnd_Type
+
diff --git a/src/OpenAFP/Prelude/InstanceAFP/M.hs b/src/OpenAFP/Prelude/InstanceAFP/M.hs
new file mode 100644
--- /dev/null
+++ b/src/OpenAFP/Prelude/InstanceAFP/M.hs
@@ -0,0 +1,35 @@
+
+module OpenAFP.Prelude.InstanceAFP.M () where
+import OpenAFP.Types
+import OpenAFP.Records
+import OpenAFP.Internals
+import qualified Data.ByteString.Char8 as C
+
+instance Rec MBC where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MBC a01 a02 a03
+ recPut r = do put $ mbc_Type r; put $ mbc_ r; put $ mbc r; return ()
+ recSizeOf r = sum [ sizeOf $ mbc_Type r, sizeOf $ mbc_ r, sizeOf $ mbc r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mbc_Type r), viewField "_" (viewNumber $ mbc_ r), viewField "" (viewNStr $ mbc r) ]
+ recType = fromEnum . mbc_Type
+
+instance Rec MCA where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MCA a01 a02 a03
+ recPut r = do put $ mca_Type r; put $ mca_ r; put $ mca r; return ()
+ recSizeOf r = sum [ sizeOf $ mca_Type r, sizeOf $ mca_ r, sizeOf $ mca r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mca_Type r), viewField "_" (viewNumber $ mca_ r), viewField "" (viewNStr $ mca r) ]
+ recType = fromEnum . mca_Type
+
+instance Rec MCC where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MCC a01 a02 a03
+ recPut r = do put $ mcc_Type r; put $ mcc_ r; put $ mcc r; return ()
+ recSizeOf r = sum [ sizeOf $ mcc_Type r, sizeOf $ mcc_ r, sizeOf $ mcc r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mcc_Type r), viewField "_" (viewNumber $ mcc_ r), viewField "" (viewNStr $ mcc r) ]
+ recType = fromEnum . mcc_Type
+
+instance Rec MCD where
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MCD a01 a02 a03
+ recPut r = do put $ mcd_Type r; put $ mcd_ r; put $ mcd r; return ()
+ recSizeOf r = sum [ sizeOf $ mcd_Type r, sizeOf $ mcd_ r, sizeOf $ mcd r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mcd_Type r), viewField "_" (viewNumber $ mcd_ r), viewField "" (viewNStr $ mcd r) ]
+ recType = fromEnum . mcd_Type
+
diff --git a/src/OpenAFP/Prelude/InstancePTX.hs b/src/OpenAFP/Prelude/InstancePTX.hs
--- a/src/OpenAFP/Prelude/InstancePTX.hs
+++ b/src/OpenAFP/Prelude/InstancePTX.hs
@@ -1,210 +1,209 @@
-{-# OPTIONS -fglasgow-exts #-}
module OpenAFP.Prelude.InstancePTX () where
import OpenAFP.Types
import OpenAFP.Records
import OpenAFP.Internals
-
-recOf :: (ChunkBuf c n b, Binary (Record r)) => c -> IO r
-recOf c = return . fromRecord =<< chunkToRecord c
+import qualified Data.ByteString as S
-apply :: (MonadIO m) => (t -> IO a) -> t -> (a -> m b) -> m b
-apply ctr c f = f =<< (liftIO $ ctr c)
+apply :: (Chunk c, Rec r) => c -> (r -> t) -> t
+apply c f = f (decodeChunk c)
instance Rec PTX_AMB where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_AMB a01 a02
- recPut bh r = do put bh $ ptx_amb_Type r; put bh $ ptx_amb r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_AMB a01 a02
+ recPut r = do put $ ptx_amb_Type r; put $ ptx_amb r; return ()
recSizeOf r = sum [ sizeOf $ ptx_amb_Type r, sizeOf $ ptx_amb r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_amb_Type r), viewField "" (viewNumber $ ptx_amb r) ]
recType = fromEnum . ptx_amb_Type
instance Rec PTX_AMI where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_AMI a01 a02
- recPut bh r = do put bh $ ptx_ami_Type r; put bh $ ptx_ami r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_AMI a01 a02
+ recPut r = do put $ ptx_ami_Type r; put $ ptx_ami r; return ()
recSizeOf r = sum [ sizeOf $ ptx_ami_Type r, sizeOf $ ptx_ami r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_ami_Type r), viewField "" (viewNumber $ ptx_ami r) ]
recType = fromEnum . ptx_ami_Type
instance Rec PTX_BLN where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_BLN a01 a02
- recPut bh r = do put bh $ ptx_bln_Type r; put bh $ ptx_bln r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_BLN a01 a02
+ recPut r = do put $ ptx_bln_Type r; put $ ptx_bln r; return ()
recSizeOf r = sum [ sizeOf $ ptx_bln_Type r, sizeOf $ ptx_bln r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_bln_Type r), viewField "" (viewNStr $ ptx_bln r) ]
recType = fromEnum . ptx_bln_Type
instance Rec PTX_BSU where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_BSU a01 a02
- recPut bh r = do put bh $ ptx_bsu_Type r; put bh $ ptx_bsu r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_BSU a01 a02
+ recPut r = do put $ ptx_bsu_Type r; put $ ptx_bsu r; return ()
recSizeOf r = sum [ sizeOf $ ptx_bsu_Type r, sizeOf $ ptx_bsu r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_bsu_Type r), viewField "" (viewNStr $ ptx_bsu r) ]
recType = fromEnum . ptx_bsu_Type
instance Rec PTX_DBR where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_DBR a01 a02
- recPut bh r = do put bh $ ptx_dbr_Type r; put bh $ ptx_dbr r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_DBR a01 a02
+ recPut r = do put $ ptx_dbr_Type r; put $ ptx_dbr r; return ()
recSizeOf r = sum [ sizeOf $ ptx_dbr_Type r, sizeOf $ ptx_dbr r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_dbr_Type r), viewField "" (viewNStr $ ptx_dbr r) ]
recType = fromEnum . ptx_dbr_Type
instance Rec PTX_DIR where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_DIR a01 a02
- recPut bh r = do put bh $ ptx_dir_Type r; put bh $ ptx_dir r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_DIR a01 a02
+ recPut r = do put $ ptx_dir_Type r; put $ ptx_dir r; return ()
recSizeOf r = sum [ sizeOf $ ptx_dir_Type r, sizeOf $ ptx_dir r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_dir_Type r), viewField "" (viewNStr $ ptx_dir r) ]
recType = fromEnum . ptx_dir_Type
instance Rec PTX_ESU where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_ESU a01 a02
- recPut bh r = do put bh $ ptx_esu_Type r; put bh $ ptx_esu r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_ESU a01 a02
+ recPut r = do put $ ptx_esu_Type r; put $ ptx_esu r; return ()
recSizeOf r = sum [ sizeOf $ ptx_esu_Type r, sizeOf $ ptx_esu r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_esu_Type r), viewField "" (viewNStr $ ptx_esu r) ]
recType = fromEnum . ptx_esu_Type
instance Rec PTX_NOP where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_NOP a01 a02
- recPut bh r = do put bh $ ptx_nop_Type r; put bh $ ptx_nop r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_NOP a01 a02
+ recPut r = do put $ ptx_nop_Type r; put $ ptx_nop r; return ()
recSizeOf r = sum [ sizeOf $ ptx_nop_Type r, sizeOf $ ptx_nop r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_nop_Type r), viewField "" (viewNStr $ ptx_nop r) ]
recType = fromEnum . ptx_nop_Type
instance Rec PTX_RMB where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_RMB a01 a02
- recPut bh r = do put bh $ ptx_rmb_Type r; put bh $ ptx_rmb r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_RMB a01 a02
+ recPut r = do put $ ptx_rmb_Type r; put $ ptx_rmb r; return ()
recSizeOf r = sum [ sizeOf $ ptx_rmb_Type r, sizeOf $ ptx_rmb r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_rmb_Type r), viewField "" (viewNumber $ ptx_rmb r) ]
recType = fromEnum . ptx_rmb_Type
instance Rec PTX_RMI where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_RMI a01 a02
- recPut bh r = do put bh $ ptx_rmi_Type r; put bh $ ptx_rmi r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_RMI a01 a02
+ recPut r = do put $ ptx_rmi_Type r; put $ ptx_rmi r; return ()
recSizeOf r = sum [ sizeOf $ ptx_rmi_Type r, sizeOf $ ptx_rmi r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_rmi_Type r), viewField "" (viewNumber $ ptx_rmi r) ]
recType = fromEnum . ptx_rmi_Type
instance Rec PTX_RPS where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_RPS a01 a02
- recPut bh r = do put bh $ ptx_rps_Type r; put bh $ ptx_rps r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_RPS a01 a02
+ recPut r = do put $ ptx_rps_Type r; put $ ptx_rps r; return ()
recSizeOf r = sum [ sizeOf $ ptx_rps_Type r, sizeOf $ ptx_rps r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_rps_Type r), viewField "" (viewNStr $ ptx_rps r) ]
recType = fromEnum . ptx_rps_Type
instance Rec PTX_SBI where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_SBI a01 a02
- recPut bh r = do put bh $ ptx_sbi_Type r; put bh $ ptx_sbi r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_SBI a01 a02
+ recPut r = do put $ ptx_sbi_Type r; put $ ptx_sbi r; return ()
recSizeOf r = sum [ sizeOf $ ptx_sbi_Type r, sizeOf $ ptx_sbi r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_sbi_Type r), viewField "" (viewNumber $ ptx_sbi r) ]
recType = fromEnum . ptx_sbi_Type
instance Rec PTX_SCFL where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_SCFL a01 a02
- recPut bh r = do put bh $ ptx_scfl_Type r; put bh $ ptx_scfl r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_SCFL a01 a02
+ recPut r = do put $ ptx_scfl_Type r; put $ ptx_scfl r; return ()
recSizeOf r = sum [ sizeOf $ ptx_scfl_Type r, sizeOf $ ptx_scfl r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_scfl_Type r), viewField "" (viewNumber $ ptx_scfl r) ]
recType = fromEnum . ptx_scfl_Type
instance Rec PTX_SIA where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_SIA a01 a02
- recPut bh r = do put bh $ ptx_sia_Type r; put bh $ ptx_sia r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_SIA a01 a02
+ recPut r = do put $ ptx_sia_Type r; put $ ptx_sia r; return ()
recSizeOf r = sum [ sizeOf $ ptx_sia_Type r, sizeOf $ ptx_sia r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_sia_Type r), viewField "" (viewNumber $ ptx_sia r) ]
recType = fromEnum . ptx_sia_Type
instance Rec PTX_SIM where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_SIM a01 a02
- recPut bh r = do put bh $ ptx_sim_Type r; put bh $ ptx_sim r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_SIM a01 a02
+ recPut r = do put $ ptx_sim_Type r; put $ ptx_sim r; return ()
recSizeOf r = sum [ sizeOf $ ptx_sim_Type r, sizeOf $ ptx_sim r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_sim_Type r), viewField "" (viewNumber $ ptx_sim r) ]
recType = fromEnum . ptx_sim_Type
instance Rec PTX_STC where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_STC a01 a02
- recPut bh r = do put bh $ ptx_stc_Type r; put bh $ ptx_stc r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_STC a01 a02
+ recPut r = do put $ ptx_stc_Type r; put $ ptx_stc r; return ()
recSizeOf r = sum [ sizeOf $ ptx_stc_Type r, sizeOf $ ptx_stc r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_stc_Type r), viewField "" (viewNStr $ ptx_stc r) ]
recType = fromEnum . ptx_stc_Type
instance Rec PTX_STO where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ PTX_STO a01 a02 a03
- recPut bh r = do put bh $ ptx_sto_Type r; put bh $ ptx_sto_Orientation r; put bh $ ptx_sto_WrapDirection r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ PTX_STO a01 a02 a03
+ recPut r = do put $ ptx_sto_Type r; put $ ptx_sto_Orientation r; put $ ptx_sto_WrapDirection r; return ()
recSizeOf r = sum [ sizeOf $ ptx_sto_Type r, sizeOf $ ptx_sto_Orientation r, sizeOf $ ptx_sto_WrapDirection r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_sto_Type r), viewField "Orientation" (viewNumber $ ptx_sto_Orientation r), viewField "WrapDirection" (viewNumber $ ptx_sto_WrapDirection r) ]
recType = fromEnum . ptx_sto_Type
instance Rec PTX_SVI where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_SVI a01 a02
- recPut bh r = do put bh $ ptx_svi_Type r; put bh $ ptx_svi r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_SVI a01 a02
+ recPut r = do put $ ptx_svi_Type r; put $ ptx_svi r; return ()
recSizeOf r = sum [ sizeOf $ ptx_svi_Type r, sizeOf $ ptx_svi r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_svi_Type r), viewField "" (viewNumber $ ptx_svi r) ]
recType = fromEnum . ptx_svi_Type
instance Rec PTX_TRN where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ PTX_TRN a01 a02
- recPut bh r = do put bh $ ptx_trn_Type r; put bh $ ptx_trn r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ PTX_TRN a01 a02
+ recPut r = do put $ ptx_trn_Type r; put $ ptx_trn r; return ()
recSizeOf r = sum [ sizeOf $ ptx_trn_Type r, sizeOf $ ptx_trn r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_trn_Type r), viewField "" (viewNStr $ ptx_trn r) ]
recType = fromEnum . ptx_trn_Type
-instance ChunkBuf PTX_ N1 Buffer1 where
- chunkCon = PTX_
- chunkDecon (PTX_ x) = x
+instance Chunk PTX_ where
+ type N PTX_ = N1
+ type BufOf PTX_ = Buffer1
+ mkChunk = PTX_
+ chunkDecon (PTX_ x y) = (x, y)
chunkTypeLookup = lookupPTX
chunkApply = applyPTX
-applyPTX :: forall m x. (MonadIO m)
- => N1 -> PTX_ -> (forall a. (Rec a) => (a -> m x)) -> m x
+applyPTX :: forall x. N1 -> PTX_ -> (forall a. (Rec a) => (a -> x)) -> x
applyPTX x rec f = case x of
- 0x74 -> apply recOf rec (f :: PTX_STC -> m x)
- 0x75 -> apply recOf rec (f :: PTX_STC -> m x)
- 0xC0 -> apply recOf rec (f :: PTX_SIM -> m x)
- 0xC1 -> apply recOf rec (f :: PTX_SIM -> m x)
- 0xC2 -> apply recOf rec (f :: PTX_SIA -> m x)
- 0xC3 -> apply recOf rec (f :: PTX_SIA -> m x)
- 0xC4 -> apply recOf rec (f :: PTX_SVI -> m x)
- 0xC5 -> apply recOf rec (f :: PTX_SVI -> m x)
- 0xC6 -> apply recOf rec (f :: PTX_AMI -> m x)
- 0xC7 -> apply recOf rec (f :: PTX_AMI -> m x)
- 0xC8 -> apply recOf rec (f :: PTX_RMI -> m x)
- 0xC9 -> apply recOf rec (f :: PTX_RMI -> m x)
- 0xD0 -> apply recOf rec (f :: PTX_SBI -> m x)
- 0xD1 -> apply recOf rec (f :: PTX_SBI -> m x)
- 0xD2 -> apply recOf rec (f :: PTX_AMB -> m x)
- 0xD3 -> apply recOf rec (f :: PTX_AMB -> m x)
- 0xD4 -> apply recOf rec (f :: PTX_RMB -> m x)
- 0xD5 -> apply recOf rec (f :: PTX_RMB -> m x)
- 0xD8 -> apply recOf rec (f :: PTX_BLN -> m x)
- 0xD9 -> apply recOf rec (f :: PTX_BLN -> m x)
- 0xDA -> apply recOf rec (f :: PTX_TRN -> m x)
- 0xDB -> apply recOf rec (f :: PTX_TRN -> m x)
- 0xE4 -> apply recOf rec (f :: PTX_DIR -> m x)
- 0xE5 -> apply recOf rec (f :: PTX_DIR -> m x)
- 0xE6 -> apply recOf rec (f :: PTX_DBR -> m x)
- 0xE7 -> apply recOf rec (f :: PTX_DBR -> m x)
- 0xEE -> apply recOf rec (f :: PTX_RPS -> m x)
- 0xEF -> apply recOf rec (f :: PTX_RPS -> m x)
- 0xF0 -> apply recOf rec (f :: PTX_SCFL -> m x)
- 0xF1 -> apply recOf rec (f :: PTX_SCFL -> m x)
- 0xF2 -> apply recOf rec (f :: PTX_BSU -> m x)
- 0xF3 -> apply recOf rec (f :: PTX_BSU -> m x)
- 0xF4 -> apply recOf rec (f :: PTX_ESU -> m x)
- 0xF5 -> apply recOf rec (f :: PTX_ESU -> m x)
- 0xF6 -> apply recOf rec (f :: PTX_STO -> m x)
- 0xF7 -> apply recOf rec (f :: PTX_STO -> m x)
- 0xF8 -> apply recOf rec (f :: PTX_NOP -> m x)
- 0xF9 -> apply recOf rec (f :: PTX_NOP -> m x)
- _ -> apply recOf rec (f :: Unknown -> m x)
+ 0x74 -> apply rec (f :: PTX_STC -> x)
+ 0x75 -> apply rec (f :: PTX_STC -> x)
+ 0xC0 -> apply rec (f :: PTX_SIM -> x)
+ 0xC1 -> apply rec (f :: PTX_SIM -> x)
+ 0xC2 -> apply rec (f :: PTX_SIA -> x)
+ 0xC3 -> apply rec (f :: PTX_SIA -> x)
+ 0xC4 -> apply rec (f :: PTX_SVI -> x)
+ 0xC5 -> apply rec (f :: PTX_SVI -> x)
+ 0xC6 -> apply rec (f :: PTX_AMI -> x)
+ 0xC7 -> apply rec (f :: PTX_AMI -> x)
+ 0xC8 -> apply rec (f :: PTX_RMI -> x)
+ 0xC9 -> apply rec (f :: PTX_RMI -> x)
+ 0xD0 -> apply rec (f :: PTX_SBI -> x)
+ 0xD1 -> apply rec (f :: PTX_SBI -> x)
+ 0xD2 -> apply rec (f :: PTX_AMB -> x)
+ 0xD3 -> apply rec (f :: PTX_AMB -> x)
+ 0xD4 -> apply rec (f :: PTX_RMB -> x)
+ 0xD5 -> apply rec (f :: PTX_RMB -> x)
+ 0xD8 -> apply rec (f :: PTX_BLN -> x)
+ 0xD9 -> apply rec (f :: PTX_BLN -> x)
+ 0xDA -> apply rec (f :: PTX_TRN -> x)
+ 0xDB -> apply rec (f :: PTX_TRN -> x)
+ 0xE4 -> apply rec (f :: PTX_DIR -> x)
+ 0xE5 -> apply rec (f :: PTX_DIR -> x)
+ 0xE6 -> apply rec (f :: PTX_DBR -> x)
+ 0xE7 -> apply rec (f :: PTX_DBR -> x)
+ 0xEE -> apply rec (f :: PTX_RPS -> x)
+ 0xEF -> apply rec (f :: PTX_RPS -> x)
+ 0xF0 -> apply rec (f :: PTX_SCFL -> x)
+ 0xF1 -> apply rec (f :: PTX_SCFL -> x)
+ 0xF2 -> apply rec (f :: PTX_BSU -> x)
+ 0xF3 -> apply rec (f :: PTX_BSU -> x)
+ 0xF4 -> apply rec (f :: PTX_ESU -> x)
+ 0xF5 -> apply rec (f :: PTX_ESU -> x)
+ 0xF6 -> apply rec (f :: PTX_STO -> x)
+ 0xF7 -> apply rec (f :: PTX_STO -> x)
+ 0xF8 -> apply rec (f :: PTX_NOP -> x)
+ 0xF9 -> apply rec (f :: PTX_NOP -> x)
+ _ -> apply rec (f :: Unknown -> x)
-instance RecChunk PTX PTX_ N1 Buffer1 where
+instance RecChunk PTX where
+ type ChunkOf PTX = PTX_
readChunks r = ptx_Chunks r
writeChunks r io = do
cs <- io
return $ r { ptx_Chunks = cs }
instance Rec PTX_ where
- recSizeOf c = 1 + (snd $ chunkToPStrLen c)
+ recSizeOf c = 1 + (S.length $ packChunk c)
instance Rec PTX where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; return $ PTX a01 a02 a03 a04
- recPut bh r = do put bh $ ptx_Type r; put bh $ ptx_ r; put bh $ ptx_EscapeSequence r; put bh $ ptx_Chunks r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- getList; return $ PTX a01 a02 a03 a04
+ recPut r = do put $ ptx_Type r; put $ ptx_ r; put $ ptx_EscapeSequence r; putList $ ptx_Chunks r; return ()
recSizeOf r = sum [ sizeOf $ ptx_Type r, sizeOf $ ptx_ r, sizeOf $ ptx_EscapeSequence r, sizeOf $ ptx_Chunks r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptx_Type r), viewField "_" (viewNumber $ ptx_ r), viewField "EscapeSequence" (viewNumber $ ptx_EscapeSequence r), viewField "Chunks" (viewChunks $ ptx_Chunks r) ]
recType = fromEnum . ptx_Type
diff --git a/src/OpenAFP/Prelude/InstanceT.hs b/src/OpenAFP/Prelude/InstanceT.hs
--- a/src/OpenAFP/Prelude/InstanceT.hs
+++ b/src/OpenAFP/Prelude/InstanceT.hs
@@ -1,478 +1,474 @@
-{-# OPTIONS -fglasgow-exts #-}
-
module OpenAFP.Prelude.InstanceT () where
import OpenAFP.Types
import OpenAFP.Records
import OpenAFP.Internals
-recOf :: (ChunkBuf c n b, Binary (Record r)) => c -> IO r
-recOf c = return . fromRecord =<< chunkToRecord c
-
-apply :: (MonadIO m) => (t -> IO a) -> t -> (a -> m b) -> m b
-apply ctr c f = f =<< (liftIO $ ctr c)
+apply :: (Chunk c, Rec r) => c -> (r -> t) -> t
+apply c f = f (decodeChunk c)
instance Rec T_AD where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_AD a01 a02
- recPut bh r = do put bh $ t_ad_Type r; put bh $ t_ad r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_AD a01 a02
+ recPut r = do put $ t_ad_Type r; put $ t_ad r; return ()
recSizeOf r = sum [ sizeOf $ t_ad_Type r, sizeOf $ t_ad r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_ad_Type r), viewField "" (viewNStr $ t_ad r) ]
recType = fromEnum . t_ad_Type
instance Rec T_AQ where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_AQ a01 a02
- recPut bh r = do put bh $ t_aq_Type r; put bh $ t_aq r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_AQ a01 a02
+ recPut r = do put $ t_aq_Type r; put $ t_aq r; return ()
recSizeOf r = sum [ sizeOf $ t_aq_Type r, sizeOf $ t_aq r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_aq_Type r), viewField "" (viewNStr $ t_aq r) ]
recType = fromEnum . t_aq_Type
instance Rec T_AV where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_AV a01 a02
- recPut bh r = do put bh $ t_av_Type r; put bh $ t_av r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_AV a01 a02
+ recPut r = do put $ t_av_Type r; put $ t_av r; return ()
recSizeOf r = sum [ sizeOf $ t_av_Type r, sizeOf $ t_av r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_av_Type r), viewField "" (viewNStr $ t_av r) ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_av_Type r), viewField "" (viewAStr $ t_av r) ]
recType = fromEnum . t_av_Type
instance Rec T_C where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_C a01 a02
- recPut bh r = do put bh $ t_c_Type r; put bh $ t_c r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_C a01 a02
+ recPut r = do put $ t_c_Type r; put $ t_c r; return ()
recSizeOf r = sum [ sizeOf $ t_c_Type r, sizeOf $ t_c r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_c_Type r), viewField "" (viewNStr $ t_c r) ]
recType = fromEnum . t_c_Type
instance Rec T_CF where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_CF a01 a02
- recPut bh r = do put bh $ t_cf_Type r; put bh $ t_cf r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_CF a01 a02
+ recPut r = do put $ t_cf_Type r; put $ t_cf r; return ()
recSizeOf r = sum [ sizeOf $ t_cf_Type r, sizeOf $ t_cf r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_cf_Type r), viewField "" (viewNStr $ t_cf r) ]
recType = fromEnum . t_cf_Type
instance Rec T_CGCSGI where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_CGCSGI a01 a02
- recPut bh r = do put bh $ t_cgcsgi_Type r; put bh $ t_cgcsgi r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_CGCSGI a01 a02
+ recPut r = do put $ t_cgcsgi_Type r; put $ t_cgcsgi r; return ()
recSizeOf r = sum [ sizeOf $ t_cgcsgi_Type r, sizeOf $ t_cgcsgi r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_cgcsgi_Type r), viewField "" (viewNStr $ t_cgcsgi r) ]
recType = fromEnum . t_cgcsgi_Type
instance Rec T_CR where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_CR a01 a02
- recPut bh r = do put bh $ t_cr_Type r; put bh $ t_cr r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_CR a01 a02
+ recPut r = do put $ t_cr_Type r; put $ t_cr r; return ()
recSizeOf r = sum [ sizeOf $ t_cr_Type r, sizeOf $ t_cr r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_cr_Type r), viewField "" (viewNStr $ t_cr r) ]
recType = fromEnum . t_cr_Type
instance Rec T_CS where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_CS a01 a02
- recPut bh r = do put bh $ t_cs_Type r; put bh $ t_cs r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_CS a01 a02
+ recPut r = do put $ t_cs_Type r; put $ t_cs r; return ()
recSizeOf r = sum [ sizeOf $ t_cs_Type r, sizeOf $ t_cs r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_cs_Type r), viewField "" (viewNStr $ t_cs r) ]
recType = fromEnum . t_cs_Type
instance Rec T_DP where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_DP a01 a02
- recPut bh r = do put bh $ t_dp_Type r; put bh $ t_dp r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_DP a01 a02
+ recPut r = do put $ t_dp_Type r; put $ t_dp r; return ()
recSizeOf r = sum [ sizeOf $ t_dp_Type r, sizeOf $ t_dp r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_dp_Type r), viewField "" (viewNStr $ t_dp r) ]
recType = fromEnum . t_dp_Type
instance Rec T_EF where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_EF a01 a02
- recPut bh r = do put bh $ t_ef_Type r; put bh $ t_ef r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_EF a01 a02
+ recPut r = do put $ t_ef_Type r; put $ t_ef r; return ()
recSizeOf r = sum [ sizeOf $ t_ef_Type r, sizeOf $ t_ef r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_ef_Type r), viewField "" (viewNStr $ t_ef r) ]
recType = fromEnum . t_ef_Type
instance Rec T_ERLI where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_ERLI a01 a02
- recPut bh r = do put bh $ t_erli_Type r; put bh $ t_erli r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_ERLI a01 a02
+ recPut r = do put $ t_erli_Type r; put $ t_erli r; return ()
recSizeOf r = sum [ sizeOf $ t_erli_Type r, sizeOf $ t_erli r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_erli_Type r), viewField "" (viewNStr $ t_erli r) ]
recType = fromEnum . t_erli_Type
instance Rec T_ESI where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_ESI a01 a02
- recPut bh r = do put bh $ t_esi_Type r; put bh $ t_esi r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_ESI a01 a02
+ recPut r = do put $ t_esi_Type r; put $ t_esi r; return ()
recSizeOf r = sum [ sizeOf $ t_esi_Type r, sizeOf $ t_esi r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_esi_Type r), viewField "" (viewNStr $ t_esi r) ]
recType = fromEnum . t_esi_Type
instance Rec T_FCGCSGI where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_FCGCSGI a01 a02
- recPut bh r = do put bh $ t_fcgcsgi_Type r; put bh $ t_fcgcsgi r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_FCGCSGI a01 a02
+ recPut r = do put $ t_fcgcsgi_Type r; put $ t_fcgcsgi r; return ()
recSizeOf r = sum [ sizeOf $ t_fcgcsgi_Type r, sizeOf $ t_fcgcsgi r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_fcgcsgi_Type r), viewField "" (viewNStr $ t_fcgcsgi r) ]
recType = fromEnum . t_fcgcsgi_Type
instance Rec T_FDS where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_FDS a01 a02
- recPut bh r = do put bh $ t_fds_Type r; put bh $ t_fds r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_FDS a01 a02
+ recPut r = do put $ t_fds_Type r; put $ t_fds r; return ()
recSizeOf r = sum [ sizeOf $ t_fds_Type r, sizeOf $ t_fds r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_fds_Type r), viewField "" (viewNStr $ t_fds r) ]
recType = fromEnum . t_fds_Type
instance Rec T_FF where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_FF a01 a02
- recPut bh r = do put bh $ t_ff_Type r; put bh $ t_ff r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_FF a01 a02
+ recPut r = do put $ t_ff_Type r; put $ t_ff r; return ()
recSizeOf r = sum [ sizeOf $ t_ff_Type r, sizeOf $ t_ff r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_ff_Type r), viewField "" (viewNStr $ t_ff r) ]
recType = fromEnum . t_ff_Type
instance Rec T_FHSF where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_FHSF a01 a02
- recPut bh r = do put bh $ t_fhsf_Type r; put bh $ t_fhsf r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_FHSF a01 a02
+ recPut r = do put $ t_fhsf_Type r; put $ t_fhsf r; return ()
recSizeOf r = sum [ sizeOf $ t_fhsf_Type r, sizeOf $ t_fhsf r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_fhsf_Type r), viewField "" (viewNStr $ t_fhsf r) ]
recType = fromEnum . t_fhsf_Type
instance Rec T_FO where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_FO a01 a02
- recPut bh r = do put bh $ t_fo_Type r; put bh $ t_fo r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_FO a01 a02
+ recPut r = do put $ t_fo_Type r; put $ t_fo r; return ()
recSizeOf r = sum [ sizeOf $ t_fo_Type r, sizeOf $ t_fo r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_fo_Type r), viewField "" (viewNStr $ t_fo r) ]
recType = fromEnum . t_fo_Type
instance Rec T_FQN where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; return $ T_FQN a01 a02 a03 a04
- recPut bh r = do put bh $ t_fqn_Type r; put bh $ t_fqn_SubType r; put bh $ t_fqn_Format r; put bh $ t_fqn r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; return $ T_FQN a01 a02 a03 a04
+ recPut r = do put $ t_fqn_Type r; put $ t_fqn_SubType r; put $ t_fqn_Format r; put $ t_fqn r; return ()
recSizeOf r = sum [ sizeOf $ t_fqn_Type r, sizeOf $ t_fqn_SubType r, sizeOf $ t_fqn_Format r, sizeOf $ t_fqn r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_fqn_Type r), viewField "SubType" (viewNumber $ t_fqn_SubType r), viewField "Format" (viewNumber $ t_fqn_Format r), viewField "" (viewString $ t_fqn r) ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_fqn_Type r), viewField "SubType" (viewNumber $ t_fqn_SubType r), viewField "Format" (viewNumber $ t_fqn_Format r), viewField "" (viewAStr $ t_fqn r) ]
recType = fromEnum . t_fqn_Type
instance Rec T_FRMT where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_FRMT a01 a02
- recPut bh r = do put bh $ t_frmt_Type r; put bh $ t_frmt r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_FRMT a01 a02
+ recPut r = do put $ t_frmt_Type r; put $ t_frmt r; return ()
recSizeOf r = sum [ sizeOf $ t_frmt_Type r, sizeOf $ t_frmt r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_frmt_Type r), viewField "" (viewNStr $ t_frmt r) ]
recType = fromEnum . t_frmt_Type
instance Rec T_II where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_II a01 a02
- recPut bh r = do put bh $ t_ii_Type r; put bh $ t_ii r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_II a01 a02
+ recPut r = do put $ t_ii_Type r; put $ t_ii r; return ()
recSizeOf r = sum [ sizeOf $ t_ii_Type r, sizeOf $ t_ii r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_ii_Type r), viewField "" (viewNStr $ t_ii r) ]
recType = fromEnum . t_ii_Type
instance Rec T_LDOPM where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_LDOPM a01 a02
- recPut bh r = do put bh $ t_ldopm_Type r; put bh $ t_ldopm r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_LDOPM a01 a02
+ recPut r = do put $ t_ldopm_Type r; put $ t_ldopm r; return ()
recSizeOf r = sum [ sizeOf $ t_ldopm_Type r, sizeOf $ t_ldopm r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_ldopm_Type r), viewField "" (viewNStr $ t_ldopm r) ]
recType = fromEnum . t_ldopm_Type
instance Rec T_LDTS where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_LDTS a01 a02
- recPut bh r = do put bh $ t_ldts_Type r; put bh $ t_ldts r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_LDTS a01 a02
+ recPut r = do put $ t_ldts_Type r; put $ t_ldts r; return ()
recSizeOf r = sum [ sizeOf $ t_ldts_Type r, sizeOf $ t_ldts r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_ldts_Type r), viewField "" (viewNStr $ t_ldts r) ]
recType = fromEnum . t_ldts_Type
instance Rec T_MA where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_MA a01 a02
- recPut bh r = do put bh $ t_ma_Type r; put bh $ t_ma r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_MA a01 a02
+ recPut r = do put $ t_ma_Type r; put $ t_ma r; return ()
recSizeOf r = sum [ sizeOf $ t_ma_Type r, sizeOf $ t_ma r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_ma_Type r), viewField "" (viewNStr $ t_ma r) ]
recType = fromEnum . t_ma_Type
instance Rec T_MEC where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_MEC a01 a02
- recPut bh r = do put bh $ t_mec_Type r; put bh $ t_mec r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_MEC a01 a02
+ recPut r = do put $ t_mec_Type r; put $ t_mec r; return ()
recSizeOf r = sum [ sizeOf $ t_mec_Type r, sizeOf $ t_mec r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_mec_Type r), viewField "" (viewNStr $ t_mec r) ]
recType = fromEnum . t_mec_Type
instance Rec T_MF where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_MF a01 a02
- recPut bh r = do put bh $ t_mf_Type r; put bh $ t_mf r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_MF a01 a02
+ recPut r = do put $ t_mf_Type r; put $ t_mf r; return ()
recSizeOf r = sum [ sizeOf $ t_mf_Type r, sizeOf $ t_mf r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_mf_Type r), viewField "" (viewNStr $ t_mf r) ]
recType = fromEnum . t_mf_Type
instance Rec T_MIS where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_MIS a01 a02
- recPut bh r = do put bh $ t_mis_Type r; put bh $ t_mis r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_MIS a01 a02
+ recPut r = do put $ t_mis_Type r; put $ t_mis r; return ()
recSizeOf r = sum [ sizeOf $ t_mis_Type r, sizeOf $ t_mis r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_mis_Type r), viewField "" (viewNStr $ t_mis r) ]
recType = fromEnum . t_mis_Type
instance Rec T_MMPN where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_MMPN a01 a02
- recPut bh r = do put bh $ t_mmpn_Type r; put bh $ t_mmpn r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_MMPN a01 a02
+ recPut r = do put $ t_mmpn_Type r; put $ t_mmpn r; return ()
recSizeOf r = sum [ sizeOf $ t_mmpn_Type r, sizeOf $ t_mmpn r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_mmpn_Type r), viewField "" (viewNStr $ t_mmpn r) ]
recType = fromEnum . t_mmpn_Type
instance Rec T_MO where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_MO a01 a02
- recPut bh r = do put bh $ t_mo_Type r; put bh $ t_mo r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_MO a01 a02
+ recPut r = do put $ t_mo_Type r; put $ t_mo r; return ()
recSizeOf r = sum [ sizeOf $ t_mo_Type r, sizeOf $ t_mo r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_mo_Type r), viewField "" (viewNStr $ t_mo r) ]
recType = fromEnum . t_mo_Type
instance Rec T_MOR where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_MOR a01 a02
- recPut bh r = do put bh $ t_mor_Type r; put bh $ t_mor r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_MOR a01 a02
+ recPut r = do put $ t_mor_Type r; put $ t_mor r; return ()
recSizeOf r = sum [ sizeOf $ t_mor_Type r, sizeOf $ t_mor r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_mor_Type r), viewField "" (viewNStr $ t_mor r) ]
recType = fromEnum . t_mor_Type
instance Rec T_OAMU where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_OAMU a01 a02
- recPut bh r = do put bh $ t_oamu_Type r; put bh $ t_oamu r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_OAMU a01 a02
+ recPut r = do put $ t_oamu_Type r; put $ t_oamu r; return ()
recSizeOf r = sum [ sizeOf $ t_oamu_Type r, sizeOf $ t_oamu r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_oamu_Type r), viewField "" (viewNStr $ t_oamu r) ]
recType = fromEnum . t_oamu_Type
instance Rec T_OAS where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_OAS a01 a02
- recPut bh r = do put bh $ t_oas_Type r; put bh $ t_oas r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_OAS a01 a02
+ recPut r = do put $ t_oas_Type r; put $ t_oas r; return ()
recSizeOf r = sum [ sizeOf $ t_oas_Type r, sizeOf $ t_oas r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_oas_Type r), viewField "" (viewNStr $ t_oas r) ]
recType = fromEnum . t_oas_Type
instance Rec T_OBE where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_OBE a01 a02
- recPut bh r = do put bh $ t_obe_Type r; put bh $ t_obe r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_OBE a01 a02
+ recPut r = do put $ t_obe_Type r; put $ t_obe r; return ()
recSizeOf r = sum [ sizeOf $ t_obe_Type r, sizeOf $ t_obe r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_obe_Type r), viewField "" (viewNStr $ t_obe r) ]
recType = fromEnum . t_obe_Type
instance Rec T_OBO where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_OBO a01 a02
- recPut bh r = do put bh $ t_obo_Type r; put bh $ t_obo r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_OBO a01 a02
+ recPut r = do put $ t_obo_Type r; put $ t_obo r; return ()
recSizeOf r = sum [ sizeOf $ t_obo_Type r, sizeOf $ t_obo r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_obo_Type r), viewField "" (viewNStr $ t_obo r) ]
recType = fromEnum . t_obo_Type
instance Rec T_OCH where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_OCH a01 a02
- recPut bh r = do put bh $ t_och_Type r; put bh $ t_och r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_OCH a01 a02
+ recPut r = do put $ t_och_Type r; put $ t_och r; return ()
recSizeOf r = sum [ sizeOf $ t_och_Type r, sizeOf $ t_och r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_och_Type r), viewField "" (viewNStr $ t_och r) ]
recType = fromEnum . t_och_Type
instance Rec T_OCL where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_OCL a01 a02
- recPut bh r = do put bh $ t_ocl_Type r; put bh $ t_ocl r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_OCL a01 a02
+ recPut r = do put $ t_ocl_Type r; put $ t_ocl r; return ()
recSizeOf r = sum [ sizeOf $ t_ocl_Type r, sizeOf $ t_ocl r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_ocl_Type r), viewField "" (viewNStr $ t_ocl r) ]
recType = fromEnum . t_ocl_Type
instance Rec T_OCO where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_OCO a01 a02
- recPut bh r = do put bh $ t_oco_Type r; put bh $ t_oco r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_OCO a01 a02
+ recPut r = do put $ t_oco_Type r; put $ t_oco r; return ()
recSizeOf r = sum [ sizeOf $ t_oco_Type r, sizeOf $ t_oco r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_oco_Type r), viewField "" (viewNStr $ t_oco r) ]
recType = fromEnum . t_oco_Type
instance Rec T_OFSS where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_OFSS a01 a02
- recPut bh r = do put bh $ t_ofss_Type r; put bh $ t_ofss r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_OFSS a01 a02
+ recPut r = do put $ t_ofss_Type r; put $ t_ofss r; return ()
recSizeOf r = sum [ sizeOf $ t_ofss_Type r, sizeOf $ t_ofss r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_ofss_Type r), viewField "" (viewNStr $ t_ofss r) ]
recType = fromEnum . t_ofss_Type
instance Rec T_OO where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_OO a01 a02
- recPut bh r = do put bh $ t_oo_Type r; put bh $ t_oo r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_OO a01 a02
+ recPut r = do put $ t_oo_Type r; put $ t_oo r; return ()
recSizeOf r = sum [ sizeOf $ t_oo_Type r, sizeOf $ t_oo r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_oo_Type r), viewField "" (viewNStr $ t_oo r) ]
recType = fromEnum . t_oo_Type
instance Rec T_OOI where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_OOI a01 a02
- recPut bh r = do put bh $ t_ooi_Type r; put bh $ t_ooi r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_OOI a01 a02
+ recPut r = do put $ t_ooi_Type r; put $ t_ooi r; return ()
recSizeOf r = sum [ sizeOf $ t_ooi_Type r, sizeOf $ t_ooi r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_ooi_Type r), viewField "" (viewNStr $ t_ooi r) ]
recType = fromEnum . t_ooi_Type
instance Rec T_OSFE where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_OSFE a01 a02
- recPut bh r = do put bh $ t_osfe_Type r; put bh $ t_osfe r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_OSFE a01 a02
+ recPut r = do put $ t_osfe_Type r; put $ t_osfe r; return ()
recSizeOf r = sum [ sizeOf $ t_osfe_Type r, sizeOf $ t_osfe r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_osfe_Type r), viewField "" (viewNStr $ t_osfe r) ]
recType = fromEnum . t_osfe_Type
instance Rec T_OSFO where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_OSFO a01 a02
- recPut bh r = do put bh $ t_osfo_Type r; put bh $ t_osfo r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_OSFO a01 a02
+ recPut r = do put $ t_osfo_Type r; put $ t_osfo r; return ()
recSizeOf r = sum [ sizeOf $ t_osfo_Type r, sizeOf $ t_osfo r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_osfo_Type r), viewField "" (viewNStr $ t_osfo r) ]
recType = fromEnum . t_osfo_Type
instance Rec T_PC where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_PC a01 a02
- recPut bh r = do put bh $ t_pc_Type r; put bh $ t_pc r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_PC a01 a02
+ recPut r = do put $ t_pc_Type r; put $ t_pc r; return ()
recSizeOf r = sum [ sizeOf $ t_pc_Type r, sizeOf $ t_pc r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_pc_Type r), viewField "" (viewNStr $ t_pc r) ]
recType = fromEnum . t_pc_Type
instance Rec T_POCP where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_POCP a01 a02
- recPut bh r = do put bh $ t_pocp_Type r; put bh $ t_pocp r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_POCP a01 a02
+ recPut r = do put $ t_pocp_Type r; put $ t_pocp r; return ()
recSizeOf r = sum [ sizeOf $ t_pocp_Type r, sizeOf $ t_pocp r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_pocp_Type r), viewField "" (viewNStr $ t_pocp r) ]
recType = fromEnum . t_pocp_Type
instance Rec T_PPI where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_PPI a01 a02
- recPut bh r = do put bh $ t_ppi_Type r; put bh $ t_ppi r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_PPI a01 a02
+ recPut r = do put $ t_ppi_Type r; put $ t_ppi r; return ()
recSizeOf r = sum [ sizeOf $ t_ppi_Type r, sizeOf $ t_ppi r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_ppi_Type r), viewField "" (viewNStr $ t_ppi r) ]
recType = fromEnum . t_ppi_Type
instance Rec T_PSMR where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_PSMR a01 a02
- recPut bh r = do put bh $ t_psmr_Type r; put bh $ t_psmr r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_PSMR a01 a02
+ recPut r = do put $ t_psmr_Type r; put $ t_psmr r; return ()
recSizeOf r = sum [ sizeOf $ t_psmr_Type r, sizeOf $ t_psmr r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_psmr_Type r), viewField "" (viewNStr $ t_psmr r) ]
recType = fromEnum . t_psmr_Type
instance Rec T_PSRM where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_PSRM a01 a02
- recPut bh r = do put bh $ t_psrm_Type r; put bh $ t_psrm r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_PSRM a01 a02
+ recPut r = do put $ t_psrm_Type r; put $ t_psrm r; return ()
recSizeOf r = sum [ sizeOf $ t_psrm_Type r, sizeOf $ t_psrm r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_psrm_Type r), viewField "" (viewNStr $ t_psrm r) ]
recType = fromEnum . t_psrm_Type
instance Rec T_PV where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_PV a01 a02
- recPut bh r = do put bh $ t_pv_Type r; put bh $ t_pv r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_PV a01 a02
+ recPut r = do put $ t_pv_Type r; put $ t_pv r; return ()
recSizeOf r = sum [ sizeOf $ t_pv_Type r, sizeOf $ t_pv r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_pv_Type r), viewField "" (viewNStr $ t_pv r) ]
recType = fromEnum . t_pv_Type
instance Rec T_RLI where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ T_RLI a01 a02 a03
- recPut bh r = do put bh $ t_rli_Type r; put bh $ t_rli_SubType r; put bh $ t_rli r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ T_RLI a01 a02 a03
+ recPut r = do put $ t_rli_Type r; put $ t_rli_SubType r; put $ t_rli r; return ()
recSizeOf r = sum [ sizeOf $ t_rli_Type r, sizeOf $ t_rli_SubType r, sizeOf $ t_rli r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_rli_Type r), viewField "SubType" (viewNumber $ t_rli_SubType r), viewField "" (viewNumber $ t_rli r) ]
recType = fromEnum . t_rli_Type
instance Rec T_ROI where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_ROI a01 a02
- recPut bh r = do put bh $ t_roi_Type r; put bh $ t_roi r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_ROI a01 a02
+ recPut r = do put $ t_roi_Type r; put $ t_roi r; return ()
recSizeOf r = sum [ sizeOf $ t_roi_Type r, sizeOf $ t_roi r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_roi_Type r), viewField "" (viewNStr $ t_roi r) ]
recType = fromEnum . t_roi_Type
instance Rec T_ROT where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_ROT a01 a02
- recPut bh r = do put bh $ t_rot_Type r; put bh $ t_rot r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_ROT a01 a02
+ recPut r = do put $ t_rot_Type r; put $ t_rot r; return ()
recSizeOf r = sum [ sizeOf $ t_rot_Type r, sizeOf $ t_rot r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_rot_Type r), viewField "" (viewNStr $ t_rot r) ]
recType = fromEnum . t_rot_Type
instance Rec T_RSN where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_RSN a01 a02
- recPut bh r = do put bh $ t_rsn_Type r; put bh $ t_rsn r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_RSN a01 a02
+ recPut r = do put $ t_rsn_Type r; put $ t_rsn r; return ()
recSizeOf r = sum [ sizeOf $ t_rsn_Type r, sizeOf $ t_rsn r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_rsn_Type r), viewField "" (viewNStr $ t_rsn r) ]
recType = fromEnum . t_rsn_Type
instance Rec T_RUA where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_RUA a01 a02
- recPut bh r = do put bh $ t_rua_Type r; put bh $ t_rua r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_RUA a01 a02
+ recPut r = do put $ t_rua_Type r; put $ t_rua r; return ()
recSizeOf r = sum [ sizeOf $ t_rua_Type r, sizeOf $ t_rua r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_rua_Type r), viewField "" (viewNStr $ t_rua r) ]
recType = fromEnum . t_rua_Type
instance Rec T_T1CRMT where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_T1CRMT a01 a02
- recPut bh r = do put bh $ t_t1crmt_Type r; put bh $ t_t1crmt r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_T1CRMT a01 a02
+ recPut r = do put $ t_t1crmt_Type r; put $ t_t1crmt r; return ()
recSizeOf r = sum [ sizeOf $ t_t1crmt_Type r, sizeOf $ t_t1crmt r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_t1crmt_Type r), viewField "" (viewNStr $ t_t1crmt r) ]
recType = fromEnum . t_t1crmt_Type
instance Rec T_T2FRMT where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_T2FRMT a01 a02
- recPut bh r = do put bh $ t_t2frmt_Type r; put bh $ t_t2frmt r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_T2FRMT a01 a02
+ recPut r = do put $ t_t2frmt_Type r; put $ t_t2frmt r; return ()
recSizeOf r = sum [ sizeOf $ t_t2frmt_Type r, sizeOf $ t_t2frmt r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_t2frmt_Type r), viewField "" (viewNStr $ t_t2frmt r) ]
recType = fromEnum . t_t2frmt_Type
instance Rec T_TO where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_TO a01 a02
- recPut bh r = do put bh $ t_to_Type r; put bh $ t_to r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_TO a01 a02
+ recPut r = do put $ t_to_Type r; put $ t_to r; return ()
recSizeOf r = sum [ sizeOf $ t_to_Type r, sizeOf $ t_to r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_to_Type r), viewField "" (viewNStr $ t_to r) ]
recType = fromEnum . t_to_Type
instance Rec T_TS where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_TS a01 a02
- recPut bh r = do put bh $ t_ts_Type r; put bh $ t_ts r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_TS a01 a02
+ recPut r = do put $ t_ts_Type r; put $ t_ts r; return ()
recSizeOf r = sum [ sizeOf $ t_ts_Type r, sizeOf $ t_ts r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_ts_Type r), viewField "" (viewNStr $ t_ts r) ]
recType = fromEnum . t_ts_Type
instance Rec T_UDTS where
- recGet bh = do a01 <- get bh; a02 <- get bh; return $ T_UDTS a01 a02
- recPut bh r = do put bh $ t_udts_Type r; put bh $ t_udts r; return ()
+ recGet = do a01 <- get; a02 <- get; return $ T_UDTS a01 a02
+ recPut r = do put $ t_udts_Type r; put $ t_udts r; return ()
recSizeOf r = sum [ sizeOf $ t_udts_Type r, sizeOf $ t_udts r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ t_udts_Type r), viewField "" (viewNStr $ t_udts r) ]
recType = fromEnum . t_udts_Type
-instance ChunkBuf T_ N1 Buffer1 where
- chunkCon = T_
- chunkDecon (T_ x) = x
+instance Chunk T_ where
+ type N T_ = N1
+ type BufOf T_ = Buffer1
+ mkChunk = T_
+ chunkDecon (T_ x y) = (x, y)
chunkTypeLookup = lookupT
chunkApply = applyT
-applyT :: forall m x. (MonadIO m)
- => N1 -> T_ -> (forall a. (Rec a) => (a -> m x)) -> m x
+applyT :: forall x. N1 -> T_ -> (forall a. (Rec a) => (a -> x)) -> x
applyT x rec f = case x of
- 0x01 -> apply recOf rec (f :: T_CGCSGI -> m x)
- 0x02 -> apply recOf rec (f :: T_FQN -> m x)
- 0x04 -> apply recOf rec (f :: T_MO -> m x)
- 0x10 -> apply recOf rec (f :: T_OCL -> m x)
- 0x18 -> apply recOf rec (f :: T_MIS -> m x)
- 0x1D -> apply recOf rec (f :: T_TO -> m x)
- 0x1F -> apply recOf rec (f :: T_FDS -> m x)
- 0x20 -> apply recOf rec (f :: T_FCGCSGI -> m x)
- 0x21 -> apply recOf rec (f :: T_OFSS -> m x)
- 0x22 -> apply recOf rec (f :: T_ROT -> m x)
- 0x23 -> apply recOf rec (f :: T_ERLI -> m x)
- 0x24 -> apply recOf rec (f :: T_RLI -> m x)
- 0x25 -> apply recOf rec (f :: T_RSN -> m x)
- 0x26 -> apply recOf rec (f :: T_CR -> m x)
- 0x27 -> apply recOf rec (f :: T_LDOPM -> m x)
- 0x2D -> apply recOf rec (f :: T_OBO -> m x)
- 0x36 -> apply recOf rec (f :: T_AV -> m x)
- 0x43 -> apply recOf rec (f :: T_DP -> m x)
- 0x45 -> apply recOf rec (f :: T_MEC -> m x)
- 0x46 -> apply recOf rec (f :: T_POCP -> m x)
- 0x47 -> apply recOf rec (f :: T_RUA -> m x)
- 0x4B -> apply recOf rec (f :: T_OAMU -> m x)
- 0x4C -> apply recOf rec (f :: T_OAS -> m x)
- 0x4D -> apply recOf rec (f :: T_AD -> m x)
- 0x4E -> apply recOf rec (f :: T_CS -> m x)
- 0x50 -> apply recOf rec (f :: T_ESI -> m x)
- 0x56 -> apply recOf rec (f :: T_MMPN -> m x)
- 0x57 -> apply recOf rec (f :: T_OBE -> m x)
- 0x58 -> apply recOf rec (f :: T_OSFO -> m x)
- 0x59 -> apply recOf rec (f :: T_OSFE -> m x)
- 0x5A -> apply recOf rec (f :: T_OO -> m x)
- 0x5D -> apply recOf rec (f :: T_FHSF -> m x)
- 0x5E -> apply recOf rec (f :: T_OCO -> m x)
- 0x62 -> apply recOf rec (f :: T_LDTS -> m x)
- 0x63 -> apply recOf rec (f :: T_T2FRMT -> m x)
- 0x64 -> apply recOf rec (f :: T_OOI -> m x)
- 0x65 -> apply recOf rec (f :: T_C -> m x)
- 0x68 -> apply recOf rec (f :: T_MOR -> m x)
- 0x6C -> apply recOf rec (f :: T_ROI -> m x)
- 0x6D -> apply recOf rec (f :: T_EF -> m x)
- 0x70 -> apply recOf rec (f :: T_PSRM -> m x)
- 0x71 -> apply recOf rec (f :: T_PSMR -> m x)
- 0x72 -> apply recOf rec (f :: T_UDTS -> m x)
- 0x73 -> apply recOf rec (f :: T_II -> m x)
- 0x74 -> apply recOf rec (f :: T_TS -> m x)
- 0x75 -> apply recOf rec (f :: T_CF -> m x)
- 0x78 -> apply recOf rec (f :: T_FF -> m x)
- 0x79 -> apply recOf rec (f :: T_MA -> m x)
- 0x80 -> apply recOf rec (f :: T_AQ -> m x)
- 0x81 -> apply recOf rec (f :: T_PPI -> m x)
- 0x82 -> apply recOf rec (f :: T_PV -> m x)
- 0x83 -> apply recOf rec (f :: T_PC -> m x)
- 0x84 -> apply recOf rec (f :: T_FRMT -> m x)
- 0x85 -> apply recOf rec (f :: T_FO -> m x)
- 0x87 -> apply recOf rec (f :: T_MF -> m x)
- _ -> apply recOf rec (f :: Unknown -> m x)
+ 0x01 -> apply rec (f :: T_CGCSGI -> x)
+ 0x02 -> apply rec (f :: T_FQN -> x)
+ 0x04 -> apply rec (f :: T_MO -> x)
+ 0x10 -> apply rec (f :: T_OCL -> x)
+ 0x18 -> apply rec (f :: T_MIS -> x)
+ 0x1D -> apply rec (f :: T_TO -> x)
+ 0x1F -> apply rec (f :: T_FDS -> x)
+ 0x20 -> apply rec (f :: T_FCGCSGI -> x)
+ 0x21 -> apply rec (f :: T_OFSS -> x)
+ 0x22 -> apply rec (f :: T_ROT -> x)
+ 0x23 -> apply rec (f :: T_ERLI -> x)
+ 0x24 -> apply rec (f :: T_RLI -> x)
+ 0x25 -> apply rec (f :: T_RSN -> x)
+ 0x26 -> apply rec (f :: T_CR -> x)
+ 0x27 -> apply rec (f :: T_LDOPM -> x)
+ 0x2D -> apply rec (f :: T_OBO -> x)
+ 0x36 -> apply rec (f :: T_AV -> x)
+ 0x43 -> apply rec (f :: T_DP -> x)
+ 0x45 -> apply rec (f :: T_MEC -> x)
+ 0x46 -> apply rec (f :: T_POCP -> x)
+ 0x47 -> apply rec (f :: T_RUA -> x)
+ 0x4B -> apply rec (f :: T_OAMU -> x)
+ 0x4C -> apply rec (f :: T_OAS -> x)
+ 0x4D -> apply rec (f :: T_AD -> x)
+ 0x4E -> apply rec (f :: T_CS -> x)
+ 0x50 -> apply rec (f :: T_ESI -> x)
+ 0x56 -> apply rec (f :: T_MMPN -> x)
+ 0x57 -> apply rec (f :: T_OBE -> x)
+ 0x58 -> apply rec (f :: T_OSFO -> x)
+ 0x59 -> apply rec (f :: T_OSFE -> x)
+ 0x5A -> apply rec (f :: T_OO -> x)
+ 0x5D -> apply rec (f :: T_FHSF -> x)
+ 0x5E -> apply rec (f :: T_OCO -> x)
+ 0x62 -> apply rec (f :: T_LDTS -> x)
+ 0x63 -> apply rec (f :: T_T2FRMT -> x)
+ 0x64 -> apply rec (f :: T_OOI -> x)
+ 0x65 -> apply rec (f :: T_C -> x)
+ 0x68 -> apply rec (f :: T_MOR -> x)
+ 0x6C -> apply rec (f :: T_ROI -> x)
+ 0x6D -> apply rec (f :: T_EF -> x)
+ 0x70 -> apply rec (f :: T_PSRM -> x)
+ 0x71 -> apply rec (f :: T_PSMR -> x)
+ 0x72 -> apply rec (f :: T_UDTS -> x)
+ 0x73 -> apply rec (f :: T_II -> x)
+ 0x74 -> apply rec (f :: T_TS -> x)
+ 0x75 -> apply rec (f :: T_CF -> x)
+ 0x78 -> apply rec (f :: T_FF -> x)
+ 0x79 -> apply rec (f :: T_MA -> x)
+ 0x80 -> apply rec (f :: T_AQ -> x)
+ 0x81 -> apply rec (f :: T_PPI -> x)
+ 0x82 -> apply rec (f :: T_PV -> x)
+ 0x83 -> apply rec (f :: T_PC -> x)
+ 0x84 -> apply rec (f :: T_FRMT -> x)
+ 0x85 -> apply rec (f :: T_FO -> x)
+ 0x87 -> apply rec (f :: T_MF -> x)
+ _ -> apply rec (f :: Unknown -> x)
diff --git a/src/OpenAFP/Prelude/Instances.hs b/src/OpenAFP/Prelude/Instances.hs
--- a/src/OpenAFP/Prelude/Instances.hs
+++ b/src/OpenAFP/Prelude/Instances.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts #-}
module OpenAFP.Prelude.Instances where
import OpenAFP.Types
@@ -7,379 +6,384 @@
import OpenAFP.Prelude.InstanceT
import OpenAFP.Prelude.InstancePTX
import OpenAFP.Prelude.InstanceAFP
+import qualified Data.ByteString as S
instance Rec T_ where
- recSizeOf c = 1 + (snd $ chunkToPStrLen c)
+ recSizeOf c = 1 + (S.length $ packChunk c)
-instance ChunkBuf AFP_ N3 Buffer2 where
- chunkCon = AFP_
- chunkDecon (AFP_ x) = x
+instance Chunk AFP_ where
+ type N AFP_ = N3
+ type BufOf AFP_ = Buffer2
+ mkChunk = AFP_
+ chunkDecon (AFP_ x y) = (x, y)
chunkTypeLookup = lookupAFP
chunkApply = applyAFP
-recOf :: (ChunkBuf c n b, Binary (Record r)) => c -> IO r
-recOf c = return . fromRecord =<< chunkToRecord c
-
-apply :: (MonadIO m) => (t -> IO a) -> t -> (a -> m b) -> m b
-apply ctr c f = f =<< (liftIO $ ctr c)
+apply :: (Chunk c, Rec r) => c -> (r -> t) -> t
+apply c f = f (decodeChunk c)
-applyAFP :: forall m x. (MonadIO m)
- => N3 -> AFP_ -> (forall a. (Rec a) => (a -> m x)) -> m x
+applyAFP :: forall x. N3 -> AFP_ -> (forall a. (Rec a) => (a -> x)) -> x
applyAFP x rec f = case x of
- 0xD38C87 -> apply recOf rec (f :: CPI -> m x)
- 0xD38C89 -> apply recOf rec (f :: FNI -> m x)
- 0xD38C8A -> apply recOf rec (f :: CFI -> m x)
- 0xD3A088 -> apply recOf rec (f :: MFC -> m x)
- 0xD3A090 -> apply recOf rec (f :: TLE -> m x)
- 0xD3A288 -> apply recOf rec (f :: MCC -> m x)
- 0xD3A289 -> apply recOf rec (f :: FNM -> m x)
- 0xD3A66B -> apply recOf rec (f :: OBD -> m x)
- 0xD3A67B -> apply recOf rec (f :: IID -> m x)
- 0xD3A687 -> apply recOf rec (f :: CPD -> m x)
- 0xD3A688 -> apply recOf rec (f :: MDD -> m x)
- 0xD3A689 -> apply recOf rec (f :: FND -> m x)
- 0xD3A692 -> apply recOf rec (f :: CDD -> m x)
- 0xD3A69B -> apply recOf rec (f :: PTD1 -> m x)
- 0xD3A6AF -> apply recOf rec (f :: PGD -> m x)
- 0xD3A6BB -> apply recOf rec (f :: GDD -> m x)
- 0xD3A6C5 -> apply recOf rec (f :: FGD -> m x)
- 0xD3A6E3 -> apply recOf rec (f :: DXD -> m x)
- 0xD3A6E7 -> apply recOf rec (f :: LND -> m x)
- 0xD3A6EB -> apply recOf rec (f :: BDD -> m x)
- 0xD3A6FB -> apply recOf rec (f :: IDD -> m x)
- 0xD3A77B -> apply recOf rec (f :: IOC -> m x)
- 0xD3A787 -> apply recOf rec (f :: CPC -> m x)
- 0xD3A788 -> apply recOf rec (f :: MMC -> m x)
- 0xD3A789 -> apply recOf rec (f :: FNC -> m x)
- 0xD3A78A -> apply recOf rec (f :: CFC -> m x)
- 0xD3A79B -> apply recOf rec (f :: CTC -> m x)
- 0xD3A7AF -> apply recOf rec (f :: PMC -> m x)
- 0xD3A85F -> apply recOf rec (f :: BPS -> m x)
- 0xD3A877 -> apply recOf rec (f :: BCA -> m x)
- 0xD3A87B -> apply recOf rec (f :: BII -> m x)
- 0xD3A887 -> apply recOf rec (f :: BCP -> m x)
- 0xD3A889 -> apply recOf rec (f :: BFN -> m x)
- 0xD3A88A -> apply recOf rec (f :: BCF -> m x)
- 0xD3A892 -> apply recOf rec (f :: BOC -> m x)
- 0xD3A89B -> apply recOf rec (f :: BPT -> m x)
- 0xD3A8A7 -> apply recOf rec (f :: BDI -> m x)
- 0xD3A8A8 -> apply recOf rec (f :: BDT -> m x)
- 0xD3A8AD -> apply recOf rec (f :: BNG -> m x)
- 0xD3A8AF -> apply recOf rec (f :: BPG -> m x)
- 0xD3A8BB -> apply recOf rec (f :: BGR -> m x)
- 0xD3A8C4 -> apply recOf rec (f :: BDG -> m x)
- 0xD3A8C5 -> apply recOf rec (f :: BFG -> m x)
- 0xD3A8C6 -> apply recOf rec (f :: BRG -> m x)
- 0xD3A8C7 -> apply recOf rec (f :: BOG -> m x)
- 0xD3A8C9 -> apply recOf rec (f :: BAG -> m x)
- 0xD3A8CA -> apply recOf rec (f :: BDM -> m x)
- 0xD3A8CB -> apply recOf rec (f :: BPM -> m x)
- 0xD3A8CC -> apply recOf rec (f :: BMM -> m x)
- 0xD3A8CD -> apply recOf rec (f :: BFM -> m x)
- 0xD3A8CE -> apply recOf rec (f :: BR -> m x)
- 0xD3A8D9 -> apply recOf rec (f :: BSG -> m x)
- 0xD3A8DF -> apply recOf rec (f :: BMO -> m x)
- 0xD3A8E3 -> apply recOf rec (f :: BDX -> m x)
- 0xD3A8EB -> apply recOf rec (f :: BBC -> m x)
- 0xD3A8FB -> apply recOf rec (f :: BIM -> m x)
- 0xD3A95F -> apply recOf rec (f :: EPS -> m x)
- 0xD3A977 -> apply recOf rec (f :: ECA -> m x)
- 0xD3A97B -> apply recOf rec (f :: EII -> m x)
- 0xD3A987 -> apply recOf rec (f :: ECP -> m x)
- 0xD3A989 -> apply recOf rec (f :: EFN -> m x)
- 0xD3A98A -> apply recOf rec (f :: ECF -> m x)
- 0xD3A992 -> apply recOf rec (f :: EOC -> m x)
- 0xD3A99B -> apply recOf rec (f :: EPT -> m x)
- 0xD3A9A7 -> apply recOf rec (f :: EDI -> m x)
- 0xD3A9A8 -> apply recOf rec (f :: EDT -> m x)
- 0xD3A9AD -> apply recOf rec (f :: ENG -> m x)
- 0xD3A9AF -> apply recOf rec (f :: EPG -> m x)
- 0xD3A9BB -> apply recOf rec (f :: EGR -> m x)
- 0xD3A9C4 -> apply recOf rec (f :: EDG -> m x)
- 0xD3A9C5 -> apply recOf rec (f :: EFG -> m x)
- 0xD3A9C6 -> apply recOf rec (f :: ERG -> m x)
- 0xD3A9C7 -> apply recOf rec (f :: EOG -> m x)
- 0xD3A9C9 -> apply recOf rec (f :: EAG -> m x)
- 0xD3A9CA -> apply recOf rec (f :: EDM -> m x)
- 0xD3A9CB -> apply recOf rec (f :: EPM -> m x)
- 0xD3A9CC -> apply recOf rec (f :: EMM -> m x)
- 0xD3A9CD -> apply recOf rec (f :: EFM -> m x)
- 0xD3A9CE -> apply recOf rec (f :: ER -> m x)
- 0xD3A9D9 -> apply recOf rec (f :: ESG -> m x)
- 0xD3A9DF -> apply recOf rec (f :: EMO -> m x)
- 0xD3A9E3 -> apply recOf rec (f :: EDX -> m x)
- 0xD3A9EB -> apply recOf rec (f :: EBC -> m x)
- 0xD3A9FB -> apply recOf rec (f :: EIM -> m x)
- 0xD3AAE7 -> apply recOf rec (f :: LNC -> m x)
- 0xD3AB77 -> apply recOf rec (f :: MCA -> m x)
- 0xD3AB88 -> apply recOf rec (f :: MMT -> m x)
- 0xD3AB89 -> apply recOf rec (f :: FNN -> m x)
- 0xD3AB8A -> apply recOf rec (f :: MCF -> m x)
- 0xD3AB92 -> apply recOf rec (f :: MCD -> m x)
- 0xD3ABAF -> apply recOf rec (f :: MPG -> m x)
- 0xD3ABBB -> apply recOf rec (f :: MGO -> m x)
- 0xD3ABC3 -> apply recOf rec (f :: MDR -> m x)
- 0xD3ABCC -> apply recOf rec (f :: IMM -> m x)
- 0xD3ABD8 -> apply recOf rec (f :: MPO -> m x)
- 0xD3ABEA -> apply recOf rec (f :: MSU -> m x)
- 0xD3ABEB -> apply recOf rec (f :: MBC -> m x)
- 0xD3ABFB -> apply recOf rec (f :: MIO -> m x)
- 0xD3AC6B -> apply recOf rec (f :: OBP -> m x)
- 0xD3AC7B -> apply recOf rec (f :: ICP -> m x)
- 0xD3AC89 -> apply recOf rec (f :: FNP -> m x)
- 0xD3ACAF -> apply recOf rec (f :: PGP1 -> m x)
- 0xD3AE89 -> apply recOf rec (f :: FNO -> m x)
- 0xD3AF5F -> apply recOf rec (f :: IPS -> m x)
- 0xD3AFAF -> apply recOf rec (f :: IPG -> m x)
- 0xD3AFC3 -> apply recOf rec (f :: IOB -> m x)
- 0xD3AFD8 -> apply recOf rec (f :: IPO -> m x)
- 0xD3B077 -> apply recOf rec (f :: CAT -> m x)
- 0xD3B15F -> apply recOf rec (f :: MPS -> m x)
- 0xD3B18A -> apply recOf rec (f :: MCF1 -> m x)
- 0xD3B19B -> apply recOf rec (f :: PTD -> m x)
- 0xD3B1AF -> apply recOf rec (f :: PGP -> m x)
- 0xD3B1DF -> apply recOf rec (f :: MMO -> m x)
- 0xD3B288 -> apply recOf rec (f :: PFC -> m x)
- 0xD3B2A7 -> apply recOf rec (f :: IEL -> m x)
- 0xD3B490 -> apply recOf rec (f :: LLE -> m x)
- 0xD3EE7B -> apply recOf rec (f :: IRD -> m x)
- 0xD3EE89 -> apply recOf rec (f :: FNG -> m x)
- 0xD3EE92 -> apply recOf rec (f :: OCD -> m x)
- 0xD3EE9B -> apply recOf rec (f :: PTX -> m x)
- 0xD3EEBB -> apply recOf rec (f :: GAD -> m x)
- 0xD3EEEB -> apply recOf rec (f :: BDA -> m x)
- 0xD3EEEE -> apply recOf rec (f :: NOP -> m x)
- 0xD3EEFB -> apply recOf rec (f :: IPD -> m x)
- _ -> apply recOf rec (f :: Unknown -> m x)
+ 0xD38C87 -> apply rec (f :: CPI -> x)
+ 0xD38C89 -> apply rec (f :: FNI -> x)
+ 0xD38C8A -> apply rec (f :: CFI -> x)
+ 0xD3A088 -> apply rec (f :: MFC -> x)
+ 0xD3A090 -> apply rec (f :: TLE -> x)
+ 0xD3A288 -> apply rec (f :: MCC -> x)
+ 0xD3A289 -> apply rec (f :: FNM -> x)
+ 0xD3A66B -> apply rec (f :: OBD -> x)
+ 0xD3A67B -> apply rec (f :: IID -> x)
+ 0xD3A687 -> apply rec (f :: CPD -> x)
+ 0xD3A688 -> apply rec (f :: MDD -> x)
+ 0xD3A689 -> apply rec (f :: FND -> x)
+ 0xD3A692 -> apply rec (f :: CDD -> x)
+ 0xD3A69B -> apply rec (f :: PTD1 -> x)
+ 0xD3A6AF -> apply rec (f :: PGD -> x)
+ 0xD3A6BB -> apply rec (f :: GDD -> x)
+ 0xD3A6C5 -> apply rec (f :: FGD -> x)
+ 0xD3A6E3 -> apply rec (f :: DXD -> x)
+ 0xD3A6E7 -> apply rec (f :: LND -> x)
+ 0xD3A6EB -> apply rec (f :: BDD -> x)
+ 0xD3A6FB -> apply rec (f :: IDD -> x)
+ 0xD3A77B -> apply rec (f :: IOC -> x)
+ 0xD3A787 -> apply rec (f :: CPC -> x)
+ 0xD3A788 -> apply rec (f :: MMC -> x)
+ 0xD3A789 -> apply rec (f :: FNC -> x)
+ 0xD3A78A -> apply rec (f :: CFC -> x)
+ 0xD3A79B -> apply rec (f :: CTC -> x)
+ 0xD3A7AF -> apply rec (f :: PMC -> x)
+ 0xD3A85F -> apply rec (f :: BPS -> x)
+ 0xD3A877 -> apply rec (f :: BCA -> x)
+ 0xD3A87B -> apply rec (f :: BII -> x)
+ 0xD3A887 -> apply rec (f :: BCP -> x)
+ 0xD3A889 -> apply rec (f :: BFN -> x)
+ 0xD3A88A -> apply rec (f :: BCF -> x)
+ 0xD3A892 -> apply rec (f :: BOC -> x)
+ 0xD3A89B -> apply rec (f :: BPT -> x)
+ 0xD3A8A7 -> apply rec (f :: BDI -> x)
+ 0xD3A8A8 -> apply rec (f :: BDT -> x)
+ 0xD3A8AD -> apply rec (f :: BNG -> x)
+ 0xD3A8AF -> apply rec (f :: BPG -> x)
+ 0xD3A8BB -> apply rec (f :: BGR -> x)
+ 0xD3A8C4 -> apply rec (f :: BDG -> x)
+ 0xD3A8C5 -> apply rec (f :: BFG -> x)
+ 0xD3A8C6 -> apply rec (f :: BRG -> x)
+ 0xD3A8C7 -> apply rec (f :: BOG -> x)
+ 0xD3A8C9 -> apply rec (f :: BAG -> x)
+ 0xD3A8CA -> apply rec (f :: BDM -> x)
+ 0xD3A8CB -> apply rec (f :: BPM -> x)
+ 0xD3A8CC -> apply rec (f :: BMM -> x)
+ 0xD3A8CD -> apply rec (f :: BFM -> x)
+ 0xD3A8CE -> apply rec (f :: BR -> x)
+ 0xD3A8D9 -> apply rec (f :: BSG -> x)
+ 0xD3A8DF -> apply rec (f :: BMO -> x)
+ 0xD3A8E3 -> apply rec (f :: BDX -> x)
+ 0xD3A8EB -> apply rec (f :: BBC -> x)
+ 0xD3A8FB -> apply rec (f :: BIM -> x)
+ 0xD3A95F -> apply rec (f :: EPS -> x)
+ 0xD3A977 -> apply rec (f :: ECA -> x)
+ 0xD3A97B -> apply rec (f :: EII -> x)
+ 0xD3A987 -> apply rec (f :: ECP -> x)
+ 0xD3A989 -> apply rec (f :: EFN -> x)
+ 0xD3A98A -> apply rec (f :: ECF -> x)
+ 0xD3A992 -> apply rec (f :: EOC -> x)
+ 0xD3A99B -> apply rec (f :: EPT -> x)
+ 0xD3A9A7 -> apply rec (f :: EDI -> x)
+ 0xD3A9A8 -> apply rec (f :: EDT -> x)
+ 0xD3A9AD -> apply rec (f :: ENG -> x)
+ 0xD3A9AF -> apply rec (f :: EPG -> x)
+ 0xD3A9BB -> apply rec (f :: EGR -> x)
+ 0xD3A9C4 -> apply rec (f :: EDG -> x)
+ 0xD3A9C5 -> apply rec (f :: EFG -> x)
+ 0xD3A9C6 -> apply rec (f :: ERG -> x)
+ 0xD3A9C7 -> apply rec (f :: EOG -> x)
+ 0xD3A9C9 -> apply rec (f :: EAG -> x)
+ 0xD3A9CA -> apply rec (f :: EDM -> x)
+ 0xD3A9CB -> apply rec (f :: EPM -> x)
+ 0xD3A9CC -> apply rec (f :: EMM -> x)
+ 0xD3A9CD -> apply rec (f :: EFM -> x)
+ 0xD3A9CE -> apply rec (f :: ER -> x)
+ 0xD3A9D9 -> apply rec (f :: ESG -> x)
+ 0xD3A9DF -> apply rec (f :: EMO -> x)
+ 0xD3A9E3 -> apply rec (f :: EDX -> x)
+ 0xD3A9EB -> apply rec (f :: EBC -> x)
+ 0xD3A9FB -> apply rec (f :: EIM -> x)
+ 0xD3AAE7 -> apply rec (f :: LNC -> x)
+ 0xD3AB77 -> apply rec (f :: MCA -> x)
+ 0xD3AB88 -> apply rec (f :: MMT -> x)
+ 0xD3AB89 -> apply rec (f :: FNN -> x)
+ 0xD3AB8A -> apply rec (f :: MCF -> x)
+ 0xD3AB92 -> apply rec (f :: MCD -> x)
+ 0xD3ABAF -> apply rec (f :: MPG -> x)
+ 0xD3ABBB -> apply rec (f :: MGO -> x)
+ 0xD3ABC3 -> apply rec (f :: MDR -> x)
+ 0xD3ABCC -> apply rec (f :: IMM -> x)
+ 0xD3ABD8 -> apply rec (f :: MPO -> x)
+ 0xD3ABEA -> apply rec (f :: MSU -> x)
+ 0xD3ABEB -> apply rec (f :: MBC -> x)
+ 0xD3ABFB -> apply rec (f :: MIO -> x)
+ 0xD3AC6B -> apply rec (f :: OBP -> x)
+ 0xD3AC7B -> apply rec (f :: ICP -> x)
+ 0xD3AC89 -> apply rec (f :: FNP -> x)
+ 0xD3ACAF -> apply rec (f :: PGP1 -> x)
+ 0xD3AE89 -> apply rec (f :: FNO -> x)
+ 0xD3AF5F -> apply rec (f :: IPS -> x)
+ 0xD3AFAF -> apply rec (f :: IPG -> x)
+ 0xD3AFC3 -> apply rec (f :: IOB -> x)
+ 0xD3AFD8 -> apply rec (f :: IPO -> x)
+ 0xD3B077 -> apply rec (f :: CAT -> x)
+ 0xD3B15F -> apply rec (f :: MPS -> x)
+ 0xD3B18A -> apply rec (f :: MCF1 -> x)
+ 0xD3B19B -> apply rec (f :: PTD -> x)
+ 0xD3B1AF -> apply rec (f :: PGP -> x)
+ 0xD3B1DF -> apply rec (f :: MMO -> x)
+ 0xD3B288 -> apply rec (f :: PFC -> x)
+ 0xD3B2A7 -> apply rec (f :: IEL -> x)
+ 0xD3B490 -> apply rec (f :: LLE -> x)
+ 0xD3EE7B -> apply rec (f :: IRD -> x)
+ 0xD3EE89 -> apply rec (f :: FNG -> x)
+ 0xD3EE92 -> apply rec (f :: OCD -> x)
+ 0xD3EE9B -> apply rec (f :: PTX -> x)
+ 0xD3EEBB -> apply rec (f :: GAD -> x)
+ 0xD3EEEB -> apply rec (f :: BDA -> x)
+ 0xD3EEEE -> apply rec (f :: NOP -> x)
+ 0xD3EEFB -> apply rec (f :: IPD -> x)
+ _ -> apply rec (f :: Unknown -> x)
-instance ChunkBuf MCF_ N0 Buffer2 where
- chunkCon = MCF_
- chunkDecon (MCF_ x) = x
+instance Chunk MCF_ where
+ type N MCF_ = N0
+ type BufOf MCF_ = Buffer2
+ mkChunk = MCF_
+ chunkDecon (MCF_ x y) = (x, y)
chunkTypeLookup = lookupMCF
chunkApply = applyMCF
-applyMCF :: forall m x. (MonadIO m)
- => N0 -> MCF_ -> (forall a. (Rec a) => (a -> m x)) -> m x
+applyMCF :: forall x. N0 -> MCF_ -> (forall a. (Rec a) => (a -> x)) -> x
applyMCF x rec f = case x of
- _ -> apply recOf rec (f :: MCF_T -> m x)
+ _ -> apply rec (f :: MCF_T -> x)
-instance RecChunk MCF MCF_ N0 Buffer2 where
+instance RecChunk MCF where
+ type ChunkOf MCF = MCF_
readChunks r = mcf_Chunks r
writeChunks r io = do
cs <- io
return $ r { mcf_Chunks = cs }
instance Rec MCF_ where
- recSizeOf c = 2 + (snd $ chunkToPStrLen c)
+ recSizeOf c = 2 + (S.length $ packChunk c)
instance Rec MCF where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MCF a01 a02 a03
- recPut bh r = do put bh $ mcf_Type r; put bh $ mcf_ r; put bh $ mcf_Chunks r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- getList; return $ MCF a01 a02 a03
+ recPut r = do put $ mcf_Type r; put $ mcf_ r; putList $ mcf_Chunks r; return ()
recSizeOf r = sum [ sizeOf $ mcf_Type r, sizeOf $ mcf_ r, sizeOf $ mcf_Chunks r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mcf_Type r), viewField "_" (viewNumber $ mcf_ r), viewField "Chunks" (viewChunks $ mcf_Chunks r) ]
recType = fromEnum . mcf_Type
instance Rec MCF1_Data where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; a05 <- get bh; a06 <- get bh; a07 <- get bh; a08 <- get bh; return $ MCF1_Data a01 a02 a03 a04 a05 a06 a07 a08
- recPut bh r = do put bh $ mcf1_CodedFontLocalId r; put bh $ mcf1_Reserved1 r; put bh $ mcf1_CodedFontResourceSectionId r; put bh $ mcf1_Reserved2 r; put bh $ mcf1_CodedFontName r; put bh $ mcf1_CodePageName r; put bh $ mcf1_FontCharacterSetName r; put bh $ mcf1_CharacterRotation r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; a05 <- get; a06 <- get; a07 <- get; a08 <- get; return $ MCF1_Data a01 a02 a03 a04 a05 a06 a07 a08
+ recPut r = do put $ mcf1_CodedFontLocalId r; put $ mcf1_Reserved1 r; put $ mcf1_CodedFontResourceSectionId r; put $ mcf1_Reserved2 r; put $ mcf1_CodedFontName r; put $ mcf1_CodePageName r; put $ mcf1_FontCharacterSetName r; put $ mcf1_CharacterRotation r; return ()
recSizeOf r = sum [ sizeOf $ mcf1_CodedFontLocalId r, sizeOf $ mcf1_Reserved1 r, sizeOf $ mcf1_CodedFontResourceSectionId r, sizeOf $ mcf1_Reserved2 r, sizeOf $ mcf1_CodedFontName r, sizeOf $ mcf1_CodePageName r, sizeOf $ mcf1_FontCharacterSetName r, sizeOf $ mcf1_CharacterRotation r ]
recView r = viewRecord (typeOf r) [ viewField "CodedFontLocalId" (viewNumber $ mcf1_CodedFontLocalId r), viewField "Reserved1" (viewString $ mcf1_Reserved1 r), viewField "CodedFontResourceSectionId" (viewNumber $ mcf1_CodedFontResourceSectionId r), viewField "Reserved2" (viewString $ mcf1_Reserved2 r), viewField "CodedFontName" (viewString $ mcf1_CodedFontName r), viewField "CodePageName" (viewString $ mcf1_CodePageName r), viewField "FontCharacterSetName" (viewString $ mcf1_FontCharacterSetName r), viewField "CharacterRotation" (viewNumber $ mcf1_CharacterRotation r) ]
recType r = 0
instance RecData MCF1 MCF1_Data where
+ type RecOf MCF1_Data = MCF1
+ type DataOf MCF1 = MCF1_Data
readData r = mcf1_Data r
writeData r cs = r { mcf1_Data = cs }
instance Rec MCF1 where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; a05 <- get bh; return $ MCF1 a01 a02 a03 a04 a05
- recPut bh r = do put bh $ mcf1_Type r; put bh $ mcf1_ r; put bh $ mcf1_RepeatingGroupLength r; put bh $ mcf1__ r; put bh $ mcf1_Data r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; a05 <- getList; return $ MCF1 a01 a02 a03 a04 a05
+ recPut r = do put $ mcf1_Type r; put $ mcf1_ r; put $ mcf1_RepeatingGroupLength r; put $ mcf1__ r; putList $ mcf1_Data r; return ()
recSizeOf r = sum [ sizeOf $ mcf1_Type r, sizeOf $ mcf1_ r, sizeOf $ mcf1_RepeatingGroupLength r, sizeOf $ mcf1__ r, sizeOf $ mcf1_Data r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mcf1_Type r), viewField "_" (viewNumber $ mcf1_ r), viewField "RepeatingGroupLength" (viewNumber $ mcf1_RepeatingGroupLength r), viewField "__" (viewString $ mcf1__ r), viewField "Data" (viewData $ mcf1_Data r) ]
recType = fromEnum . mcf1_Type
instance Rec MDD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MDD a01 a02 a03
- recPut bh r = do put bh $ mdd_Type r; put bh $ mdd_ r; put bh $ mdd r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MDD a01 a02 a03
+ recPut r = do put $ mdd_Type r; put $ mdd_ r; put $ mdd r; return ()
recSizeOf r = sum [ sizeOf $ mdd_Type r, sizeOf $ mdd_ r, sizeOf $ mdd r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mdd_Type r), viewField "_" (viewNumber $ mdd_ r), viewField "" (viewNStr $ mdd r) ]
recType = fromEnum . mdd_Type
instance Rec MDR where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MDR a01 a02 a03
- recPut bh r = do put bh $ mdr_Type r; put bh $ mdr_ r; put bh $ mdr r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MDR a01 a02 a03
+ recPut r = do put $ mdr_Type r; put $ mdr_ r; put $ mdr r; return ()
recSizeOf r = sum [ sizeOf $ mdr_Type r, sizeOf $ mdr_ r, sizeOf $ mdr r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mdr_Type r), viewField "_" (viewNumber $ mdr_ r), viewField "" (viewNStr $ mdr r) ]
recType = fromEnum . mdr_Type
instance Rec MFC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MFC a01 a02 a03
- recPut bh r = do put bh $ mfc_Type r; put bh $ mfc_ r; put bh $ mfc r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MFC a01 a02 a03
+ recPut r = do put $ mfc_Type r; put $ mfc_ r; put $ mfc r; return ()
recSizeOf r = sum [ sizeOf $ mfc_Type r, sizeOf $ mfc_ r, sizeOf $ mfc r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mfc_Type r), viewField "_" (viewNumber $ mfc_ r), viewField "" (viewNStr $ mfc r) ]
recType = fromEnum . mfc_Type
instance Rec MGO where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MGO a01 a02 a03
- recPut bh r = do put bh $ mgo_Type r; put bh $ mgo_ r; put bh $ mgo r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MGO a01 a02 a03
+ recPut r = do put $ mgo_Type r; put $ mgo_ r; put $ mgo r; return ()
recSizeOf r = sum [ sizeOf $ mgo_Type r, sizeOf $ mgo_ r, sizeOf $ mgo r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mgo_Type r), viewField "_" (viewNumber $ mgo_ r), viewField "" (viewNStr $ mgo r) ]
recType = fromEnum . mgo_Type
instance Rec MIO where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MIO a01 a02 a03
- recPut bh r = do put bh $ mio_Type r; put bh $ mio_ r; put bh $ mio r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MIO a01 a02 a03
+ recPut r = do put $ mio_Type r; put $ mio_ r; put $ mio r; return ()
recSizeOf r = sum [ sizeOf $ mio_Type r, sizeOf $ mio_ r, sizeOf $ mio r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mio_Type r), viewField "_" (viewNumber $ mio_ r), viewField "" (viewNStr $ mio r) ]
recType = fromEnum . mio_Type
instance Rec MMC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MMC a01 a02 a03
- recPut bh r = do put bh $ mmc_Type r; put bh $ mmc_ r; put bh $ mmc r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MMC a01 a02 a03
+ recPut r = do put $ mmc_Type r; put $ mmc_ r; put $ mmc r; return ()
recSizeOf r = sum [ sizeOf $ mmc_Type r, sizeOf $ mmc_ r, sizeOf $ mmc r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mmc_Type r), viewField "_" (viewNumber $ mmc_ r), viewField "" (viewNStr $ mmc r) ]
recType = fromEnum . mmc_Type
instance Rec MMO where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MMO a01 a02 a03
- recPut bh r = do put bh $ mmo_Type r; put bh $ mmo_ r; put bh $ mmo r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MMO a01 a02 a03
+ recPut r = do put $ mmo_Type r; put $ mmo_ r; put $ mmo r; return ()
recSizeOf r = sum [ sizeOf $ mmo_Type r, sizeOf $ mmo_ r, sizeOf $ mmo r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mmo_Type r), viewField "_" (viewNumber $ mmo_ r), viewField "" (viewNStr $ mmo r) ]
recType = fromEnum . mmo_Type
instance Rec MMT where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MMT a01 a02 a03
- recPut bh r = do put bh $ mmt_Type r; put bh $ mmt_ r; put bh $ mmt r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MMT a01 a02 a03
+ recPut r = do put $ mmt_Type r; put $ mmt_ r; put $ mmt r; return ()
recSizeOf r = sum [ sizeOf $ mmt_Type r, sizeOf $ mmt_ r, sizeOf $ mmt r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mmt_Type r), viewField "_" (viewNumber $ mmt_ r), viewField "" (viewNStr $ mmt r) ]
recType = fromEnum . mmt_Type
instance Rec MPG where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MPG a01 a02 a03
- recPut bh r = do put bh $ mpg_Type r; put bh $ mpg_ r; put bh $ mpg r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MPG a01 a02 a03
+ recPut r = do put $ mpg_Type r; put $ mpg_ r; put $ mpg r; return ()
recSizeOf r = sum [ sizeOf $ mpg_Type r, sizeOf $ mpg_ r, sizeOf $ mpg r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mpg_Type r), viewField "_" (viewNumber $ mpg_ r), viewField "" (viewNStr $ mpg r) ]
recType = fromEnum . mpg_Type
instance Rec MPO where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MPO a01 a02 a03
- recPut bh r = do put bh $ mpo_Type r; put bh $ mpo_ r; put bh $ mpo r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MPO a01 a02 a03
+ recPut r = do put $ mpo_Type r; put $ mpo_ r; put $ mpo r; return ()
recSizeOf r = sum [ sizeOf $ mpo_Type r, sizeOf $ mpo_ r, sizeOf $ mpo r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mpo_Type r), viewField "_" (viewNumber $ mpo_ r), viewField "" (viewNStr $ mpo r) ]
recType = fromEnum . mpo_Type
instance Rec MPS where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MPS a01 a02 a03
- recPut bh r = do put bh $ mps_Type r; put bh $ mps_ r; put bh $ mps r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MPS a01 a02 a03
+ recPut r = do put $ mps_Type r; put $ mps_ r; put $ mps r; return ()
recSizeOf r = sum [ sizeOf $ mps_Type r, sizeOf $ mps_ r, sizeOf $ mps r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ mps_Type r), viewField "_" (viewNumber $ mps_ r), viewField "" (viewNStr $ mps r) ]
recType = fromEnum . mps_Type
instance Rec MSU where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ MSU a01 a02 a03
- recPut bh r = do put bh $ msu_Type r; put bh $ msu_ r; put bh $ msu r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ MSU a01 a02 a03
+ recPut r = do put $ msu_Type r; put $ msu_ r; put $ msu r; return ()
recSizeOf r = sum [ sizeOf $ msu_Type r, sizeOf $ msu_ r, sizeOf $ msu r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ msu_Type r), viewField "_" (viewNumber $ msu_ r), viewField "" (viewNStr $ msu r) ]
recType = fromEnum . msu_Type
instance Rec NOP where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ NOP a01 a02 a03
- recPut bh r = do put bh $ nop_Type r; put bh $ nop_ r; put bh $ nop r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ NOP a01 a02 a03
+ recPut r = do put $ nop_Type r; put $ nop_ r; put $ nop r; return ()
recSizeOf r = sum [ sizeOf $ nop_Type r, sizeOf $ nop_ r, sizeOf $ nop r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ nop_Type r), viewField "_" (viewNumber $ nop_ r), viewField "" (viewNStr $ nop r) ]
recType = fromEnum . nop_Type
instance Rec OBD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ OBD a01 a02 a03
- recPut bh r = do put bh $ obd_Type r; put bh $ obd_ r; put bh $ obd r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ OBD a01 a02 a03
+ recPut r = do put $ obd_Type r; put $ obd_ r; put $ obd r; return ()
recSizeOf r = sum [ sizeOf $ obd_Type r, sizeOf $ obd_ r, sizeOf $ obd r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ obd_Type r), viewField "_" (viewNumber $ obd_ r), viewField "" (viewNStr $ obd r) ]
recType = fromEnum . obd_Type
instance Rec OBP where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ OBP a01 a02 a03
- recPut bh r = do put bh $ obp_Type r; put bh $ obp_ r; put bh $ obp r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ OBP a01 a02 a03
+ recPut r = do put $ obp_Type r; put $ obp_ r; put $ obp r; return ()
recSizeOf r = sum [ sizeOf $ obp_Type r, sizeOf $ obp_ r, sizeOf $ obp r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ obp_Type r), viewField "_" (viewNumber $ obp_ r), viewField "" (viewNStr $ obp r) ]
recType = fromEnum . obp_Type
instance Rec OCD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ OCD a01 a02 a03
- recPut bh r = do put bh $ ocd_Type r; put bh $ ocd_ r; put bh $ ocd r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ OCD a01 a02 a03
+ recPut r = do put $ ocd_Type r; put $ ocd_ r; put $ ocd r; return ()
recSizeOf r = sum [ sizeOf $ ocd_Type r, sizeOf $ ocd_ r, sizeOf $ ocd r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ocd_Type r), viewField "_" (viewNumber $ ocd_ r), viewField "" (viewNStr $ ocd r) ]
recType = fromEnum . ocd_Type
instance Rec PFC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ PFC a01 a02 a03
- recPut bh r = do put bh $ pfc_Type r; put bh $ pfc_ r; put bh $ pfc r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ PFC a01 a02 a03
+ recPut r = do put $ pfc_Type r; put $ pfc_ r; put $ pfc r; return ()
recSizeOf r = sum [ sizeOf $ pfc_Type r, sizeOf $ pfc_ r, sizeOf $ pfc r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ pfc_Type r), viewField "_" (viewNumber $ pfc_ r), viewField "" (viewNStr $ pfc r) ]
recType = fromEnum . pfc_Type
instance Rec PGD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; a05 <- get bh; a06 <- get bh; a07 <- get bh; a08 <- get bh; a09 <- get bh; a10 <- get bh; a11 <- get bh; return $ PGD a01 a02 a03 a04 a05 a06 a07 a08 a09 a10 a11
- recPut bh r = do put bh $ pgd_Type r; put bh $ pgd_ r; put bh $ pgd_XUnitBase r; put bh $ pgd_YUnitBase r; put bh $ pgd_XLUnitsperUnitBase r; put bh $ pgd_YLUnitsperUnitBase r; put bh $ pgd_Reserved1 r; put bh $ pgd_XPageSize r; put bh $ pgd_Reserved2 r; put bh $ pgd_YPageSize r; put bh $ pgd__ r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; a04 <- get; a05 <- get; a06 <- get; a07 <- get; a08 <- get; a09 <- get; a10 <- get; a11 <- get; return $ PGD a01 a02 a03 a04 a05 a06 a07 a08 a09 a10 a11
+ recPut r = do put $ pgd_Type r; put $ pgd_ r; put $ pgd_XUnitBase r; put $ pgd_YUnitBase r; put $ pgd_XLUnitsperUnitBase r; put $ pgd_YLUnitsperUnitBase r; put $ pgd_Reserved1 r; put $ pgd_XPageSize r; put $ pgd_Reserved2 r; put $ pgd_YPageSize r; put $ pgd__ r; return ()
recSizeOf r = sum [ sizeOf $ pgd_Type r, sizeOf $ pgd_ r, sizeOf $ pgd_XUnitBase r, sizeOf $ pgd_YUnitBase r, sizeOf $ pgd_XLUnitsperUnitBase r, sizeOf $ pgd_YLUnitsperUnitBase r, sizeOf $ pgd_Reserved1 r, sizeOf $ pgd_XPageSize r, sizeOf $ pgd_Reserved2 r, sizeOf $ pgd_YPageSize r, sizeOf $ pgd__ r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ pgd_Type r), viewField "_" (viewNumber $ pgd_ r), viewField "XUnitBase" (viewNumber $ pgd_XUnitBase r), viewField "YUnitBase" (viewNumber $ pgd_YUnitBase r), viewField "XLUnitsperUnitBase" (viewNumber $ pgd_XLUnitsperUnitBase r), viewField "YLUnitsperUnitBase" (viewNumber $ pgd_YLUnitsperUnitBase r), viewField "Reserved1" (viewNumber $ pgd_Reserved1 r), viewField "XPageSize" (viewNumber $ pgd_XPageSize r), viewField "Reserved2" (viewNumber $ pgd_Reserved2 r), viewField "YPageSize" (viewNumber $ pgd_YPageSize r), viewField "__" (viewNStr $ pgd__ r) ]
recType = fromEnum . pgd_Type
instance Rec PGP where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ PGP a01 a02 a03
- recPut bh r = do put bh $ pgp_Type r; put bh $ pgp_ r; put bh $ pgp r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ PGP a01 a02 a03
+ recPut r = do put $ pgp_Type r; put $ pgp_ r; put $ pgp r; return ()
recSizeOf r = sum [ sizeOf $ pgp_Type r, sizeOf $ pgp_ r, sizeOf $ pgp r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ pgp_Type r), viewField "_" (viewNumber $ pgp_ r), viewField "" (viewNStr $ pgp r) ]
recType = fromEnum . pgp_Type
instance Rec PGP1 where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ PGP1 a01 a02 a03
- recPut bh r = do put bh $ pgp1_Type r; put bh $ pgp1_ r; put bh $ pgp1 r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ PGP1 a01 a02 a03
+ recPut r = do put $ pgp1_Type r; put $ pgp1_ r; put $ pgp1 r; return ()
recSizeOf r = sum [ sizeOf $ pgp1_Type r, sizeOf $ pgp1_ r, sizeOf $ pgp1 r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ pgp1_Type r), viewField "_" (viewNumber $ pgp1_ r), viewField "" (viewNStr $ pgp1 r) ]
recType = fromEnum . pgp1_Type
instance Rec PMC where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ PMC a01 a02 a03
- recPut bh r = do put bh $ pmc_Type r; put bh $ pmc_ r; put bh $ pmc r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ PMC a01 a02 a03
+ recPut r = do put $ pmc_Type r; put $ pmc_ r; put $ pmc r; return ()
recSizeOf r = sum [ sizeOf $ pmc_Type r, sizeOf $ pmc_ r, sizeOf $ pmc r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ pmc_Type r), viewField "_" (viewNumber $ pmc_ r), viewField "" (viewNStr $ pmc r) ]
recType = fromEnum . pmc_Type
instance Rec PTD where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ PTD a01 a02 a03
- recPut bh r = do put bh $ ptd_Type r; put bh $ ptd_ r; put bh $ ptd r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ PTD a01 a02 a03
+ recPut r = do put $ ptd_Type r; put $ ptd_ r; put $ ptd r; return ()
recSizeOf r = sum [ sizeOf $ ptd_Type r, sizeOf $ ptd_ r, sizeOf $ ptd r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptd_Type r), viewField "_" (viewNumber $ ptd_ r), viewField "" (viewNStr $ ptd r) ]
recType = fromEnum . ptd_Type
instance Rec PTD1 where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; return $ PTD1 a01 a02 a03
- recPut bh r = do put bh $ ptd1_Type r; put bh $ ptd1_ r; put bh $ ptd1 r; return ()
+ recGet = do a01 <- get; a02 <- get; a03 <- get; return $ PTD1 a01 a02 a03
+ recPut r = do put $ ptd1_Type r; put $ ptd1_ r; put $ ptd1 r; return ()
recSizeOf r = sum [ sizeOf $ ptd1_Type r, sizeOf $ ptd1_ r, sizeOf $ ptd1 r ]
recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ ptd1_Type r), viewField "_" (viewNumber $ ptd1_ r), viewField "" (viewNStr $ ptd1 r) ]
recType = fromEnum . ptd1_Type
-instance RecChunk TLE T_ N1 Buffer1 where
+instance RecChunk TLE where
+ type ChunkOf TLE = T_
readChunks r = tle_Chunks r
writeChunks r io = do
cs <- io
return $ r { tle_Chunks = cs }
instance Rec TLE where
- recGet bh = do a01 <- get bh; a02 <- get bh; a03 <- get bh; a04 <- get bh; a05 <- get bh; a06 <- get bh; a07 <- get bh; a08 <- get bh; a09 <- get bh; a10 <- get bh; return $ TLE a01 a02 a03 a04 a05 a06 a07 a08 a09 a10
- recPut bh r = do put bh $ tle_Type r; put bh $ tle_ r; put bh $ tle_Chunks r; put bh $ tle_XUnitBase r; put bh $ tle_YUnitBase r; put bh $ tle_XLUnitsperUnitBase r; put bh $ tle_YLUnitsperUnitBase r; put bh $ tle_XPageSize r; put bh $ tle_YPageSize r; put bh $ tle__ r; return ()
- recSizeOf r = sum [ sizeOf $ tle_Type r, sizeOf $ tle_ r, sizeOf $ tle_Chunks r, sizeOf $ tle_XUnitBase r, sizeOf $ tle_YUnitBase r, sizeOf $ tle_XLUnitsperUnitBase r, sizeOf $ tle_YLUnitsperUnitBase r, sizeOf $ tle_XPageSize r, sizeOf $ tle_YPageSize r, sizeOf $ tle__ r ]
- recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ tle_Type r), viewField "_" (viewNumber $ tle_ r), viewField "Chunks" (viewChunks $ tle_Chunks r), viewField "XUnitBase" (viewNumber $ tle_XUnitBase r), viewField "YUnitBase" (viewNumber $ tle_YUnitBase r), viewField "XLUnitsperUnitBase" (viewNumber $ tle_XLUnitsperUnitBase r), viewField "YLUnitsperUnitBase" (viewNumber $ tle_YLUnitsperUnitBase r), viewField "XPageSize" (viewNumber $ tle_XPageSize r), viewField "YPageSize" (viewNumber $ tle_YPageSize r), viewField "__" (viewNStr $ tle__ r) ]
+ recGet = do a01 <- get; a02 <- get; a03 <- getList; return $ TLE a01 a02 a03
+ recPut r = do put $ tle_Type r; put $ tle_ r; putList $ tle_Chunks r
+ recSizeOf r = sum [ sizeOf $ tle_Type r, sizeOf $ tle_ r, sizeOf $ tle_Chunks r ]
+ recView r = viewRecord (typeOf r) [ viewField "Type" (viewNumber $ tle_Type r), viewField "_" (viewNumber $ tle_ r), viewField "Chunks" (viewChunks $ tle_Chunks r) ]
recType = fromEnum . tle_Type
-instance RecChunk MCF_T T_ N1 Buffer1 where
+instance RecChunk MCF_T where
+ type ChunkOf MCF_T = T_
readChunks r = mcf_t_Chunks r
writeChunks r io = do
cs <- io
return $ r { mcf_t_Chunks = cs }
instance Rec MCF_T where
- recGet bh = do a01 <- get bh; return $ MCF_T a01
- recPut bh r = do put bh $ mcf_t_Chunks r; return ()
+ recGet = do a01 <- getList; return $ MCF_T a01
+ recPut r = do putList $ mcf_t_Chunks r; return ()
recSizeOf r = sum [ sizeOf $ mcf_t_Chunks r ]
recView r = viewRecord (typeOf r) [ viewField "Chunks" (viewChunks $ mcf_t_Chunks r) ]
recType r = 0
diff --git a/src/OpenAFP/Prelude/Lookups.hs b/src/OpenAFP/Prelude/Lookups.hs
--- a/src/OpenAFP/Prelude/Lookups.hs
+++ b/src/OpenAFP/Prelude/Lookups.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts #-}
module OpenAFP.Prelude.Lookups where
import OpenAFP.Types
diff --git a/src/OpenAFP/Prelude/Utils.hs b/src/OpenAFP/Prelude/Utils.hs
--- a/src/OpenAFP/Prelude/Utils.hs
+++ b/src/OpenAFP/Prelude/Utils.hs
@@ -1,5 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
-
-----------------------------------------------------------------------------
-- |
-- Module : OpenAFP.Prelude.Utils
@@ -18,7 +16,27 @@
import OpenAFP.Types
import OpenAFP.Records
import OpenAFP.Internals
+import qualified Data.ByteString as S
+import qualified Data.ByteString.Unsafe as S
+import qualified Data.ByteString.Internal as S
+import qualified Data.ByteString.Lazy as L
+import Data.Int
+import GHC.Base (build, unsafeChr)
+
+hashByteString (S.PS x s l) = inlinePerformIO $ withForeignPtr x $ \p ->
+ go (0 :: Int32) (p `plusPtr` s) l
+ where
+ go :: Int32 -> Ptr Word8 -> Int -> IO Int32
+ go a b c | a `seq` b `seq` c `seq` False = undefined
+ go h _ 0 = return h
+ go h p n = do w <- peek p
+ go (fromIntegral w + rotateL h 8) (p `plusPtr` 1) (n-1)
+
+{-# INLINE inlinePerformIO #-}
+inlinePerformIO :: IO a -> a
+inlinePerformIO = S.inlinePerformIO
+
infixl 5 $$
infixl 5 $=
infixl 5 +=
@@ -68,13 +86,13 @@
vars <- ask
liftIO $ mapM_ (\(k, v) -> writeIOArray (l vars) k v) kvList
-applyToChunk :: (Rec a, ChunkBuf c n b) => (a -> x) -> c -> IOm x
-applyToChunk f c = return . f . fromRecord =<< (liftIO . chunkToRecord) c
+applyToChunk :: (Monad m, Rec a, Chunk c) => (a -> x) -> c -> m x
+applyToChunk f = return . f . decodeChunk
-withChunk :: (ChunkBuf a n b, MonadIO m) => a -> (forall r. (Rec r) => r -> m x) -> m x
+withChunk :: (Chunk a) => a -> (forall r. (Rec r) => r -> x) -> x
withChunk c = chunkApply (fst . chunkDecon $ c) c
-splitRecords :: (ChunkBuf c n b, Typeable t) => t -> [c] -> [[c]]
+splitRecords :: (Chunk c, Typeable t) => t -> [c] -> [[c]]
splitRecords t = groupBy (const $ not . (~~ t))
findRecord :: (a -> Bool) -> [Record a] -> a
@@ -95,47 +113,24 @@
findRecordMaybe :: (a -> Bool) -> [Record a] -> Maybe a
findRecordMaybe f = maybe Nothing (Just . fromRecord) . find (f . fromRecord)
-fromA :: (Binary a, Storable a) => a -> IOm String
-fromA item = liftIO $ do
- bh <- newBinBuf (sizeOf item)
- put bh item
- seekBin bh 0
- return . trim =<< fromAStr =<< get bh
+fromA :: (Binary a, Storable a) => a -> String
+fromA = trim . fromAStr . mkBuf . S.concat . L.toChunks . encode
trim :: String -> String
trim = takeWhile $ not . isSpace
-catBuf :: (Buf a) => a -> a -> IOm a
-catBuf b1 b2 = liftIO $ do
- pstr <- mallocForeignPtrBytes len
- withForeignPtr pstr $ \cstr -> do
- when (l1 > 0) $
- withForeignPtr p1 $ \c1 -> copyBytes cstr c1 l1
- when (l2 > 0) $
- withForeignPtr p2 $ \c2 -> copyBytes (plusPtr cstr l1) c2 l2
- return $ bufFromPStrLen (pstr, len)
- where
- len = l1 + l2
- (p1, l1) = bufToPStrLen b1
- (p2, l2) = bufToPStrLen b2
+catBuf :: Buf a => a -> a -> a
+catBuf b1 b2 = mkBuf (packBuf b1 `S.append` packBuf b2)
-subBuf :: (Buf a, Integral b, Integral c) => a -> b -> c -> IOm a
-subBuf buf pos len = liftIO $ do
- withForeignPtr pstr $ \cstr -> do
- pstr' <- newForeignPtr_ (plusPtr cstr $ fromEnum pos)
- addFinalizer pstr' $ touchForeignPtr pstr -- ???
- return $ bufFromPStrLen (pstr', fromEnum len)
- where
- (pstr, _) = bufToPStrLen buf -- XXX - check size bounds?
+subBuf :: (Buf a, Integral b, Integral c) => a -> b -> c -> a
+subBuf buf pos len = mkBuf (S.take (fromIntegral len) (S.drop (fromIntegral pos) (packBuf buf)))
-subBufs :: (Buf a, Integral b, Integral c) => [a] -> b -> c -> IOm a
-subBufs (b:bs) pos len = do
- if (pos <= len') then
- subBuf b pos len
- else
- subBufs bs (pos - len') len
+subBufs :: (Buf a, Integral b, Integral c) => [a] -> b -> c -> a
+subBufs (b:bs) pos len
+ | pos <= len' = subBuf b pos len
+ | otherwise = subBufs bs (pos - len') len
where
- len' = toEnum $ snd $ bufToPStrLen b -- XXX - check size bounds?
+ len' = fromIntegral . S.length $ packBuf b
showBitmap :: (Integral i, Show a) => [a] -> i -> IOm ()
showBitmap [] _ = return ()
@@ -160,6 +155,26 @@
hex2bin 'E' = "@@@."
hex2bin 'F' = "@@@@"
+toA8 :: String -> A8
+toA8 s = sum
+ [ n1 `shiftL` 56, n2 `shiftL` 48, n3 `shiftL` 40, n4 `shiftL` 32
+ , n5 `shiftL` 24, n6 `shiftL` 16, n7 `shiftL` 8 , n8
+ ]
+ where
+ [n1, n2, n3, n4, n5, n6, n7, n8] = map (fromIntegral . (asc2ebc !) . ord) padded
+ padded = take 8 (s ++ repeat ' ')
+
+packA8 :: A8 -> S.ByteString
+packA8 w = S.unsafeCreate 8 $ \ptr -> do
+ pokeByteOff ptr 0 (ebc2ascW8 ! fromIntegral (w `shiftR` 56))
+ pokeByteOff ptr 1 (ebc2ascW8 ! fromIntegral ((w `shiftR` 48) .&. 0xff))
+ pokeByteOff ptr 2 (ebc2ascW8 ! fromIntegral ((w `shiftR` 40) .&. 0xff))
+ pokeByteOff ptr 3 (ebc2ascW8 ! fromIntegral ((w `shiftR` 32) .&. 0xff))
+ pokeByteOff ptr 4 (ebc2ascW8 ! fromIntegral ((w `shiftR` 24) .&. 0xff))
+ pokeByteOff ptr 5 (ebc2ascW8 ! fromIntegral ((w `shiftR` 16) .&. 0xff))
+ pokeByteOff ptr 6 (ebc2ascW8 ! fromIntegral ((w `shiftR` 8) .&. 0xff))
+ pokeByteOff ptr 7 (ebc2ascW8 ! fromIntegral (w .&. 0xff))
+
fromA8 :: A8 -> String
fromA8 w = [
(ebc2asc ! fromIntegral (w `shiftR` 56)),
@@ -199,3 +214,5 @@
requiredOpt usage r = unsafePerformIO $ do
usage $ "missing argument: --" ++ r
+io :: MonadIO m => IO a -> m a
+io = liftIO
diff --git a/src/OpenAFP/Records.hs b/src/OpenAFP/Records.hs
--- a/src/OpenAFP/Records.hs
+++ b/src/OpenAFP/Records.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
-----------------------------------------------------------------------------
-- |
@@ -33,33 +32,34 @@
import OpenAFP.Records.MCF
import OpenAFP.Records.T
+import Data.Binary.Get
+import qualified Data.ByteString as S
+import qualified Data.ByteString.Lazy as L
+
---[ Unknown ]--------------------------------------------------
newtype Unknown = Unknown NStr
deriving (Show, Typeable)
instance Rec Unknown where
- recGet bh = get bh >>= return . Unknown
- recPut bh (Unknown r) = put bh r
+ recGet = fmap Unknown get
+ recPut (Unknown r) = put r
recSizeOf (Unknown r) = sizeOf r
recView (Unknown r) = viewRecord (typeOf _Unknown) [ viewField "" (viewNStr r) ]
instance Binary Unknown where
- get bh = return $ Unknown $ bufFromPStrLen (bufOf bh)
- put bh (Unknown buf) = putBuf bh $ bufToPStrLen buf
+ get = fmap Unknown get
+ put (Unknown buf) = put buf
_Unknown = Unknown _NStr
---[ AFP ]-----------------------------------------------------
-newtype AFP_ = AFP_ (N3, Buffer2) deriving (Show, Typeable)
+data AFP_ = AFP_ !N3 !Buffer2 deriving (Show, Typeable)
instance Binary AFP_ where
- put bh (AFP_ (_, buf)) = do
- put bh ('\x5A', buf)
- get bh = do
- getByte bh
- get' AFP_ bh
+ put (AFP_ _ buf) = putWord8 0x5A >> put buf
+ get = skip 1 >> get' AFP_
lookupMCF :: MCF_ -> N0 -> ChunkType
lookupMCF _ _ = chunkTypeOf _MCF_T -- MCF Triplets
@@ -301,29 +301,23 @@
_ -> chunkTypeOf _Unknown
-- XXX -- refactor it back to class
-get' :: (Binary t, Buf b, Binary b) => ((t, b) -> c) -> BinHandle -> IO c
-get' constr bh = do
- buf <- get bh
- buftype <- getBufType buf
- let chunk = constr (buftype, buf)
- let (pstr, len) = bufToPStrLen buf
- addFinalizer chunk $ touchForeignPtr pstr
- return chunk
-
-getBufType buf = do
- bh <- openBinBuf $ bufToPStrLen buf
- get bh
+get' :: (Binary t, Buf b, Binary b) => (t -> b -> c) -> Get c
+get' constr = do
+ buf <- get
+ let ty = decode $ L.fromChunks [packBuf buf]
+ return $ constr ty buf
+ -- addFinalizer chunk $ touchForeignPtr pstr
instance Binary PTX_ where
- put bh (PTX_ (_, buf)) = put bh buf
+ put (PTX_ _ buf) = put buf
get = get' PTX_
instance Binary MCF_ where
- put bh (MCF_ (_, buf)) = put bh buf
- get bh = do
- buf <- get bh
- return $ MCF_ (N0 (), buf)
+ put (MCF_ _ buf) = put buf
+ get = do
+ buf <- get
+ return $ MCF_ N0 buf
instance Binary T_ where
- put bh (T_ (_, buf)) = put bh buf
+ put (T_ _ buf) = put buf
get = get' T_
diff --git a/src/OpenAFP/Records/AFP.hs b/src/OpenAFP/Records/AFP.hs
--- a/src/OpenAFP/Records/AFP.hs
+++ b/src/OpenAFP/Records/AFP.hs
@@ -288,7 +288,7 @@
_BGR :: BGR
_BGR = BGR 0xD3A8BB 0 _NStr
_BII :: BII
-_BII = BII 0xD3A87B 0 0
+_BII = BII 0xD3A87B 0 _NStr
_BIM :: BIM
_BIM = BIM 0xD3A8FB 0 _NStr
_BMM :: BMM
@@ -366,7 +366,7 @@
_EGR :: EGR
_EGR = EGR 0xD3A9BB 0 _NStr
_EII :: EII
-_EII = EII 0xD3A97B 0 0
+_EII = EII 0xD3A97B 0 _NStr
_EIM :: EIM
_EIM = EIM 0xD3A9FB 0 _NStr
_EMM :: EMM
@@ -512,5 +512,5 @@
_PTX :: PTX
_PTX = PTX 0xD3EE9B 0 0 []
_TLE :: TLE
-_TLE = TLE 0xD3A090 0 [] 0 0 0 0 0 0 _NStr
+_TLE = TLE 0xD3A090 0 []
diff --git a/src/OpenAFP/Records/AFP/BAG.hs b/src/OpenAFP/Records/AFP/BAG.hs
--- a/src/OpenAFP/Records/AFP/BAG.hs
+++ b/src/OpenAFP/Records/AFP/BAG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BAG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BBC.hs b/src/OpenAFP/Records/AFP/BBC.hs
--- a/src/OpenAFP/Records/AFP/BBC.hs
+++ b/src/OpenAFP/Records/AFP/BBC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BBC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BCA.hs b/src/OpenAFP/Records/AFP/BCA.hs
--- a/src/OpenAFP/Records/AFP/BCA.hs
+++ b/src/OpenAFP/Records/AFP/BCA.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BCA where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BCF.hs b/src/OpenAFP/Records/AFP/BCF.hs
--- a/src/OpenAFP/Records/AFP/BCF.hs
+++ b/src/OpenAFP/Records/AFP/BCF.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BCF where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BCP.hs b/src/OpenAFP/Records/AFP/BCP.hs
--- a/src/OpenAFP/Records/AFP/BCP.hs
+++ b/src/OpenAFP/Records/AFP/BCP.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BCP where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BDA.hs b/src/OpenAFP/Records/AFP/BDA.hs
--- a/src/OpenAFP/Records/AFP/BDA.hs
+++ b/src/OpenAFP/Records/AFP/BDA.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BDA where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BDD.hs b/src/OpenAFP/Records/AFP/BDD.hs
--- a/src/OpenAFP/Records/AFP/BDD.hs
+++ b/src/OpenAFP/Records/AFP/BDD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BDD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BDG.hs b/src/OpenAFP/Records/AFP/BDG.hs
--- a/src/OpenAFP/Records/AFP/BDG.hs
+++ b/src/OpenAFP/Records/AFP/BDG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BDG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BDI.hs b/src/OpenAFP/Records/AFP/BDI.hs
--- a/src/OpenAFP/Records/AFP/BDI.hs
+++ b/src/OpenAFP/Records/AFP/BDI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BDI where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BDM.hs b/src/OpenAFP/Records/AFP/BDM.hs
--- a/src/OpenAFP/Records/AFP/BDM.hs
+++ b/src/OpenAFP/Records/AFP/BDM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BDM where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BDT.hs b/src/OpenAFP/Records/AFP/BDT.hs
--- a/src/OpenAFP/Records/AFP/BDT.hs
+++ b/src/OpenAFP/Records/AFP/BDT.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BDT where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BDX.hs b/src/OpenAFP/Records/AFP/BDX.hs
--- a/src/OpenAFP/Records/AFP/BDX.hs
+++ b/src/OpenAFP/Records/AFP/BDX.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BDX where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BFG.hs b/src/OpenAFP/Records/AFP/BFG.hs
--- a/src/OpenAFP/Records/AFP/BFG.hs
+++ b/src/OpenAFP/Records/AFP/BFG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BFG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BFM.hs b/src/OpenAFP/Records/AFP/BFM.hs
--- a/src/OpenAFP/Records/AFP/BFM.hs
+++ b/src/OpenAFP/Records/AFP/BFM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BFM where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BFN.hs b/src/OpenAFP/Records/AFP/BFN.hs
--- a/src/OpenAFP/Records/AFP/BFN.hs
+++ b/src/OpenAFP/Records/AFP/BFN.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BFN where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BGR.hs b/src/OpenAFP/Records/AFP/BGR.hs
--- a/src/OpenAFP/Records/AFP/BGR.hs
+++ b/src/OpenAFP/Records/AFP/BGR.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BGR where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BII.hs b/src/OpenAFP/Records/AFP/BII.hs
--- a/src/OpenAFP/Records/AFP/BII.hs
+++ b/src/OpenAFP/Records/AFP/BII.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BII where
import OpenAFP.Types
@@ -7,6 +6,6 @@
data BII = BII {
bii_Type :: !N3
,bii_ :: !N3
- ,bii_ImageObjectName :: !A8
+ ,bii_ImageObjectName :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/AFP/BIM.hs b/src/OpenAFP/Records/AFP/BIM.hs
--- a/src/OpenAFP/Records/AFP/BIM.hs
+++ b/src/OpenAFP/Records/AFP/BIM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BIM where
import OpenAFP.Types
@@ -7,6 +6,6 @@
data BIM = BIM {
bim_Type :: !N3
,bim_ :: !N3
- ,bim :: !NStr
+ ,bim :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/AFP/BMM.hs b/src/OpenAFP/Records/AFP/BMM.hs
--- a/src/OpenAFP/Records/AFP/BMM.hs
+++ b/src/OpenAFP/Records/AFP/BMM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BMM where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BMO.hs b/src/OpenAFP/Records/AFP/BMO.hs
--- a/src/OpenAFP/Records/AFP/BMO.hs
+++ b/src/OpenAFP/Records/AFP/BMO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BMO where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BNG.hs b/src/OpenAFP/Records/AFP/BNG.hs
--- a/src/OpenAFP/Records/AFP/BNG.hs
+++ b/src/OpenAFP/Records/AFP/BNG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BNG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BOC.hs b/src/OpenAFP/Records/AFP/BOC.hs
--- a/src/OpenAFP/Records/AFP/BOC.hs
+++ b/src/OpenAFP/Records/AFP/BOC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BOC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BOG.hs b/src/OpenAFP/Records/AFP/BOG.hs
--- a/src/OpenAFP/Records/AFP/BOG.hs
+++ b/src/OpenAFP/Records/AFP/BOG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BOG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BPG.hs b/src/OpenAFP/Records/AFP/BPG.hs
--- a/src/OpenAFP/Records/AFP/BPG.hs
+++ b/src/OpenAFP/Records/AFP/BPG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BPG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BPM.hs b/src/OpenAFP/Records/AFP/BPM.hs
--- a/src/OpenAFP/Records/AFP/BPM.hs
+++ b/src/OpenAFP/Records/AFP/BPM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BPM where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BPS.hs b/src/OpenAFP/Records/AFP/BPS.hs
--- a/src/OpenAFP/Records/AFP/BPS.hs
+++ b/src/OpenAFP/Records/AFP/BPS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BPS where
import OpenAFP.Types
@@ -7,6 +6,6 @@
data BPS = BPS {
bps_Type :: !N3
,bps_ :: !N3
- ,bps :: !NStr
+ ,bps :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/AFP/BPT.hs b/src/OpenAFP/Records/AFP/BPT.hs
--- a/src/OpenAFP/Records/AFP/BPT.hs
+++ b/src/OpenAFP/Records/AFP/BPT.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BPT where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BR.hs b/src/OpenAFP/Records/AFP/BR.hs
--- a/src/OpenAFP/Records/AFP/BR.hs
+++ b/src/OpenAFP/Records/AFP/BR.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BR where
import OpenAFP.Types
@@ -7,6 +6,6 @@
data BR = BR {
br_Type :: !N3
,br_ :: !N3
- ,br :: !NStr
+ ,br :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/AFP/BRG.hs b/src/OpenAFP/Records/AFP/BRG.hs
--- a/src/OpenAFP/Records/AFP/BRG.hs
+++ b/src/OpenAFP/Records/AFP/BRG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BRG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/BSG.hs b/src/OpenAFP/Records/AFP/BSG.hs
--- a/src/OpenAFP/Records/AFP/BSG.hs
+++ b/src/OpenAFP/Records/AFP/BSG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.BSG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/CAT.hs b/src/OpenAFP/Records/AFP/CAT.hs
--- a/src/OpenAFP/Records/AFP/CAT.hs
+++ b/src/OpenAFP/Records/AFP/CAT.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.CAT where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/CDD.hs b/src/OpenAFP/Records/AFP/CDD.hs
--- a/src/OpenAFP/Records/AFP/CDD.hs
+++ b/src/OpenAFP/Records/AFP/CDD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.CDD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/CFC.hs b/src/OpenAFP/Records/AFP/CFC.hs
--- a/src/OpenAFP/Records/AFP/CFC.hs
+++ b/src/OpenAFP/Records/AFP/CFC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.CFC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/CFI.hs b/src/OpenAFP/Records/AFP/CFI.hs
--- a/src/OpenAFP/Records/AFP/CFI.hs
+++ b/src/OpenAFP/Records/AFP/CFI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.CFI where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/CPC.hs b/src/OpenAFP/Records/AFP/CPC.hs
--- a/src/OpenAFP/Records/AFP/CPC.hs
+++ b/src/OpenAFP/Records/AFP/CPC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.CPC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/CPD.hs b/src/OpenAFP/Records/AFP/CPD.hs
--- a/src/OpenAFP/Records/AFP/CPD.hs
+++ b/src/OpenAFP/Records/AFP/CPD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.CPD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/CPI.hs b/src/OpenAFP/Records/AFP/CPI.hs
--- a/src/OpenAFP/Records/AFP/CPI.hs
+++ b/src/OpenAFP/Records/AFP/CPI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.CPI where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/CTC.hs b/src/OpenAFP/Records/AFP/CTC.hs
--- a/src/OpenAFP/Records/AFP/CTC.hs
+++ b/src/OpenAFP/Records/AFP/CTC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.CTC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/DXD.hs b/src/OpenAFP/Records/AFP/DXD.hs
--- a/src/OpenAFP/Records/AFP/DXD.hs
+++ b/src/OpenAFP/Records/AFP/DXD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.DXD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EAG.hs b/src/OpenAFP/Records/AFP/EAG.hs
--- a/src/OpenAFP/Records/AFP/EAG.hs
+++ b/src/OpenAFP/Records/AFP/EAG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EAG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EBC.hs b/src/OpenAFP/Records/AFP/EBC.hs
--- a/src/OpenAFP/Records/AFP/EBC.hs
+++ b/src/OpenAFP/Records/AFP/EBC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EBC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/ECA.hs b/src/OpenAFP/Records/AFP/ECA.hs
--- a/src/OpenAFP/Records/AFP/ECA.hs
+++ b/src/OpenAFP/Records/AFP/ECA.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.ECA where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/ECF.hs b/src/OpenAFP/Records/AFP/ECF.hs
--- a/src/OpenAFP/Records/AFP/ECF.hs
+++ b/src/OpenAFP/Records/AFP/ECF.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.ECF where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/ECP.hs b/src/OpenAFP/Records/AFP/ECP.hs
--- a/src/OpenAFP/Records/AFP/ECP.hs
+++ b/src/OpenAFP/Records/AFP/ECP.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.ECP where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EDG.hs b/src/OpenAFP/Records/AFP/EDG.hs
--- a/src/OpenAFP/Records/AFP/EDG.hs
+++ b/src/OpenAFP/Records/AFP/EDG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EDG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EDI.hs b/src/OpenAFP/Records/AFP/EDI.hs
--- a/src/OpenAFP/Records/AFP/EDI.hs
+++ b/src/OpenAFP/Records/AFP/EDI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EDI where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EDM.hs b/src/OpenAFP/Records/AFP/EDM.hs
--- a/src/OpenAFP/Records/AFP/EDM.hs
+++ b/src/OpenAFP/Records/AFP/EDM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EDM where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EDT.hs b/src/OpenAFP/Records/AFP/EDT.hs
--- a/src/OpenAFP/Records/AFP/EDT.hs
+++ b/src/OpenAFP/Records/AFP/EDT.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EDT where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EDX.hs b/src/OpenAFP/Records/AFP/EDX.hs
--- a/src/OpenAFP/Records/AFP/EDX.hs
+++ b/src/OpenAFP/Records/AFP/EDX.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EDX where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EFG.hs b/src/OpenAFP/Records/AFP/EFG.hs
--- a/src/OpenAFP/Records/AFP/EFG.hs
+++ b/src/OpenAFP/Records/AFP/EFG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EFG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EFM.hs b/src/OpenAFP/Records/AFP/EFM.hs
--- a/src/OpenAFP/Records/AFP/EFM.hs
+++ b/src/OpenAFP/Records/AFP/EFM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EFM where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EFN.hs b/src/OpenAFP/Records/AFP/EFN.hs
--- a/src/OpenAFP/Records/AFP/EFN.hs
+++ b/src/OpenAFP/Records/AFP/EFN.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EFN where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EGR.hs b/src/OpenAFP/Records/AFP/EGR.hs
--- a/src/OpenAFP/Records/AFP/EGR.hs
+++ b/src/OpenAFP/Records/AFP/EGR.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EGR where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EII.hs b/src/OpenAFP/Records/AFP/EII.hs
--- a/src/OpenAFP/Records/AFP/EII.hs
+++ b/src/OpenAFP/Records/AFP/EII.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EII where
import OpenAFP.Types
@@ -7,6 +6,6 @@
data EII = EII {
eii_Type :: !N3
,eii_ :: !N3
- ,eii_ImageObjectName :: !A8
+ ,eii_ImageObjectName :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/AFP/EIM.hs b/src/OpenAFP/Records/AFP/EIM.hs
--- a/src/OpenAFP/Records/AFP/EIM.hs
+++ b/src/OpenAFP/Records/AFP/EIM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EIM where
import OpenAFP.Types
@@ -7,6 +6,6 @@
data EIM = EIM {
eim_Type :: !N3
,eim_ :: !N3
- ,eim :: !NStr
+ ,eim :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/AFP/EMM.hs b/src/OpenAFP/Records/AFP/EMM.hs
--- a/src/OpenAFP/Records/AFP/EMM.hs
+++ b/src/OpenAFP/Records/AFP/EMM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EMM where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EMO.hs b/src/OpenAFP/Records/AFP/EMO.hs
--- a/src/OpenAFP/Records/AFP/EMO.hs
+++ b/src/OpenAFP/Records/AFP/EMO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EMO where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/ENG.hs b/src/OpenAFP/Records/AFP/ENG.hs
--- a/src/OpenAFP/Records/AFP/ENG.hs
+++ b/src/OpenAFP/Records/AFP/ENG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.ENG where
import OpenAFP.Types
@@ -7,6 +6,6 @@
data ENG = ENG {
eng_Type :: !N3
,eng_ :: !N3
- ,eng :: !NStr
+ ,eng :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/AFP/EOC.hs b/src/OpenAFP/Records/AFP/EOC.hs
--- a/src/OpenAFP/Records/AFP/EOC.hs
+++ b/src/OpenAFP/Records/AFP/EOC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EOC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EOG.hs b/src/OpenAFP/Records/AFP/EOG.hs
--- a/src/OpenAFP/Records/AFP/EOG.hs
+++ b/src/OpenAFP/Records/AFP/EOG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EOG where
import OpenAFP.Types
@@ -7,6 +6,6 @@
data EOG = EOG {
eog_Type :: !N3
,eog_ :: !N3
- ,eog :: !NStr
+ ,eog :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/AFP/EPG.hs b/src/OpenAFP/Records/AFP/EPG.hs
--- a/src/OpenAFP/Records/AFP/EPG.hs
+++ b/src/OpenAFP/Records/AFP/EPG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EPG where
import OpenAFP.Types
@@ -7,6 +6,6 @@
data EPG = EPG {
epg_Type :: !N3
,epg_ :: !N3
- ,epg :: !NStr
+ ,epg :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/AFP/EPM.hs b/src/OpenAFP/Records/AFP/EPM.hs
--- a/src/OpenAFP/Records/AFP/EPM.hs
+++ b/src/OpenAFP/Records/AFP/EPM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EPM where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/EPS.hs b/src/OpenAFP/Records/AFP/EPS.hs
--- a/src/OpenAFP/Records/AFP/EPS.hs
+++ b/src/OpenAFP/Records/AFP/EPS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EPS where
import OpenAFP.Types
@@ -7,6 +6,6 @@
data EPS = EPS {
eps_Type :: !N3
,eps_ :: !N3
- ,eps :: !NStr
+ ,eps :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/AFP/EPT.hs b/src/OpenAFP/Records/AFP/EPT.hs
--- a/src/OpenAFP/Records/AFP/EPT.hs
+++ b/src/OpenAFP/Records/AFP/EPT.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.EPT where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/ER.hs b/src/OpenAFP/Records/AFP/ER.hs
--- a/src/OpenAFP/Records/AFP/ER.hs
+++ b/src/OpenAFP/Records/AFP/ER.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.ER where
import OpenAFP.Types
@@ -7,6 +6,6 @@
data ER = ER {
er_Type :: !N3
,er_ :: !N3
- ,er :: !NStr
+ ,er :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/AFP/ERG.hs b/src/OpenAFP/Records/AFP/ERG.hs
--- a/src/OpenAFP/Records/AFP/ERG.hs
+++ b/src/OpenAFP/Records/AFP/ERG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.ERG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/ESG.hs b/src/OpenAFP/Records/AFP/ESG.hs
--- a/src/OpenAFP/Records/AFP/ESG.hs
+++ b/src/OpenAFP/Records/AFP/ESG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.ESG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/FGD.hs b/src/OpenAFP/Records/AFP/FGD.hs
--- a/src/OpenAFP/Records/AFP/FGD.hs
+++ b/src/OpenAFP/Records/AFP/FGD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.FGD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/FNC.hs b/src/OpenAFP/Records/AFP/FNC.hs
--- a/src/OpenAFP/Records/AFP/FNC.hs
+++ b/src/OpenAFP/Records/AFP/FNC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.FNC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/FND.hs b/src/OpenAFP/Records/AFP/FND.hs
--- a/src/OpenAFP/Records/AFP/FND.hs
+++ b/src/OpenAFP/Records/AFP/FND.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.FND where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/FNG.hs b/src/OpenAFP/Records/AFP/FNG.hs
--- a/src/OpenAFP/Records/AFP/FNG.hs
+++ b/src/OpenAFP/Records/AFP/FNG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.FNG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/FNI.hs b/src/OpenAFP/Records/AFP/FNI.hs
--- a/src/OpenAFP/Records/AFP/FNI.hs
+++ b/src/OpenAFP/Records/AFP/FNI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.FNI where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/FNM.hs b/src/OpenAFP/Records/AFP/FNM.hs
--- a/src/OpenAFP/Records/AFP/FNM.hs
+++ b/src/OpenAFP/Records/AFP/FNM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.FNM where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/FNN.hs b/src/OpenAFP/Records/AFP/FNN.hs
--- a/src/OpenAFP/Records/AFP/FNN.hs
+++ b/src/OpenAFP/Records/AFP/FNN.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.FNN where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/FNO.hs b/src/OpenAFP/Records/AFP/FNO.hs
--- a/src/OpenAFP/Records/AFP/FNO.hs
+++ b/src/OpenAFP/Records/AFP/FNO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.FNO where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/FNP.hs b/src/OpenAFP/Records/AFP/FNP.hs
--- a/src/OpenAFP/Records/AFP/FNP.hs
+++ b/src/OpenAFP/Records/AFP/FNP.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.FNP where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/GAD.hs b/src/OpenAFP/Records/AFP/GAD.hs
--- a/src/OpenAFP/Records/AFP/GAD.hs
+++ b/src/OpenAFP/Records/AFP/GAD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.GAD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/GDD.hs b/src/OpenAFP/Records/AFP/GDD.hs
--- a/src/OpenAFP/Records/AFP/GDD.hs
+++ b/src/OpenAFP/Records/AFP/GDD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.GDD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/ICP.hs b/src/OpenAFP/Records/AFP/ICP.hs
--- a/src/OpenAFP/Records/AFP/ICP.hs
+++ b/src/OpenAFP/Records/AFP/ICP.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.ICP where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/IDD.hs b/src/OpenAFP/Records/AFP/IDD.hs
--- a/src/OpenAFP/Records/AFP/IDD.hs
+++ b/src/OpenAFP/Records/AFP/IDD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.IDD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/IEL.hs b/src/OpenAFP/Records/AFP/IEL.hs
--- a/src/OpenAFP/Records/AFP/IEL.hs
+++ b/src/OpenAFP/Records/AFP/IEL.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.IEL where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/IID.hs b/src/OpenAFP/Records/AFP/IID.hs
--- a/src/OpenAFP/Records/AFP/IID.hs
+++ b/src/OpenAFP/Records/AFP/IID.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.IID where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/IMM.hs b/src/OpenAFP/Records/AFP/IMM.hs
--- a/src/OpenAFP/Records/AFP/IMM.hs
+++ b/src/OpenAFP/Records/AFP/IMM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.IMM where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/IOB.hs b/src/OpenAFP/Records/AFP/IOB.hs
--- a/src/OpenAFP/Records/AFP/IOB.hs
+++ b/src/OpenAFP/Records/AFP/IOB.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.IOB where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/IOC.hs b/src/OpenAFP/Records/AFP/IOC.hs
--- a/src/OpenAFP/Records/AFP/IOC.hs
+++ b/src/OpenAFP/Records/AFP/IOC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.IOC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/IPD.hs b/src/OpenAFP/Records/AFP/IPD.hs
--- a/src/OpenAFP/Records/AFP/IPD.hs
+++ b/src/OpenAFP/Records/AFP/IPD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.IPD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/IPG.hs b/src/OpenAFP/Records/AFP/IPG.hs
--- a/src/OpenAFP/Records/AFP/IPG.hs
+++ b/src/OpenAFP/Records/AFP/IPG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.IPG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/IPO.hs b/src/OpenAFP/Records/AFP/IPO.hs
--- a/src/OpenAFP/Records/AFP/IPO.hs
+++ b/src/OpenAFP/Records/AFP/IPO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.IPO where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/IPS.hs b/src/OpenAFP/Records/AFP/IPS.hs
--- a/src/OpenAFP/Records/AFP/IPS.hs
+++ b/src/OpenAFP/Records/AFP/IPS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.IPS where
import OpenAFP.Types
@@ -7,6 +6,6 @@
data IPS = IPS {
ips_Type :: !N3
,ips_ :: !N3
- ,ips :: !NStr
+ ,ips :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/AFP/IRD.hs b/src/OpenAFP/Records/AFP/IRD.hs
--- a/src/OpenAFP/Records/AFP/IRD.hs
+++ b/src/OpenAFP/Records/AFP/IRD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.IRD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/LLE.hs b/src/OpenAFP/Records/AFP/LLE.hs
--- a/src/OpenAFP/Records/AFP/LLE.hs
+++ b/src/OpenAFP/Records/AFP/LLE.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.LLE where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/LNC.hs b/src/OpenAFP/Records/AFP/LNC.hs
--- a/src/OpenAFP/Records/AFP/LNC.hs
+++ b/src/OpenAFP/Records/AFP/LNC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.LNC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/LND.hs b/src/OpenAFP/Records/AFP/LND.hs
--- a/src/OpenAFP/Records/AFP/LND.hs
+++ b/src/OpenAFP/Records/AFP/LND.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.LND where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MBC.hs b/src/OpenAFP/Records/AFP/MBC.hs
--- a/src/OpenAFP/Records/AFP/MBC.hs
+++ b/src/OpenAFP/Records/AFP/MBC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MBC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MCA.hs b/src/OpenAFP/Records/AFP/MCA.hs
--- a/src/OpenAFP/Records/AFP/MCA.hs
+++ b/src/OpenAFP/Records/AFP/MCA.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MCA where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MCC.hs b/src/OpenAFP/Records/AFP/MCC.hs
--- a/src/OpenAFP/Records/AFP/MCC.hs
+++ b/src/OpenAFP/Records/AFP/MCC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MCC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MCD.hs b/src/OpenAFP/Records/AFP/MCD.hs
--- a/src/OpenAFP/Records/AFP/MCD.hs
+++ b/src/OpenAFP/Records/AFP/MCD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MCD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MCF.hs b/src/OpenAFP/Records/AFP/MCF.hs
--- a/src/OpenAFP/Records/AFP/MCF.hs
+++ b/src/OpenAFP/Records/AFP/MCF.hs
@@ -1,10 +1,9 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MCF where
import OpenAFP.Types
import OpenAFP.Internals
-newtype MCF_ = MCF_ (N0, Buffer2) deriving (Show, Typeable)
+data MCF_ = MCF_ !N0 !Buffer2 deriving (Show, Typeable)
data MCF = MCF {
mcf_Type :: !N3
diff --git a/src/OpenAFP/Records/AFP/MCF1.hs b/src/OpenAFP/Records/AFP/MCF1.hs
--- a/src/OpenAFP/Records/AFP/MCF1.hs
+++ b/src/OpenAFP/Records/AFP/MCF1.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MCF1 where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MDD.hs b/src/OpenAFP/Records/AFP/MDD.hs
--- a/src/OpenAFP/Records/AFP/MDD.hs
+++ b/src/OpenAFP/Records/AFP/MDD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MDD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MDR.hs b/src/OpenAFP/Records/AFP/MDR.hs
--- a/src/OpenAFP/Records/AFP/MDR.hs
+++ b/src/OpenAFP/Records/AFP/MDR.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MDR where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MFC.hs b/src/OpenAFP/Records/AFP/MFC.hs
--- a/src/OpenAFP/Records/AFP/MFC.hs
+++ b/src/OpenAFP/Records/AFP/MFC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MFC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MGO.hs b/src/OpenAFP/Records/AFP/MGO.hs
--- a/src/OpenAFP/Records/AFP/MGO.hs
+++ b/src/OpenAFP/Records/AFP/MGO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MGO where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MIO.hs b/src/OpenAFP/Records/AFP/MIO.hs
--- a/src/OpenAFP/Records/AFP/MIO.hs
+++ b/src/OpenAFP/Records/AFP/MIO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MIO where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MMC.hs b/src/OpenAFP/Records/AFP/MMC.hs
--- a/src/OpenAFP/Records/AFP/MMC.hs
+++ b/src/OpenAFP/Records/AFP/MMC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MMC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MMO.hs b/src/OpenAFP/Records/AFP/MMO.hs
--- a/src/OpenAFP/Records/AFP/MMO.hs
+++ b/src/OpenAFP/Records/AFP/MMO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MMO where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MMT.hs b/src/OpenAFP/Records/AFP/MMT.hs
--- a/src/OpenAFP/Records/AFP/MMT.hs
+++ b/src/OpenAFP/Records/AFP/MMT.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MMT where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MPG.hs b/src/OpenAFP/Records/AFP/MPG.hs
--- a/src/OpenAFP/Records/AFP/MPG.hs
+++ b/src/OpenAFP/Records/AFP/MPG.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MPG where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MPO.hs b/src/OpenAFP/Records/AFP/MPO.hs
--- a/src/OpenAFP/Records/AFP/MPO.hs
+++ b/src/OpenAFP/Records/AFP/MPO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MPO where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MPS.hs b/src/OpenAFP/Records/AFP/MPS.hs
--- a/src/OpenAFP/Records/AFP/MPS.hs
+++ b/src/OpenAFP/Records/AFP/MPS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MPS where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/MSU.hs b/src/OpenAFP/Records/AFP/MSU.hs
--- a/src/OpenAFP/Records/AFP/MSU.hs
+++ b/src/OpenAFP/Records/AFP/MSU.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.MSU where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/NOP.hs b/src/OpenAFP/Records/AFP/NOP.hs
--- a/src/OpenAFP/Records/AFP/NOP.hs
+++ b/src/OpenAFP/Records/AFP/NOP.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.NOP where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/OBD.hs b/src/OpenAFP/Records/AFP/OBD.hs
--- a/src/OpenAFP/Records/AFP/OBD.hs
+++ b/src/OpenAFP/Records/AFP/OBD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.OBD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/OBP.hs b/src/OpenAFP/Records/AFP/OBP.hs
--- a/src/OpenAFP/Records/AFP/OBP.hs
+++ b/src/OpenAFP/Records/AFP/OBP.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.OBP where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/OCD.hs b/src/OpenAFP/Records/AFP/OCD.hs
--- a/src/OpenAFP/Records/AFP/OCD.hs
+++ b/src/OpenAFP/Records/AFP/OCD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.OCD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/PFC.hs b/src/OpenAFP/Records/AFP/PFC.hs
--- a/src/OpenAFP/Records/AFP/PFC.hs
+++ b/src/OpenAFP/Records/AFP/PFC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.PFC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/PGD.hs b/src/OpenAFP/Records/AFP/PGD.hs
--- a/src/OpenAFP/Records/AFP/PGD.hs
+++ b/src/OpenAFP/Records/AFP/PGD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.PGD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/PGP.hs b/src/OpenAFP/Records/AFP/PGP.hs
--- a/src/OpenAFP/Records/AFP/PGP.hs
+++ b/src/OpenAFP/Records/AFP/PGP.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.PGP where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/PGP1.hs b/src/OpenAFP/Records/AFP/PGP1.hs
--- a/src/OpenAFP/Records/AFP/PGP1.hs
+++ b/src/OpenAFP/Records/AFP/PGP1.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.PGP1 where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/PMC.hs b/src/OpenAFP/Records/AFP/PMC.hs
--- a/src/OpenAFP/Records/AFP/PMC.hs
+++ b/src/OpenAFP/Records/AFP/PMC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.PMC where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/PTD.hs b/src/OpenAFP/Records/AFP/PTD.hs
--- a/src/OpenAFP/Records/AFP/PTD.hs
+++ b/src/OpenAFP/Records/AFP/PTD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.PTD where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/PTD1.hs b/src/OpenAFP/Records/AFP/PTD1.hs
--- a/src/OpenAFP/Records/AFP/PTD1.hs
+++ b/src/OpenAFP/Records/AFP/PTD1.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.PTD1 where
import OpenAFP.Types
diff --git a/src/OpenAFP/Records/AFP/PTX.hs b/src/OpenAFP/Records/AFP/PTX.hs
--- a/src/OpenAFP/Records/AFP/PTX.hs
+++ b/src/OpenAFP/Records/AFP/PTX.hs
@@ -1,10 +1,9 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.PTX where
import OpenAFP.Types
import OpenAFP.Internals
-newtype PTX_ = PTX_ (N1, Buffer1) deriving (Show, Typeable)
+data PTX_ = PTX_ !N1 !Buffer1 deriving (Show, Typeable)
data PTX = PTX {
ptx_Type :: !N3
diff --git a/src/OpenAFP/Records/AFP/TLE.hs b/src/OpenAFP/Records/AFP/TLE.hs
--- a/src/OpenAFP/Records/AFP/TLE.hs
+++ b/src/OpenAFP/Records/AFP/TLE.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.AFP.TLE where
import OpenAFP.Types
@@ -8,12 +7,5 @@
tle_Type :: !N3
,tle_ :: !N3
,tle_Chunks :: ![T_]
- ,tle_XUnitBase :: !N1
- ,tle_YUnitBase :: !N1
- ,tle_XLUnitsperUnitBase :: !N2
- ,tle_YLUnitsperUnitBase :: !N2
- ,tle_XPageSize :: !N3
- ,tle_YPageSize :: !N3
- ,tle__ :: !NStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/MCF/T.hs b/src/OpenAFP/Records/MCF/T.hs
--- a/src/OpenAFP/Records/MCF/T.hs
+++ b/src/OpenAFP/Records/MCF/T.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.MCF.T where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/AMB.hs b/src/OpenAFP/Records/PTX/AMB.hs
--- a/src/OpenAFP/Records/PTX/AMB.hs
+++ b/src/OpenAFP/Records/PTX/AMB.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.AMB where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/AMI.hs b/src/OpenAFP/Records/PTX/AMI.hs
--- a/src/OpenAFP/Records/PTX/AMI.hs
+++ b/src/OpenAFP/Records/PTX/AMI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.AMI where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/BLN.hs b/src/OpenAFP/Records/PTX/BLN.hs
--- a/src/OpenAFP/Records/PTX/BLN.hs
+++ b/src/OpenAFP/Records/PTX/BLN.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.BLN where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/BSU.hs b/src/OpenAFP/Records/PTX/BSU.hs
--- a/src/OpenAFP/Records/PTX/BSU.hs
+++ b/src/OpenAFP/Records/PTX/BSU.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.BSU where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/DBR.hs b/src/OpenAFP/Records/PTX/DBR.hs
--- a/src/OpenAFP/Records/PTX/DBR.hs
+++ b/src/OpenAFP/Records/PTX/DBR.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.DBR where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/DIR.hs b/src/OpenAFP/Records/PTX/DIR.hs
--- a/src/OpenAFP/Records/PTX/DIR.hs
+++ b/src/OpenAFP/Records/PTX/DIR.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.DIR where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/ESU.hs b/src/OpenAFP/Records/PTX/ESU.hs
--- a/src/OpenAFP/Records/PTX/ESU.hs
+++ b/src/OpenAFP/Records/PTX/ESU.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.ESU where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/NOP.hs b/src/OpenAFP/Records/PTX/NOP.hs
--- a/src/OpenAFP/Records/PTX/NOP.hs
+++ b/src/OpenAFP/Records/PTX/NOP.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.NOP where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/RMB.hs b/src/OpenAFP/Records/PTX/RMB.hs
--- a/src/OpenAFP/Records/PTX/RMB.hs
+++ b/src/OpenAFP/Records/PTX/RMB.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.RMB where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/RMI.hs b/src/OpenAFP/Records/PTX/RMI.hs
--- a/src/OpenAFP/Records/PTX/RMI.hs
+++ b/src/OpenAFP/Records/PTX/RMI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.RMI where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/RPS.hs b/src/OpenAFP/Records/PTX/RPS.hs
--- a/src/OpenAFP/Records/PTX/RPS.hs
+++ b/src/OpenAFP/Records/PTX/RPS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.RPS where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/SBI.hs b/src/OpenAFP/Records/PTX/SBI.hs
--- a/src/OpenAFP/Records/PTX/SBI.hs
+++ b/src/OpenAFP/Records/PTX/SBI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.SBI where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/SCFL.hs b/src/OpenAFP/Records/PTX/SCFL.hs
--- a/src/OpenAFP/Records/PTX/SCFL.hs
+++ b/src/OpenAFP/Records/PTX/SCFL.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.SCFL where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/SIA.hs b/src/OpenAFP/Records/PTX/SIA.hs
--- a/src/OpenAFP/Records/PTX/SIA.hs
+++ b/src/OpenAFP/Records/PTX/SIA.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.SIA where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/SIM.hs b/src/OpenAFP/Records/PTX/SIM.hs
--- a/src/OpenAFP/Records/PTX/SIM.hs
+++ b/src/OpenAFP/Records/PTX/SIM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.SIM where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/STC.hs b/src/OpenAFP/Records/PTX/STC.hs
--- a/src/OpenAFP/Records/PTX/STC.hs
+++ b/src/OpenAFP/Records/PTX/STC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.STC where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/STO.hs b/src/OpenAFP/Records/PTX/STO.hs
--- a/src/OpenAFP/Records/PTX/STO.hs
+++ b/src/OpenAFP/Records/PTX/STO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.STO where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/SVI.hs b/src/OpenAFP/Records/PTX/SVI.hs
--- a/src/OpenAFP/Records/PTX/SVI.hs
+++ b/src/OpenAFP/Records/PTX/SVI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.SVI where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/PTX/TRN.hs b/src/OpenAFP/Records/PTX/TRN.hs
--- a/src/OpenAFP/Records/PTX/TRN.hs
+++ b/src/OpenAFP/Records/PTX/TRN.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.PTX.TRN where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T.hs b/src/OpenAFP/Records/T.hs
--- a/src/OpenAFP/Records/T.hs
+++ b/src/OpenAFP/Records/T.hs
@@ -151,7 +151,7 @@
_T_FO :: T_FO
_T_FO = T_FO 0x85 _NStr
_T_FQN :: T_FQN
-_T_FQN = T_FQN 0x02 0 0 0
+_T_FQN = T_FQN 0x02 0 0 _NStr
_T_FRMT :: T_FRMT
_T_FRMT = T_FRMT 0x84 _NStr
_T_II :: T_II
diff --git a/src/OpenAFP/Records/T/AD.hs b/src/OpenAFP/Records/T/AD.hs
--- a/src/OpenAFP/Records/T/AD.hs
+++ b/src/OpenAFP/Records/T/AD.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.AD where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/AQ.hs b/src/OpenAFP/Records/T/AQ.hs
--- a/src/OpenAFP/Records/T/AQ.hs
+++ b/src/OpenAFP/Records/T/AQ.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.AQ where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/AV.hs b/src/OpenAFP/Records/T/AV.hs
--- a/src/OpenAFP/Records/T/AV.hs
+++ b/src/OpenAFP/Records/T/AV.hs
@@ -1,10 +1,9 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.AV where
import OpenAFP.Types
import OpenAFP.Internals
data T_AV = T_AV {
t_av_Type :: !N1
- ,t_av :: !NStr
+ ,t_av :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/T/C.hs b/src/OpenAFP/Records/T/C.hs
--- a/src/OpenAFP/Records/T/C.hs
+++ b/src/OpenAFP/Records/T/C.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.C where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/CF.hs b/src/OpenAFP/Records/T/CF.hs
--- a/src/OpenAFP/Records/T/CF.hs
+++ b/src/OpenAFP/Records/T/CF.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.CF where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/CGCSGI.hs b/src/OpenAFP/Records/T/CGCSGI.hs
--- a/src/OpenAFP/Records/T/CGCSGI.hs
+++ b/src/OpenAFP/Records/T/CGCSGI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.CGCSGI where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/CR.hs b/src/OpenAFP/Records/T/CR.hs
--- a/src/OpenAFP/Records/T/CR.hs
+++ b/src/OpenAFP/Records/T/CR.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.CR where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/CS.hs b/src/OpenAFP/Records/T/CS.hs
--- a/src/OpenAFP/Records/T/CS.hs
+++ b/src/OpenAFP/Records/T/CS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.CS where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/DP.hs b/src/OpenAFP/Records/T/DP.hs
--- a/src/OpenAFP/Records/T/DP.hs
+++ b/src/OpenAFP/Records/T/DP.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.DP where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/EF.hs b/src/OpenAFP/Records/T/EF.hs
--- a/src/OpenAFP/Records/T/EF.hs
+++ b/src/OpenAFP/Records/T/EF.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.EF where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/ERLI.hs b/src/OpenAFP/Records/T/ERLI.hs
--- a/src/OpenAFP/Records/T/ERLI.hs
+++ b/src/OpenAFP/Records/T/ERLI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.ERLI where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/ESI.hs b/src/OpenAFP/Records/T/ESI.hs
--- a/src/OpenAFP/Records/T/ESI.hs
+++ b/src/OpenAFP/Records/T/ESI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.ESI where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/FCGCSGI.hs b/src/OpenAFP/Records/T/FCGCSGI.hs
--- a/src/OpenAFP/Records/T/FCGCSGI.hs
+++ b/src/OpenAFP/Records/T/FCGCSGI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.FCGCSGI where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/FDS.hs b/src/OpenAFP/Records/T/FDS.hs
--- a/src/OpenAFP/Records/T/FDS.hs
+++ b/src/OpenAFP/Records/T/FDS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.FDS where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/FF.hs b/src/OpenAFP/Records/T/FF.hs
--- a/src/OpenAFP/Records/T/FF.hs
+++ b/src/OpenAFP/Records/T/FF.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.FF where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/FHSF.hs b/src/OpenAFP/Records/T/FHSF.hs
--- a/src/OpenAFP/Records/T/FHSF.hs
+++ b/src/OpenAFP/Records/T/FHSF.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.FHSF where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/FO.hs b/src/OpenAFP/Records/T/FO.hs
--- a/src/OpenAFP/Records/T/FO.hs
+++ b/src/OpenAFP/Records/T/FO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.FO where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/FQN.hs b/src/OpenAFP/Records/T/FQN.hs
--- a/src/OpenAFP/Records/T/FQN.hs
+++ b/src/OpenAFP/Records/T/FQN.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.FQN where
import OpenAFP.Types
import OpenAFP.Internals
@@ -7,6 +6,6 @@
t_fqn_Type :: !N1
,t_fqn_SubType :: !N1
,t_fqn_Format :: !N1
- ,t_fqn :: !A8
+ ,t_fqn :: !AStr
} deriving (Show, Typeable)
diff --git a/src/OpenAFP/Records/T/FRMT.hs b/src/OpenAFP/Records/T/FRMT.hs
--- a/src/OpenAFP/Records/T/FRMT.hs
+++ b/src/OpenAFP/Records/T/FRMT.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.FRMT where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/II.hs b/src/OpenAFP/Records/T/II.hs
--- a/src/OpenAFP/Records/T/II.hs
+++ b/src/OpenAFP/Records/T/II.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.II where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/LDOPM.hs b/src/OpenAFP/Records/T/LDOPM.hs
--- a/src/OpenAFP/Records/T/LDOPM.hs
+++ b/src/OpenAFP/Records/T/LDOPM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.LDOPM where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/LDTS.hs b/src/OpenAFP/Records/T/LDTS.hs
--- a/src/OpenAFP/Records/T/LDTS.hs
+++ b/src/OpenAFP/Records/T/LDTS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.LDTS where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/MA.hs b/src/OpenAFP/Records/T/MA.hs
--- a/src/OpenAFP/Records/T/MA.hs
+++ b/src/OpenAFP/Records/T/MA.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.MA where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/MEC.hs b/src/OpenAFP/Records/T/MEC.hs
--- a/src/OpenAFP/Records/T/MEC.hs
+++ b/src/OpenAFP/Records/T/MEC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.MEC where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/MF.hs b/src/OpenAFP/Records/T/MF.hs
--- a/src/OpenAFP/Records/T/MF.hs
+++ b/src/OpenAFP/Records/T/MF.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.MF where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/MIS.hs b/src/OpenAFP/Records/T/MIS.hs
--- a/src/OpenAFP/Records/T/MIS.hs
+++ b/src/OpenAFP/Records/T/MIS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.MIS where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/MMPN.hs b/src/OpenAFP/Records/T/MMPN.hs
--- a/src/OpenAFP/Records/T/MMPN.hs
+++ b/src/OpenAFP/Records/T/MMPN.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.MMPN where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/MO.hs b/src/OpenAFP/Records/T/MO.hs
--- a/src/OpenAFP/Records/T/MO.hs
+++ b/src/OpenAFP/Records/T/MO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.MO where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/MOR.hs b/src/OpenAFP/Records/T/MOR.hs
--- a/src/OpenAFP/Records/T/MOR.hs
+++ b/src/OpenAFP/Records/T/MOR.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.MOR where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/OAMU.hs b/src/OpenAFP/Records/T/OAMU.hs
--- a/src/OpenAFP/Records/T/OAMU.hs
+++ b/src/OpenAFP/Records/T/OAMU.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.OAMU where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/OAS.hs b/src/OpenAFP/Records/T/OAS.hs
--- a/src/OpenAFP/Records/T/OAS.hs
+++ b/src/OpenAFP/Records/T/OAS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.OAS where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/OBE.hs b/src/OpenAFP/Records/T/OBE.hs
--- a/src/OpenAFP/Records/T/OBE.hs
+++ b/src/OpenAFP/Records/T/OBE.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.OBE where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/OBO.hs b/src/OpenAFP/Records/T/OBO.hs
--- a/src/OpenAFP/Records/T/OBO.hs
+++ b/src/OpenAFP/Records/T/OBO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.OBO where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/OCH.hs b/src/OpenAFP/Records/T/OCH.hs
--- a/src/OpenAFP/Records/T/OCH.hs
+++ b/src/OpenAFP/Records/T/OCH.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.OCH where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/OCL.hs b/src/OpenAFP/Records/T/OCL.hs
--- a/src/OpenAFP/Records/T/OCL.hs
+++ b/src/OpenAFP/Records/T/OCL.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.OCL where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/OCO.hs b/src/OpenAFP/Records/T/OCO.hs
--- a/src/OpenAFP/Records/T/OCO.hs
+++ b/src/OpenAFP/Records/T/OCO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.OCO where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/OFSS.hs b/src/OpenAFP/Records/T/OFSS.hs
--- a/src/OpenAFP/Records/T/OFSS.hs
+++ b/src/OpenAFP/Records/T/OFSS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.OFSS where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/OO.hs b/src/OpenAFP/Records/T/OO.hs
--- a/src/OpenAFP/Records/T/OO.hs
+++ b/src/OpenAFP/Records/T/OO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.OO where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/OOI.hs b/src/OpenAFP/Records/T/OOI.hs
--- a/src/OpenAFP/Records/T/OOI.hs
+++ b/src/OpenAFP/Records/T/OOI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.OOI where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/OSFE.hs b/src/OpenAFP/Records/T/OSFE.hs
--- a/src/OpenAFP/Records/T/OSFE.hs
+++ b/src/OpenAFP/Records/T/OSFE.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.OSFE where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/OSFO.hs b/src/OpenAFP/Records/T/OSFO.hs
--- a/src/OpenAFP/Records/T/OSFO.hs
+++ b/src/OpenAFP/Records/T/OSFO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.OSFO where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/PC.hs b/src/OpenAFP/Records/T/PC.hs
--- a/src/OpenAFP/Records/T/PC.hs
+++ b/src/OpenAFP/Records/T/PC.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.PC where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/POCP.hs b/src/OpenAFP/Records/T/POCP.hs
--- a/src/OpenAFP/Records/T/POCP.hs
+++ b/src/OpenAFP/Records/T/POCP.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.POCP where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/PPI.hs b/src/OpenAFP/Records/T/PPI.hs
--- a/src/OpenAFP/Records/T/PPI.hs
+++ b/src/OpenAFP/Records/T/PPI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.PPI where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/PSMR.hs b/src/OpenAFP/Records/T/PSMR.hs
--- a/src/OpenAFP/Records/T/PSMR.hs
+++ b/src/OpenAFP/Records/T/PSMR.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.PSMR where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/PSRM.hs b/src/OpenAFP/Records/T/PSRM.hs
--- a/src/OpenAFP/Records/T/PSRM.hs
+++ b/src/OpenAFP/Records/T/PSRM.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.PSRM where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/PV.hs b/src/OpenAFP/Records/T/PV.hs
--- a/src/OpenAFP/Records/T/PV.hs
+++ b/src/OpenAFP/Records/T/PV.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.PV where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/RLI.hs b/src/OpenAFP/Records/T/RLI.hs
--- a/src/OpenAFP/Records/T/RLI.hs
+++ b/src/OpenAFP/Records/T/RLI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.RLI where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/ROI.hs b/src/OpenAFP/Records/T/ROI.hs
--- a/src/OpenAFP/Records/T/ROI.hs
+++ b/src/OpenAFP/Records/T/ROI.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.ROI where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/ROT.hs b/src/OpenAFP/Records/T/ROT.hs
--- a/src/OpenAFP/Records/T/ROT.hs
+++ b/src/OpenAFP/Records/T/ROT.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.ROT where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/RSN.hs b/src/OpenAFP/Records/T/RSN.hs
--- a/src/OpenAFP/Records/T/RSN.hs
+++ b/src/OpenAFP/Records/T/RSN.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.RSN where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/RUA.hs b/src/OpenAFP/Records/T/RUA.hs
--- a/src/OpenAFP/Records/T/RUA.hs
+++ b/src/OpenAFP/Records/T/RUA.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.RUA where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/T1CRMT.hs b/src/OpenAFP/Records/T/T1CRMT.hs
--- a/src/OpenAFP/Records/T/T1CRMT.hs
+++ b/src/OpenAFP/Records/T/T1CRMT.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.T1CRMT where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/T2FRMT.hs b/src/OpenAFP/Records/T/T2FRMT.hs
--- a/src/OpenAFP/Records/T/T2FRMT.hs
+++ b/src/OpenAFP/Records/T/T2FRMT.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.T2FRMT where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/TO.hs b/src/OpenAFP/Records/T/TO.hs
--- a/src/OpenAFP/Records/T/TO.hs
+++ b/src/OpenAFP/Records/T/TO.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.TO where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/TS.hs b/src/OpenAFP/Records/T/TS.hs
--- a/src/OpenAFP/Records/T/TS.hs
+++ b/src/OpenAFP/Records/T/TS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.TS where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Records/T/UDTS.hs b/src/OpenAFP/Records/T/UDTS.hs
--- a/src/OpenAFP/Records/T/UDTS.hs
+++ b/src/OpenAFP/Records/T/UDTS.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}
module OpenAFP.Records.T.UDTS where
import OpenAFP.Types
import OpenAFP.Internals
diff --git a/src/OpenAFP/Types.hs b/src/OpenAFP/Types.hs
--- a/src/OpenAFP/Types.hs
+++ b/src/OpenAFP/Types.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts #-}
-----------------------------------------------------------------------------
-- |
@@ -11,7 +10,7 @@
-- Portability : non-portable (GHC-only)
--
-- This module imports and re-exports the fundamental types in the OpenAFP
--- framework: Buffer, ChunkBuf and Record.
+-- framework: Buffer, Chunk and Record.
--
-----------------------------------------------------------------------------
@@ -21,44 +20,37 @@
module OpenAFP.Types.Record,
module OpenAFP.Types.View,
T_(..), viewChunks, viewData, viewNumber,
- viewString, viewNStr, viewField, viewRecord
+ viewString, viewNStr, viewAStr, viewField, viewRecord
) where
import OpenAFP.Types.Buffer
import OpenAFP.Types.Chunk
import OpenAFP.Types.Record
import OpenAFP.Types.View
import OpenAFP.Internals
+import qualified Data.ByteString as S
+import qualified Data.ByteString.Char8 as C
-newtype T_ = T_ (N1, Buffer1) deriving (Show, Typeable)
+data T_ = T_ !N1 !Buffer1 deriving (Show, Typeable)
-viewChunks cs = do
- rs <- mapM viewChunk cs
- return $ ViewChunks (typeOf cs, rs)
+viewChunks cs = ViewChunks (typeOf cs) (map viewChunk cs)
viewChunk c = withChunk c recView
-withChunk :: (ChunkBuf a n b, MonadIO m) => a -> (forall r. (Rec r) => r -> m x) -> m x
+withChunk :: Chunk a => a -> (forall r. (Rec r) => r -> x) -> x
withChunk c = chunkApply (fst . chunkDecon $ c) c
-viewData ds = do
- rs <- mapM recView ds
- return $ ViewData (typeOf ds, rs)
+viewData ds = ViewData (typeOf ds) (map recView ds)
-viewNumber n = return $ ViewNumber (typeOf n, fromEnum n)
+viewNumber n = ViewNumber (typeOf n) (fromEnum n)
-viewString a = return $ ViewString (typeOf a, reverse [ toAsc n | n <- [ 0..((sizeOf a)-1) ] ])
- where toAsc n = ebc2asc ! fromIntegral ((a `shiftR` (8 * n)) .&. 0xFF)
+viewString a = ViewString (typeOf a) (S.reverse $ S.pack [ toAsc n | n <- [ 0..((sizeOf a)-1) ] ])
+ where
+ toAsc n = ebc2ascW8 ! fromIntegral ((a `shiftR` (8 * n)) .&. 0xFF)
-viewNStr nstr = do
- let (pstr, len) = bufToPStrLen nstr
- withForeignPtr (castForeignPtr pstr) $ \cstr -> do
- ns <- peekArray (min len 80) cstr
- return $ ViewNStr (typeOf nstr, ns)
+viewNStr nstr = ViewNStr (typeOf nstr) (S.take 80 $ packBuf nstr)
-viewField l io = do
- content <- io
- return $ ViewField (l, content)
+viewAStr nstr = ViewString (typeOf nstr) (S.map (ebc2ascW8 !) (S.take 80 $ packBuf nstr))
-viewRecord t io = do
- fields <- sequence io
- return $ ViewRecord (t, fields)
+viewField l content = ViewField (C.pack l) content
+
+viewRecord = ViewRecord
diff --git a/src/OpenAFP/Types/Buffer.hs b/src/OpenAFP/Types/Buffer.hs
--- a/src/OpenAFP/Types/Buffer.hs
+++ b/src/OpenAFP/Types/Buffer.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts #-}
-----------------------------------------------------------------------------
-- |
@@ -16,56 +15,61 @@
module OpenAFP.Types.Buffer where
import OpenAFP.Internals
+import Data.Binary.Get
+import Data.Binary.Put
+import qualified Data.ByteString as S
+import qualified Data.ByteString.Lazy as L
-- | The Buf class represents buffers, with the leading bytes
-- representing its length.
class (Show a, Typeable a) => Buf a where
- bufFromPStrLen :: PStringLen -> a
- bufToPStrLen :: a -> PStringLen
+ {-# SPECIALIZE mkBuf :: BS -> Buffer0 #-}
+ {-# SPECIALIZE mkBuf :: BS -> Buffer1 #-}
+ {-# SPECIALIZE mkBuf :: BS -> Buffer2 #-}
+ mkBuf :: BS -> a
+ {-# SPECIALIZE packBuf :: Buffer0 -> BS #-}
+ {-# SPECIALIZE packBuf :: Buffer1 -> BS #-}
+ {-# SPECIALIZE packBuf :: Buffer2 -> BS #-}
+ packBuf :: a -> BS
--- | Buffer0, being a simple PStringLen, is of unlimited length.
-newtype Buffer0 = Buf0 PStringLen deriving (Show, Typeable)
+-- | Buffer0, being a simple BS, is of unlimited length.
+newtype Buffer0 = Buf0 { fromBuf0 :: BS } deriving (Show, Typeable)
-- | Buffer1 uses one byte as length, hence is at most 254 bytes long.
-newtype Buffer1 = Buf1 PStringLen deriving (Show, Typeable)
+newtype Buffer1 = Buf1 { fromBuf1 :: BS } deriving (Show, Typeable)
-- | Buffer2 uses two bytes; it can store up to 65535 bytes.
-newtype Buffer2 = Buf2 PStringLen deriving (Show, Typeable)
+newtype Buffer2 = Buf2 { fromBuf2 :: BS } deriving (Show, Typeable)
instance Buf Buffer0 where
- bufFromPStrLen = Buf0
- bufToPStrLen (Buf0 b) = b
+ mkBuf = Buf0
+ packBuf = fromBuf0
instance Buf Buffer1 where
- bufFromPStrLen = Buf1
- bufToPStrLen (Buf1 b) = b
+ mkBuf = Buf1
+ packBuf = fromBuf1
instance Buf Buffer2 where
- bufFromPStrLen = Buf2
- bufToPStrLen (Buf2 b) = b
+ mkBuf = Buf2
+ packBuf = fromBuf2
instance Binary Buffer0 where
- put bh buf = putBuf bh $ bufToPStrLen buf
- get bh = do
- pos <- tellBin bh
- size <- sizeBin bh
- pstrlen <- getBuf bh (size - pos)
- return $ bufFromPStrLen pstrlen
+ put (Buf0 bs) = putByteString bs
+ get = fmap (Buf0 . S.concat . L.toChunks) getRemainingLazyByteString
instance Binary Buffer1 where
- put bh buf = do
- put bh (fromIntegral (len + 1) :: N1)
- putBuf bh $ bufToPStrLen buf
- where len = snd $ bufToPStrLen buf
- get bh = do
- size <- get bh :: IO N1
- pstrlen <- getBuf bh $ (fromEnum size) - 1
- return $ bufFromPStrLen pstrlen
+ put (Buf1 bs) = do
+ putWord8 $ toEnum (S.length bs) + 1
+ putByteString bs
+ get = do
+ sz <- getWord8
+ bs <- getByteString $ fromEnum sz - 1
+ return (Buf1 bs)
instance Binary Buffer2 where
- put bh buf = do
- put bh (fromIntegral (len + 2) :: N2)
- putBuf bh $ bufToPStrLen buf
- where len = snd $ bufToPStrLen buf
- get bh = do
- size <- get bh :: IO N2
- pstrlen <- getBuf bh $ (fromEnum size) - 2
- return $ bufFromPStrLen pstrlen
+ put (Buf2 bs) = do
+ putWord16be $ toEnum (S.length bs) + 2
+ putByteString bs
+ get = do
+ sz <- getWord16be
+ bs <- getByteString $ fromEnum sz - 2
+ return (Buf2 bs)
+
diff --git a/src/OpenAFP/Types/Chunk.hs b/src/OpenAFP/Types/Chunk.hs
--- a/src/OpenAFP/Types/Chunk.hs
+++ b/src/OpenAFP/Types/Chunk.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts #-}
-----------------------------------------------------------------------------
-- |
@@ -18,6 +17,10 @@
import OpenAFP.Internals
import OpenAFP.Types.Buffer
import OpenAFP.Types.Record
+import System.IO.Unsafe (unsafePerformIO)
+import qualified Data.ByteString as S
+import qualified Data.ByteString.Lazy as L
+import qualified Data.ByteString.Char8 as C
infixl 4 ~~
infixl 4 <~~
@@ -35,172 +38,137 @@
type AStr = NStr
type ChunkWriter c = WriterT (ChunkQueue c)
-type WriterStateIO v a = (ChunkBuf c n b, MonadReader v m, MonadPlus m, MonadIO m, MonadError e m, Show e, Typeable e) => ChunkWriter c m a
+type WriterStateIO v a = (Chunk c, MonadReader v m) => ChunkWriter c m a
instance Storable NStr where
alignment _ = 8
- sizeOf = snd . bufToPStrLen
+ sizeOf = S.length . packBuf
nullForeignPtr = unsafePerformIO (newForeignPtr_ nullPtr)
_NStr :: NStr
-_NStr = bufFromPStrLen (nullForeignPtr, 0)
+_NStr = mkBuf S.empty
-fromAStr :: AStr -> IOm String
-fromAStr nstr = liftIO $ do
- let (pstr, len) = bufToPStrLen nstr
- withForeignPtr (castForeignPtr pstr) $ \cstr -> do
- ns <- peekArray len cstr
- return $ map (ebc2asc !) ns
+packAStr :: AStr -> S.ByteString
+packAStr = S.map (ebc2ascW8 !) . packBuf
-toAStr :: String -> IOm AStr
-toAStr str = liftIO $ do
- let len = length str
- pstr <- mallocForeignPtrBytes len
- withForeignPtr pstr $ \cstr -> do
- pokeArray cstr $ map ((asc2ebc !) . ord) str
- return $ bufFromPStrLen (castForeignPtr pstr, len)
+fromAStr :: AStr -> String
+fromAStr = C.unpack . packAStr
-fromNStr :: NStr -> IOm [N1]
-fromNStr nstr = liftIO $ do
- let (pstr, len) = bufToPStrLen nstr
- withForeignPtr (castForeignPtr pstr) $ \cstr ->
- peekArray len cstr
+toAStr :: String -> AStr
+toAStr = mkBuf . S.pack . map (asc2ebcW8 !)
-toNStr :: [N1] -> IOm NStr
-toNStr list = liftIO $ do
- let len = length list
- pstr <- mallocForeignPtrBytes len
- withForeignPtr pstr $ \cstr -> do
- pokeArray cstr list
- return $ bufFromPStrLen (castForeignPtr pstr, len)
+packNStr :: NStr -> S.ByteString
+packNStr = packBuf
-newtype ChunkType = MkChunkType String
+fromNStr :: NStr -> [N1]
+fromNStr = map N1 . S.unpack . packNStr
+
+toNStr :: [N1] -> NStr
+toNStr = mkBuf . S.pack . map fromN1
+
+newtype ChunkType = MkChunkType Int
deriving (Show, Eq, Typeable, Ord)
+typeInt :: TypeRep -> Int
+typeInt x = unsafePerformIO (typeRepKey x)
+
chunkTypeOf :: Typeable a => a -> ChunkType
-chunkTypeOf = MkChunkType . show . typeOf
+chunkTypeOf = MkChunkType . typeInt . typeOf
--- | The ChunkBuf class represents non-parsed chunks, constructed from a
+-- | The Chunk class represents non-parsed chunks, constructed from a
-- (ChunkType, Buffer) tuple.
-class (Show c, Typeable c, Buf b, Num n, Enum n) => ChunkBuf c n b | c -> n, c -> b where
- chunkApply :: (MonadIO m) => n -> c -> (forall a. (Rec a) => (a -> m x)) -> m x
- chunkCon :: (n, b) -> c
- chunkDecon :: c -> (n, b)
+class (Show c, Typeable c, Buf (BufOf c), Enum (N c), Num (N c)) => Chunk c where
+ type N c
+ type BufOf c
+ chunkApply :: N c -> c -> (forall a. (Rec a) => (a -> x)) -> x
+ mkChunk :: N c -> BufOf c -> c
+ mkChunk = curry chunkCon
+ chunkCon :: (N c, BufOf c) -> c
+ chunkCon = uncurry mkChunk
+ chunkDecon :: c -> (N c, BufOf c)
chunkType :: c -> ChunkType
- chunkType c = chunkTypeLookup c . fst . chunkDecon $ c
- chunkTypeLookup :: c -> n -> ChunkType
- chunkToPStrLen :: c -> PStringLen
- chunkMapFiltersM_ :: (MonadIO m) => c -> [(ChunkType, c -> m [c])] -> m ()
- chunkMapFiltersM_ c possibleFilters
- | null filters = return ()
- | otherwise = mapM_ (\(_, f) -> do f c ; return ()) filters
- where filters = filter (\(t, _) -> (t == chunkType c)) possibleFilters
- chunkMapFiltersM :: (MonadIO m) => c -> [(ChunkType, c -> m [c])] -> m [c]
- chunkMapFiltersM c possibleFilters
- | null filters = return [c]
- | otherwise = do
- c' <- foldM applyF [c] filters
- return c'
+ chunkType c = chunkTypeLookup c . fst $ chunkDecon c
+ chunkTypeLookup :: c -> N c -> ChunkType
+ packChunk :: c -> PStringLen
+ chunkMapFiltersM_ :: (Monad m) => c -> [(ChunkType, c -> m [c])] -> m ()
+ chunkMapFiltersM_ c possibleFilters = mapM_ (\(_, f) -> f c) filters
where
- filters = filter (\(t, _) -> (t == chunkType c)) possibleFilters
- applyF r (_, f) = do
- r' <- mapM f r
- return $ concat r'
- chunksMapFiltersM :: (MonadIO m) => [c] -> [(ChunkType, c -> m [c])] -> m [c]
- chunksMapFiltersM cs list = do
- lol <- mapM (`chunkMapFiltersM` list) cs
- return $ concat lol
- chunksMapFiltersM_ :: (MonadIO m) => [c] -> [(ChunkType, c -> m [c])] -> m ()
+ filters = filter (\(t, _) -> (t == chunkType c)) possibleFilters
+ chunkMapFiltersM :: (Monad m) => c -> [(ChunkType, c -> m [c])] -> m [c]
+ chunkMapFiltersM c possibleFilters = foldM applyF [c] filters
+ where
+ filters = filter (\(t, _) -> (t == chunkType c)) possibleFilters
+ applyF r (_, f) = liftM concat (mapM f r)
+ chunksMapFiltersM :: (Monad m) => [c] -> [(ChunkType, c -> m [c])] -> m [c]
+ chunksMapFiltersM cs list = liftM concat (mapM (`chunkMapFiltersM` list) cs)
+ chunksMapFiltersM_ :: (Monad m) => [c] -> [(ChunkType, c -> m [c])] -> m ()
chunksMapFiltersM_ cs list = mapM_ (`chunkMapFiltersM_` list) cs
- chunkToRecord :: (Binary (Record r)) => c -> IO (Record r)
- chunkToRecord c = do
- let (pstr, len) = chunkToPStrLen c
- bh <- openBinBuf (pstr, len)
- -- XXX: Associate this with the reified chunkType
- (Record r) <- get bh
- addFinalizer r $ touchForeignPtr pstr
- return $ Record r
- chunkToPStrLen c = bufToPStrLen buf where (_, buf) = chunkDecon c
- chunkFromRecord :: (Binary r, Storable r, Rec r) => r -> IO c
- chunkFromRecord item = do
- bh <- newBinBuf (sizeOf item)
- put bh item
- return $ chunkCon (toEnum . recType $ item, bufFromPStrLen $ bufOf bh)
+ decodeChunk :: (Binary (Record r)) => c -> r
+ decodeChunk c = fromRecord (decode (L.fromChunks [packChunk c]))
+ encodeChunk :: (Binary r, Storable r, Rec r) => r -> c
+ encodeChunk item = mkChunk (toEnum (recType item)) bs
+ where
+ bs = mkBuf $ S.concat (L.toChunks (encode item))
+ packChunk c = packBuf buf where (_, buf) = chunkDecon c
-- | The RecChunk class unifies a Rec (parent) with its contained
-- chunk types (children).
-class (Rec r, ChunkBuf c n b) => RecChunk r c n b | r -> c where
- readChunks :: r -> [c]
+class (Rec r, Chunk (ChunkOf r)) => RecChunk r where
+ type ChunkOf r
+ readChunks :: r -> [ChunkOf r]
readChunks = error "readChunks not defined"
- writeChunks :: (MonadIO m) => r -> m [c] -> m r
+ writeChunks :: Monad m => r -> m [ChunkOf r] -> m r
writeChunks = error "writeChunks not defined"
+-- Mutual dependency of Rec/Data pair.
+
-- | The RecData class unifies a Rec (parent) with its contained
-- Rec data type (children).
-class (Rec a, Rec b) => RecData a b | a -> b, b -> a where
+class (Rec a, Rec b, DataOf a ~ b, RecOf b ~ a) => RecData a b where
+ type DataOf a
+ type RecOf b
readData :: a -> [Record b]
readData = error "readData not defined"
writeData :: a -> [Record b] -> a
writeData = error "writeData not defined"
--- | The ChunkLookup class unifies a Chunk (parent) with its lookup
--- dispatch function.
-{-
-
-class ChunkLookup a b | a -> b where
- chunkLookup :: (ChunkBuf a c) => b -> c -> a
-
-instance (ChunkLookup a b, ChunkBuf a c, Binary c) => Binary a where
- put bh chunk = put bh $ snd $ chunkDecon chunk
- get bh = do
- buf <- get bh
- bh' <- openBinBuf $ bufToPStrLen buf
- buftype <- get bh'
- return $ chunkLookup buftype buf
--}
-
-
instance (Rec a, Binary a) => Storable [a] where
alignment = undefined
sizeOf r = recSizeOf r
-(~~) :: (ChunkBuf c n b, Typeable t) => c -> t -> Bool
+(~~) :: (Chunk c, Typeable t) => c -> t -> Bool
c ~~ t = (chunkTypeOf t == chunkType c)
-(<~~) :: (ChunkBuf c n b, Typeable t, Rec r) => t -> [c] -> IOm r
-t <~~ cs = do
- Record r <- liftIO $ chunkToRecord $ fromJust $ find (~~ t) cs
- return r
+(<~~) :: (Monad m, Chunk c, Typeable t, Rec r) => t -> [c] -> m r
+t <~~ cs = case find (~~ t) cs of
+ Just c -> return (decodeChunk c)
+ _ -> fail $ "Cannot find locate chunk: " ++ show (typeOf t, cs)
-(~~>) :: (ChunkBuf c n b, Typeable t, Rec r) => [c] -> t -> IOm r
-cs ~~> t = do
- Record r <- liftIO $ chunkToRecord $ fromJust $ find (~~ t) cs
- return r
+(~~>) :: (Monad m, Chunk c, Typeable t, Rec r) => [c] -> t -> m r
+(~~>) = flip (<~~)
-(==>) :: (ChunkBuf c n b, MonadIO m) => [c] -> [(ChunkType, c -> m [c])] -> m [c]
-cs ==> fs = chunksMapFiltersM cs fs
+(==>) :: (Chunk c, Monad m) => [c] -> [(ChunkType, c -> m [c])] -> m [c]
+cs ==> fs = length cs `seq` chunksMapFiltersM cs fs
-(<==) :: (ChunkBuf c n b, MonadIO m) => [(ChunkType, c -> m [c])] -> [c] -> m [c]
+(<==) :: (Chunk c, Monad m) => [(ChunkType, c -> m [c])] -> [c] -> m [c]
(<==) = flip (==>)
-(..>) :: (ChunkBuf c n b, MonadIO m) => [c] -> [(ChunkType, c -> m [c])] -> m ()
-cs ..> fs = chunksMapFiltersM_ cs fs
+(..>) :: (Chunk c, Monad m) => [c] -> [(ChunkType, c -> m [c])] -> m ()
+cs ..> fs = length cs `seq` chunksMapFiltersM_ cs fs
-(<..) :: (ChunkBuf c n b, MonadIO m) => [(ChunkType, c -> m [c])] -> [c] -> m ()
+(<..) :: (Chunk c, Monad m) => [(ChunkType, c -> m [c])] -> [c] -> m ()
(<..) = flip (..>)
t === f = (chunkTypeOf t, processChunk t f)
-- t ==== f = (chunkTypeOf t, processChunk t (lift . f))
-- t ===== f = (chunkTypeOf t, processChunk t (lift . lift . f))
-processChunk :: (MonadIO m, Rec r, ChunkBuf c n b) =>
+processChunk :: (Monad m, Rec r, Chunk c) =>
r -> (r -> ChunkWriter c m a) -> (c -> m [c])
processChunk _ f c = do
- -- grab a naked record
- (Record r) <- liftIO $ chunkToRecord c
-- pass it to the filter along with the push function
- (_, ChunkQueue cs) <- runWriterT (f r)
+ (_, ChunkQueue cs) <- runWriterT (f (decodeChunk c))
-- collect the pushed stuff
return cs
@@ -208,20 +176,14 @@
t .... f = (chunkTypeOf t, inspectChunk t (lift . f))
t ..... f = (chunkTypeOf t, inspectChunk t (lift . lift . f))
-inspectChunk :: (MonadIO m, Rec a, ChunkBuf c n b) => a -> (a -> m t) -> (c -> m [c])
-inspectChunk _ f c = do
- (Record r) <- liftIO $ chunkToRecord c
- f r
- return [c]
+inspectChunk :: (Monad m, Rec a, Chunk c) => a -> (a -> m t) -> (c -> m [c])
+inspectChunk _ f c = f (decodeChunk c) >> return [c]
-push :: (ChunkBuf c n b, MonadIO m, Rec a) => a -> ChunkWriter c m ()
-push r = do
- chunk <- liftIO $ chunkFromRecord $ Record r
- tell $ ChunkItem chunk
- return ()
+push :: (Chunk c, Monad m, Rec a) => a -> ChunkWriter c m ()
+push = tell . ChunkItem . encodeChunk . Record
-filterChunks :: (MonadIO m, RecChunk r c n b, ChunkBuf c' n' b') =>
- r -> [(ChunkType, c -> ChunkWriter c' m [c])] -> ChunkWriter c' m ()
+filterChunks :: (Monad m, RecChunk r, Chunk c) =>
+ r -> [(ChunkType, ChunkOf r -> ChunkWriter c m [ChunkOf r])] -> ChunkWriter c m ()
filterChunks r list = do
push =<< (writeChunks r $ list <== readChunks r)
@@ -229,5 +191,7 @@
instance Monoid (ChunkQueue a) where
mempty = ChunkQueue []
- mappend (ChunkItem a) (ChunkQueue b) = ChunkQueue (a:b)
- mappend (ChunkQueue a) (ChunkQueue b) = ChunkQueue (a ++ b)
+ mappend (ChunkItem a) (ChunkItem b) = ChunkQueue [a, b]
+ mappend (ChunkItem a) (ChunkQueue b) = ChunkQueue (a:b)
+ mappend (ChunkQueue a) (ChunkQueue b) = ChunkQueue (a ++ b)
+ mappend (ChunkQueue a) (ChunkItem b) = ChunkQueue (a ++ [b])
diff --git a/src/OpenAFP/Types/Record.hs b/src/OpenAFP/Types/Record.hs
--- a/src/OpenAFP/Types/Record.hs
+++ b/src/OpenAFP/Types/Record.hs
@@ -1,5 +1,3 @@
-{-# OPTIONS -O -fglasgow-exts #-}
-
-----------------------------------------------------------------------------
-- |
-- Module : OpenAFP.Types.Record
@@ -18,52 +16,41 @@
import OpenAFP.Internals
import OpenAFP.Types.View
-newtype Record a = Record a
+newtype Record a = Record { fromRecord :: a }
deriving (Show, Eq, Typeable)
class (Show a, Typeable a) => Rec a where
- recGet :: BinHandle -> IO a
+ recGet :: Get a
recGet = error "recGet not defined"
- recPut :: BinHandle -> a -> IO ()
- recPut = error "recPut not defined"
+ recPut :: a -> Put
+ recPut x = error ("recPut not defined: " ++ show x)
recSizeOf :: a -> Int
- recSizeOf = error "recSizeOf not defined"
- recView :: a -> IO ViewRecord
- recView x = error ("recView not defined for " ++ show x)
+ recSizeOf x = error ("recSizeOf not defined: " ++ show x)
+ recView :: a -> ViewRecord
+ recView x = error ("recView not defined: " ++ show x)
recType :: a -> Int
- recType = error "recType not defined"
+ recType x = error ("recType not defined: " ++ show x)
--- (forall a. (Rec a) => (a -> m b))
-instance (Rec a) => Storable (Record a) where
+instance Rec a => Storable (Record a) where
alignment (Record r) = 8
sizeOf (Record r) = recSizeOf r
- -- sizeOf (Record r) = sum $ recApply func r
-{-
-func :: (Storable x) => String -> x -> Int
-func x y = sizeOf y
--}
-func x y = 0
-
-instance (Rec a) => Rec (Record a) where
- recView (Record a) = recView a
+instance Rec a => Rec (Record a) where
+ recGet = liftM Record recGet
+ recPut (Record a) = recPut a
+ recView (Record a) = recView a
+ recSizeOf (Record a) = recSizeOf a
+ recType (Record a) = recType a
-instance (Rec a) => Binary (Record a) where
- get bh = do
- b <- recGet bh
- return $ Record b
- put bh (Record a) = do
- recPut bh a
- return ()
+instance Rec a => Binary (Record a) where
+ get = fmap Record recGet
+ put (Record a) = recPut a
instance (Binary a, Rec a, Show a, Typeable a) => Rec [a] where
recSizeOf list = sum $ map recSizeOf list
- recGet bh = get bh
- recPut bh list = do
- mapM_ (put bh) list
+ recGet = getList
+ recPut = mapM_ put
instance Rec N1 where
recSizeOf _ = 1
-
-fromRecord (Record a) = a
diff --git a/src/OpenAFP/Types/View.hs b/src/OpenAFP/Types/View.hs
--- a/src/OpenAFP/Types/View.hs
+++ b/src/OpenAFP/Types/View.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS -fglasgow-exts #-}
-----------------------------------------------------------------------------
-- |
@@ -17,6 +16,7 @@
module OpenAFP.Types.View where
import OpenAFP.Types.Buffer
import OpenAFP.Internals
+import Data.ByteString
type ChunksType = TypeRep
type RecordType = TypeRep
@@ -24,16 +24,25 @@
type NStrType = TypeRep
type StringType = TypeRep
type DataType = TypeRep
-type FieldLabel = String
+type FieldLabel = ByteString
--- newtype ViewChunks = ViewChunks (ChunksType, [ViewRecord])
-newtype ViewRecord = ViewRecord (RecordType, [ViewField]) deriving (Show, Typeable)
-newtype ViewField = ViewField (FieldLabel, ViewContent) deriving (Show, Typeable)
+data ViewRecord = ViewRecord
+ { vr_type :: !RecordType
+ , vr_field :: ![ViewField]
+ }
+ deriving (Show, Typeable)
+
+data ViewField = ViewField
+ { vf_label :: !FieldLabel
+ , vf_content :: !ViewContent
+ }
+ deriving (Show, Typeable)
+
data ViewContent
- = ViewNumber (NumberType, Int)
- | ViewString (StringType, String)
- | ViewNStr (NStrType, [N1])
- | ViewChunks (ChunksType, [ViewRecord])
- | ViewData (DataType, [ViewRecord])
+ = ViewNumber { vc_type :: !NumberType, vc_number :: !Int }
+ | ViewString { vc_type :: !StringType, vc_string :: !ByteString }
+ | ViewNStr { vc_type :: !NStrType, vc_nstr :: !ByteString }
+ | ViewChunks { vc_type :: !ChunksType, vc_chunks :: ![ViewRecord] }
+ | ViewData { vc_type :: !DataType, vc_data :: ![ViewRecord] }
deriving (Show, Typeable)