packages feed

OpenAFP 1.0 → 1.1

raw patch · 231 files changed

+33946/−2527 lines, 231 filesdep +arraydep +binarydep +bytestring

Dependencies added: array, binary, bytestring, containers, directory, process

Files

OpenAFP.cabal view
@@ -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
src/OpenAFP.hs view
@@ -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
src/OpenAFP/Internals.hs view
@@ -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
src/OpenAFP/Internals/Binary.hs view
@@ -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---     <http://www.cs.york.ac.uk/fp/nhc98/>---------------------------------------------------------------------------------- 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)
src/OpenAFP/Internals/Ebc2Asc.hs view
@@ -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"
− src/OpenAFP/Internals/UConv.hs 
@@ -1,67 +0,0 @@-{-# OPTIONS -#include <unicode/ucnv.h> #-}-{-# 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 -- ("<<error: " ++ (show errCode) ++ ">>")-    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
− src/OpenAFP/Prelude/Exts.hs 
@@ -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-
src/OpenAFP/Prelude/InstanceAFP.hs view
@@ -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 ()
+ src/OpenAFP/Prelude/InstanceAFP/B.hs view
@@ -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+
+ src/OpenAFP/Prelude/InstanceAFP/C.hs view
@@ -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+
+ src/OpenAFP/Prelude/InstanceAFP/D.hs view
@@ -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+
+ src/OpenAFP/Prelude/InstanceAFP/E.hs view
@@ -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+
+ src/OpenAFP/Prelude/InstanceAFP/F.hs view
@@ -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+
+ src/OpenAFP/Prelude/InstanceAFP/G.hs view
@@ -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+
+ src/OpenAFP/Prelude/InstanceAFP/I.hs view
@@ -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+
+ src/OpenAFP/Prelude/InstanceAFP/L.hs view
@@ -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+
+ src/OpenAFP/Prelude/InstanceAFP/M.hs view
@@ -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+
src/OpenAFP/Prelude/InstancePTX.hs view
@@ -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
src/OpenAFP/Prelude/InstanceT.hs view
@@ -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)
src/OpenAFP/Prelude/Instances.hs view
@@ -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
src/OpenAFP/Prelude/Lookups.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts #-}  module OpenAFP.Prelude.Lookups where import OpenAFP.Types
src/OpenAFP/Prelude/Utils.hs view
@@ -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
src/OpenAFP/Records.hs view
@@ -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_
src/OpenAFP/Records/AFP.hs view
@@ -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 []
src/OpenAFP/Records/AFP/BAG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BAG where import OpenAFP.Types
src/OpenAFP/Records/AFP/BBC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BBC where import OpenAFP.Types
src/OpenAFP/Records/AFP/BCA.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BCA where import OpenAFP.Types
src/OpenAFP/Records/AFP/BCF.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BCF where import OpenAFP.Types
src/OpenAFP/Records/AFP/BCP.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BCP where import OpenAFP.Types
src/OpenAFP/Records/AFP/BDA.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BDA where import OpenAFP.Types
src/OpenAFP/Records/AFP/BDD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BDD where import OpenAFP.Types
src/OpenAFP/Records/AFP/BDG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BDG where import OpenAFP.Types
src/OpenAFP/Records/AFP/BDI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BDI where import OpenAFP.Types
src/OpenAFP/Records/AFP/BDM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BDM where import OpenAFP.Types
src/OpenAFP/Records/AFP/BDT.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BDT where import OpenAFP.Types
src/OpenAFP/Records/AFP/BDX.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BDX where import OpenAFP.Types
src/OpenAFP/Records/AFP/BFG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BFG where import OpenAFP.Types
src/OpenAFP/Records/AFP/BFM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BFM where import OpenAFP.Types
src/OpenAFP/Records/AFP/BFN.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BFN where import OpenAFP.Types
src/OpenAFP/Records/AFP/BGR.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BGR where import OpenAFP.Types
src/OpenAFP/Records/AFP/BII.hs view
@@ -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)
src/OpenAFP/Records/AFP/BIM.hs view
@@ -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)
src/OpenAFP/Records/AFP/BMM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BMM where import OpenAFP.Types
src/OpenAFP/Records/AFP/BMO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BMO where import OpenAFP.Types
src/OpenAFP/Records/AFP/BNG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BNG where import OpenAFP.Types
src/OpenAFP/Records/AFP/BOC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BOC where import OpenAFP.Types
src/OpenAFP/Records/AFP/BOG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BOG where import OpenAFP.Types
src/OpenAFP/Records/AFP/BPG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BPG where import OpenAFP.Types
src/OpenAFP/Records/AFP/BPM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BPM where import OpenAFP.Types
src/OpenAFP/Records/AFP/BPS.hs view
@@ -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)
src/OpenAFP/Records/AFP/BPT.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BPT where import OpenAFP.Types
src/OpenAFP/Records/AFP/BR.hs view
@@ -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)
src/OpenAFP/Records/AFP/BRG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BRG where import OpenAFP.Types
src/OpenAFP/Records/AFP/BSG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.BSG where import OpenAFP.Types
src/OpenAFP/Records/AFP/CAT.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.CAT where import OpenAFP.Types
src/OpenAFP/Records/AFP/CDD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.CDD where import OpenAFP.Types
src/OpenAFP/Records/AFP/CFC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.CFC where import OpenAFP.Types
src/OpenAFP/Records/AFP/CFI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.CFI where import OpenAFP.Types
src/OpenAFP/Records/AFP/CPC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.CPC where import OpenAFP.Types
src/OpenAFP/Records/AFP/CPD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.CPD where import OpenAFP.Types
src/OpenAFP/Records/AFP/CPI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.CPI where import OpenAFP.Types
src/OpenAFP/Records/AFP/CTC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.CTC where import OpenAFP.Types
src/OpenAFP/Records/AFP/DXD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.DXD where import OpenAFP.Types
src/OpenAFP/Records/AFP/EAG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EAG where import OpenAFP.Types
src/OpenAFP/Records/AFP/EBC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EBC where import OpenAFP.Types
src/OpenAFP/Records/AFP/ECA.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.ECA where import OpenAFP.Types
src/OpenAFP/Records/AFP/ECF.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.ECF where import OpenAFP.Types
src/OpenAFP/Records/AFP/ECP.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.ECP where import OpenAFP.Types
src/OpenAFP/Records/AFP/EDG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EDG where import OpenAFP.Types
src/OpenAFP/Records/AFP/EDI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EDI where import OpenAFP.Types
src/OpenAFP/Records/AFP/EDM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EDM where import OpenAFP.Types
src/OpenAFP/Records/AFP/EDT.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EDT where import OpenAFP.Types
src/OpenAFP/Records/AFP/EDX.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EDX where import OpenAFP.Types
src/OpenAFP/Records/AFP/EFG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EFG where import OpenAFP.Types
src/OpenAFP/Records/AFP/EFM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EFM where import OpenAFP.Types
src/OpenAFP/Records/AFP/EFN.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EFN where import OpenAFP.Types
src/OpenAFP/Records/AFP/EGR.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EGR where import OpenAFP.Types
src/OpenAFP/Records/AFP/EII.hs view
@@ -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)
src/OpenAFP/Records/AFP/EIM.hs view
@@ -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)
src/OpenAFP/Records/AFP/EMM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EMM where import OpenAFP.Types
src/OpenAFP/Records/AFP/EMO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EMO where import OpenAFP.Types
src/OpenAFP/Records/AFP/ENG.hs view
@@ -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)
src/OpenAFP/Records/AFP/EOC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EOC where import OpenAFP.Types
src/OpenAFP/Records/AFP/EOG.hs view
@@ -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)
src/OpenAFP/Records/AFP/EPG.hs view
@@ -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)
src/OpenAFP/Records/AFP/EPM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EPM where import OpenAFP.Types
src/OpenAFP/Records/AFP/EPS.hs view
@@ -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)
src/OpenAFP/Records/AFP/EPT.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.EPT where import OpenAFP.Types
src/OpenAFP/Records/AFP/ER.hs view
@@ -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)
src/OpenAFP/Records/AFP/ERG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.ERG where import OpenAFP.Types
src/OpenAFP/Records/AFP/ESG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.ESG where import OpenAFP.Types
src/OpenAFP/Records/AFP/FGD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.FGD where import OpenAFP.Types
src/OpenAFP/Records/AFP/FNC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.FNC where import OpenAFP.Types
src/OpenAFP/Records/AFP/FND.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.FND where import OpenAFP.Types
src/OpenAFP/Records/AFP/FNG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.FNG where import OpenAFP.Types
src/OpenAFP/Records/AFP/FNI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.FNI where import OpenAFP.Types
src/OpenAFP/Records/AFP/FNM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.FNM where import OpenAFP.Types
src/OpenAFP/Records/AFP/FNN.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.FNN where import OpenAFP.Types
src/OpenAFP/Records/AFP/FNO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.FNO where import OpenAFP.Types
src/OpenAFP/Records/AFP/FNP.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.FNP where import OpenAFP.Types
src/OpenAFP/Records/AFP/GAD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.GAD where import OpenAFP.Types
src/OpenAFP/Records/AFP/GDD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.GDD where import OpenAFP.Types
src/OpenAFP/Records/AFP/ICP.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.ICP where import OpenAFP.Types
src/OpenAFP/Records/AFP/IDD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.IDD where import OpenAFP.Types
src/OpenAFP/Records/AFP/IEL.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.IEL where import OpenAFP.Types
src/OpenAFP/Records/AFP/IID.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.IID where import OpenAFP.Types
src/OpenAFP/Records/AFP/IMM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.IMM where import OpenAFP.Types
src/OpenAFP/Records/AFP/IOB.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.IOB where import OpenAFP.Types
src/OpenAFP/Records/AFP/IOC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.IOC where import OpenAFP.Types
src/OpenAFP/Records/AFP/IPD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.IPD where import OpenAFP.Types
src/OpenAFP/Records/AFP/IPG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.IPG where import OpenAFP.Types
src/OpenAFP/Records/AFP/IPO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.IPO where import OpenAFP.Types
src/OpenAFP/Records/AFP/IPS.hs view
@@ -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)
src/OpenAFP/Records/AFP/IRD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.IRD where import OpenAFP.Types
src/OpenAFP/Records/AFP/LLE.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.LLE where import OpenAFP.Types
src/OpenAFP/Records/AFP/LNC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.LNC where import OpenAFP.Types
src/OpenAFP/Records/AFP/LND.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.LND where import OpenAFP.Types
src/OpenAFP/Records/AFP/MBC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MBC where import OpenAFP.Types
src/OpenAFP/Records/AFP/MCA.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MCA where import OpenAFP.Types
src/OpenAFP/Records/AFP/MCC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MCC where import OpenAFP.Types
src/OpenAFP/Records/AFP/MCD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MCD where import OpenAFP.Types
src/OpenAFP/Records/AFP/MCF.hs view
@@ -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
src/OpenAFP/Records/AFP/MCF1.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MCF1 where import OpenAFP.Types
src/OpenAFP/Records/AFP/MDD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MDD where import OpenAFP.Types
src/OpenAFP/Records/AFP/MDR.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MDR where import OpenAFP.Types
src/OpenAFP/Records/AFP/MFC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MFC where import OpenAFP.Types
src/OpenAFP/Records/AFP/MGO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MGO where import OpenAFP.Types
src/OpenAFP/Records/AFP/MIO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MIO where import OpenAFP.Types
src/OpenAFP/Records/AFP/MMC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MMC where import OpenAFP.Types
src/OpenAFP/Records/AFP/MMO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MMO where import OpenAFP.Types
src/OpenAFP/Records/AFP/MMT.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MMT where import OpenAFP.Types
src/OpenAFP/Records/AFP/MPG.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MPG where import OpenAFP.Types
src/OpenAFP/Records/AFP/MPO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MPO where import OpenAFP.Types
src/OpenAFP/Records/AFP/MPS.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MPS where import OpenAFP.Types
src/OpenAFP/Records/AFP/MSU.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.MSU where import OpenAFP.Types
src/OpenAFP/Records/AFP/NOP.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.NOP where import OpenAFP.Types
src/OpenAFP/Records/AFP/OBD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.OBD where import OpenAFP.Types
src/OpenAFP/Records/AFP/OBP.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.OBP where import OpenAFP.Types
src/OpenAFP/Records/AFP/OCD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.OCD where import OpenAFP.Types
src/OpenAFP/Records/AFP/PFC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.PFC where import OpenAFP.Types
src/OpenAFP/Records/AFP/PGD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.PGD where import OpenAFP.Types
src/OpenAFP/Records/AFP/PGP.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.PGP where import OpenAFP.Types
src/OpenAFP/Records/AFP/PGP1.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.PGP1 where import OpenAFP.Types
src/OpenAFP/Records/AFP/PMC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.PMC where import OpenAFP.Types
src/OpenAFP/Records/AFP/PTD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.PTD where import OpenAFP.Types
src/OpenAFP/Records/AFP/PTD1.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-}  module OpenAFP.Records.AFP.PTD1 where import OpenAFP.Types
src/OpenAFP/Records/AFP/PTX.hs view
@@ -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
src/OpenAFP/Records/AFP/TLE.hs view
@@ -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)
src/OpenAFP/Records/MCF/T.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.MCF.T where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/AMB.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.AMB where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/AMI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.AMI where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/BLN.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.BLN where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/BSU.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.BSU where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/DBR.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.DBR where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/DIR.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.DIR where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/ESU.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.ESU where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/NOP.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.NOP where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/RMB.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.RMB where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/RMI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.RMI where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/RPS.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.RPS where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/SBI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.SBI where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/SCFL.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.SCFL where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/SIA.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.SIA where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/SIM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.SIM where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/STC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.STC where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/STO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.STO where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/SVI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.SVI where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/PTX/TRN.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.PTX.TRN where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T.hs view
@@ -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
src/OpenAFP/Records/T/AD.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.AD where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/AQ.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.AQ where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/AV.hs view
@@ -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)
src/OpenAFP/Records/T/C.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.C where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/CF.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.CF where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/CGCSGI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.CGCSGI where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/CR.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.CR where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/CS.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.CS where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/DP.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.DP where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/EF.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.EF where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/ERLI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.ERLI where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/ESI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.ESI where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/FCGCSGI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.FCGCSGI where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/FDS.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.FDS where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/FF.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.FF where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/FHSF.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.FHSF where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/FO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.FO where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/FQN.hs view
@@ -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)
src/OpenAFP/Records/T/FRMT.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.FRMT where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/II.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.II where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/LDOPM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.LDOPM where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/LDTS.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.LDTS where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/MA.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.MA where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/MEC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.MEC where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/MF.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.MF where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/MIS.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.MIS where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/MMPN.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.MMPN where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/MO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.MO where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/MOR.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.MOR where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/OAMU.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.OAMU where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/OAS.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.OAS where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/OBE.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.OBE where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/OBO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.OBO where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/OCH.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.OCH where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/OCL.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.OCL where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/OCO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.OCO where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/OFSS.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.OFSS where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/OO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.OO where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/OOI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.OOI where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/OSFE.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.OSFE where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/OSFO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.OSFO where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/PC.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.PC where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/POCP.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.POCP where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/PPI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.PPI where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/PSMR.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.PSMR where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/PSRM.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.PSRM where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/PV.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.PV where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/RLI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.RLI where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/ROI.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.ROI where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/ROT.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.ROT where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/RSN.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.RSN where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/RUA.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.RUA where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/T1CRMT.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.T1CRMT where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/T2FRMT.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.T2FRMT where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/TO.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.TO where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/TS.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.TS where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Records/T/UDTS.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS -fglasgow-exts -funbox-strict-fields #-} module OpenAFP.Records.T.UDTS where import OpenAFP.Types import OpenAFP.Internals
src/OpenAFP/Types.hs view
@@ -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
src/OpenAFP/Types/Buffer.hs view
@@ -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)+
src/OpenAFP/Types/Chunk.hs view
@@ -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])
src/OpenAFP/Types/Record.hs view
@@ -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
src/OpenAFP/Types/View.hs view
@@ -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)