hprotoc-fork (empty) → 2.0.16
raw patch · 21 files changed
+6622/−0 lines, 21 filesdep +arraydep +basedep +binarysetup-changed
Dependencies added: array, base, binary, bytestring, containers, directory, filepath, haskell-src-exts, mtl, parsec, protocol-buffers-descriptor-fork, protocol-buffers-fork, utf8-string
Files
- LICENSE +11/−0
- README +11/−0
- Setup.hs +2/−0
- Text/ProtocolBuffers/ProtoCompile.hs +266/−0
- Text/ProtocolBuffers/ProtoCompile/BreakRecursion.hs +503/−0
- Text/ProtocolBuffers/ProtoCompile/Gen.hs +882/−0
- Text/ProtocolBuffers/ProtoCompile/Identifiers.hs +215/−0
- Text/ProtocolBuffers/ProtoCompile/Instances.hs +85/−0
- Text/ProtocolBuffers/ProtoCompile/Lexer.x +200/−0
- Text/ProtocolBuffers/ProtoCompile/MakeReflections.hs +315/−0
- Text/ProtocolBuffers/ProtoCompile/Parser.hs +624/−0
- Text/ProtocolBuffers/ProtoCompile/Resolve.hs +1380/−0
- dist/build/Text/ProtocolBuffers/ProtoCompile/Lexer.hs +548/−0
- dist/build/hprotoc/hprotoc-tmp/Text/ProtocolBuffers/ProtoCompile/Lexer.hs +548/−0
- google-proto-files/google/protobuf/descriptor.proto +533/−0
- google-proto-files/google/protobuf/plugin.proto +145/−0
- hprotoc-fork.cabal +130/−0
- protoc-gen-haskell/Text/Google/Protobuf/Compiler.hs +20/−0
- protoc-gen-haskell/Text/Google/Protobuf/Compiler/CodeGeneratorRequest.hs +70/−0
- protoc-gen-haskell/Text/Google/Protobuf/Compiler/CodeGeneratorResponse.hs +67/−0
- protoc-gen-haskell/Text/Google/Protobuf/Compiler/CodeGeneratorResponse/File.hs +67/−0
+ LICENSE view
@@ -0,0 +1,11 @@+Copyright (c) 2008, Christopher Edward Kuklewicz+All rights reserved.++Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:++ * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.+ * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.+ * Neither the name of the copyright holder nor the names of the contributors may be used to endorse or promote products derived from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.+hi
+ README view
@@ -0,0 +1,11 @@+To regenerate the plugin haskell files, please run++hprotoc -u --prefix=Text -d protoc-gen-haskell -I google-proto-files/ google/protobuf/plugin.proto ++This was last populated from version 2.4.0a of Google's code.++Also, one can invoke cabal build to make dist/autogen and then++ghci -package parsec-2.1.0.1 -idist/build/autogen -iprotoc-gen-haskell Text/ProtocolBuffers/ProtoCompile.hs++should work.
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMainWithHooks defaultUserHooks
+ Text/ProtocolBuffers/ProtoCompile.hs view
@@ -0,0 +1,266 @@+-- | This is the Main module for the command line program 'hprotoc'+module Main where++import Control.Monad(unless,forM_)+import Control.Monad.State(State, execState, modify)+import qualified Data.ByteString.Lazy.Char8 as LC (hGetContents, hPut, pack, unpack)+import Data.Foldable (toList)+import qualified Data.Sequence as Seq (fromList,singleton)+import Data.Sequence ((|>))+import Data.Version(showVersion)+import Language.Haskell.Exts.Pretty(prettyPrintStyleMode,Style(..),Mode(..),PPHsMode(..),PPLayout(..))+import System.Console.GetOpt(OptDescr(Option),ArgDescr(NoArg,ReqArg)+ ,usageInfo,getOpt,ArgOrder(ReturnInOrder))+import System.Directory(getCurrentDirectory,createDirectoryIfMissing)+import System.Environment(getProgName, getArgs)+import System.FilePath(takeDirectory,combine,joinPath)+import qualified System.FilePath.Posix as Canon(takeBaseName)+import System.IO (stdin, stdout)++import Text.ProtocolBuffers.Basic(defaultValue, Utf8(..), utf8)+import Text.ProtocolBuffers.Identifiers(MName,checkDIString,mangle)+import Text.ProtocolBuffers.Reflections(ProtoInfo(..),EnumInfo(..))+import Text.ProtocolBuffers.WireMessage (messagePut, messageGet)++import qualified Text.DescriptorProtos.FileDescriptorProto as D(FileDescriptorProto)+import qualified Text.DescriptorProtos.FileDescriptorProto as D.FileDescriptorProto(FileDescriptorProto(..))+-- import qualified Text.DescriptorProtos.FileDescriptorSet as D(FileDescriptorSet)+import qualified Text.DescriptorProtos.FileDescriptorSet as D.FileDescriptorSet(FileDescriptorSet(..))++import Text.ProtocolBuffers.ProtoCompile.BreakRecursion(makeResult)+import Text.ProtocolBuffers.ProtoCompile.Gen(protoModule,descriptorModules,enumModule)+import Text.ProtocolBuffers.ProtoCompile.MakeReflections(makeProtoInfo,serializeFDP)+import Text.ProtocolBuffers.ProtoCompile.Resolve(loadProto,loadCodeGenRequest,makeNameMaps,getTLS+ ,Env,LocalFP(..),CanonFP(..),TopLevel(..))++import Text.Google.Protobuf.Compiler.CodeGeneratorRequest+import Text.Google.Protobuf.Compiler.CodeGeneratorResponse hiding (error, file)+import qualified Text.Google.Protobuf.Compiler.CodeGeneratorResponse as CGR(file)+import qualified Text.Google.Protobuf.Compiler.CodeGeneratorResponse.File as CGR.File++-- The Paths_hprotoc module is produced by cabal+import Paths_hprotoc(version)++data Options = Options { optPrefix :: [MName String]+ , optAs :: [(CanonFP,[MName String])]+ , optTarget :: LocalFP+ , optInclude :: [LocalFP]+ , optProto :: LocalFP+ , optDesc :: Maybe (LocalFP)+ , optImports,optVerbose,optUnknownFields,optLazy,optDryRun :: Bool }+ deriving Show++setPrefix,setTarget,setInclude,setProto,setDesc :: String -> Options -> Options+setImports,setVerbose,setUnknown,setLazy,setDryRun :: Options -> Options+setPrefix s o = o { optPrefix = toPrefix s }+setTarget s o = o { optTarget = (LocalFP s) }+setInclude s o = o { optInclude = LocalFP s : optInclude o }+setProto s o = o { optProto = LocalFP s }+setDesc s o = o { optDesc = Just (LocalFP s) }+setImports o = o { optImports = True }+setVerbose o = o { optVerbose = True }+setUnknown o = o { optUnknownFields = True }+setLazy o = o { optLazy = True }+setDryRun o = o { optDryRun = True }++toPrefix :: String -> [MName String]+toPrefix s = case checkDIString s of+ Left msg -> error $ "Bad module name in options:"++show s++"\n"++msg+ Right (True,_) -> error $ "Bad module name in options (cannot start with '.'): "++show s+ Right (False,ms) -> map mangle ms++-- | 'setAs' puts both the full path and the basename as keys into the association list+setAs :: String -> Options -> Options+setAs s o =+ case break ('='==) s of+ (filepath,'=':rawPrefix) -> let value = toPrefix rawPrefix+ in o { optAs = (CanonFP filepath,value):+ (CanonFP (Canon.takeBaseName filepath),value):+ optAs o}+ _ -> error . unlines $ [ "Malformed -a or --as option "++show s+ , " Expected \"FILEPATH=MODULE\""+ , " where FILEPATH is the basename or relative path (using '/') of an imported file"+ , " where MODULE is a dotted Haskell name to use as a prefix"+ , " also MODULE can be empty to have no prefix" ]++data OptionAction = Mutate (Options->Options) | Run (Options->Options) | Switch Flag++data Flag = VersionInfo++optionList :: [OptDescr OptionAction]+optionList =+ [ Option ['a'] ["as"] (ReqArg (Mutate . setAs) "FILEPATH=MODULE")+ "assign prefix module to imported proto file: --as descriptor.proto=Text"+ , Option ['I'] ["proto_path"] (ReqArg (Mutate . setInclude) "DIR")+ "directory from which to search for imported proto files (default is pwd); all DIR searched"+ , Option ['d'] ["haskell_out"] (ReqArg (Mutate . setTarget) "DIR")+ "directory to use are root of generated files (default is pwd); last flag"+ , Option ['n'] ["dry_run"] (NoArg (Mutate setDryRun))+ "produce no output but still parse and check the proto file(s)"+ , Option ['o'] ["descriptor_set_out"] (ReqArg (Mutate . setDesc) "FILE")+ "filename to write binary FileDescriptorSet to"+ , Option [] ["include_imports"] (NoArg (Mutate setImports))+ "when writing descriptor_set_out include all imported files to be self-contained"+ , Option ['p'] ["prefix"] (ReqArg (Mutate . setPrefix) "MODULE")+ "dotted Haskell MODULE name to use as a prefix (default is none); last flag used"+ , Option ['u'] ["unknown_fields"] (NoArg (Mutate setUnknown))+ "generated messages and groups all support unknown fields"+ , Option ['l'] ["lazy_fields"] (NoArg (Mutate setLazy))+ "new default is now messages with strict fields, this reverts to generating lazy fields"+ , Option ['v'] ["verbose"] (NoArg (Mutate setVerbose))+ "increase amount of printed information"+ , Option [] ["version"] (NoArg (Switch VersionInfo))+ "print out version information"+ ]++usageMsg,versionInfo :: String+usageMsg = usageInfo "Usage: protoCompile [OPTION..] path-to-file.proto ..." optionList++versionInfo = unlines $+ [ "Welcome to protocol-buffers version "++showVersion version+ , "Copyright (c) 2008-2011, Christopher Kuklewicz."+ , "Released under BSD3 style license, see LICENSE file for details."+ , "Some proto files, such as descriptor.proto and unittest*.proto"+ , "are from google's code and are under an Apache 2.0 license."+ , ""+ , "Most command line arguments are similar to those of 'protoc'."+ , ""+ , "This program reads a .proto file and generates haskell code files."+ , "See http://code.google.com/apis/protocolbuffers/docs/overview.html for more."+ ]++processOptions :: [String] -> Either String [OptionAction]+processOptions argv =+ case getOpt (ReturnInOrder (Run . setProto)) optionList argv of+ (opts,_,[]) -> Right opts+ (_,_,errs) -> Left (unlines errs ++ usageMsg)++defaultOptions :: IO Options+defaultOptions = do+ pwd <- fmap LocalFP getCurrentDirectory+ return $ Options { optPrefix = []+ , optAs = []+ , optTarget = pwd+ , optInclude = [pwd]+ , optProto = LocalFP ""+ , optDesc = Nothing+ , optImports = False+ , optVerbose = False+ , optUnknownFields = False+ , optLazy = False+ , optDryRun = False }++main :: IO ()+main = do+ progName <- getProgName+ case progName of+ "protoc-gen-haskell" -> pluginMain+ _ -> standaloneMain++pluginMain :: IO ()+pluginMain = do+ defs <- defaultOptions+ inputBytes <- LC.hGetContents stdin+ let req = either error fst $ messageGet inputBytes+ let prefix = fmap (LC.unpack . utf8) $ parameter req+ let opts = maybe defs (flip setPrefix $ defs) prefix+ let resp = runPlugin opts req+ LC.hPut stdout $ messagePut resp++standaloneMain :: IO ()+standaloneMain = do+ defs <- defaultOptions+ args <- getArgs+ case processOptions args of+ Left msg -> putStrLn msg+ Right todo -> process defs todo++process :: Options -> [OptionAction] -> IO ()+process options [] = if null (unLocalFP (optProto options))+ then do putStrLn "No proto file specified (or empty proto file)"+ putStrLn ""+ putStrLn usageMsg+ else putStrLn "Processing complete, have a nice day."+process options (Mutate f:rest) = process (f options) rest+process options (Run f:rest) = let options' = f options+ in runStandalone options' >> process options' rest+process _options (Switch VersionInfo:_) = putStrLn versionInfo+ +mkdirFor :: FilePath -> IO ()+mkdirFor p = createDirectoryIfMissing True (takeDirectory p)++style :: Style+style = Style PageMode 132 0.6++myMode :: PPHsMode+myMode = PPHsMode 2 2 2 2 4 1 True PPOffsideRule False -- True++dump :: (Monad m) => Output m -> Bool -> Maybe LocalFP -> D.FileDescriptorProto -> [D.FileDescriptorProto] -> m ()+dump _ _ Nothing _ _ = return ()+dump o imports (Just (LocalFP dumpFile)) fdp fdps = do+ outputReport o $ "dumping to filename: "++show dumpFile+ let s = if imports then Seq.fromList fdps else Seq.singleton fdp+ outputWriteFile o dumpFile $ LC.unpack (messagePut $ defaultValue { D.FileDescriptorSet.file = s })+ outputReport o $ "finished dumping FileDescriptorSet binary of: "++show (D.FileDescriptorProto.name fdp)++data (Monad m) => Output m = Output {+ outputReport :: String -> m (),+ outputWriteFile :: FilePath -> String -> m ()+}++runStandalone :: Options -> IO ()+runStandalone options = do+ (env,fdps) <- loadProto (optInclude options) (optProto options)+ putStrLn "All proto files loaded"+ run' standaloneMode options env fdps where+ standaloneMode :: Output IO+ standaloneMode = Output putStrLn emitFile+ emitFile file contents = do+ let fullPath = combine (unLocalFP . optTarget $ options) file+ putStrLn fullPath+ mkdirFor fullPath+ unless (optDryRun options) $ writeFile fullPath contents++runPlugin :: Options -> CodeGeneratorRequest -> CodeGeneratorResponse+runPlugin options req = execState (run' pluginOutput options env fdps) defaultValue where+ (env,fdps) = loadCodeGenRequest req (head requestedFiles)+ pluginOutput :: Output (State CodeGeneratorResponse)+ pluginOutput = Output {+ outputReport = const $ return (),+ outputWriteFile = appendFileRecord+ }+ appendFileRecord :: FilePath -> String -> State CodeGeneratorResponse ()+ appendFileRecord f c = modify $ \resp -> resp {+ CGR.file = (CGR.file resp) |> newFile+ } where+ newFile = defaultValue {+ CGR.File.name = Just $ Utf8 $ LC.pack f,+ CGR.File.content = Just $ Utf8 $ LC.pack c+ }+ requestedFiles = map (LocalFP . LC.unpack . utf8) . toList . file_to_generate $ req++-- This run' operates for both runStandalone and runPlugin+run' :: (Monad m) => Output m -> Options -> Env -> [D.FileDescriptorProto] -> m ()+run' o@(Output print' writeFile') options env fdps = do+ let fdp = either error id . top'FDP . fst . getTLS $ env+ unless (optDryRun options) $ dump o (optImports options) (optDesc options) fdp fdps+ -- Compute the nameMap that determine how to translate from proto names to haskell names+ -- This is the part that uses the (optional) package name+ nameMap <- either error return $ makeNameMaps (optPrefix options) (optAs options) env+ print' "Haskell name mangling done"+ let protoInfo = makeProtoInfo (optUnknownFields options,optLazy options) nameMap fdp+ result = makeResult protoInfo+ seq result (print' "Recursive modules resolved")+ let produceMSG di = do+ unless (optDryRun options) $ do+ -- There might be several modules+ let fileModules = descriptorModules result di+ forM_ fileModules $ \ (relPath,modSyn) -> do+ writeFile' relPath (prettyPrintStyleMode style myMode modSyn)+ produceENM ei = do+ let file = joinPath . enumFilePath $ ei+ writeFile' file (prettyPrintStyleMode style myMode (enumModule ei))+ mapM_ produceMSG (messages protoInfo)+ mapM_ produceENM (enums protoInfo)+ let file = joinPath . protoFilePath $ protoInfo+ writeFile' file (prettyPrintStyleMode style myMode (protoModule result protoInfo (serializeFDP fdp)))
+ Text/ProtocolBuffers/ProtoCompile/BreakRecursion.hs view
@@ -0,0 +1,503 @@+{-| Analysis and design of this module++If there are SCCs then additional files are inevitable.+Separate files to define the keys are usually avoidable.+Separating Key definitions are needed only if the key imports form a SCC,+and even these may be sometimes avoided by declaring keys in boot files.++Choose to minimize the create of separate Key-desf definitions by+locating and breaking the key SCCs first. Use the "score" to pick a+single vertex at a time to greedily minimize the number of separate+Key-defs. After this initial step the set of separate Key-defs is+fixed.++With this understanding, there are FOUR renderings of a descriptor.+Two renderings have non-separate Key-defs (or no Key-defs at all).+Two renderings have separate Key-defs.++The two non-separate Key-defs renderings are:++"simple" :+ * normal file with the type-def and any Key-defs++"type-boot" :+ * normal file with the type-def and any Key-defs+ - hs-boot file declares the type-def++The other two have separate Key-defs, in ".hs-boot" or "'Key.hs" files:++"key-type-boot" :+ + normal file with the type-def and the Key-defs+ * hs-boot file declares the type-def and the Key-defs++"split-key,type-boot" :+ + normal file with the type-def and maybe imports keyfile+ * keyfile file with the the Key-defs+ - hs-boot file declares the type-def++In general, all nodes without keys could be rendered as "type-boot"+and all nodes with keys as "split-key,type-boot", which would break+all SCCs. But that is wasteful: 2 or 3 files each (2 for root+ProtoInfo file). And this waste will also lead to warnings from ghc+nagging about unneeded {-# SOURCE #-} pragmas.++Only the files marked with * have incoming and outgoing edges and NEED+to be considered. With enough {-# SOURCE #-} pragmas, the + are+just sources and - are just sinks.++Initially all renderings are optimistically Simple. Some are quickly+changed into TypeBoot by observing the modules which import foreign+keys and marking the reciprocal type imports as TypeBoot.++The next task is to break the SCCs which arise just from the foreign+key imports. The algorithm makes a graph of these and breaks all of+them by changing the one with the best score from a TypeBoot node into+a KeyTypeBoot node.++Note: The top protoInfo node will be rendered like "simple" as+TopProtoInfo and never change. The most that happens to the top+protoInfo node is that its targets get changed and some imports get+SOURCE pragmas.++Now considering both type and key imports as links, more SCCs+might arise. These are also scored. The thing to grasp is how+changing a message's rending is allowed to happen:++TopProtoInfo will never change+Simple may become TypeBoot+TypeBoot will never change+KeyTypeBoot may become SplitKeyTypeBoot+SplitKeyTypeBoot will never change++It always possible to choose a vertex in any SCC that can change,+which is not obvious. The deduction is that if all vertices in the+SCC are unchanging then there are no internal type import links; thus+the only loops being created are with foreign key imports. The+initial setup broke all SCCs made only of foreign key imports; thus+this stuck SCC is a contradiction.++The best score is the choice that reduces the size of the scc in the+next round (and secondarily increases the number of sub-SCCs).++The final Result is a Map of names to the non-Simple/TopProtoInfo+renderings and a list of "pairs" (a,p,b) where part 'p' of module 'a'+should import the type defined in 'b' using a SOURCE pragma. Keys+from messages rendered as KeyTypeBoot should be imported using SOURCE+pragmas. Keys from messages rendered as SplitKeyTypeBoot should be+imported from the auxiliary 'Key files.++The code below is more complicated in order to reduce the SOURCE+pragmas and avoid ghc's warnings. All files are tracked and SOURCE+pragmas are added in steps. This is unlikely to be perfect — some+extra SOURCE pragmas might be left over, but I do not have an example+of this happening. This also means a DescriptorInfo may have several+file parts and these may end up in different SCCs. To simplify+processing these different SCCs which share a DescriptorInfo are+merged by 'rejoinVertices'.++-}++module Text.ProtocolBuffers.ProtoCompile.BreakRecursion+ ( makeResult,displayResult,Result(..),VertexKind(..),Part(..),pKey,pfKey,getKind ) where++import Prelude hiding (pi)+import Control.Monad(guard,mplus)+import qualified Data.Foldable as F+import Data.Function(on)+import Data.Graph+import Data.List+import qualified Data.Map as Map+import Data.Map(Map)+import Data.Maybe(mapMaybe)+import Data.Monoid+import qualified Data.Set as Set+import Data.Set(Set)+import Text.ProtocolBuffers.Basic+import Text.ProtocolBuffers.Identifiers+import Text.ProtocolBuffers.Reflections++import Debug.Trace(trace)++ecart :: String -> a -> a+ecart _ a = a++fst3 :: (a,b,c) -> a+fst3 (x,_,_) = x++snd3 :: (a,b,c) -> b+snd3 (_,x,_) = x++imp :: String -> a+imp s = error $ "Inconceivable! Text.ProtocolBuffers.ProtoCompile.BreakRecursion."++s++iguard :: Monad m => Bool -> String -> m ()+iguard True _ = return ()+iguard False s = imp s++-- The Gen.hs module will be working with these String types+type MKey = FMName String++pKey :: ProtoName -> MKey+pKey (ProtoName {haskellPrefix=a,parentModule=b,baseName=c}) = foldr1 dotFM . map promoteFM $ a++b++[c]++pfKey :: ProtoFName -> MKey+pfKey (ProtoFName {haskellPrefix'=a,parentModule'=b}) = foldr1 dotFM . map promoteFM $ a++b++-- Which reprensentation a message currently has+data VertexKind = TopProtoInfo+ | Simple+ | TypeBoot+ | KeyTypeBoot+ | SplitKeyTypeBoot+ deriving (Show,Eq,Ord)++-- Which of the 3 sorts of files (maked with * in analysis) a vertex represents+data Part = Normal | Source | KeyFile deriving (Show,Eq,Ord)++-- Vertex data. A graph may have several nodes with the same value of+-- V and different values of Part.+data V = V { vMKey :: !MKey+ , vNeedsKeys :: !(Set MKey)+ , vKeysNeedsTypes :: !(Set MKey)+ , vTypeNeedsTypes :: !(Set MKey) }+ deriving Show++-- A link to a module's file+data Label = L !Part !MKey deriving (Show,Eq,Ord)++type E = (V,Label,[Label])+type G = [E]+type SCCs = [G]++-- The end product of this module is the Result value+data Result = Result { rKind :: Map MKey VertexKind+ , rIBoot :: Set (MKey,Part,MKey)+ , rIKey :: Set (MKey,MKey) }+ deriving Eq++displayResult :: Result -> String+displayResult (Result {rKind = kv, rIBoot = ab, rIKey=ab'keys }) = unlines $+ [ "--- displayResult ----"+ , "Modules which are not Simple"+ ] ++ map (\(k,v) -> indent . shows (fmName k) . (" has kind "++) $ show v) (Map.assocs kv) +++ [ "Module imports marked with SOURCE for Types"+ ] ++ map (indent . untriple) (Set.toAscList ab) +++ [ "Module imports marked with SOURCE or 'Key for keys"+ ] ++ map (indent . unpair) (Set.toAscList ab'keys)+ where indent = (' ':).(' ':)+ untriple (a,p,b) = fmName a ++ " " ++ show p ++ " : import {-# SOURCE #-} " ++ fmName b+ unpair (a,b) = fmName a ++ " : import {-# SOURCE or 'Key #-} " ++ fmName b++showSCCs :: SCCs -> String+showSCCs gs = concatMap (\ g -> "\n>< SCC Graph ><\n"++concatMap showE g) gs+showG :: G -> String+showG g = '\n':concatMap showE g+showE :: E -> String+showE (v,n,ls) = unlines $ [ "( "++show n, " , "++show v, " , "++show ls, ")" ]++instance Monoid Result where+ mempty = Result mempty mempty mempty+ mappend r1 r2 = Result { rKind = Map.unionWith max (rKind r1) (rKind r2)+ , rIBoot = mappend (rIBoot r1) (rIBoot r2)+ , rIKey = mappend (rIKey r1) (rIKey r2) }++getKind :: Result -> MKey -> VertexKind+getKind r = let m = rKind r in \n -> Map.findWithDefault Simple n m++getType :: VertexKind -> Part+getType TopProtoInfo = imp "getType: TopProtoInfo"+getType Simple = Normal+getType TypeBoot = Source+getType KeyTypeBoot = Source+getType SplitKeyTypeBoot = Source++getKey :: VertexKind -> Part+getKey TopProtoInfo = Normal+getKey Simple = Normal+getKey TypeBoot = Normal+getKey KeyTypeBoot = Source+getKey SplitKeyTypeBoot = KeyFile++-- 'makeResult' is the main function for this module+makeResult :: ProtoInfo -> Result+makeResult protoInfo =+ let pvs@(p,vs) = makeVertices protoInfo+ initResult = breakKeys pvs+ sccs = cycles (makeG (p:vs) initResult)+ answer = cull (p:vs) $ breakGraph initResult sccs+ finalGraph = makeG (p:vs) answer+ remainingProblems = cycles finalGraph+ msg = unlines [ "<!!!!!!!!!!!> KLAXON, RED SPINNING LIGHT, ETC."+ , "! WARNING: hprotoc unexpectedly failed to disentangle all the mutually-recursive message definitions."+ , "! PLEASE REPORT THIS FAILURE ALONG WITH THE PROTO FILE."+ , "! The failed subset is:"+ ] ++ showSCCs remainingProblems ++ "\n</!!!!!!!!!!!>"+ in if null remainingProblems then ecart (showG finalGraph) answer+ else trace msg answer++-- Build the graph using the vertices and the Result so far.+makeG :: [V] -> Result -> G+makeG vs r = concatMap (makeEdgesForV r) vs++-- Returns all as Simple and Normal. The fst V is from the ProtoInfo+-- the snd [V] is from the DescriptorInfo.+makeVertices :: ProtoInfo -> (V,[V])+makeVertices pi = answer where+ answer = ( protoInfoV , map makeV (messages pi) )++ protoInfoV = V { vMKey = pKey (protoMod pi)+ , vNeedsKeys = mempty+ , vKeysNeedsTypes = knt (extensionKeys pi)+ , vTypeNeedsTypes = mempty }++ makeV di = V { vMKey = pKey (descName di)+ , vNeedsKeys = nk (knownKeys di)+ , vKeysNeedsTypes = knt (keys di)+ , vTypeNeedsTypes = tnt (fields di) }++ allK = Set.fromList (pKey (protoMod pi) : map (pKey . descName) (messages pi))+ allT = Set.fromList (map (pKey . descName) (messages pi))++ tnt :: Seq FieldInfo -> Set MKey+ tnt fs = Set.intersection allT $ Set.fromList $ map pKey . mapMaybe typeName . F.toList $ fs++ knt :: Seq KeyInfo -> Set MKey+ knt ks =+ let (pns, fsL) = unzip (F.toList ks)+ fnt :: [FieldInfo] -> Set MKey+ fnt fs = Set.fromList $ (map pKey . mapMaybe typeName $ fs) ++ (map (pfKey . fieldName) fs)+ in Set.intersection allT $ Set.union (Set.fromList (map pKey pns)) (fnt fsL)++ nk :: Seq FieldInfo -> Set MKey+ nk fs = Set.intersection allK $ Set.fromList $ map (pfKey . fieldName) . F.toList $ fs++-- The only need for KeyTypeBoot (and SplitKeyTypeBoot) is to break+-- key-only import cycles. 'breakKeys' finds and breaks these SSCs by+-- marking files as KeyTypeBoot. Since foreign keys implies a+-- reciprocal type import, additional files can get changed to+-- TypeBoot and some incoming links marked to use Source.+breakKeys :: (V,[V]) -> Result+breakKeys (pv,vsOther) =+ let vs = pv : vsOther+ es = map makeInitialEdges vs where+ makeInitialEdges v = (v,L Normal self,[ L Normal b | b <- Set.toList (vNeedsKeys v), b/=self ])+ where self = vMKey v+ -- For 'a'/='b': if 'a' needs key from 'b' then 'b' must need type from 'a'+ -- this recursion means 'a' cannot be Simple so change to TypeBoot+ startingResult = Result { rKind = needTypeBoot, rIBoot = mempty, rIKey = mempty }+ needTypeBoot = Map.singleton (vMKey pv) TopProtoInfo `Map.union`+ ( Map.fromList . map (\(_,L _ a,_) -> (a,TypeBoot))+ . filter (\(_,_,bLs) -> not (null bLs)) $ es )+ -- break always moves things to KeyTypeBoot from TypeBoot (not+ -- Simple) because they are in a Key-import SCC: this means they+ -- are importing foreign keys and thus they are in needTypeBoot+ breakSCCs :: Result -> SCCs -> Result+ breakSCCs r sccs = r `mappend` mconcat (map breakSCC sccs)+ breakSCC :: G -> Result+ breakSCC [] = imp $ "breakKeys.breakSCC: The SCC cannot be empty!"+ breakSCC es' = let (toBust,next'sccs) = snd $ maximumBy (compare `on` fst) (map f (pullEach es'))+ where f ((v,_,_),es'') = let (s,sccs) = score es'' in (s,(v,sccs))+ bk = vMKey toBust -- ZZZ + ik = Set.fromList [ (ek,bk) | ek <- map (vMKey . fst3) es', ek/=bk ] -- ZZZ+ newResult = Result { rKind = Map.singleton bk KeyTypeBoot+ , rIBoot = mempty+ , rIKey = ik } -- ZZZ+ in breakSCCs newResult next'sccs+ -- Init boot marks some incoming links to use SOURCE+ initBoot r = r { rIBoot = Set.fromList . concatMap withParts $ es }+ where withParts (_,L _ a,bLs) = [ withPart a b | L _ b <- bLs ]+ withPart a b = let p = getKey (getKind r b) in (b,p,a)+ in initBoot $ breakSCCs startingResult (cycles es)++score :: G -> ( (Int,Int), SCCs )+score es = ((value,parts),sccs) where+ sccs = cycles es+ -- A length n SCC can be solved by changing at most (n-1) vertices+ -- The value is the difference between the+ -- old graph which required at most (pred . length) ed changes+ -- and the new graphs which require at most (sum (map (pred . length) sccs)) changes+ -- so a larger value is preferred+ value = (pred . length) es - (sum (map (pred . length) sccs))+ -- The number of parts is used as a potential tie breaker, prefering more parts+ parts = length sccs -- # of pieces++-- select the non-trivial sccs from edges+cycles :: G -> SCCs+cycles = filter atLeastTwo . map flattenSCC . stronglyConnCompR+ where atLeastTwo :: [a] -> Bool+ atLeastTwo (_:_:_) = True+ atLeastTwo _ = False++-- pull out each element as candidate and list without the element+pullEach :: [a] -> [(a,[a])]+pullEach = go id where go _ [] = []+ go f (x:xs) = (x,f xs) : go (f . (x:)) xs++-- This builds an edge E from the vertex V and ensures that V has the+-- right vKind from the Result. This must make the same judgements as+-- Gen.hs does in importPN and import PFN+makeEdgesForV :: Result -> V -> [E]+makeEdgesForV r v =+ let me = vMKey v; myKind = getK me+ getK = getKind r; self p = L p me;+ typeL p n = if Set.notMember (me,p,n) (rIBoot r) then L Normal n+ else let checkSource = getType (getK n)+ in if checkSource == Source then L Source n -- sanity check+ else error "makeEdgesForV.typeL.getType.getK of n did not return Source!"+ keyL n = if Set.notMember (me,n) (rIKey r) then L Normal n+ else L (getKey (getK n)) n+ sKNT (L p _) = Set.map (typeL p) (vKeysNeedsTypes v)+ sTNT (L p _) = Set.map (typeL p) (vTypeNeedsTypes v)+ sNK _ = Set.map keyL (vNeedsKeys v)++ notMe set = [ e | e@(L _p o) <- Set.toList set, o/=me ]+ standard = let s = self Normal in (v,s,notMe $ Set.unions [ sKNT s, sTNT s, sNK s])+ source = let s = self Source in (v,s,[])+ sourceKTB = let s = self Source in (v,s,notMe $ sKNT s)+ standardSKTB = let s = self Normal in (v,s,notMe' $ Set.union (sNK s) (sTNT s))+ where notMe' set = [ e | e@(L p o) <- Set.toList set, o/=me || p==KeyFile ]+ keyfileSKTB = let s = self KeyFile in (v,s,Set.toList $ sKNT s)++ in case myKind of -- commented out the purely SOURCE and SINK nodes:+ TopProtoInfo -> [standard]+ Simple -> [standard]+ TypeBoot -> [standard,source]+ KeyTypeBoot -> [standard,sourceKTB]+ SplitKeyTypeBoot -> [standardSKTB,keyfileSKTB,source]++breakGraph :: Result -> SCCs -> Result+breakGraph r [] = ecart ("\nbreakGraph leaf answer\n"++displayResult r) $ r+breakGraph r sccs = ecart ("\nbreakGraph\n"++displayResult r) $+ r `mappend` mconcat (map (breakCycle r) (rejoinVertices sccs))++-- I wonder if there is any input which leads to a module having+-- different parts in different SCCs. Rather than try and+-- over-analyze this wierd edge case this 'rejoinVertices' function+-- will detect it and join the SCCs.+rejoinVertices :: SCCs -> SCCs+rejoinVertices [] = []+rejoinVertices g@([_]) = g+rejoinVertices gs = + let vgs :: [(Set MKey,G)]+ vgs = map (\ g -> (Set.fromList . map (vMKey . fst3) $ g,g)) gs+ process [] = []+ process ((_,g):[]) = [g]+ process ((v,g):rest) = walk id rest where+ walk p [] = g : process (p [])+ walk p (x@(v',g'):rest') | Set.null (Set.intersection v v') = walk (p . (x:)) rest'+ | otherwise = process ((Set.union v v',g++g') : p [])+ in process vgs++{-+breakCycle is a work in progress. The ans' value tries to change+incoming type links to the Source file, then ans'R. The ans'R tries to+change outgoing links to point to Source files. The ans'TB changes+from Simple/Normal to TypeBoot (adding a source file). The ans'SKTB+changes from KeyTypeBoot/Source to SplitKeyTypeBoot.++The reason these changes are done in stages is to try and avoid ghc's+warnings that a {-# SOURCE #-} import is not not needed.+-}+breakCycle :: Result -> G -> Result+breakCycle oldR sccIn = + let bits = map snd3 sccIn -- trace+ -- toCompare should never be null.+ toCompare = mapMaybe f (pullEach sccIn) where+ allV = Set.fromList (map (vMKey . fst3) sccIn)+ f :: (E,[E]) -> Maybe ((Int, Int), (Result, SCCs))+ f (e@(v,L p me,_bLs), es) = ecart (">< picking:\n"++showE e+++ "\nfrom:"++show bits+++ "\nscore: "++show observe++"\n") $+ answer where+ answer = case (getKind oldR me,p) of+ (TopProtoInfo,Normal) -> ans'R+ (Simple,Normal) -> ans'R `mplus` ans'TB -- ans' is part of ans'TB+ (TypeBoot,Normal) -> ans' `mplus` ans'R+ (KeyTypeBoot,Normal) -> ans' `mplus` ans'R+ (KeyTypeBoot,Source) -> ans'RK `mplus` ans'SKTB -- ans' may be redundant+ (SplitKeyTypeBoot,Normal) -> ans' `mplus` ans'R+ (SplitKeyTypeBoot,KeyFile) -> ans'RK -- ans' may be redundant+ (TypeBoot,Source) -> imp $+ "breakCycle.toCompare.f cannot have (TypeBoot,Source) in SCC!" ++ eMsg+ (SplitKeyTypeBoot,Source) -> imp $+ "breakCycle.toCompare.f cannot have (SplitKeyTypeBoot,Source) in SCC!" ++ eMsg+ _ -> imp $ "breakCycle.toCompare.f: impossible combination in SCC:"++ eMsg+ observe = case answer of Nothing -> "Nothing"; Just (s,_) -> "Just "++show s -- trace+ eMsg = '\n':unlines (map showE (e:es))++ ans',ans'R,ans'TB,ans'SKTB :: Maybe ((Int, Int), (Result, SCCs))+ ans' = if Set.null newIBoot then Nothing+ else go $ oldR `mappend` Result { rKind = mempty+ , rIBoot = newIBoot+ , rIKey = mempty }+ ans'R = if Set.null newIBootR then Nothing+ else go $ oldR `mappend` Result { rKind = mempty+ , rIBoot = newIBootR+ , rIKey = mempty }+ ans'RK = if Set.null newIBootRK then Nothing+ else go $ oldR `mappend` Result { rKind = mempty+ , rIBoot = newIBootRK+ , rIKey = mempty }+ ans'TB = go $ oldR `mappend` Result { rKind = Map.singleton me TypeBoot+ , rIBoot = newIBoot -- do (TypeBoot,Normal) -> ans'+ , rIKey = mempty }+ ans'SKTB = go $ oldR `mappend` Result { rKind = Map.singleton me SplitKeyTypeBoot+ , rIBoot = newIBootSKTB+ , rIKey = Set.singleton (me,me) }++ newIBoot,newIBootR,newIBootRK,newIBootSKTB :: Set (MKey,Part,MKey)+ newIBoot = Set.fromList $ do+ (va,L pa a,_) <- es+ iguard (Set.member a allV) $+ "breakCycle.toCompare.newIBoot sanity check 083425 failed:"++eMsg+ guard (((pa == Normal) &&+ (Set.member me (vTypeNeedsTypes va))) ||+ ((pa == getKey (getKind oldR a)) &&+ (Set.member me (vKeysNeedsTypes va))))+ let x=(a,pa,me)+ guard (Set.notMember x (rIBoot oldR)) -- needed when used in newIBoot2+ return x+ newIBootR = Set.fromList $ do+ b <- Set.toList (Set.union (vTypeNeedsTypes v) (vKeysNeedsTypes v))+ guard (Set.member b allV)+ guard (Source == getType (getKind oldR b))+ guard (me /= b || p == KeyFile)+ let x = (me,p,b)+ guard (Set.notMember x (rIBoot oldR))+ return x+ newIBootRK = Set.fromList $ do+ b <- Set.toList (vKeysNeedsTypes v)+ guard (Set.member b allV)+ guard (Source == getType (getKind oldR b))+ guard (me /= b || p == KeyFile)+ let x = (me,p,b)+ guard (Set.notMember x (rIBoot oldR))+ return x+ newIBootSKTB = Set.union newIBoot . Set.fromList $ + (if Set.member me (vKeysNeedsTypes v) then ((me,KeyFile,me):) else id) $ do+ b <- Set.toList (vKeysNeedsTypes v)+ guard (Set.member (me,Source,b) (rIBoot oldR)) -- copy from (me,Source,b)+ let x = (me,KeyFile,b) -- copy to (me,KeyFile,b)+ iguard (Set.notMember x (rIBoot oldR)) $+ "breakCycle.toCompare.newIBoot2 KeyTypeBoot already had entries for KeyFile!:"++eMsg+ return x++ go :: Result -> Maybe ((Int, Int), (Result, SCCs))+ go newR = let (s,sccs) = score (makeG (map fst3 (e:es)) newR)+ in Just (s,(newR,sccs))+ in ecart (">< breakCycle of "++show bits++"\n\n") $+ if null toCompare+ then imp $ "breakCycle: This SCC had no Simple or KeyTypeBoot nodes!\n"++ unlines (map show sccIn)+ else let (newR,next'sccs) = snd $ maximumBy (compare `on` fst) toCompare+ in breakGraph newR next'sccs++-- 'cull' tries to remove all the extra {-# SOURCE #-} pragmas. I am+-- not certain that repeating the 'cull' will make any difference.+cull :: [V] -> Result -> Result+cull vs rIn =+ let trial :: Result -> (MKey,Part,MKey) -> Result+ trial old x = let new = old { rIBoot = Set.delete x (rIBoot old) }+ in if null (cycles (makeG vs new)) then new else old+ rOut = foldl' trial rIn (Set.toList (rIBoot rIn))+ in if rOut == rIn then rOut else cull vs rOut+
+ Text/ProtocolBuffers/ProtoCompile/Gen.hs view
@@ -0,0 +1,882 @@+-- This module uses the Reflection data structures (ProtoInfo,EnumInfo,DescriptorInfo) to+-- build an AST using Language.Haskell.Syntax. This get quite verbose, so a large number+-- of helper functions (and operators) are defined to aid in specifying the output code.+--+-- Note that this may eventually also generate hs-boot files to allow+-- for breaking mutual recursion.+--+-- Mangling: For the current moment, assume the mangling is done in a prior pass:+-- (*) Uppercase all module names and type names and enum constants+-- (*) lowercase all field names+-- (*) add a prime after all field names than conflict with reserved words+--+-- The names are also assumed to have become fully-qualified, and all+-- the optional type codes have been set.+--+module Text.ProtocolBuffers.ProtoCompile.Gen(protoModule,descriptorModules,enumModule,prettyPrint) where++import Text.ProtocolBuffers.Basic+import Text.ProtocolBuffers.Identifiers+import Text.ProtocolBuffers.Reflections(KeyInfo,HsDefault(..),SomeRealFloat(..),DescriptorInfo(..),ProtoInfo(..),EnumInfo(..),ProtoName(..),ProtoFName(..),FieldInfo(..))++import Text.ProtocolBuffers.ProtoCompile.BreakRecursion(Result(..),VertexKind(..),pKey,pfKey,getKind,Part(..))++--import Paths_hprotoc(version)+--import Data.Version(showVersion)+import qualified Data.ByteString.Lazy.Char8 as LC(unpack)+import qualified Data.Foldable as F(foldr,toList)+import Data.List(sortBy,foldl',foldl1',group,sort,union)+import Data.Function(on)+import Language.Haskell.Exts.Pretty(prettyPrint)+import Language.Haskell.Exts.Syntax hiding (Int,String)+import Language.Haskell.Exts.Syntax as Hse+import Data.Char(isLower,isUpper)+import qualified Data.Map as M+import Data.Maybe(mapMaybe)+import qualified Data.Sequence as Seq(null,length)+import qualified Data.Set as S+import System.FilePath(joinPath)++--import Debug.Trace(trace)++ecart :: String -> a -> a+ecart _ x = x++default (Int)++-- -- -- -- Helper functions++imp :: String -> a+imp s = error ("Impossible? Text.ProtocolBuffers.ProtoCompile.Gen."++s)++nubSort :: Ord a => [a] -> [a]+nubSort = map head . group . sort++noWhere :: Binds+noWhere = BDecls []++($$) :: Exp -> Exp -> Exp+($$) = App++infixl 1 $$++src :: SrcLoc+src = SrcLoc "No SrcLoc" 0 0++litStr :: String -> Exp+litStr = Lit . Hse.String++litIntP :: Integral x => x -> Pat+litIntP x | x<0 = PParen $ PLit (Hse.Int (toInteger x))+ | otherwise = PLit (Hse.Int (toInteger x))++-- Pin down the type inference+litIntP' :: Int -> Pat+litIntP' = litIntP++litInt :: Integral x => x -> Exp+litInt x | x<0 = Paren $ Lit (Hse.Int (toInteger x))+ | otherwise = Lit (Hse.Int (toInteger x))++litInt' :: Int -> Exp+litInt' = litInt++typeApp :: String -> Type -> Type+typeApp s = TyApp (TyCon (private s))++-- private is for Text.ProtocolBuffers.Header, prelude is for Prelude, local is unqualified+private :: String -> QName+private t = Qual (ModuleName "P'") (Ident t)++prelude :: String -> QName+prelude t = Qual (ModuleName "Prelude'") (Ident t)++local :: String -> QName+local t = UnQual (Ident t)++-- pvar and preludevar and lvar are for lower-case identifiers+isVar :: String -> Bool+isVar (x:_) = isLower x+isVar _ = False++isCon :: String -> Bool+isCon (x:_) = isUpper x+isCon _ = False++pvar :: String -> Exp+pvar t | isVar t = Var (private t)+ | otherwise = error $ "hprotoc Gen.hs assertion failed: pvar expected lower-case first letter in " ++ show t++preludevar :: String -> Exp+preludevar t | isVar t = Var (prelude t)+ | otherwise = error $ "hprotoc Gen.hs assertion failed: preludevar expected lower-case first letter in " ++ show t++lvar :: String -> Exp+lvar t | isVar t = Var (local t)+ | otherwise = error $ "hprotoc Gen.hs assertion failed: lvar expected lower-case first letter in " ++ show t++-- pcon and preludecon and lcon are for upper-case identifiers+pcon :: String -> Exp+pcon t | isCon t = Con (private t)+ | otherwise = error $ "hprotoc Gen.hs assertion failed: pcon expected upper-case first letter in " ++ show t++preludecon :: String -> Exp+preludecon t | isCon t = Con (prelude t)+ | otherwise = error $ "hprotoc Gen.hs assertion failed: preludecon expected upper-case first letter in " ++ show t++lcon :: String -> Exp+lcon t | isCon t = Con (local t)+ | otherwise = error $ "hprotoc Gen.hs assertion failed: lcon expected upper-case first letter in " ++ show t++-- patvar is a pattern that binds a new lower-case variable name+patvar :: String -> Pat+patvar t | isVar t = PVar (Ident t)+ | otherwise = error $ "hprotoc Gen.hs assertion failed: patvar expected lower-case first letter in " ++ show t++match :: String -> [Pat] -> Exp -> Match+match s p r = Match src (Ident s) p Nothing (UnGuardedRhs r) noWhere++inst :: String -> [Pat] -> Exp -> InstDecl+inst s p r = InsDecl $ FunBind [match s p r]++defun :: String -> [Pat] -> Exp -> Decl+defun s p r = FunBind [match s p r]++mkOp :: String -> Exp -> Exp -> Exp+mkOp s a b = InfixApp a (QVarOp (UnQual (Symbol s))) b++compose :: Exp -> Exp -> Exp+compose = mkOp "."++fqMod :: ProtoName -> String+fqMod (ProtoName _ a b c) = joinMod $ a++b++[c]++-- importPN takes the Result to look up the target info, it takes the+-- current MKey (pKey of protoName, no 'Key appended), and Part to+-- identify the module being created. The ProtoName is the target+-- TYPE that is needed.+importPN :: Result -> ModuleName -> Part -> ProtoName -> Maybe ImportDecl+importPN r selfMod@(ModuleName self) part pn =+ let o = pKey pn+ m1 = ModuleName (joinMod (haskellPrefix pn ++ parentModule pn ++ [baseName pn]))+ m2 = ModuleName (joinMod (parentModule pn))+ fromSource = S.member (FMName self,part,o) (rIBoot r)+ ans = if m1 == selfMod && part /= KeyFile then Nothing+ else Just $ ImportDecl src m1 True fromSource Nothing (Just m2)+ (Just (False,[IAbs (Ident (mName (baseName pn)))]))+ in ecart (unlines . map (\ (a,b) -> a ++ " = "++b) $+ [("selfMod",show selfMod)+ ,("part",show part)+ ,("pn",show pn)+ ,("o",show o)+ ,("m1",show m1)+ ,("m2",show m2)+ ,("fromSource",show fromSource)+ ,("ans",show ans)]) $+ ans++importPFN :: Result -> ModuleName -> ProtoFName -> Maybe ImportDecl+importPFN r m@(ModuleName self) pfn =+ let o@(FMName _other) = pfKey pfn+ m1@(ModuleName m1') = ModuleName (joinMod (haskellPrefix' pfn ++ parentModule' pfn))+ m2 = ModuleName (joinMod (parentModule' pfn))+ spec = Just (False,[IVar (Ident (fName (baseName' pfn)))])+ kind = getKind r o+ fromAlt = S.member (FMName self,FMName m1') (rIKey r)+ m1key = if kind == SplitKeyTypeBoot && fromAlt+ then keyFile m1+ else m1+ qualifiedFlag = (m1 /= m)+ qualifiedName | qualifiedFlag = if m2/=m1key then Just m2 else Nothing+ | otherwise = Nothing+ sourceFlag = (kind == KeyTypeBoot) && fromAlt+ ans = if not qualifiedFlag && kind /= SplitKeyTypeBoot then Nothing else Just $+ ImportDecl src m1key qualifiedFlag sourceFlag Nothing qualifiedName spec+ in ecart (unlines . map (\ (a,b) -> a ++ " = "++b) $+ [("m",show m)+ ,("pfn",show pfn)+ ,("o",show o)+ ,("m1",show m1)+ ,("m2",show m2)+ ,("kind",show kind)+ ,("ans",show ans)]) $+ ans++-- Several items might be taken from the same module, combine these statements+mergeImports :: [ImportDecl] -> [ImportDecl]+mergeImports importsIn =+ let idKey (ImportDecl _p1 p2 p3 p4 _ p5 (Just (p6,_xs))) = (p2,p3,p4,p5,Just p6)+ idKey (ImportDecl _p1 p2 p3 p4 _ p5 Nothing) = (p2,p3,p4,p5,Nothing)+ mergeImports' (ImportDecl p1 p2 p3 p4 _ p5 (Just (p6,xs)))+ (ImportDecl _ _ _ _ _ _ (Just (_,ys))) =+ ImportDecl p1 p2 p3 p4 Nothing p5 (Just (p6,xs `union` ys))+ mergeImports' i _ = i -- identical, so drop one+ combined = M.fromListWith mergeImports' . map (\ i -> (idKey i,i)) $ importsIn+ in M.elems combined++keyFile :: ModuleName -> ModuleName+keyFile (ModuleName s) = ModuleName (s++"'Key")++joinMod :: [MName String] -> String+joinMod [] = ""+joinMod ms = fmName $ foldr1 dotFM . map promoteFM $ ms++baseIdent :: ProtoName -> Name+baseIdent = Ident . mName . baseName+baseIdent' :: ProtoFName -> Name+baseIdent' = Ident . fName . baseName'++qualName :: ProtoName -> QName+qualName p@(ProtoName _ _prefix [] _base) = UnQual (baseIdent p)+qualName p@(ProtoName _ _prefix (parents) _base) = Qual (ModuleName (joinMod parents)) (baseIdent p)++qualFName :: ProtoFName -> QName+qualFName p@(ProtoFName _ _prefix [] _base) = UnQual (baseIdent' p)+qualFName p@(ProtoFName _ _prefix parents _base) = Qual (ModuleName (joinMod parents)) (baseIdent' p)++unqualName :: ProtoName -> QName+unqualName p = UnQual (baseIdent p)++unqualFName :: ProtoFName -> QName+unqualFName p = UnQual (baseIdent' p)++mayQualName :: ProtoName -> ProtoFName -> QName+mayQualName (ProtoName _ c'prefix c'parents c'base) name@(ProtoFName _ prefix parents _base) =+ if joinMod (c'prefix++c'parents++[c'base]) == joinMod (prefix++parents)+ then UnQual (baseIdent' name) -- name is local, make UnQual+ else qualFName name -- name is imported, make Qual++--------------------------------------------+-- Define LANGUAGE options as [ModulePramga]+--------------------------------------------+modulePragmas :: [ModulePragma]+modulePragmas = [ LanguagePragma src (map Ident ["BangPatterns","DeriveDataTypeable","FlexibleInstances","MultiParamTypeClasses"]) ]++--------------------------------------------+-- EnumDescriptorProto module creation+--------------------------------------------+enumModule :: EnumInfo -> Module+enumModule ei+ = let protoName = enumName ei+ in Module src (ModuleName (fqMod protoName)) modulePragmas Nothing+ (Just [EThingAll (unqualName protoName)])+ (standardImports True False) (enumDecls ei)++enumDecls :: EnumInfo -> [Decl]+enumDecls ei = map ($ ei) [ enumX+ , instanceMergeableEnum+ , instanceBounded+ , instanceDefaultEnum ]+ ++ declToEnum ei +++ map ($ ei) [ instanceEnum+ , instanceWireEnum+ , instanceGPB . enumName+ , instanceMessageAPI . enumName+ , instanceReflectEnum+ ]++enumX :: EnumInfo -> Decl+enumX ei = DataDecl src DataType [] (baseIdent (enumName ei)) [] (map enumValueX (enumValues ei)) derivesEnum+-- where enumValueX (_,name) = ConDecl src (HsIdent name) []+ where enumValueX (_,name) = QualConDecl src [] [] (ConDecl (Ident name) [])++instanceMergeableEnum :: EnumInfo -> Decl+instanceMergeableEnum ei + = InstDecl src [] (private "Mergeable") [TyCon (unqualName (enumName ei))] []++instanceBounded :: EnumInfo -> Decl+instanceBounded ei+ = InstDecl src [] (prelude "Bounded") [TyCon (unqualName (enumName ei))] + [set "minBound" (head values),set "maxBound" (last values)] -- values cannot be null in a well formed enum+ where values = enumValues ei+ set f (_,n) = inst f [] (lcon n)++{- from google's descriptor.h, about line 346:++ // Get the field default value if cpp_type() == CPPTYPE_ENUM. If no+ // explicit default was defined, the default is the first value defined+ // in the enum type (all enum types are required to have at least one value).+ // This never returns NULL.++-}+instanceDefaultEnum :: EnumInfo -> Decl+instanceDefaultEnum ei+ = InstDecl src [] (private "Default") [TyCon (unqualName (enumName ei))]+ [ inst "defaultValue" [] firstValue ]+ where firstValue :: Exp+ firstValue = case enumValues ei of+ (:) (_,n) _ -> lcon n+ [] -> error $ "Impossible? EnumDescriptorProto had empty sequence of EnumValueDescriptorProto.\n" ++ show ei++declToEnum :: EnumInfo -> [Decl]+declToEnum ei = [ TypeSig src [Ident "toMaybe'Enum"]+ (TyFun (TyCon (prelude "Int"))+ (typeApp "Maybe" (TyCon (unqualName (enumName ei)))))+ , FunBind (map toEnum'one values ++ [final]) ]+ where values = enumValues ei+ toEnum'one (v,n) = match "toMaybe'Enum" [litIntP (getEnumCode v)] (preludecon "Just" $$ lcon n)+ final = match "toMaybe'Enum" [PWildCard] (preludecon "Nothing")++instanceEnum :: EnumInfo -> Decl+instanceEnum ei+ = InstDecl src [] (prelude "Enum") [TyCon (unqualName (enumName ei))]+ (map (InsDecl . FunBind) [fromEnum',toEnum',succ',pred'])+ where values = enumValues ei+ fromEnum' = map fromEnum'one values+ fromEnum'one (v,n) = match "fromEnum" [PApp (local n) []] (litInt (getEnumCode v))+ toEnum' = [ match "toEnum" [] (compose mayErr (lvar "toMaybe'Enum")) ]+ mayErr = pvar "fromMaybe" $$ (Paren (preludevar "error" $$ (litStr $ + "hprotoc generated code: toEnum failure for type "++ fqMod (enumName ei))))+ succ' = zipWith (equate "succ") values (tail values) +++ [ match "succ" [PWildCard] (preludevar "error" $$ (litStr $ + "hprotoc generated code: succ failure for type "++ fqMod (enumName ei))) ]+ pred' = zipWith (equate "pred") (tail values) values +++ [ match "pred" [PWildCard] (preludevar "error" $$ (litStr $ + "hprotoc generated code: pred failure for type "++ fqMod (enumName ei))) ]+ equate f (_,n1) (_,n2) = match f [PApp (local n1) []] (lcon n2)++-- fromEnum TYPE_ENUM == 14 :: Int+instanceWireEnum :: EnumInfo -> Decl+instanceWireEnum ei+ = InstDecl src [] (private "Wire") [TyCon (unqualName (enumName ei))]+ [ withName "wireSize", withName "wirePut", withGet, withGetErr,withGetPacked,withGetPackedErr ]+ where withName foo = inst foo [patvar "ft'",patvar "enum"] rhs+ where rhs = pvar foo $$ lvar "ft'" $$+ (Paren $ preludevar "fromEnum" $$ lvar "enum")+ withGet = inst "wireGet" [litIntP' 14] rhs+ where rhs = pvar "wireGetEnum" $$ lvar "toMaybe'Enum"+ withGetErr = inst "wireGet" [patvar "ft'"] rhs+ where rhs = pvar "wireGetErr" $$ lvar "ft'"+ withGetPacked = inst "wireGetPacked" [litIntP' 14] rhs+ where rhs = pvar "wireGetPackedEnum" $$ lvar "toMaybe'Enum"+ withGetPackedErr = inst "wireGetPacked" [patvar "ft'"] rhs+ where rhs = pvar "wireGetErr" $$ lvar "ft'"++instanceGPB :: ProtoName -> Decl+instanceGPB protoName+ = InstDecl src [] (private "GPB") [TyCon (unqualName protoName)] []++instanceReflectEnum :: EnumInfo -> Decl+instanceReflectEnum ei+ = InstDecl src [] (private "ReflectEnum") [TyCon (unqualName (enumName ei))]+ [ inst "reflectEnum" [] ascList+ , inst "reflectEnumInfo" [ PWildCard ] ei' ]+ where (ProtoName xxx a b c) = enumName ei+ xxx'Exp = Paren $ pvar "pack" $$ litStr (LC.unpack (utf8 (fiName xxx)))+ values = enumValues ei+ ascList,ei',protoNameExp :: Exp+ ascList = List (map one values)+ where one (v,ns) = Tuple Boxed [litInt (getEnumCode v),litStr ns,lcon ns]+ ei' = foldl' App (pcon "EnumInfo") [protoNameExp+ ,List $ map litStr (enumFilePath ei)+ ,List (map two values)]+ where two (v,ns) = Tuple Boxed [litInt (getEnumCode v),litStr ns]+ protoNameExp = Paren $ foldl' App (pvar "makePNF")+ [ xxx'Exp, mList a, mList b, litStr (mName c) ]+ where mList = List . map (litStr . mName)++hasExt :: DescriptorInfo -> Bool+hasExt di = not (null (extRanges di))++--------------------------------------------+-- FileDescriptorProto module creation+--------------------------------------------++protoModule :: Result -> ProtoInfo -> ByteString -> Module+protoModule result pri fdpBS+ = let protoName = protoMod pri+ (extendees,myKeys) = unzip $ F.toList (extensionKeys pri)+ m = ModuleName (fqMod protoName)+ exportKeys = map (EVar . unqualFName . fieldName) myKeys+ exportNames = map (EVar . UnQual . Ident) ["protoInfo","fileDescriptorProto"]+ imports = (protoImports ++) . mergeImports $+ mapMaybe (importPN result m Normal) $+ extendees ++ mapMaybe typeName myKeys+ in Module src m modulePragmas Nothing (Just (exportKeys++exportNames)) imports+ (keysXTypeVal protoName (extensionKeys pri) ++ embed'ProtoInfo pri ++ embed'fdpBS fdpBS)+ where protoImports = standardImports False (not . Seq.null . extensionKeys $ pri) +++ [ ImportDecl src (ModuleName "Text.DescriptorProtos.FileDescriptorProto") False False Nothing Nothing+ (Just (False,[IAbs (Ident "FileDescriptorProto")]))+ , ImportDecl src (ModuleName "Text.ProtocolBuffers.Reflections") False False Nothing Nothing+ (Just (False,[IAbs (Ident "ProtoInfo")]))+ , ImportDecl src (ModuleName "Text.ProtocolBuffers.WireMessage") True False Nothing (Just (ModuleName "P'"))+ (Just (False,[IVar (Ident "wireGet,getFromBS")])) ]++embed'ProtoInfo :: ProtoInfo -> [Decl]+embed'ProtoInfo pri = [ myType, myValue ]+ where myType = TypeSig src [ Ident "protoInfo" ] (TyCon (local "ProtoInfo"))+ myValue = PatBind src (PApp (local "protoInfo") []) Nothing (UnGuardedRhs $+ preludevar "read" $$ litStr (show pri)) noWhere++embed'fdpBS :: ByteString -> [Decl]+embed'fdpBS bs = [ myType, myValue ]+ where myType = TypeSig src [ Ident "fileDescriptorProto" ] (TyCon (local "FileDescriptorProto"))+ myValue = PatBind src (PApp (local "fileDescriptorProto") []) Nothing (UnGuardedRhs $+ pvar "getFromBS" $$+ Paren (pvar "wireGet" $$ litInt' 11) $$ + Paren (pvar "pack" $$ litStr (LC.unpack bs))) noWhere++--------------------------------------------+-- DescriptorProto module creation+--------------------------------------------+descriptorModules :: Result -> DescriptorInfo -> [(FilePath,Module)]+descriptorModules result di+ = let mainPath = joinPath (descFilePath di)+ bootPath = joinPath (descFilePath di) ++ "-boot"+ keyfilePath = take (length mainPath - 3) mainPath ++ "'Key.hs"+ in (mainPath,descriptorNormalModule result di) :+ case getKind result (pKey (descName di)) of+ TopProtoInfo -> imp $ "descriptorModules was given a TopProtoInfo kinded DescriptorInfo!"+ Simple -> []+ TypeBoot -> [(bootPath,descriptorBootModule di)]+ KeyTypeBoot -> [(bootPath,descriptorKeyBootModule result di)]+ SplitKeyTypeBoot -> [(bootPath,descriptorBootModule di)+ ,(keyfilePath,descriptorKeyfileModule result di)]++-- This build a hs-boot that declares the type of the data type only+descriptorBootModule :: DescriptorInfo -> Module+descriptorBootModule di+ = let protoName = descName di+ un = unqualName protoName+ classes = [prelude "Show",prelude "Eq",prelude "Ord",prelude "Typeable",prelude "Data"+ ,private "Mergeable",private "Default",private "Wire",private "GPB",private "ReflectDescriptor"]+ ++ if hasExt di then [private "ExtendMessage"] else []+ ++ if storeUnknown di then [private "UnknownMessage"] else []+ instMesAPI = InstDecl src [] (private "MessageAPI")+ [TyVar (Ident "msg'"), TyFun (TyVar (Ident "msg'")) (TyCon un), (TyCon un)] []+ dataDecl = DataDecl src DataType [] (baseIdent protoName) [] [] []+ mkInst s = InstDecl src [] s [TyCon un] []+ in Module src (ModuleName (fqMod protoName)) modulePragmas Nothing (Just [EAbs un]) minimalImports+ (dataDecl : instMesAPI : map mkInst classes)++-- This builds on the output of descriptorBootModule and declares a hs-boot that+-- declares the data type and the keys+descriptorKeyBootModule :: Result -> DescriptorInfo -> Module+descriptorKeyBootModule result di+ = let Module p1 m@(ModuleName _self) p3 p4 (Just exports) imports decls = descriptorBootModule di+ (extendees,myKeys) = unzip $ F.toList (keys di)+ exportKeys = map (EVar . unqualFName . fieldName) myKeys+ importTypes = mergeImports . mapMaybe (importPN result m Source) . nubSort $+ extendees ++ mapMaybe typeName myKeys+ declKeys = keysXType (descName di) (keys di)+ in Module p1 m p3 p4 (Just (exports++exportKeys)) (imports++importTypes) (decls++declKeys)++-- This build the 'Key module that defines the keys only+descriptorKeyfileModule :: Result -> DescriptorInfo -> Module+descriptorKeyfileModule result di+ = let protoName'Key = (descName di) { baseName = MName . (++"'Key") . mName $ (baseName (descName di)) }+ (extendees,myKeys) = unzip $ F.toList (keys di)+ mBase = ModuleName (fqMod (descName di))+ m = ModuleName (fqMod protoName'Key)+ exportKeys = map (EVar . unqualFName . fieldName) myKeys+ importTypes = mergeImports . mapMaybe (importPN result mBase KeyFile) . nubSort $+ extendees ++ mapMaybe typeName myKeys+ declKeys = keysXTypeVal protoName'Key (keys di)+ in Module src m modulePragmas Nothing (Just exportKeys) (minimalImports++importTypes) declKeys++-- This builds the normal module+descriptorNormalModule :: Result -> DescriptorInfo -> Module+descriptorNormalModule result di+ = let protoName = descName di+ un = unqualName protoName+ myKind = getKind result (pKey protoName)+ sepKey = myKind == SplitKeyTypeBoot+ (extendees,myKeys) = unzip $ F.toList (keys di)+ extendees' = if sepKey then [] else extendees+ myKeys' = if sepKey then [] else myKeys+ m = ModuleName (fqMod protoName)+ exportKeys = map (EVar . unqualFName . fieldName) myKeys+ imports = (standardImports False (hasExt di) ++) . mergeImports . concat $+ [ mapMaybe (importPN result m Normal) $+ extendees' ++ mapMaybe typeName (myKeys' ++ (F.toList (fields di)))+ , mapMaybe (importPFN result m) (map fieldName (myKeys ++ F.toList (knownKeys di))) ]+ declKeys | sepKey = []+ | otherwise = keysXTypeVal (descName di) (keys di)+ in Module src m modulePragmas Nothing (Just (EThingAll un : exportKeys)) imports+ (descriptorX di : declKeys ++ instancesDescriptor di)++minimalImports :: [ImportDecl]+minimalImports =+ [ ImportDecl src (ModuleName "Prelude") True False Nothing (Just (ModuleName "Prelude'")) Nothing+ , ImportDecl src (ModuleName "Data.Typeable") True False Nothing (Just (ModuleName "Prelude'")) Nothing+ , ImportDecl src (ModuleName "Data.Data") True False Nothing (Just (ModuleName "Prelude'")) Nothing+ , ImportDecl src (ModuleName "Text.ProtocolBuffers.Header") True False Nothing (Just (ModuleName "P'")) Nothing ]++standardImports :: Bool -> Bool -> [ImportDecl]+standardImports isEnumMod ext =+ [ ImportDecl src (ModuleName "Prelude") False False Nothing Nothing (Just (False,ops))+ , ImportDecl src (ModuleName "Prelude") True False Nothing (Just (ModuleName "Prelude'")) Nothing+ , ImportDecl src (ModuleName "Data.Typeable") True False Nothing (Just (ModuleName "Prelude'")) Nothing+ , ImportDecl src (ModuleName "Data.Data") True False Nothing (Just (ModuleName "Prelude'")) Nothing+ , ImportDecl src (ModuleName "Text.ProtocolBuffers.Header") True False Nothing (Just (ModuleName "P'")) Nothing ]+ where ops | ext = map (IVar . Symbol) $ base ++ ["==","<=","&&"]+ | otherwise = map (IVar . Symbol) base+ base | isEnumMod = ["+","/","."]+ | otherwise = ["+","/"]++keysXType :: ProtoName -> Seq KeyInfo -> [Decl]+keysXType self ks = map (makeKeyType self) . F.toList $ ks++keysXTypeVal :: ProtoName -> Seq KeyInfo -> [Decl]+keysXTypeVal self ks = concatMap (\ ki -> [makeKeyType self ki,makeKeyVal self ki]) . F.toList $ ks++makeKeyType :: ProtoName -> KeyInfo -> Decl+makeKeyType self (extendee,f) = keyType+ where keyType = TypeSig src [ baseIdent' . fieldName $ f ] (foldl1 TyApp . map TyCon $+ [ private "Key", private labeled+ , if extendee /= self then qualName extendee else unqualName extendee+ , typeQName ])+ labeled | isPacked f = "PackedSeq"+ | canRepeat f = "Seq"+ | otherwise = "Maybe"+ typeNumber = getFieldType . typeCode $ f+ typeQName :: QName+ typeQName = case useType typeNumber of+ Just s -> private s+ Nothing -> case typeName f of+ Just s | self /= s -> qualName s+ | otherwise -> unqualName s+ Nothing -> error $ "No Name for Field!\n" ++ show f++makeKeyVal :: ProtoName -> KeyInfo -> Decl+makeKeyVal _self (_extendee,f) = keyVal+ where typeNumber = getFieldType . typeCode $ f+ keyVal = PatBind src (PApp (unqualFName . fieldName $ f) []) Nothing (UnGuardedRhs+ (pcon "Key" $$ litInt (getFieldId (fieldNumber f))+ $$ litInt typeNumber+ $$ maybe (preludecon "Nothing")+ (Paren . (preludecon "Just" $$) . (defToSyntax (typeCode f)))+ (hsDefault f)+ )) noWhere++defToSyntax :: FieldType -> HsDefault -> Exp+defToSyntax tc x =+ case x of+ HsDef'Bool b -> preludecon (show b)+ HsDef'ByteString bs -> (if tc == 9 then (\ xx -> Paren (pcon "Utf8" $$ xx)) else id) $+ (Paren $ pvar "pack" $$ litStr (LC.unpack bs))+ HsDef'RealFloat (SRF'Rational r) | r < 0 -> Paren $ Lit (Frac r)+ | otherwise -> Lit (Frac r)+ HsDef'RealFloat SRF'nan -> litInt' 0 /! litInt' 0+ HsDef'RealFloat SRF'ninf -> litInt' 1 /! litInt' 0+ HsDef'RealFloat SRF'inf -> litInt' (-1) /! litInt' 0+ HsDef'Integer i -> litInt i+ HsDef'Enum s -> Paren $ preludevar "read" $$ litStr s+ where (/!) a b = Paren (mkOp "/" a b)++descriptorX :: DescriptorInfo -> Decl+descriptorX di = DataDecl src DataType [] name [] [QualConDecl src [] [] con] derives+ where self = descName di+ name = baseIdent self+ con = RecDecl name eFields+ where eFields = F.foldr ((:) . fieldX) end (fields di)+ end = (if hasExt di then (extfield:) else id) + $ (if storeUnknown di then [unknownField] else [])+ bangType = if lazyFields di then UnBangedTy else BangedTy+ extfield :: ([Name],BangType)+ extfield = ([Ident "ext'field"], bangType (TyCon (private "ExtField")))+ unknownField :: ([Name],BangType)+ unknownField = ([Ident "unknown'field"], bangType (TyCon (private "UnknownField")))+ fieldX :: FieldInfo -> ([Name],BangType)+ fieldX fi = ([baseIdent' . fieldName $ fi], bangType (labeled (TyCon typed)))+ where labeled | canRepeat fi = typeApp "Seq"+ | isRequired fi = id+ | otherwise = typeApp "Maybe"+ typed :: QName+ typed = case useType (getFieldType (typeCode fi)) of+ Just s -> private s+ Nothing -> case typeName fi of+ Just s | self /= s -> qualName s+ | otherwise -> unqualName s+ Nothing -> error $ "No Name for Field!\n" ++ show fi++instancesDescriptor :: DescriptorInfo -> [Decl]+instancesDescriptor di = map ($ di) $+ (if hasExt di then (instanceExtendMessage:) else id) $+ (if storeUnknown di then (instanceUnknownMessage:) else id) $+ [ instanceMergeable+ , instanceDefault+ , instanceWireDescriptor+ , instanceMessageAPI . descName+ , instanceGPB . descName + , instanceReflectDescriptor+ ]++instanceExtendMessage :: DescriptorInfo -> Decl+instanceExtendMessage di+ = InstDecl src [] (private "ExtendMessage") [TyCon (unqualName (descName di))]+ [ inst "getExtField" [] (lvar "ext'field")+ , inst "putExtField" [patvar "e'f", patvar "msg"] putextfield+ , inst "validExtRanges" [patvar "msg"] (pvar "extRanges" $$ (Paren $ pvar "reflectDescriptorInfo" $$ lvar "msg"))+ ]+ where putextfield = RecUpdate (lvar "msg") [ FieldUpdate (local "ext'field") (lvar "e'f") ]++instanceUnknownMessage :: DescriptorInfo -> Decl+instanceUnknownMessage di+ = InstDecl src [] (private "UnknownMessage") [TyCon (unqualName (descName di))]+ [ inst "getUnknownField" [] (lvar "unknown'field")+ , inst "putUnknownField" [patvar "u'f",patvar "msg"] putunknownfield+ ]+ where putunknownfield = RecUpdate (lvar "msg") [ FieldUpdate (local "unknown'field") (lvar "u'f") ]++instanceMergeable :: DescriptorInfo -> Decl+instanceMergeable di+ = InstDecl src [] (private "Mergeable") [TyCon un]+ [ -- inst "mergeEmpty" [] (foldl' App (Con un) (replicate len (pvar "mergeEmpty"))),+ inst "mergeAppend" [PApp un patternVars1, PApp un patternVars2]+ (foldl' App (Con un) (zipWith append vars1 vars2))+ ]+ where un = unqualName (descName di)+ len = (if hasExt di then succ else id)+ $ (if storeUnknown di then succ else id)+ $ Seq.length (fields di)+ patternVars1,patternVars2 :: [Pat]+ patternVars1 = take len inf+ where inf = map (\ n -> patvar ("x'" ++ show n)) [(1::Int)..]+ patternVars2 = take len inf+ where inf = map (\ n -> patvar ("y'" ++ show n)) [(1::Int)..]+ vars1,vars2 :: [Exp]+ vars1 = take len inf+ where inf = map (\ n -> lvar ("x'" ++ show n)) [(1::Int)..]+ vars2 = take len inf+ where inf = map (\ n -> lvar ("y'" ++ show n)) [(1::Int)..]+ append x y = Paren $ pvar "mergeAppend" $$ x $$ y++instanceDefault :: DescriptorInfo -> Decl+instanceDefault di+ = InstDecl src [] (private "Default") [TyCon un]+ [ inst "defaultValue" [] (foldl' App (Con un) deflistExt) ]+ where un = unqualName (descName di)+ deflistExt = F.foldr ((:) . defX) end (fields di)+ end = (if hasExt di then (pvar "defaultValue":) else id) + $ (if storeUnknown di then [pvar "defaultValue"] else [])++ defX :: FieldInfo -> Exp+ defX fi | isRequired fi = dv1+ | otherwise = dv2+ where dv1 = case hsDefault fi of+ Nothing -> pvar "defaultValue"+ Just hsdef -> defToSyntax (typeCode fi) hsdef+ dv2 = case hsDefault fi of+ Nothing -> pvar "defaultValue"+ Just hsdef -> Paren $ preludecon "Just" $$ defToSyntax (typeCode fi) hsdef++instanceMessageAPI :: ProtoName -> Decl+instanceMessageAPI protoName+ = InstDecl src [] (private "MessageAPI")+ [TyVar (Ident "msg'"), TyFun (TyVar (Ident "msg'")) (TyCon un), (TyCon un)]+ [ inst "getVal" [patvar "m'",patvar "f'"] (App (lvar "f'" ) (lvar "m'")) ]+ where un = unqualName protoName++instanceWireDescriptor :: DescriptorInfo -> Decl+instanceWireDescriptor di@(DescriptorInfo { descName = protoName+ , fields = fieldInfos+ , extRanges = allowedExts+ , knownKeys = fieldExts })+ = let me = unqualName protoName+ extensible = not (null allowedExts)+ len = (if extensible then succ else id) + $ (if storeUnknown di then succ else id)+ $ Seq.length fieldInfos+ mine = PApp me . take len . map (\ n -> patvar ("x'" ++ show n)) $ [(1::Int)..]+ vars = take len . map (\ n -> lvar ("x'" ++ show n)) $ [(1::Int)..]+ mExt | extensible = Just (vars !! Seq.length fieldInfos)+ | otherwise = Nothing+ mUnknown | storeUnknown di = Just (last vars)+ | otherwise = Nothing++-- reusable 'cases' generator+ -- first case is for Group behavior, second case is for Message behavior, last is error handler+ cases g m e = Case (lvar "ft'") [ Alt src (litIntP' 10) (UnGuardedAlt g) noWhere+ , Alt src (litIntP' 11) (UnGuardedAlt m) noWhere+ , Alt src PWildCard (UnGuardedAlt e) noWhere+ ]++-- wireSize generation+ sizeCases = UnGuardedRhs $ cases (lvar "calc'Size") + (pvar "prependMessageSize" $$ lvar "calc'Size")+ (pvar "wireSizeErr" $$ lvar "ft'" $$ lvar "self'")+ whereCalcSize = BDecls [defun "calc'Size" [] sizes]+ sizes | null sizesList = Lit (Hse.Int 0)+ | otherwise = Paren (foldl1' (+!) sizesList)+ where (+!) = mkOp "+"+ sizesList | Just v <- mUnknown = sizesListExt ++ [ pvar "wireSizeUnknownField" $$ v ]+ | otherwise = sizesListExt+ sizesListExt | Just v <- mExt = sizesListFields ++ [ pvar "wireSizeExtField" $$ v ] + | otherwise = sizesListFields+ sizesListFields = zipWith toSize vars . F.toList $ fieldInfos+ toSize var fi = let f = if isPacked fi then "wireSizePacked"+ else if isRequired fi then "wireSizeReq"+ else if canRepeat fi then "wireSizeRep"+ else "wireSizeOpt"+ in foldl' App (pvar f) [ litInt (wireTagLength fi)+ , litInt (getFieldType (typeCode fi))+ , var]++-- wirePut generation+ putCases = UnGuardedRhs $ cases+ (lvar "put'Fields")+ (Do [ Qualifier $ pvar "putSize" $$+ (Paren $ foldl' App (pvar "wireSize") [ litInt' 10 , lvar "self'" ])+ , Qualifier $ lvar "put'Fields" ])+ (pvar "wirePutErr" $$ lvar "ft'" $$ lvar "self'")+ wherePutFields = BDecls [defun "put'Fields" [] (Do putStmts)]+ putStmts = putStmtsContent+ where putStmtsContent | null putStmtsAll = [Qualifier $ preludevar "return" $$ Con (Special UnitCon)]+ | otherwise = putStmtsAll+ putStmtsAll | Just v <- mUnknown = putStmtsListExt ++ [ Qualifier $ pvar "wirePutUnknownField" $$ v ]+ | otherwise = putStmtsListExt+ putStmtsListExt | Just v <- mExt = sortedPutStmtsList ++ [ Qualifier $ pvar "wirePutExtField" $$ v ]+ | otherwise = sortedPutStmtsList+ sortedPutStmtsList = map snd -- remove number+ . sortBy (compare `on` fst) -- sort by number+ . zip (map fieldNumber . F.toList $ fieldInfos) -- add number as fst+ $ putStmtsList+ putStmtsList = zipWith toPut vars . F.toList $ fieldInfos+ toPut var fi = let f = if isPacked fi then "wirePutPacked"+ else if isRequired fi then "wirePutReq"+ else if canRepeat fi then "wirePutRep"+ else "wirePutOpt"+ in Qualifier $+ foldl' App (pvar f) [ litInt (getWireTag (wireTag fi))+ , litInt (getFieldType (typeCode fi))+ , var]+-- wireGet generation+-- new for 1.5.7, rewriting this a great deal!+ getCases = let param = if storeUnknown di+ then Paren (pvar "catch'Unknown" $$ lvar "update'Self")+ else lvar "update'Self"+ in UnGuardedRhs $ cases (pvar "getBareMessageWith" $$ param)+ (pvar "getMessageWith" $$ param)+ (pvar "wireGetErr" $$ lvar "ft'")+ whereDecls = BDecls [whereUpdateSelf]+ whereUpdateSelf = defun "update'Self" [patvar "wire'Tag", patvar "old'Self"]+ (Case (lvar "wire'Tag") updateAlts)+ -- update cases are all normal fields then all known extensions then wildcard+ updateAlts = concatMap toUpdate (F.toList fieldInfos)+ ++ (if extensible then concatMap toUpdateExt (F.toList fieldExts) else [])+ ++ [Alt src PWildCard (UnGuardedAlt wildcardAlt) noWhere]+ -- the wildcard alternative handles new extensions and + wildcardAlt = letPair extBranch+ where letPair = Let (BDecls [PatBind src (PTuple Boxed [patvar "field'Number",patvar "wire'Type"]) Nothing+ (UnGuardedRhs (pvar "splitWireTag" $$ lvar "wire'Tag")) (BDecls [])])+ extBranch | extensible = If (isAllowedExt (lvar "field'Number"))+ (argPair (pvar "loadExtension"))+ unknownBranch+ | otherwise = unknownBranch+ unknownBranch = argPair (pvar "unknown")+ argPair x = x $$ lvar "field'Number" $$ lvar "wire'Type" $$ lvar "old'Self"+ isAllowedExt x = preludevar "or" $$ List ranges where+ (<=!) = mkOp "<="; (&&!) = mkOp "&&"; (==!) = mkOp "=="; (FieldId maxHi) = maxBound+ ranges = map (\ (FieldId lo,FieldId hi) ->+ if hi < maxHi+ then if lo == hi+ then (x ==! litInt lo)+ else (litInt lo <=! x) &&! (x <=! litInt hi)+ else litInt lo <=! x )+ allowedExts++-- wireGetErr for known extensions+-- need to check isPacked and call appropriate wireGetKey[Un]Packed substitute function+ toUpdateExt fi | Just (wt1,wt2) <- packedTag fi = [toUpdateExtUnpacked wt1, toUpdateExtPacked wt2]+ | otherwise = [toUpdateExtUnpacked (wireTag fi)]+ where (getUnP,getP) | isPacked fi = (pvar "wireGetKeyToPacked",pvar "wireGetKey")+ | otherwise = (pvar "wireGetKey",pvar "wireGetKeyToUnPacked")+ toUpdateExtUnpacked wt1 =+ Alt src (litIntP . getWireTag $ wt1)+ (UnGuardedAlt $ getUnP $$ Var (mayQualName protoName (fieldName fi)) $$ lvar "old'Self")+ noWhere+ toUpdateExtPacked wt2 =+ Alt src (litIntP . getWireTag $ wt2)+ (UnGuardedAlt $ getP $$ Var (mayQualName protoName (fieldName fi)) $$ lvar "old'Self")+ noWhere++-- wireGet without extensions+ toUpdate fi | Just (wt1,wt2) <- packedTag fi = [toUpdateUnpacked wt1 fi, toUpdatePacked wt2 fi]+ | otherwise = [toUpdateUnpacked (wireTag fi) fi]+ toUpdateUnpacked wt1 fi =+ Alt src (litIntP . getWireTag $ wt1) (UnGuardedAlt $ + preludevar "fmap" $$ (Paren $ Lambda src [PBangPat (patvar "new'Field")] $+ RecUpdate (lvar "old'Self")+ [FieldUpdate (unqualFName . fieldName $ fi)+ (labelUpdateUnpacked fi)])+ $$ (Paren (pvar "wireGet" $$ (litInt . getFieldType . typeCode $ fi)))) noWhere+ labelUpdateUnpacked fi | canRepeat fi = pvar "append" $$ Paren ((Var . unqualFName . fieldName $ fi)+ $$ lvar "old'Self")+ $$ lvar "new'Field"+ | isRequired fi = qMerge (lvar "new'Field")+ | otherwise = qMerge (preludecon "Just" $$ lvar "new'Field")+ where qMerge x | fromIntegral (getFieldType (typeCode fi)) `elem` [10,(11::Int)] =+ pvar "mergeAppend" $$ Paren ( (Var . unqualFName . fieldName $ fi)+ $$ lvar "old'Self" )+ $$ Paren x+ | otherwise = x+ toUpdatePacked wt2 fi =+ Alt src (litIntP . getWireTag $ wt2) (UnGuardedAlt $ + preludevar "fmap" $$ (Paren $ Lambda src [PBangPat (patvar "new'Field")] $+ RecUpdate (lvar "old'Self")+ [FieldUpdate (unqualFName . fieldName $ fi)+ (labelUpdatePacked fi)])+ $$ (Paren (pvar "wireGetPacked" $$ (litInt . getFieldType . typeCode $ fi)))) noWhere+ labelUpdatePacked fi = pvar "mergeAppend" $$ Paren ((Var . unqualFName . fieldName $ fi)+ $$ lvar "old'Self")+ $$ lvar "new'Field"++ -- in the above, the [10,11] check optimizes using the+ -- knowledge that only TYPE_MESSAGE and TYPE_GROUP have merges+ -- that are not right-biased replacements. The "mergeAppend" uses+ -- knowledge of how all repeated fields get merged.++ in InstDecl src [] (private "Wire") [TyCon me] . map InsDecl $+ [ FunBind [Match src (Ident "wireSize") [patvar "ft'",PAsPat (Ident "self'") (PParen mine)] Nothing sizeCases whereCalcSize]+ , FunBind [Match src (Ident "wirePut") [patvar "ft'",PAsPat (Ident "self'") (PParen mine)] Nothing putCases wherePutFields]+ , FunBind [Match src (Ident "wireGet") [patvar "ft'"] Nothing getCases whereDecls]+ ]++instanceReflectDescriptor :: DescriptorInfo -> Decl+instanceReflectDescriptor di+ = InstDecl src [] (private "ReflectDescriptor") [TyCon (unqualName (descName di))]+ [ inst "getMessageInfo" [PWildCard] gmi+ , inst "reflectDescriptorInfo" [ PWildCard ] rdi ]+ where -- massive shortcut through show and read+ rdi :: Exp+ rdi = preludevar "read" $$ litStr (show di)+ gmi,reqId,allId :: Exp+ gmi = pcon "GetMessageInfo" $$ Paren reqId $$ Paren allId+ reqId = pvar "fromDistinctAscList" $$+ List (map litInt . sort . concat $ [ allowedList fi | fi <- F.toList (fields di), isRequired fi])+ allId = pvar "fromDistinctAscList" $$+ List (map litInt . sort . concat $ [ allowedList fi | fi <- F.toList (fields di)] +++ [ allowedList fi | fi <- F.toList (knownKeys di)])+ allowedList fi | Just (wt1,wt2) <- packedTag fi = [getWireTag wt1,getWireTag wt2]+ | otherwise = [getWireTag (wireTag fi)]++------------------------------------------------------------------++derives,derivesEnum :: [Deriving]+derives = map (\ x -> (prelude x,[])) ["Show","Eq","Ord","Typeable","Data"]+derivesEnum = map (\ x -> (prelude x,[])) ["Read","Show","Eq","Ord","Typeable","Data"]++-- All of these type names are also exported by Text.ProtocolBuffers.Header via Text.ProtocolBuffers.Basic+useType :: Int -> Maybe String+useType 1 = Just "Double"+useType 2 = Just "Float"+useType 3 = Just "Int64"+useType 4 = Just "Word64"+useType 5 = Just "Int32"+useType 6 = Just "Word64"+useType 7 = Just "Word32"+useType 8 = Just "Bool"+useType 9 = Just "Utf8"+useType 10 = Nothing+useType 11 = Nothing+useType 12 = Just "ByteString"+useType 13 = Just "Word32"+useType 14 = Nothing+useType 15 = Just "Int32"+useType 16 = Just "Int64"+useType 17 = Just "Int32"+useType 18 = Just "Int64"+useType x = imp $ "useType: Unknown type code (expected 1 to 18) of "++show x++
+ Text/ProtocolBuffers/ProtoCompile/Identifiers.hs view
@@ -0,0 +1,215 @@+{-# LANGUAGE MultiParamTypeClasses,FlexibleInstances,TypeSynonymInstances,FlexibleContexts #-}+-- | This modules collects utility routines related to the different+-- incarnations of identifiers in the code. The basic identifier is+-- always ASCII, but because of the self gereneted DescriptorProto+-- data structures it is stored in 'Utf8' tagged lazy bytestrings.+--+-- An 'identifier' is a non-empty ASCII string made of [a-zA-Z0-9_]+-- where the first character is never in [0-9].+--+-- A 'field' is a mangled identifer that is a valid Haskell name that+-- begins with lower case, and which may have a single quote at the+-- end if needed to avoid a reserved word.+--+-- A 'module' is a mangled identifier that is a valid Haskell name+-- that begins with upper case. These never have a single quote. A+-- leading _ is replaced with a leading U'_ to make a valid+-- identifier.+module Text.ProtocolBuffers.ProtoCompile.Identifiers where++import qualified Data.ByteString.Lazy.Char8 as LC+import qualified Data.ByteString.Lazy.UTF8 as U+import Data.Char+import Data.List+import Data.Monoid+import Data.Set(Set)+import qualified Data.Set as S+import Text.ProtocolBuffers.Basic++-- | Contains one identifier name+newtype IName a = IName {iName::a} deriving (Show,Read,Eq,Ord)+-- | Contains one module name+newtype MName a = MName {mName::a} deriving (Show,Read,Eq,Ord)+-- | Contains one field name+newtype FName a = FName {fName::a} deriving (Show,Read,Eq,Ord)+-- | '.' separated identifier which may or may start with a dot+newtype DIName a = DIName {diName :: a}+-- | Fully qualified identifier: repeated '.' then identifier.+newtype FIName a = FIName {fiName::a} deriving (Show,Read,Eq,Ord)+-- | Full Haskell module name: MNames separated by '.', ending with a module+newtype FMName a = FMName {fmName::a} deriving (Show,Read,Eq,Ord)+-- | Full Haskell field name: MNames separated by '.', ending with a field+newtype FFName a = FFName {ffName::a} deriving (Show,Read,Eq,Ord)+-- | Parsed Haskell name ending with MName+data PMName a = PMName [MName a] (MName a) deriving (Show,Read,Eq,Ord)+-- | Parsed Haskell name ending with FName+data PFName a = PFName [MName a] (FName a) deriving (Show,Read,Eq,Ord)++dotPM :: Dotted a => PMName a -> FMName a+dotPM (PMName xs (MName x)) = FMName (foldr dot x . map mName $ xs)++dotPF :: Dotted a => PFName a -> FFName a+dotPF (PFName xs (FName x)) = FFName (foldr dot x . map mName $ xs)++dotUtf8 (Utf8 a) (Utf8 b) = Utf8 (LC.append a (LC.cons '.' b))++dotString a b = a ++ ('.':b)++unull :: Utf8 -> Bool+unull = LC.null . utf8++preUtf8 :: Utf8 -> Utf8+preUtf8 (Utf8 x) = Utf8 (LC.cons 'x' x)++preString :: String -> String+preString = ('.':)++splitUtf8 :: DIName Utf8 -> [IName Utf8]+splitUtf8 = unfoldr s . utf8 . diName where+ s :: ByteString -> Maybe (IName Utf8,ByteString)+ s y | LC.null y = Nothing+ | otherwise = case U.span ('.'/=) y of+ (a,b) | LC.null a -> s b+ | otherwise -> Just (IName (Utf8 a),b)++splitString :: DIName String -> [IName String]+splitString = unfoldr s . diName where+ s [] = Nothing+ s ('.':xs) = s xs -- delete all '.' in the input+ s xs = Just (let (a,b) = span ('.'/=) xs in (IName a,b))++toString :: Utf8 -> String+toString = U.toString . utf8++fromString :: String -> Utf8+fromString = Utf8 . U.fromString++difi :: Dotted a => DIName a -> FIName a+difi (DIName a) = case uncons a of+ Nothing -> FIName mempty+ Just ('.',_) -> FIName a+ _ -> FIName (preDot a)++{- in Text.ProtocolBuffers.Basic now+instance Monoid Utf8 where+ mempty = Utf8 mempty+ mappend (Utf8 x) (Utf8 y) = Utf8 (mappend x y)+-}++class Monoid a => Dotted a where+ uncons :: a -> Maybe (Char,a)+ preDot :: a -> a+ dot :: a -> a -> a+ splitDI :: DIName a -> [IName a]++instance Dotted Utf8 where+ uncons x = case U.uncons (utf8 x) of+ Nothing -> Nothing+ Just (c,b) -> Just (c,Utf8 b)+ preDot = preUtf8+ dot = dotUtf8+ splitDI = splitUtf8++instance Dotted String where+ uncons [] = Nothing+ uncons (x:xs) = Just (x,xs)+ preDot = preString+ dot = dotString+ splitDI = splitString++splitFI :: Dotted a => FIName a -> [IName a]+splitFI = splitDI . DIName . fiName++fqDots :: Dotted a => [IName a] -> FIName a+fqDots [] = FIName mempty+fqDots xs = FIName (preDot (foldr1 dot . map iName $ xs))++joinDots :: Dotted a => [a] -> a+joinDots [] = mempty+joinDots xs = foldr1 dot xs++-- | Right (True,_) means the input is a FIName.+-- Right (False,_) means the input is a DIName (without leading '.')+checkDIString :: String -> Either String (Bool,[IName String])+checkDIString "" = Left $ "Invalid empty identifier: "++show ""+checkDIString "." = Left $ "Invalid identifier of just a period: "++show "."+checkDIString xs | ('.':ys) <- xs = fmap ((,) True) $ parts id (span ('.'/=) ys)+ | otherwise = fmap ((,) False) $ parts id (span ('.'/=) xs)+ where parts f ("","") = Left $ "Invalid identifier because it ends with a period: "++show xs+ parts f ("",_) = Left $ "Invalid identifier because is contains two periods in a row: "++show xs+ parts f (_,"") = Right (f [])+ parts f (a,b) = parts (f . (IName a:)) (span ('.'/=) (tail b))++-- | Right (True,_) means the input is a FIName.+-- Right (False,_) means the input is a DIName (without leading '.')+checkDIUtf8 :: Utf8 -> Either String (Bool,[IName Utf8])+checkDIUtf8 s@(Utf8 xs) =+ case U.uncons xs of+ Nothing -> Left $ "Invalid empty identifier: "++show ""+ Just ('.',ys) | LC.null ys -> Left $ "Invalid identifier of just a period: "++show "."+ | otherwise -> fmap ((,) True) $ parts id (U.span ('.'/=) ys)+ Just _ -> fmap ((,) False) $ parts id (U.span ('.'/=) xs)+ where parts f (a,b) = case (LC.null a,LC.null b) of+ (True,True) -> Left $ "Invalid identifier because it ends with a period: "++show (toString s)+ (True,_) -> Left $ "Invalid identifier because is contains two periods in a row: "++show (toString s)+ (_,True) -> Right (f [])+ _ -> parts (f . (IName (Utf8 a):)) (U.span ('.'/=) (U.drop 1 b))++manglePM :: Mangle a (MName x) => [a] -> PMName x+manglePM = go id where+ go ms [x] = PMName (ms []) (mangle x)+ go ms (x:xs) = go (ms . (mangle x:)) xs++manglePF :: (Mangle a (MName x),Mangle a (FName x)) => [a] -> PFName x+manglePF = go id where+ go ms [x] = PFName (ms []) (mangle x)+ go ms (x:xs) = go (ms . (mangle x:)) xs++class Mangle a b where+ mangle :: a -> b++err :: String -> a+err s = error ("Text.ProtocolBuffers.ProtoCompile.Identifiers: "++s)++instance Mangle (IName String) (MName String) where+ mangle (IName s) = MName (fixUp s)++instance Mangle (IName Utf8) (MName Utf8) where+ mangle (IName s) = MName (fromString . fixUp . toString $ s)++instance Mangle (IName Utf8) (MName String) where+ mangle (IName s) = MName (fixUp . toString $ s)++instance Mangle (IName String) (FName String) where+ mangle (IName s) = FName (fixLow s)++instance Mangle (IName Utf8) (FName Utf8) where+ mangle (IName s) = FName (fromString . fixLow . toString $ s)++instance Mangle (IName Utf8) (FName String) where+ mangle (IName s) = FName (fixLow . toString $ s)++-- make leading upper case letter or "U'_"+fixUp ('_':xs) = "U'"++xs+fixUp i@(x:xs) | isLower x =+ let x' = toUpper x+ in if isLower x' then err ("fixUp: stubborn lower case"++show i)+ else x': xs+fixUp xs = xs++-- make leading '_' or lower case letter, may end with single quote.+fixLow :: String -> String+fixLow i@(x:xs) | i `S.member` reserved = i ++ "'"+ | isUpper x = let x' = toLower x+ in if isUpper x' then err ("fixLow: stubborn upper case: "++show i)+ else let i' = (x':xs)+ in if i' `S.member` reserved then i' ++ "'" else i'+ | otherwise = i++reserved :: Set String+reserved = S.fromDistinctAscList+ ["_"+ ,"case","class","data","default","deriving","do","else","foreign"+ ,"if","import","in","infix","infixl","infixr","instance"+ ,"let","mdo","module","newtype","of","then","type","where"+ ]
+ Text/ProtocolBuffers/ProtoCompile/Instances.hs view
@@ -0,0 +1,85 @@+module Text.ProtocolBuffers.ProtoCompile.Instances(showsType,parseType,showsLabel,parseLabel) where++import Text.ParserCombinators.ReadP+import Text.DescriptorProtos.FieldDescriptorProto.Type(Type(..))+import Text.DescriptorProtos.FieldDescriptorProto.Label(Label(..))++{-+instance Show Type where+ showsPrec _ = showsType++instance Read Type where+ readsPrec _ = readP_to_S readType+-}++showsLabel :: Label -> ShowS+showsLabel LABEL_OPTIONAL s = "optional" ++ s+showsLabel LABEL_REQUIRED s = "required" ++ s+showsLabel LABEL_REPEATED s = "repeated" ++ s++showsType :: Type -> ShowS+showsType TYPE_DOUBLE s = "double" ++ s+showsType TYPE_FLOAT s = "float" ++ s+showsType TYPE_INT64 s = "int64" ++ s+showsType TYPE_UINT64 s = "uint64" ++ s+showsType TYPE_INT32 s = "int32" ++ s+showsType TYPE_FIXED64 s = "fixed64" ++ s+showsType TYPE_FIXED32 s = "fixed32" ++ s+showsType TYPE_BOOL s = "bool" ++ s+showsType TYPE_STRING s = "string" ++ s+showsType TYPE_GROUP s = "group" ++ s+showsType TYPE_MESSAGE s = "message" ++ s+showsType TYPE_BYTES s = "bytes" ++ s+showsType TYPE_UINT32 s = "uint32" ++ s+showsType TYPE_ENUM s = "enum" ++ s+showsType TYPE_SFIXED32 s = "sfixed32" ++ s+showsType TYPE_SFIXED64 s = "sfixed64" ++ s+showsType TYPE_SINT32 s = "sint32" ++ s+showsType TYPE_SINT64 s = "sint64" ++ s++-- | parseType returns Nothing when the String is user-defined. This means it could be either a+-- Message or an Enum or a syntax error. The Nothing return is fixed up in+-- Text.ProtocolBuffers.ProtoCompile.Resolve.fqField+parseType :: String -> Maybe Type+parseType s = case readP_to_S readType s of+ [(val,[])] -> Just val+ _ -> Nothing++-- | parseLabel recognizes optional, required, and repeated. All other strings result in Nothing+parseLabel :: String -> Maybe Label+parseLabel s = case readP_to_S readLabel s of+ [(val,[])] -> Just val+ _ -> Nothing++readLabel :: ReadP Label+readLabel = choice [ return LABEL_OPTIONAL << string "optional"+ , return LABEL_REQUIRED << string "required"+ , return LABEL_REPEATED << string "repeated"+ ]++-- readType interprets the string in the proto file, but there is no way to know if an unknown+-- string refers to a Message or to an Enum+readType :: ReadP Type+readType = choice [ return TYPE_DOUBLE << string "double"+ , return TYPE_FLOAT << string "float"+ , return TYPE_INT64 << string "int64"+ , return TYPE_UINT64 << string "uint64"+ , return TYPE_INT32 << string "int32"+ , return TYPE_FIXED64 << string "fixed64"+ , return TYPE_FIXED32 << string "fixed32"+ , return TYPE_BOOL << string "bool"+ , return TYPE_STRING << string "string"+ , return TYPE_GROUP << string "group"+ , return TYPE_BYTES << string "bytes"+ , return TYPE_UINT32 << string "uint32"+ , return TYPE_SFIXED32 << string "sfixed32"+ , return TYPE_SFIXED64 << string "sfixed64"+ , return TYPE_SINT32 << string "sint32"+ , return TYPE_SINT64 << string "sint64"+ ]+-- , return TYPE_MESSAGE << string "..."+-- , return TYPE_ENUM << string "..."++(<<) :: Monad m => m a -> m b -> m a+(<<) = flip (>>)+
+ Text/ProtocolBuffers/ProtoCompile/Lexer.x view
@@ -0,0 +1,200 @@+{+{-# OPTIONS_GHC -Wwarn #-}+module Text.ProtocolBuffers.ProtoCompile.Lexer (Lexed(..), alexScanTokens,getLinePos) where++import Control.Monad.Error()+import Codec.Binary.UTF8.String(encode)+import qualified Data.ByteString.Lazy as DBL+import Data.Char(ord,isHexDigit,isOctDigit,toLower)+import Data.Word(Word8)+import Numeric(readHex,readOct,readDec,readSigned,readFloat)+import qualified Data.ByteString.Lazy.Char8 as DBL8++}++%wrapper "posn-bytestring"++@inComment = ([^\*] | $white)+ | ([\*]+ [^\/])+@comment = [\/] [\*] (@inComment)* [\*]+ [\/] | "//".* | "#".*++$d = [0-9]+@decInt = [\-]?[1-9]$d*+@hexInt = [\-]?0[xX]([A-Fa-f0-9])++@octInt = [\-]?0[0-7]*+@doubleLit = [\-]?$d+(\.$d+)?([Ee][\+\-]?$d+)?++@ident1 = [A-Za-z_][A-Za-z0-9_]*+@ident = [\.]?@ident1([\.]@ident1)*+@notChar = [^A-Za-z0-9_]++@hexEscape = \\[Xx][A-Fa-f0-9]{1,2}+@octEscape = \\0?[0-7]{1,3}+@charEscape = \\[abfnrtv\\\?'\"]+@inStr = @hexEscape | @octEscape | @charEscape | [^'\"\n] | [\0]+@strLit = ['] (@inStr | [\"])* ['] | [\"] (@inStr | ['])* [\"]++$special = [=\(\)\,\;\[\]\{\}\.\:]++@ninf = [\-][i][n][f]++:-++ $white+ ;+ @comment ;+ @decInt / @notChar { parseDec }+ @octInt / @notChar { parseOct }+ @hexInt / @notChar { parseHex }+ @doubleLit / @notChar { parseDouble }+ @decInt { dieAt "decimal followed by invalid character" }+ @octInt { dieAt "octal followed by invalid character" }+ @hexInt { dieAt "hex followed by invalid character" }+ @doubleLit { dieAt "floating followed by invalid character" }+ @strLit { parseStr }+ @ident { parseName }+ @ninf { parseNinf }+ $special { parseChar }+ . { wtfAt }++{+line :: AlexPosn -> Int+line (AlexPn _byte lineNum _col) = lineNum+{-# INLINE line #-}++data Lexed = L_Integer !Int !Integer+ | L_Double !Int !Double+ | L_Name !Int !DBL.ByteString+ | L_String !Int !DBL.ByteString !DBL.ByteString+ | L !Int !Char+ | L_Error !Int !String+ deriving (Show,Eq)++getLinePos :: Lexed -> Int+getLinePos x = case x of+ L_Integer i _ -> i+ L_Double i _ -> i+ L_Name i _ -> i+ L_String i _ _ -> i+ L i _ -> i+ L_Error i _ -> i++-- 'errAt' is the only access to L_Error, so I can see where it is created with pos+errAt :: AlexPosn -> [Char] -> Lexed+errAt pos msg = L_Error (line pos) $ "Lexical error (in Text.ProtocolBuffers.Lexer): "++ msg ++ ", at "++see pos where+ see (AlexPn char lineNum col) = "character "++show char++" line "++show lineNum++" column "++show col++"."++dieAt :: [Char] -> AlexPosn -> t -> Lexed+dieAt msg pos _s = errAt pos msg++wtfAt :: AlexPosn -> DBL8.ByteString -> Lexed+wtfAt pos s = errAt pos $ "unknown character "++show c++" (decimal "++show (ord c)++")"+ where (c:_) = DBL8.unpack s++{-# INLINE mayRead #-}+mayRead :: ReadS a -> String -> Maybe a+mayRead f s = case f s of [(a,"")] -> Just a; _ -> Nothing++-- Given the regexps above, the "parse* failed" messages should be impossible.+parseDec,parseOct,parseHex,parseDouble,parseStr,parseNinf,parseName,parseChar :: AlexPosn -> DBL8.ByteString -> Lexed+parseDec pos s = maybe (errAt pos "Impossible? parseDec failed")+ (L_Integer (line pos)) $ mayRead (readSigned readDec) (DBL8.unpack s)+parseOct pos s = maybe (errAt pos "Impossible? parseOct failed")+ (L_Integer (line pos)) $ mayRead (readSigned readOct) (DBL8.unpack s)+parseHex pos s = maybe (errAt pos "Impossible? parseHex failed")+ (L_Integer (line pos)) $ mayRead (readSigned (readHex . drop 2)) (DBL8.unpack s)+parseDouble pos s = maybe (errAt pos "Impossible? parseDouble failed")+ (L_Double (line pos)) $ mayRead (readSigned readFloat) (DBL8.unpack s)+-- The sDecode of the string contents may fail+parseStr pos s = let middle = DBL8.init . DBL8.tail $ s+ in either (errAt pos) (L_String (line pos) middle . DBL.pack)+ . sDecode . DBL8.unpack $ middle++-- Here s is always "-inf" matched by @ninf+parseNinf pos s = L_Name (line pos) s++parseName pos s = L_Name (line pos) s+parseChar pos s = L (line pos) (DBL8.head s)++-- Generalization of concat . unfoldr to monadic-Either form:+op :: ( [Char] -> Either String (Maybe ([Word8],[Char]))) -> [Char] -> Either String [Word8]+op one = go id where+ go f cs = case one cs of+ Left msg -> Left msg+ Right Nothing -> Right (f [])+ Right (Just (ws,cs')) -> go (f . (ws++)) cs'++-- Put this mess in the lexer, so the rest of the code can assume+-- everything is saner. The input is checked to really be "Char8"+-- values in the range [0..255] and to be c-escaped (in order to+-- render binary information printable). This decodes the c-escaping+-- and returns the binary data as Word8.+-- +-- A decoding error causes (Left msg) to be returned.+sDecode :: [Char] -> Either String [Word8]+sDecode = op one where+ one :: [Char] -> Either String (Maybe ([Word8],[Char]))+ one ('\\':xs) = unescape xs+ one (x:xs) = do x' <- checkChar8 x+ return $ Just (x',xs) -- main case of unescaped value+ one [] = return Nothing+ unescape [] = Left "cannot understand a string that ends with a backslash"+ unescape ys | 1 <= len =+ case mayRead readOct oct of+ Just w -> do w' <- checkByte w+ return $ Just (w',rest)+ Nothing -> Left $ "failed to decode octal sequence "++ys+ where oct = takeWhile isOctDigit (take 3 ys)+ len = length oct+ rest = drop len ys+ unescape (x:ys) | 'x' == toLower x && 1 <= len =+ case mayRead readHex hex of+ Just w -> do w' <- checkByte w+ return $ Just (w',rest)+ Nothing -> Left $ "failed to decode hex sequence "++ys+ where hex = takeWhile isHexDigit (take 2 ys)+ len = length hex+ rest = drop len ys + unescape ('u':ys) | ok =+ case mayRead readHex hex of+ Just w -> do w' <- checkUnicode w+ return $ Just (w',rest)+ Nothing -> Left $ "failed to decode 4 char unicode sequence "++ys+ where ok = all isHexDigit hex && 4 == length hex+ (hex,rest) = splitAt 4 ys+ unescape ('U':ys) | ok =+ case mayRead readHex hex of+ Just w -> do w' <- checkUnicode w+ return $ Just (w',rest)+ Nothing -> Left $ "failed to decode 8 char unicode sequence "++ys+ where ok = all isHexDigit hex && 8 == length hex+ (hex,rest) = splitAt 8 ys+ unescape (x:xs) = do x' <- decode x+ return $ Just ([x'],xs)+ decode :: Char -> Either String Word8+ decode 'a' = return 7+ decode 'b' = return 8+ decode 't' = return 9+ decode 'n' = return 10+ decode 'v' = return 11+ decode 'f' = return 12+ decode 'r' = return 13+ decode '\"' = return 34+ decode '\'' = return 39+ decode '?' = return 63 -- C99 rule : "\?" is '?'+ decode '\\' = return 92+ decode x | toLower x == 'x' = Left "cannot understand your 'xX' hexadecimal escaped value"+ decode x | toLower x == 'u' = Left "cannot understand your 'uU' unicode UTF-8 hexadecimal escaped value"+ decode _ = Left "cannot understand your backslash-escaped value"+ checkChar8 :: Char -> Either String [Word8]+ checkChar8 c | (0 <= i) && (i <= 255) = Right [toEnum i]+ | otherwise = Left $ "found Char out of range 0..255, value="++show (ord c)+ where i = fromEnum c+ checkByte :: Integer -> Either String [Word8]+ checkByte i | (0 <= i) && (i <= 255) = Right [fromInteger i]+ | otherwise = Left $ "found Oct/Hex Int out of range 0..255, value="++show i+ checkUnicode :: Integer -> Either String [Word8]+ checkUnicode i | (0 <= i) && (i <= 127) = Right [fromInteger i]+ | i <= maxChar = Right $ encode [ toEnum . fromInteger $ i ]+ | otherwise = Left $ "found Unicode Char out of range 0..0x10FFFF, value="++show i+ where maxChar = toInteger (fromEnum (maxBound ::Char)) -- 0x10FFFF++}
+ Text/ProtocolBuffers/ProtoCompile/MakeReflections.hs view
@@ -0,0 +1,315 @@+-- | The 'MakeReflections' module takes the 'FileDescriptorProto'+-- output from 'Resolve' and produces a 'ProtoInfo' from+-- 'Reflections'. This also takes a Haskell module prefix and the+-- proto's package namespace as input. The output is suitable+-- for passing to the 'Gen' module to produce the files.+--+-- This acheives several things: It moves the data from a nested tree+-- to flat lists and maps. It moves the group information from the+-- parent Descriptor to the actual Descriptor. It moves the data out+-- of Maybe types. It converts Utf8 to String. Keys known to extend+-- a Descriptor are listed in that Descriptor.+-- +-- In building the reflection info new things are computed. It changes+-- dotted names to ProtoName using the translator from+-- 'makeNameMaps'. It parses the default value from the ByteString to+-- a Haskell type. For fields, the value of the tag on the wire is+-- computed and so is its size on the wire.+module Text.ProtocolBuffers.ProtoCompile.MakeReflections(makeProtoInfo,serializeFDP) where++import qualified Text.DescriptorProtos.DescriptorProto as D(DescriptorProto)+import qualified Text.DescriptorProtos.DescriptorProto as D.DescriptorProto(DescriptorProto(..))+import qualified Text.DescriptorProtos.DescriptorProto.ExtensionRange as D.DescriptorProto(ExtensionRange(ExtensionRange))+import qualified Text.DescriptorProtos.DescriptorProto.ExtensionRange as D.DescriptorProto.ExtensionRange(ExtensionRange(..))+import qualified Text.DescriptorProtos.EnumDescriptorProto as D(EnumDescriptorProto) +import qualified Text.DescriptorProtos.EnumDescriptorProto as D.EnumDescriptorProto(EnumDescriptorProto(..)) +import qualified Text.DescriptorProtos.EnumValueDescriptorProto as D(EnumValueDescriptorProto)+import qualified Text.DescriptorProtos.EnumValueDescriptorProto as D.EnumValueDescriptorProto(EnumValueDescriptorProto(..))+import qualified Text.DescriptorProtos.FieldDescriptorProto as D(FieldDescriptorProto) +import qualified Text.DescriptorProtos.FieldDescriptorProto as D.FieldDescriptorProto(FieldDescriptorProto(..)) +-- import qualified Text.DescriptorProtos.FieldDescriptorProto.Label as D.FieldDescriptorProto(Label)+import Text.DescriptorProtos.FieldDescriptorProto.Label as D.FieldDescriptorProto.Label(Label(..))+-- import qualified Text.DescriptorProtos.FieldDescriptorProto.Type as D.FieldDescriptorProto(Type)+import Text.DescriptorProtos.FieldDescriptorProto.Type as D.FieldDescriptorProto.Type(Type(..))+import qualified Text.DescriptorProtos.FieldOptions as D(FieldOptions(FieldOptions))+import qualified Text.DescriptorProtos.FieldOptions as D.FieldOptions(FieldOptions(..))+import qualified Text.DescriptorProtos.FileDescriptorProto as D(FileDescriptorProto(FileDescriptorProto)) +import qualified Text.DescriptorProtos.FileDescriptorProto as D.FileDescriptorProto(FileDescriptorProto(..)) ++import Text.ProtocolBuffers.Basic+import Text.ProtocolBuffers.Identifiers+import Text.ProtocolBuffers.Reflections+import Text.ProtocolBuffers.WireMessage(size'WireTag,toWireTag,toPackedWireTag,runPut,Wire(..))+import Text.ProtocolBuffers.ProtoCompile.Resolve(ReMap,NameMap(..),getPackageID)++import qualified Data.Foldable as F(foldr,toList)+import qualified Data.Sequence as Seq(fromList,empty,singleton,null)+import Numeric(readHex,readOct,readDec)+import Data.Monoid(mconcat,mappend)+import qualified Data.Map as M(fromListWith,lookup,keys)+import Data.Maybe(fromMaybe,catMaybes,fromJust)+import System.FilePath++--import Debug.Trace (trace)++imp :: String -> a+imp msg = error $ "Text.ProtocolBuffers.ProtoCompile.MakeReflections: Impossible?\n "++msg++pnPath :: ProtoName -> [FilePath]+pnPath (ProtoName _ a b c) = splitDirectories .flip addExtension "hs" . joinPath . map mName $ a++b++[c]++serializeFDP :: D.FileDescriptorProto -> ByteString+serializeFDP fdp = runPut (wirePut 11 fdp)++toHaskell :: ReMap -> FIName Utf8 -> ProtoName+toHaskell reMap k = case M.lookup k reMap of+ Nothing -> imp $ "toHaskell failed to find "++show k++" among "++show (M.keys reMap)+ Just pn -> pn++makeProtoInfo :: (Bool,Bool) -- unknownField and lazyFields for makeDescriptorInfo'+ -> NameMap+ -> D.FileDescriptorProto + -> ProtoInfo+makeProtoInfo (unknownField,lazyFieldsOpt) (NameMap (packageID,hPrefix,hParent) reMap)+ fdp@(D.FileDescriptorProto { D.FileDescriptorProto.name = Just rawName })+ = ProtoInfo protoName (pnPath protoName) (toString rawName) keyInfos allMessages allEnums allKeys where+ packageName = getPackageID packageID :: FIName (Utf8)+ protoName = case hParent of+ [] -> case hPrefix of+ [] -> imp $ "makeProtoInfo: no hPrefix or hParent in NameMap for: "++show fdp+ _ -> ProtoName packageName (init hPrefix) [] (last hPrefix)+ _ -> ProtoName packageName hPrefix (init hParent) (last hParent)+ keyInfos = Seq.fromList . map (\f -> (keyExtendee' reMap f,toFieldInfo' reMap packageName f))+ . F.toList . D.FileDescriptorProto.extension $ fdp+ allMessages = concatMap (processMSG packageName False) (F.toList $ D.FileDescriptorProto.message_type fdp)+ allEnums = map (makeEnumInfo' reMap packageName) (F.toList $ D.FileDescriptorProto.enum_type fdp) + ++ concatMap (processENM packageName) (F.toList $ D.FileDescriptorProto.message_type fdp)+ allKeys = M.fromListWith mappend . map (\(k,a) -> (k,Seq.singleton a))+ . F.toList . mconcat $ keyInfos : map keys allMessages+ processMSG parent msgIsGroup msg = + let getKnownKeys protoName' = fromMaybe Seq.empty (M.lookup protoName' allKeys)+ groups = collectedGroups msg+ checkGroup x = elem (fromMaybe (imp $ "no message name in makeProtoInfo.processMSG.checkGroup:\n"++show msg)+ (D.DescriptorProto.name x))+ groups+ parent' = fqAppend parent [IName (fromJust (D.DescriptorProto.name msg))]+ in makeDescriptorInfo' reMap parent getKnownKeys msgIsGroup (unknownField,lazyFieldsOpt) msg+ : concatMap (\x -> processMSG parent' (checkGroup x) x)+ (F.toList (D.DescriptorProto.nested_type msg))+ processENM parent msg = foldr ((:) . makeEnumInfo' reMap parent') nested+ (F.toList (D.DescriptorProto.enum_type msg))+ where parent' = fqAppend parent [IName (fromJust (D.DescriptorProto.name msg))]+ nested = concatMap (processENM parent') (F.toList (D.DescriptorProto.nested_type msg))+makeProtoInfo _ _ _ = imp $ "makeProtoInfo: missing name or package"++makeEnumInfo' :: ReMap -> FIName Utf8 -> D.EnumDescriptorProto -> EnumInfo+makeEnumInfo' reMap parent+ e@(D.EnumDescriptorProto.EnumDescriptorProto+ { D.EnumDescriptorProto.name = Just rawName+ , D.EnumDescriptorProto.value = value })+ = if Seq.null value then imp $ "enum has no values: "++show e+ else EnumInfo protoName (pnPath protoName) enumVals+ where protoName = toHaskell reMap $ fqAppend parent [IName rawName]+ enumVals ::[(EnumCode,String)]+ enumVals = F.foldr ((:) . oneValue) [] value+ where oneValue :: D.EnumValueDescriptorProto -> (EnumCode,String)+ oneValue (D.EnumValueDescriptorProto.EnumValueDescriptorProto+ { D.EnumValueDescriptorProto.name = Just name+ , D.EnumValueDescriptorProto.number = Just number })+ = (EnumCode number,mName . baseName . toHaskell reMap $ fqAppend (protobufName protoName) [IName name])+ oneValue evdp = imp $ "no name or number for evdp passed to makeEnumInfo.oneValue: "++show evdp+makeEnumInfo' _ _ _ = imp "makeEnumInfo: missing name"++keyExtendee' :: ReMap -> D.FieldDescriptorProto.FieldDescriptorProto -> ProtoName+keyExtendee' reMap f = case D.FieldDescriptorProto.extendee f of+ Nothing -> imp $ "keyExtendee expected Just but found Nothing: "++show f+ Just extName -> toHaskell reMap (FIName extName)+ -- let debugMsg = unlines [ "MakeReflections.keyExtendee'.debugMsg"+ -- , "extName is " ++ show extName+ -- , "reMap is :"+ -- , show reMap ]++makeDescriptorInfo' :: ReMap -> FIName Utf8+ -> (ProtoName -> Seq FieldInfo)+ -> Bool -- msgIsGroup+ -> (Bool,Bool) -- unknownField and lazyFields+ -> D.DescriptorProto -> DescriptorInfo+makeDescriptorInfo' reMap parent getKnownKeys msgIsGroup (unknownField,lazyFieldsOpt)+ (D.DescriptorProto.DescriptorProto+ { D.DescriptorProto.name = Just rawName+ , D.DescriptorProto.field = rawFields+ , D.DescriptorProto.extension = rawKeys+ , D.DescriptorProto.extension_range = extension_range })+ = let di = DescriptorInfo protoName (pnPath protoName) msgIsGroup+ fieldInfos keyInfos extRangeList (getKnownKeys protoName)+ unknownField lazyFieldsOpt+ in di -- trace (toString rawName ++ "\n" ++ show di ++ "\n\n") $ di+ where protoName = toHaskell reMap $ fqAppend parent [IName rawName]+ fieldInfos = fmap (toFieldInfo' reMap (protobufName protoName)) rawFields+ keyInfos = fmap (\f -> (keyExtendee' reMap f,toFieldInfo' reMap (protobufName protoName) f)) rawKeys+ extRangeList = concatMap check unchecked+ where check x@(lo,hi) | hi < lo = []+ | hi<19000 || 19999<lo = [x]+ | otherwise = concatMap check [(lo,18999),(20000,hi)]+ unchecked = F.foldr ((:) . extToPair) [] extension_range+ extToPair (D.DescriptorProto.ExtensionRange+ { D.DescriptorProto.ExtensionRange.start = mStart+ , D.DescriptorProto.ExtensionRange.end = mEnd }) =+ (maybe minBound FieldId mStart, maybe maxBound (FieldId . pred) mEnd)+makeDescriptorInfo' _ _ _ _ _ _ = imp $ "makeDescriptorInfo: missing name"++toFieldInfo' :: ReMap -> FIName Utf8 -> D.FieldDescriptorProto -> FieldInfo+toFieldInfo' reMap parent+ f@(D.FieldDescriptorProto.FieldDescriptorProto+ { D.FieldDescriptorProto.name = Just name+ , D.FieldDescriptorProto.number = Just number+ , D.FieldDescriptorProto.label = Just label+ , D.FieldDescriptorProto.type' = Just type'+ , D.FieldDescriptorProto.type_name = mayTypeName+ , D.FieldDescriptorProto.default_value = mayRawDef+ , D.FieldDescriptorProto.options = mayOpt })+ = fieldInfo+ where mayDef = parseDefaultValue f+ fieldInfo = let (ProtoName x a b c) = toHaskell reMap $ fqAppend parent [IName name]+ protoFName = ProtoFName x a b (mangle c)+ fieldId = (FieldId (fromIntegral number))+ fieldType = (FieldType (fromEnum type'))+{- removed to update 1.5.5 to be compatible with protobuf-2.3.0+ wt | packedOption = toPackedWireTag fieldId+ | otherwise = toWireTag fieldId fieldType+-}+ wt | packedOption = toPackedWireTag fieldId -- write packed+ | otherwise = toWireTag fieldId fieldType -- write unpacked+ + wt2 | validPacked = Just (toWireTag fieldId fieldType -- read unpacked+ ,toPackedWireTag fieldId) -- read packed+ | otherwise = Nothing+ wtLength = size'WireTag wt+ packedOption = case mayOpt of+ Just (D.FieldOptions { D.FieldOptions.packed = Just True }) -> True+ _ -> False+ validPacked = isValidPacked label fieldType+ in FieldInfo protoFName+ fieldId+ wt+ wt2+ wtLength+ packedOption+ (label == LABEL_REQUIRED)+ (label == LABEL_REPEATED)+ validPacked+ fieldType+ (fmap (toHaskell reMap . FIName) mayTypeName)+ (fmap utf8 mayRawDef)+ mayDef+toFieldInfo' _ _ f = imp $ "toFieldInfo: missing info in "++show f++collectedGroups :: D.DescriptorProto -> [Utf8] +collectedGroups = catMaybes+ . map D.FieldDescriptorProto.type_name+ . filter (\f -> D.FieldDescriptorProto.type' f == Just TYPE_GROUP) + . F.toList+ . D.DescriptorProto.field++-- "Nothing" means no value specified+-- A failure to parse a provided value will result in an error at the moment+parseDefaultValue :: D.FieldDescriptorProto -> Maybe HsDefault+parseDefaultValue f@(D.FieldDescriptorProto.FieldDescriptorProto+ { D.FieldDescriptorProto.type' = type'+ , D.FieldDescriptorProto.default_value = mayRawDef })+ = do bs <- mayRawDef+ t <- type'+ todo <- case t of+ TYPE_MESSAGE -> Nothing+ TYPE_GROUP -> Nothing+ TYPE_ENUM -> Just parseDefEnum+ TYPE_BOOL -> Just parseDefBool+ TYPE_BYTES -> Just parseDefBytes+ TYPE_DOUBLE -> Just parseDefDouble+ TYPE_FLOAT -> Just parseDefFloat+ TYPE_STRING -> Just parseDefString+ _ -> Just parseDefInteger+ case todo bs of+ Nothing -> error $ "Could not parse as type "++ show t ++" the default value (raw) is "++ show mayRawDef ++" for field "++show f+ Just value -> return value++--- From here down is code used to parse the format of the default values in the .proto files++-- On 25 August 2010 20:12, George van den Driessche <georgevdd@google.com> sent Chris Kuklewicz a+-- patch to MakeReflections.parseDefEnum to ensure that HsDef'Enum holds the mangled form of the+-- name.+parseDefEnum :: Utf8 -> Maybe HsDefault+parseDefEnum = Just . HsDef'Enum . mName . mangle . IName . uToString++{-# INLINE mayRead #-}+mayRead :: ReadS a -> String -> Maybe a+mayRead f s = case f s of [(a,"")] -> Just a; _ -> Nothing++parseDefDouble :: Utf8 -> Maybe HsDefault+parseDefDouble bs = case (uToString bs) of+ "nan" -> Just (HsDef'RealFloat SRF'nan)+ "-inf" -> Just (HsDef'RealFloat SRF'ninf)+ "inf" -> Just (HsDef'RealFloat SRF'inf)+ s -> fmap (HsDef'RealFloat . SRF'Rational . toRational) . mayRead reads'$ s+ where reads' :: ReadS Double+ reads' = readSigned' reads++{-+parseDefDouble :: Utf8 -> Maybe HsDefault+parseDefDouble bs | + | otherwise = fmap (HsDef'Rational . toRational) + . mayRead reads' . uToString $ bs+-}+++parseDefFloat :: Utf8 -> Maybe HsDefault+parseDefFloat bs = case (uToString bs) of+ "nan" -> Just (HsDef'RealFloat SRF'nan)+ "-inf" -> Just (HsDef'RealFloat SRF'ninf)+ "inf" -> Just (HsDef'RealFloat SRF'inf)+ s -> fmap (HsDef'RealFloat . SRF'Rational . toRational) . mayRead reads'$ s+ where reads' :: ReadS Float+ reads' = readSigned' reads++{-+parseDefFloat :: Utf8 -> Maybe HsDefault+parseDefFloat bs = fmap (HsDef'Rational . toRational) + . mayRead reads' . uToString $ bs+ where reads' :: ReadS Float+ reads' = readSigned' reads+-}++parseDefString :: Utf8 -> Maybe HsDefault+parseDefString bs = Just (HsDef'ByteString (utf8 bs))++parseDefBytes :: Utf8 -> Maybe HsDefault+parseDefBytes bs = Just (HsDef'ByteString (utf8 bs))++parseDefInteger :: Utf8 -> Maybe HsDefault+parseDefInteger bs = fmap HsDef'Integer . mayRead checkSign . uToString $ bs+ where checkSign = readSigned' checkBase+ checkBase ('0':'x':xs@(_:_)) = readHex xs+ checkBase ('0':xs@(_:_)) = readOct xs+ checkBase xs = readDec xs++parseDefBool :: Utf8 -> Maybe HsDefault+parseDefBool bs | bs == uFromString "true" = Just (HsDef'Bool True)+ | bs == uFromString "false" = Just (HsDef'Bool False)+ | otherwise = Nothing++-- The Numeric.readSigned does not handle '+' for some odd reason+readSigned' :: (Num a) => ([Char] -> [(a, t)]) -> [Char] -> [(a, t)]+readSigned' f ('-':xs) = map (\(v,s) -> (-v,s)) . f $ xs+readSigned' f ('+':xs) = f xs+readSigned' f xs = f xs++-- Must keep synchronized with Parser.isValidPacked+isValidPacked :: Label -> FieldType -> Bool+isValidPacked LABEL_REPEATED fieldType =+ case fieldType of+ 9 -> False+ 10 -> False+ 11 -> False -- Impossible value for typeCode from parseType, but here for completeness+ 12 -> False+ _ -> True+isValidPacked _ _ = False
+ Text/ProtocolBuffers/ProtoCompile/Parser.hs view
@@ -0,0 +1,624 @@+{-# LANGUAGE BangPatterns, RankNTypes, ScopedTypeVariables, CPP #-}+-- | This "Parser" module takes a filename and its contents as a+-- bytestring, and uses Lexer.hs to make a stream of tokens that it+-- parses. No IO is performed and the error function is not used.+-- Since the Lexer should also avoid such errors this should be a+-- reliably total function of the input.+--+-- The internals have been updated to handle Google's protobuf version+-- 2.0.3 formats, including EnumValueOptions.+module Text.ProtocolBuffers.ProtoCompile.Parser(parseProto,isValidPacked) where++import qualified Text.DescriptorProtos.DescriptorProto as D(DescriptorProto)+import qualified Text.DescriptorProtos.DescriptorProto as D.DescriptorProto(DescriptorProto(..))+-- import qualified Text.DescriptorProtos.DescriptorProto.ExtensionRange as D(ExtensionRange)+import qualified Text.DescriptorProtos.DescriptorProto.ExtensionRange as D.ExtensionRange(ExtensionRange(..))+import qualified Text.DescriptorProtos.EnumDescriptorProto as D(EnumDescriptorProto)+import qualified Text.DescriptorProtos.EnumDescriptorProto as D.EnumDescriptorProto(EnumDescriptorProto(..))+-- import qualified Text.DescriptorProtos.EnumOptions as D(EnumOptions)+import qualified Text.DescriptorProtos.EnumOptions as D.EnumOptions(EnumOptions(..))+import qualified Text.DescriptorProtos.EnumValueDescriptorProto as D(EnumValueDescriptorProto)+import qualified Text.DescriptorProtos.EnumValueDescriptorProto as D.EnumValueDescriptorProto(EnumValueDescriptorProto(..))+-- import qualified Text.DescriptorProtos.EnumValueOptions as D(EnumValueOptions)+import qualified Text.DescriptorProtos.EnumValueOptions as D.EnumValueOptions(EnumValueOptions(..))+import qualified Text.DescriptorProtos.FieldDescriptorProto as D(FieldDescriptorProto)+import qualified Text.DescriptorProtos.FieldDescriptorProto as D.FieldDescriptorProto(FieldDescriptorProto(..))+import Text.DescriptorProtos.FieldDescriptorProto.Label+-- import qualified Text.DescriptorProtos.FieldDescriptorProto.Type as D.FieldDescriptorProto(Type)+import Text.DescriptorProtos.FieldDescriptorProto.Type (Type(..))+-- import qualified Text.DescriptorProtos.FieldOptions as D(FieldOptions)+import qualified Text.DescriptorProtos.FieldOptions as D.FieldOptions(FieldOptions(..))+import qualified Text.DescriptorProtos.FileDescriptorProto as D(FileDescriptorProto)+import qualified Text.DescriptorProtos.FileDescriptorProto as D.FileDescriptorProto(FileDescriptorProto(..))+-- import qualified Text.DescriptorProtos.FileOptions as D(FileOptions)+import qualified Text.DescriptorProtos.FileOptions as D.FileOptions(FileOptions(..))+-- import qualified Text.DescriptorProtos.MessageOptions as D(MessageOptions)+import qualified Text.DescriptorProtos.MessageOptions as D.MessageOptions(MessageOptions(..))+import qualified Text.DescriptorProtos.MethodDescriptorProto as D(MethodDescriptorProto)+import qualified Text.DescriptorProtos.MethodDescriptorProto as D.MethodDescriptorProto(MethodDescriptorProto(..))+-- import qualified Text.DescriptorProtos.MethodOptions as D(MethodOptions)+import qualified Text.DescriptorProtos.MethodOptions as D.MethodOptions(MethodOptions(..))+import qualified Text.DescriptorProtos.ServiceDescriptorProto as D(ServiceDescriptorProto)+import qualified Text.DescriptorProtos.ServiceDescriptorProto as D.ServiceDescriptorProto(ServiceDescriptorProto(..))+-- import qualified Text.DescriptorProtos.ServiceOptions as D(ServiceOptions)+import qualified Text.DescriptorProtos.ServiceOptions as D.ServiceOptions(ServiceOptions(..))+import qualified Text.DescriptorProtos.UninterpretedOption as D(UninterpretedOption)+import qualified Text.DescriptorProtos.UninterpretedOption as D.UninterpretedOption(UninterpretedOption(..))+-- import qualified Text.DescriptorProtos.UninterpretedOption.NamePart as D(NamePart)+import qualified Text.DescriptorProtos.UninterpretedOption.NamePart as D.NamePart(NamePart(..))++import Text.ProtocolBuffers.Basic+import Text.ProtocolBuffers.Identifiers+import Text.ProtocolBuffers.Header(ReflectEnum(reflectEnumInfo),enumName)+import Text.ProtocolBuffers.ProtoCompile.Lexer(Lexed(..),alexScanTokens,getLinePos)+import Text.ProtocolBuffers.ProtoCompile.Instances(parseLabel,parseType)+-- import Text.ProtocolBuffers.Reflections()++import Control.Monad(when,liftM2,liftM3)+import qualified Data.ByteString.Lazy as L(unpack)+import qualified Data.ByteString.Lazy.Char8 as LC(notElem,head)+import qualified Data.ByteString.Lazy.UTF8 as U(fromString,toString)+import Data.Char(isUpper,toLower)+import Data.Ix(inRange)+import Data.Maybe(fromMaybe)+import Data.Monoid(mconcat)+import Data.Sequence((|>))+import qualified Data.Sequence as Seq(fromList)+import Data.Word(Word8)+import Numeric(showOct)+--import System.FilePath(takeFileName)+import Text.ParserCombinators.Parsec(GenParser,ParseError,runParser,sourceName,anyToken,many1,lookAhead,try+ ,getInput,setInput,getPosition,setPosition,getState,setState+ ,(<?>),(<|>),token,choice,between,eof,unexpected,skipMany)+import Text.ParserCombinators.Parsec.Pos(newPos)++default ()++#if MIN_VERSION_parsec(3,0,0)+type P st = GenParser Lexed st+#else+type P = GenParser Lexed+#endif++parseProto :: String -> ByteString -> Either ParseError D.FileDescriptorProto+parseProto filename fileContents = do+ let initial_line_number = case lexed of+ [] -> setPosition (newPos filename 0 0)+ (l:_) -> setPosition (newPos filename (getLinePos l) 0)+ initState = defaultValue {D.FileDescriptorProto.name=Just (uFromString filename)}+ lexed = alexScanTokens fileContents+ runParser (initial_line_number >> parser) initState filename lexed+++{-# INLINE mayRead #-}+mayRead :: ReadS a -> String -> Maybe a+mayRead f s = case f s of [(a,"")] -> Just a; _ -> Nothing++true,false :: ByteString+true = U.fromString "true"+false = U.fromString "false"++-- Use 'token' via 'tok' to make all the parsers for the Lexed values+tok :: (Lexed -> Maybe a) -> P s a+tok f = token show (\lexed -> newPos "" (getLinePos lexed) 0) f++pChar :: Char -> P s ()+pChar c = tok (\l-> case l of L _ x -> if (x==c) then return () else Nothing+ _ -> Nothing) <?> ("character "++show c)++eol,eols :: P s ()+eol = pChar ';'+eols = skipMany eol++pName :: ByteString -> P s Utf8+pName name = tok (\l-> case l of L_Name _ x -> if (x==name) then return (Utf8 x) else Nothing+ _ -> Nothing) <?> ("name "++show (U.toString name))++rawStrMany :: P s (ByteString,ByteString) -- used for any and all access to L_String+rawStrMany = fmap mconcat (many1 singleStringLit)+ where singleStringLit :: P s (ByteString,ByteString)+ singleStringLit = tok (\l-> case l of L_String _ raw x -> return (raw,x)+ _ -> Nothing) <?> "expected string literal in single or double quotes"++-- In Google's version 2.4.0 there can be default message values which are curly-brace delimited+-- aggregates. The lexer eats these fine, and this parser routine should recognized a balanced+-- expression. Used with 'undoLexer'.+--+-- This assumes the initial (L _ '{' ) has already been parsed.+getAggregate :: P s [Lexed]+getAggregate = do+ input <- getInput + let count :: Int -> Int -> P s [Lexed]+ count !n !depth = do+ -- Not using getNextToken so that the value of 'n' in count is correct.+ t <- anyToken+ case t of+ L _ '{' -> count (succ n) (succ depth)+ L _ '}' -> let n' = succ n+ depth' = pred depth+ in if 0==depth' then return (take n' input)+ else count n' depth'+ _ -> count (succ n) depth+ ls <- count 0 1+ return ls++getNextToken :: P s Lexed -- used in storing value for UninterpretedOption+getNextToken = do+ l <- lookAhead anyToken+ case l of+ L_String line _ _ -> rawStrMany >>= \(raw,bs) -> return (L_String line raw bs)+ _ -> anyToken++bsLit :: P s ByteString+bsLit = fmap fst rawStrMany <?> "quoted bytes literal, raw form"++strLit :: P s Utf8+strLit = fmap snd rawStrMany >>= \ x -> case isValidUTF8 x of+ Nothing -> return (Utf8 x)+ Just n -> fail $ "bad utf-8 byte in string literal position # "++show n++intLit,fieldInt,enumInt :: (Num a) => P s a+intLit = tok (\l-> case l of L_Integer _ x -> return (fromInteger x)+ _ -> Nothing) <?> "integer literal"++fieldInt = tok (\l-> case l of L_Integer _ x | inRange validRange x && not (inRange reservedRange x) -> return (fromInteger x)+ _ -> Nothing) <?> "field number (from 0 to 2^29-1 and not in 19000 to 19999)"+ where validRange = (0,(2^(29::Int))-1)+ reservedRange = (19000,19999)++enumInt = tok (\l-> case l of L_Integer _ x | inRange validRange x -> return (fromInteger x)+ _ -> Nothing) <?> "enum value (from -2^31 to 2^31-1)"+ where validRange = (toInteger (minBound :: Int32), toInteger (maxBound :: Int32))++doubleLit :: P s Double+doubleLit = tok (\l-> case l of L_Double _ x -> return x+ L_Integer _ x -> return (fromInteger x)+ L_Name _ s | s == U.fromString "inf" -> return (1/0)+ | s == U.fromString "-inf" -> return (-1/0)+ | s == U.fromString "nan" -> return (0/0)+ _ -> Nothing) <?> "double (or integer) literal or nan, inf, -inf"++floatLit :: P s Float+floatLit = tok (\l-> case l of L_Double _ x -> return . fromRational . toRational $ x+ L_Integer _ x -> return (fromInteger x)+ L_Name _ s | s == U.fromString "inf" -> return (1/0)+ | s == U.fromString "-inf" -> return (-1/0)+ | s == U.fromString "nan" -> return (0/0)+ _ -> Nothing) <?> "float (or integer) literal or nan, inf, -inf"++ident,ident1,ident_package :: P s Utf8+ident = tok (\l-> case l of L_Name _ x -> return (Utf8 x)+ _ -> Nothing) <?> "identifier (perhaps dotted)"++ident1 = tok (\l-> case l of L_Name _ x | LC.notElem '.' x -> return (Utf8 x)+ _ -> Nothing) <?> "identifier (not dotted)"++ident_package = tok (\l-> case l of L_Name _ x | LC.head x /= '.' -> return (Utf8 x)+ _ -> Nothing) <?> "package name (no leading dot)"++boolLit :: P s Bool+boolLit = tok (\l-> case l of L_Name _ x | x == true -> return True+ | x == false -> return False+ _ -> Nothing) <?> "boolean literal ('true' or 'false')"++enumLit :: forall s a. (Read a,ReflectEnum a) => P s a -- This is very polymorphic, and with a good error message+enumLit = do+ s <- fmap' uToString ident1+ case mayRead reads s of+ Just x -> return x+ Nothing -> let self = enumName (reflectEnumInfo (undefined :: a))+ in unexpected $ "Enum value not recognized: "++show s++", wanted enum value of type "++show self++-- -------------------------------------------------------------------+-- subParser changes the user state. It is a bit of a hack and is used+-- to define an interesting style of parsing.+subParser :: forall t sSub a s. Show t => GenParser t sSub a -> sSub -> GenParser t s sSub+subParser doSub inSub = do+ in1 <- getInput+ pos1 <- getPosition+ let out = runParser (setPosition pos1 >> doSub >> getStatus) inSub (sourceName pos1) in1+ case out of+ Left pe -> do+ let anyTok :: Int -> GenParser t s [t]+ anyTok i | i<=0 = return []+ | otherwise = try (liftM2 (:) anyToken (anyTok (pred i))) <|> (return [])+ context <- anyTok 10+ fail ( unlines [ "The error message from the nested subParser was:\n"++indent (show pe)+ , " The next 10 tokens were "++show context ] )+ Right (outSub,in2,pos2) -> setInput in2 >> setPosition pos2 >> return outSub+ where getStatus = liftM3 (,,) getState getInput getPosition+ indent = unlines . map (\s -> ' ':' ':s) . lines++{-# INLINE return' #-}+return' :: (Monad m) => a -> m a+return' a = return $! a++{-# INLINE fmap' #-}+fmap' :: (Monad m) => (a->b) -> m a -> m b+fmap' f m = m >>= \a -> seq a (return $! (f a))++{-# INLINE update' #-}+update' :: (s -> s) -> P s ()+update' f = getState >>= \s -> setState $! (f s)++parser :: P D.FileDescriptorProto D.FileDescriptorProto+parser = proto >> getState+ where proto = eof <|> (choice [ eol+ , importFile+ , package+ , fileOption+ , message upTopMsg+ , enum upTopEnum+ , extend upTopMsg upTopExt+ , service] >> proto)+ upTopMsg msg = update' (\s -> s {D.FileDescriptorProto.message_type=D.FileDescriptorProto.message_type s |> msg})+ upTopEnum e = update' (\s -> s {D.FileDescriptorProto.enum_type=D.FileDescriptorProto.enum_type s |> e})+ upTopExt f = update' (\s -> s {D.FileDescriptorProto.extension=D.FileDescriptorProto.extension s |> f})++importFile,package,fileOption,service :: P D.FileDescriptorProto.FileDescriptorProto ()+importFile = pName (U.fromString "import") >> strLit >>= \p -> eol >> update' (\s -> s {D.FileDescriptorProto.dependency=(D.FileDescriptorProto.dependency s) |> p})++package = pName (U.fromString "package") >> do+ p <- ident_package+ eol+ update' (\s -> s {D.FileDescriptorProto.package=Just p})++-- This parses the new extensible option name format of Google's protobuf verison 2.0.2+-- "foo.(bar.baz).qux" goes to Left [("foo",False),("bar.baz",True),("qux",False)]+pOptionE :: P s (Either D.UninterpretedOption String)+pOptionE = do+ let pieces = withParens <|> withoutParens+ withParens = do+ part <- between (pChar '(') (pChar ')') ident+ fmap ((part,True) :) ( choice [ pChar '=' >> return []+ , pChar '.' >> withParens+ , withoutParens ] )+ withoutParens = do+ parts <- fmap split ident+ let prepend rest = foldr (\part xs -> (part,False):xs) rest parts+ fmap prepend ( choice [ pChar '=' >> return []+ , pChar '.' >> withParens ] )+ nameParts <- pieces+ case nameParts of+ [(optName,False)] -> return (Right (uToString optName))+ _ -> do uno <- pUnValue (makeUninterpetedOption nameParts)+ return (Left uno)++pOptionWith :: P s t -> P s (Either D.UninterpretedOption String, t)+pOptionWith = liftM2 (,) (pName (U.fromString "option") >> pOptionE)++-- This does not handle D.UninterpretedOption.aggregate_value yet+pUnValue :: D.UninterpretedOption -> P s D.UninterpretedOption+pUnValue uno = getNextToken >>= storeLexed where+ storeLexed (L_Name _ bs) = return $ uno {D.UninterpretedOption.identifier_value = Just (Utf8 bs)}+ storeLexed (L_Integer _ i) | i >= 0 =+ return $ uno { D.UninterpretedOption.positive_int_value = Just (fromInteger i) }+ | otherwise =+ return $ uno { D.UninterpretedOption.negative_int_value = Just (fromInteger i) }+ storeLexed (L_Double _ d) = return $ uno {D.UninterpretedOption.double_value = Just d }+ storeLexed (L_String _ _raw bs) = return $ uno {D.UninterpretedOption.string_value = Just bs }+ storeLexed l@(L _ '{') = do ls <- getAggregate+ let bs = uFromString . concatMap undoLexer $ l:ls+ return $ uno {D.UninterpretedOption.aggregate_value = Just bs }+ storeLexed _ = fail $ "Could not the parse value of an custom (uninterpreted) option"++makeUninterpetedOption :: [(Utf8,Bool)] -> D.UninterpretedOption+makeUninterpetedOption nameParts = defaultValue { D.UninterpretedOption.name = Seq.fromList . map makeNamePart $ nameParts }+ where makeNamePart (name_part,is_extension) = defaultValue { D.NamePart.name_part = name_part+ , D.NamePart.is_extension = is_extension }++fileOption = pOptionWith getOld >>= setOption >>= setNew >> eol where+ getOld = fmap (fromMaybe defaultValue . D.FileDescriptorProto.options) getState+ setNew p = update' (\s -> s {D.FileDescriptorProto.options=Just p})+ setOption (Left uno,old) =+ return' (old {D.FileOptions.uninterpreted_option = D.FileOptions.uninterpreted_option old |> uno})+ setOption (Right optName,old) =+ case optName of+ "java_package" -> strLit >>= \p -> return' (old {D.FileOptions.java_package =Just p})+ "java_outer_classname" -> strLit >>= \p -> return' (old {D.FileOptions.java_outer_classname=Just p})+ "java_multiple_files" -> boolLit >>= \p -> return' (old {D.FileOptions.java_multiple_files =Just p})+ "java_generate_equals_and_hash" -> boolLit >>= \p -> return' (old {D.FileOptions.java_generate_equals_and_hash =Just p})+ "optimize_for" -> enumLit >>= \p -> return' (old {D.FileOptions.optimize_for =Just p})+ "cc_generic_services" -> boolLit >>= \p -> return' (old {D.FileOptions.cc_generic_services =Just p})+ "java_generic_services" -> boolLit >>= \p -> return' (old {D.FileOptions.java_generic_services =Just p})+ "py_generic_services" -> boolLit >>= \p -> return' (old {D.FileOptions.py_generic_services =Just p})+ _ -> unexpected $ "FileOptions has no option named " ++ optName++message :: (D.DescriptorProto -> P s ()) -> P s ()+message up = pName (U.fromString "message") >> do+ self <- ident1+ up =<< subParser (pChar '{' >> subMessage) (defaultValue {D.DescriptorProto.name=Just self})++-- subMessage is also used to parse group declarations+subMessage,messageOption,extensions :: P D.DescriptorProto.DescriptorProto ()+subMessage = (pChar '}') <|> (choice [ eol+ , field upNestedMsg Nothing >>= upMsgField+ , message upNestedMsg+ , enum upNestedEnum+ , extensions+ , extend upNestedMsg upExtField+ , messageOption] >> subMessage)+ where upNestedMsg msg = update' (\s -> s {D.DescriptorProto.nested_type=D.DescriptorProto.nested_type s |> msg})+ upNestedEnum e = update' (\s -> s {D.DescriptorProto.enum_type=D.DescriptorProto.enum_type s |> e})+ upMsgField f = update' (\s -> s {D.DescriptorProto.field=D.DescriptorProto.field s |> f})+ upExtField f = update' (\s -> s {D.DescriptorProto.extension=D.DescriptorProto.extension s |> f})++messageOption = pOptionWith getOld >>= setOption >>= setNew >> eol where+ getOld = fmap (fromMaybe defaultValue . D.DescriptorProto.options) getState+ setNew p = update' (\s -> s {D.DescriptorProto.options=Just p})+ setOption (Left uno,old) =+ return' (old {D.MessageOptions.uninterpreted_option = D.MessageOptions.uninterpreted_option old |> uno })+ setOption (Right optName,old) =+ case optName of+ "message_set_wire_format" -> boolLit >>= \p -> return' (old {D.MessageOptions.message_set_wire_format=Just p})+ "no_standard_descriptor_accessor" -> boolLit >>= \p -> return' (old {D.MessageOptions.no_standard_descriptor_accessor=Just p})+ _ -> unexpected $ "MessageOptions has no option named "++optName++extend :: (D.DescriptorProto -> P s ()) -> (D.FieldDescriptorProto -> P s ()) -> P s ()+extend upGroup upField = pName (U.fromString "extend") >> do+ typeExtendee <- ident+ pChar '{'+ let rest = (field upGroup (Just typeExtendee) >>= upField) >> eols >> (pChar '}' <|> rest)+ eols >> rest++field :: (D.DescriptorProto -> P s ()) -> Maybe Utf8 -> P s D.FieldDescriptorProto+field upGroup maybeExtendee = do+ let allowedLabels = case maybeExtendee of+ Nothing -> ["optional","repeated","required"]+ Just {} -> ["optional","repeated"] -- cannot declare a required extension+ sLabel <- choice . map (pName . U.fromString) $ allowedLabels+ theLabel <- maybe (fail ("not a valid Label :"++show sLabel)) return (parseLabel (uToString sLabel))+ sType <- ident+ -- parseType may return Nothing, this is fixed up in Text.ProtocolBuffers.ProtoCompile.Resolve.fqField+ let (maybeTypeCode,maybeTypeName) = case parseType (uToString sType) of+ Just t -> (Just t,Nothing)+ Nothing -> (Nothing, Just sType)+ name <- ident1+ number <- pChar '=' >> fieldInt+ let v1 = defaultValue { D.FieldDescriptorProto.name = Just name+ , D.FieldDescriptorProto.number = Just number+ , D.FieldDescriptorProto.label = Just theLabel+ , D.FieldDescriptorProto.type' = maybeTypeCode+ , D.FieldDescriptorProto.type_name = maybeTypeName+ , D.FieldDescriptorProto.extendee = maybeExtendee }+ if maybeTypeCode == Just TYPE_GROUP+ then do let nameString = uToString name+ when (null nameString) (fail "Impossible? ident1 for field name was empty")+ when (not (isUpper (head nameString))) (fail $ "Group names must start with an upper case letter: "++show name)+ upGroup =<< subParser (pChar '{' >> subMessage) (defaultValue {D.DescriptorProto.name=Just name})+ let fieldName = Just $ uFromString (map toLower nameString) -- down-case the whole name+ v = v1 { D.FieldDescriptorProto.name = fieldName+ , D.FieldDescriptorProto.type_name = Just name }+ return v+ else (eol >> return v1) <|> (subParser (pChar '[' >> subField theLabel maybeTypeCode) v1)++subField,defaultConstant :: Label -> Maybe Type -> P D.FieldDescriptorProto ()+subField label mt = do+ (defaultConstant label mt <|> fieldOption label mt) <?> "expected \"default\" or a fieldOption"+ (pChar ']' >> eol) <|> (pChar ',' >> subField label mt)++defaultConstant LABEL_REPEATED _ = pName (U.fromString "default") >> fail "Repeated fields cannot have a default value"+defaultConstant _ mt = do+ _ <- pName (U.fromString "default")+ maybeDefault <- pChar '=' >> fmap Just (constant mt)+ -- XXX Hack: we lie about Utf8 for the default_value below+ update' (\s -> s { D.FieldDescriptorProto.default_value = fmap Utf8 maybeDefault })++-- This does a type and range safe parsing of the default value,+-- except for enum constants which cannot be checked (the definition+-- may not have been parsed yet).+--+-- Double and Float are checked to be not-Nan and not-Inf. The+-- int-like types are checked to be within the corresponding range.+constant :: Maybe Type -> P s ByteString+-- With Nothing the next item may be an enum constant or a '{' and an aggregate.+constant Nothing = enumIdent <?> "expected the name of an enum or a curly-brace-enclosed aggregate value"+ where enumIdent = fmap utf8 ident1 -- hopefully a matching enum; forget about Utf8+constant (Just t) =+ case t of+ TYPE_DOUBLE -> do d <- doubleLit+-- when (isNaN d || isInfinite d)+-- (fail $ "default floating point literal "++show d++" is out of range for type "++show t)+ return' (utf8 . uFromString . showRF $ d)+ TYPE_FLOAT -> do fl <- floatLit+{-+ let fl :: Float+ fl = read (show d)+-- when (isNaN fl || isInfinite fl || (d==0) /= (fl==0))+-- (fail $ "default floating point literal "++show d++" is out of range for type "++show t)+ when (isNaN fl /= isNaN d || isInfinite fl /= isInfinite d || (d==0) /= (fl==0))+ (fail $ "default floating point literal "++show d++" is out of range for type "++show t)+-}+ return' (utf8 . uFromString . showRF $ fl)+ TYPE_BOOL -> boolLit >>= \b -> return' $ if b then true else false+ TYPE_STRING -> strLit >>= return . utf8+ TYPE_BYTES -> bsLit+ TYPE_GROUP -> unexpected $ "cannot have a default for field of "++show t+ TYPE_MESSAGE -> unexpected $ "cannot have a default for field of "++show t+ TYPE_ENUM -> fmap utf8 ident1 -- IMPOSSIBLE : SHOULD HAVE HAD Maybe Type PARAMETER match Nothing+ TYPE_SFIXED32 -> f (undefined :: Int32)+ TYPE_SINT32 -> f (undefined :: Int32)+ TYPE_INT32 -> f (undefined :: Int32)+ TYPE_SFIXED64 -> f (undefined :: Int64)+ TYPE_SINT64 -> f (undefined :: Int64)+ TYPE_INT64 -> f (undefined :: Int64)+ TYPE_FIXED32 -> f (undefined :: Word32)+ TYPE_UINT32 -> f (undefined :: Word32)+ TYPE_FIXED64 -> f (undefined :: Word64)+ TYPE_UINT64 -> f (undefined :: Word64)+ where f :: (Bounded a,Integral a) => a -> P s ByteString+ f u = do let range = (toInteger (minBound `asTypeOf` u),toInteger (maxBound `asTypeOf` u))+ i <- intLit+ when (not (inRange range i))+ (fail $ "default integer value "++show i++" is out of range for type "++show t)+ return' (utf8 . uFromString . show $ i)++fieldOption :: Label -> Maybe Type -> P D.FieldDescriptorProto ()+fieldOption label mt = liftM2 (,) pOptionE getOld >>= setOption >>= setNew where+ getOld = fmap (fromMaybe defaultValue . D.FieldDescriptorProto.options) getState+ setNew p = update' (\s -> s { D.FieldDescriptorProto.options = Just p })+ setOption (Left uno,old) =+ return' (old {D.FieldOptions.uninterpreted_option = D.FieldOptions.uninterpreted_option old |> uno })+ setOption (Right optName,old) =+ case optName of+ "ctype" | (Just TYPE_STRING) == mt -> do+ enumLit >>= \p -> return' (old {D.FieldOptions.ctype=Just p})+ | otherwise -> unexpected $ "field option cyte is only defined for string fields"+ "experimental_map_key" | Nothing == mt -> do+ strLit >>= \p -> return' (old {D.FieldOptions.experimental_map_key=Just p})+ | otherwise -> unexpected $ "field option experimental_map_key is only defined for messages"+ "packed" | isValidPacked label mt -> do+ boolLit >>= \p -> return' (old {D.FieldOptions.packed=Just p})+ | otherwise -> unexpected $ "field option packed is not defined for this kind of field"+ "deprecated" -> boolLit >>= \p -> return' (old {D.FieldOptions.deprecated=Just p})+ _ -> unexpected $ "FieldOptions has no option named "++optName++isValidPacked :: Label -> Maybe Type -> Bool+isValidPacked LABEL_REPEATED Nothing = True -- provisional, okay if Enum but wrong if Message, checked in Resolve.fqField+isValidPacked LABEL_REPEATED (Just typeCode) =+ case typeCode of+ TYPE_STRING -> False+ TYPE_GROUP -> False+ TYPE_BYTES -> False+ TYPE_MESSAGE -> False -- Impossible value for typeCode from parseType, but here for completeness+ TYPE_ENUM -> True -- Impossible value for typeCode from parseType, but here for completeness+ _ -> True+isValidPacked _ _ = False++enum :: (D.EnumDescriptorProto -> P s ()) -> P s ()+enum up = pName (U.fromString "enum") >> do+ self <- ident1+ up =<< subParser (pChar '{' >> subEnum) (defaultValue {D.EnumDescriptorProto.name=Just self})++subEnum,enumOption :: P D.EnumDescriptorProto.EnumDescriptorProto ()+subEnum = eols >> rest -- Note: Must check enumOption before enumVal+ where rest = (enumOption <|> enumVal) >> eols >> (pChar '}' <|> rest)++enumOption = pOptionWith getOld >>= setOption >>= setNew >> eol where+ getOld = fmap (fromMaybe defaultValue . D.EnumDescriptorProto.options) getState+ setNew p = update' (\s -> s {D.EnumDescriptorProto.options=Just p})+ setOption (Left uno,old) =+ return' $ (old {D.EnumOptions.uninterpreted_option = D.EnumOptions.uninterpreted_option old |> uno })+ setOption (Right optName,_old) =+ case optName of+ _ -> unexpected $ "EnumOptions has no option named "++optName++enumVal :: P D.EnumDescriptorProto ()+enumVal = do+ name <- ident1+ number <- pChar '=' >> enumInt+ let v1 = defaultValue { D.EnumValueDescriptorProto.name = Just name+ , D.EnumValueDescriptorProto.number = Just number }+ v <- (eol >> return v1) <|> subParser (pChar '[' >> subEnumValue) v1+ update' (\s -> s {D.EnumDescriptorProto.value=D.EnumDescriptorProto.value s |> v})++subEnumValue,enumValueOption :: P D.EnumValueDescriptorProto ()+subEnumValue = enumValueOption >> ( (pChar ']' >> eol) <|> (pChar ',' >> subEnumValue) )++enumValueOption = liftM2 (,) pOptionE getOld >>= setOption >>= setNew where+ getOld = fmap (fromMaybe defaultValue . D.EnumValueDescriptorProto.options) getState+ setNew p = update' (\s -> s {D.EnumValueDescriptorProto.options=Just p})+ setOption (Left uno,old) =+ return' $ (old {D.EnumValueOptions.uninterpreted_option = D.EnumValueOptions.uninterpreted_option old |> uno })+ setOption (Right optName,_old) =+ case optName of+ _ -> unexpected $ "EnumValueOptions has no option named "++optName++extensions = pName (U.fromString "extensions") >> do+ start <- fieldInt+ let noEnd = eol >> return (succ start)+ toEnd = pName (U.fromString "to") >> (fieldInt <|> (pName (U.fromString "max") >> return (getFieldId maxBound)))+ end <- choice [ noEnd, toEnd ]+ let e = defaultValue { D.ExtensionRange.start = Just start+ , D.ExtensionRange.end = Just (succ end) } -- One _past_ the end!+ update' (\s -> s {D.DescriptorProto.extension_range=D.DescriptorProto.extension_range s |> e})++service = pName (U.fromString "service") >> do+ name <- ident1+ f <- subParser (pChar '{' >> subService) (defaultValue {D.ServiceDescriptorProto.name=Just name})+ update' (\s -> s {D.FileDescriptorProto.service=D.FileDescriptorProto.service s |> f})++ where subService = pChar '}' <|> (choice [ eol, rpc, serviceOption ] >> subService)++serviceOption,rpc :: P D.ServiceDescriptorProto ()+serviceOption = pOptionWith getOld >>= setOption >>= setNew >> eol where+ getOld = fmap (fromMaybe defaultValue . D.ServiceDescriptorProto.options) getState+ setNew p = update' (\s -> s {D.ServiceDescriptorProto.options=Just p})+ setOption (Left uno,old) =+ return' (old {D.ServiceOptions.uninterpreted_option = D.ServiceOptions.uninterpreted_option old |> uno })+ setOption (Right optName,_old) =+ case optName of+ _ -> unexpected $ "ServiceOptions has no option named "++optName++rpc = pName (U.fromString "rpc") >> do+ name <- ident1+ input <- between (pChar '(') (pChar ')') ident1+ _ <- pName (U.fromString "returns")+ output <- between (pChar '(') (pChar ')') ident1+ let m1 = defaultValue { D.MethodDescriptorProto.name=Just name+ , D.MethodDescriptorProto.input_type=Just input+ , D.MethodDescriptorProto.output_type=Just output }+ m <- (eol >> return m1) <|> subParser (pChar '{' >> subRpc) m1+ update' (\s -> s {D.ServiceDescriptorProto.method=D.ServiceDescriptorProto.method s |> m})++subRpc,rpcOption :: P D.MethodDescriptorProto ()+subRpc = pChar '}' <|> (choice [ eol, rpcOption ] >> subRpc)++rpcOption = pOptionWith getOld >>= setOption >>= setNew >> eol where+ getOld = fmap (fromMaybe defaultValue . D.MethodDescriptorProto.options) getState+ setNew p = update' (\s -> s {D.MethodDescriptorProto.options=Just p})+ setOption (Left uno,old) =+ return' $ (old {D.MethodOptions.uninterpreted_option = D.MethodOptions.uninterpreted_option old |> uno })+ setOption (Right optName,_old) =+ case optName of+ _ -> unexpected $ "MethodOptions has no option named "++optName++-- see google's stubs/strutil.cc lines 398-449/1121 and C99 specification+-- This mainly targets three digit octal codes+cEncode :: [Word8] -> [Char]+cEncode = concatMap one where+ one :: Word8 -> [Char]+ -- special non-octal escaped values+ one 9 = sl 't'+ one 10 = sl 'n'+ one 13 = sl 'r'+ one 34 = sl '"'+ one 39 = sl '\''+ one 92 = sl '\\'+ -- main case of unescaped value+ one x | (32 <= x) && (x < 127) = [toEnum . fromEnum $ x]+ -- below are the octal escaped values. This always emits 3 digits.+ one 0 = '\\':"000"+ one x | x < 8 = '\\':'0':'0':(showOct x "")+ | x < 64 = '\\':'0':(showOct x "")+ | otherwise = '\\':(showOct x "")+ sl c = ['\\',c]++showRF :: (Show a, RealFloat a) => a -> String+showRF x | isNaN x = "nan"+ | isInfinite x = if 0 < x then "inf" else "-inf"+ | otherwise = show x++-- Aggregate+{-+data Lexed = L_Integer !Int !Integer+ | L_Double !Int !Double+ | L_Name !Int !L.ByteString+ | L_String !Int !L.ByteString !L.ByteString+ | L !Int !Char+ | L_Error !Int !String+ -}++undoLexer :: Lexed -> String+undoLexer (L_Integer _ integer) = ' ':show integer+undoLexer (L_Double _ double) = ' ':showRF double+undoLexer (L_Name _ bs) = ' ':U.toString bs+undoLexer (L_String _ _ bs) = let middle = L.unpack bs+ encoded = cEncode middle -- escapes both quote and double-quote+ s = '\'' : encoded ++ "'"+ in ' ':s+undoLexer (L _ '{') = " {\n"+undoLexer (L _ '}') = " }\n"+undoLexer (L _ ';') = ";\n"+undoLexer (L _ char) = ' ':[char]+undoLexer (L_Error _ errorMessage) = error ("Lexer failure found when parsing aggregate default value\n:"++errorMessage) -- XXX improve error reporting?
+ Text/ProtocolBuffers/ProtoCompile/Resolve.hs view
@@ -0,0 +1,1380 @@+{-# LANGUAGE RankNTypes, FlexibleContexts, ScopedTypeVariables #-}+{- fixing resolution. This is a large beast of a module. Sorry.+ updated for version 2.0.3 to match protoc's namespace resolution better+ updated for version 2.0.4 to differentiate Entity and E'Entity, this makes eName a total selector+ updated after version 2.0.5 to fix problem when package name was not specified in proto file.+ main calls either runStandalone or runPlugin which call loadProto or loadStandalone which both call loadProto'+ loadProto' uses getPackage to make packageName, loads the imports, and passes all this to makeTopLevel to get Env++ The "load" loop in loadProto' caches the imported TopLevel based on _filename_+ files can be loaded via multiple paths but this is not important+ this may interact badly with absent "package" declarations that act as part of importing package+ need these to be "polymorphic" in the packageID somehow?++ Speculate: makeTopLevel knows the parent from the imports:+ parent with explicit package could resolve "polymorphic" imports by a recursive transformation?+ parent with no explicit package could do nothing.+ root will need default explicit package name ? or special handling in loadProto' or load* ?++ Then loadProto or loadStandalone both call run' which calls makeNameMaps with the Env from loadProto'+ makeNameMaps calls makeNameMap on each top level fdp from each TopLevel in the Global Env from loadProto'+ makeNameMap calls getPackage to form packageName, and unless overridden it is also used for hParent++ makeNameMap on the imports gets called without any special knowledge of the "parent". If+ root or some imports are still "polymorphic" then this is most annoying.++ Alternative solution: a middle step after makeTopLevel and before makeNameMaps examines and fixes all the polymorphic imports.++ The nameMap this computes is passed by run' to makeProtoInfo from MakeReflections++ The bug is being reported by main>runStandalon>loadStandalone>loadProto'>makeTopLevel>resolveFDP>fqFileDP>fqMessage>fqField>resolvePredEnv+ ++ entityField uses resolveMGE instead of expectMGE and resolveEnv : this should allow field types to resolve just to MGE insteadof other field names.++ what about keys 'extendee' resolution to Message names only? expectM in entityField++ 'makeTopLevel' is the main internal entry point in this module.+ This is called from loadProto' which has two callers:+ loadProto and loadCodeGenRequest++ makeTopLevel uses a lazy 'myFixSE' trick and so the order of execution is not immediately clear.++ The environment for name resolution comes from the global' declaration which first involves using+ resolveFDP/runRE (E'Entity). To make things more complicated the definition of global' passes+ global' to (resolveFDP fdp).++ The resolveFDP/runRE runs all the fq* stuff (E'Entity and consumeUNO/interpretOption/resolveHere).++ Note that the only source of E'Error values of E'Entity are from 'unique' detecting name+ collisions.++ This global' environment gets fed back in as global'Param to form the SEnv for running the+ entityMsg, entityField, entityEnum, entityService functions. These clean up the parsed descriptor+ proto structures into dependable and fully resolved ones.++ The kids operator and the unZip are used to seprate and collect all the error messages, so that+ they can be checked for and reported as a group.++ ====++ Problem? Nesting namespaces allows shadowing. I forget if Google's protoc allows this.++ Problem? When the current file being resolves has the same package name as an imported file then+ hprotoc will find unqualified names in the local name space and the imported name space. But if+ there is a name collision between the two then hprotoc will not detect this; the unqualified name+ will resolve to the local file and not observe the duplicate from the import. TODO: check what+ Google's protoc does in this case.++ Solution to either of the above might be to resolve to a list of successes and check for a single+ success. This may be too lazy.++ ====++ aggregate option types not handled: Need to take fk and bytestring from parser and:+ 1) look at mVal of fk (E'Message) to understand what fields are expected (listed in mVals of this mVal).+ 2) lex the bytestring+ 3) parse the sequence of "name" ":" "value" by doing+ 4) find "name" in the expected list from (1) (E'Field)+ 5) Look at the fType of this E'Field and parse the "value", if Nothing (message/group/enum) then+ 6) resolve name and look at mVal+ 7) if enum then parse "value" as identifier or if message or group+ 8) recursively go to (1) and either prepend lenght (message) or append stop tag (group)+ 9) runPut to get the wire encoded field tag and value when Just a simple type+ 10) concatentanate the results of (3) to get the wire encoding for the message value++ Handling recursive message/groups makes this more annoying.++-}++-- | This huge module handles the loading and name resolution. The+-- loadProto command recursively gets all the imported proto files.+-- The makeNameMaps command makes the translator from proto name to+-- Haskell name. Many possible errors in the proto data are caught+-- and reported by these operations.+--+-- hprotoc will actually resolve more unqualified imported names than Google's protoc which requires+-- more qualified names. I do not have the obsessive nature to fix this.+module Text.ProtocolBuffers.ProtoCompile.Resolve(loadProto,loadCodeGenRequest,makeNameMaps,getTLS,getPackageID+ ,Env(..),TopLevel(..),ReMap,NameMap(..),PackageID(..),LocalFP(..),CanonFP(..)) where++import qualified Text.DescriptorProtos.DescriptorProto as D(DescriptorProto)+import qualified Text.DescriptorProtos.DescriptorProto as D.DescriptorProto(DescriptorProto(..))+import qualified Text.DescriptorProtos.DescriptorProto.ExtensionRange as D(ExtensionRange(ExtensionRange))+import qualified Text.DescriptorProtos.DescriptorProto.ExtensionRange as D.ExtensionRange(ExtensionRange(..))+import qualified Text.DescriptorProtos.EnumDescriptorProto as D(EnumDescriptorProto(EnumDescriptorProto))+import qualified Text.DescriptorProtos.EnumDescriptorProto as D.EnumDescriptorProto(EnumDescriptorProto(..))+import qualified Text.DescriptorProtos.EnumValueDescriptorProto as D(EnumValueDescriptorProto)+import qualified Text.DescriptorProtos.EnumValueDescriptorProto as D.EnumValueDescriptorProto(EnumValueDescriptorProto(..))+import qualified Text.DescriptorProtos.FieldDescriptorProto as D(FieldDescriptorProto(FieldDescriptorProto))+import qualified Text.DescriptorProtos.FieldDescriptorProto as D.FieldDescriptorProto(FieldDescriptorProto(..))+import Text.DescriptorProtos.FieldDescriptorProto.Label+import qualified Text.DescriptorProtos.FieldDescriptorProto.Type as D(Type)+import Text.DescriptorProtos.FieldDescriptorProto.Type as D.Type(Type(..))+import qualified Text.DescriptorProtos.FileDescriptorProto as D(FileDescriptorProto)+import qualified Text.DescriptorProtos.FileDescriptorProto as D.FileDescriptorProto(FileDescriptorProto(..))+import qualified Text.DescriptorProtos.MethodDescriptorProto as D(MethodDescriptorProto)+import qualified Text.DescriptorProtos.MethodDescriptorProto as D.MethodDescriptorProto(MethodDescriptorProto(..))+import qualified Text.DescriptorProtos.ServiceDescriptorProto as D(ServiceDescriptorProto)+import qualified Text.DescriptorProtos.ServiceDescriptorProto as D.ServiceDescriptorProto(ServiceDescriptorProto(..))+import qualified Text.DescriptorProtos.UninterpretedOption as D(UninterpretedOption)+import qualified Text.DescriptorProtos.UninterpretedOption as D.UninterpretedOption(UninterpretedOption(..))+import qualified Text.DescriptorProtos.UninterpretedOption.NamePart as D(NamePart(NamePart))+import qualified Text.DescriptorProtos.UninterpretedOption.NamePart as D.NamePart(NamePart(..))+-- import qualified Text.DescriptorProtos.EnumOptions as D(EnumOptions)+import qualified Text.DescriptorProtos.EnumOptions as D.EnumOptions(EnumOptions(uninterpreted_option))+-- import qualified Text.DescriptorProtos.EnumValueOptions as D(EnumValueOptions)+import qualified Text.DescriptorProtos.EnumValueOptions as D.EnumValueOptions(EnumValueOptions(uninterpreted_option))+import qualified Text.DescriptorProtos.FieldOptions as D(FieldOptions(FieldOptions))+import qualified Text.DescriptorProtos.FieldOptions as D.FieldOptions(FieldOptions(packed,uninterpreted_option))+-- import qualified Text.DescriptorProtos.FileOptions as D(FileOptions)+import qualified Text.DescriptorProtos.FileOptions as D.FileOptions(FileOptions(..))+-- import qualified Text.DescriptorProtos.MessageOptions as D(MessageOptions)+import qualified Text.DescriptorProtos.MessageOptions as D.MessageOptions(MessageOptions(uninterpreted_option))+-- import qualified Text.DescriptorProtos.MethodOptions as D(MethodOptions)+import qualified Text.DescriptorProtos.MethodOptions as D.MethodOptions(MethodOptions(uninterpreted_option))+-- import qualified Text.DescriptorProtos.ServiceOptions as D(ServiceOptions)+import qualified Text.DescriptorProtos.ServiceOptions as D.ServiceOptions(ServiceOptions(uninterpreted_option))++import qualified Text.Google.Protobuf.Compiler.CodeGeneratorRequest as CGR++import Text.ProtocolBuffers.Header+import Text.ProtocolBuffers.Identifiers+import Text.ProtocolBuffers.Extensions+import Text.ProtocolBuffers.WireMessage+import Text.ProtocolBuffers.ProtoCompile.Instances+import Text.ProtocolBuffers.ProtoCompile.Parser++import Control.Applicative+import Control.Monad.Identity+import Control.Monad.State+import Control.Monad.Reader+import Control.Monad.Error+import Control.Monad.Writer+import Data.Char+import Data.Ratio+import Data.Ix(inRange)+import Data.List(foldl',stripPrefix,isPrefixOf,isSuffixOf)+import Data.Map(Map)+import Data.Maybe(mapMaybe)+import Data.Typeable+-- import Data.Monoid()+import System.Directory(doesFileExist,canonicalizePath)+import qualified System.FilePath as Local(pathSeparator,splitDirectories,joinPath,combine,makeRelative)+import qualified System.FilePath.Posix as Canon(pathSeparator,splitDirectories,joinPath,takeBaseName)+import qualified Data.ByteString.Lazy.Char8 as LC+import qualified Data.ByteString.Lazy.UTF8 as U+import qualified Data.Foldable as F+import qualified Data.Sequence as Seq+import qualified Data.Map as M+import qualified Data.Set as Set+import qualified Data.Traversable as T++--import Debug.Trace(trace)++-- Used by err and throw+indent :: String -> String+indent = unlines . map (\str -> ' ':' ':str) . lines++ishow :: Show a => a -> String+ishow = indent . show++errMsg :: String -> String+errMsg s = "Text.ProtocolBuffers.ProtoCompile.Resolve fatal error encountered, message:\n"++indent s++err :: forall b. String -> b+err = error . errMsg ++throw :: (Error e, MonadError e m) => String -> m a+throw s = throwError (strMsg (errMsg s))++annErr :: (MonadError String m) => String -> m a -> m a+annErr s act = catchError act (\e -> throwError ("Text.ProtocolBuffers.ProtoCompile.Resolve annErr: "++s++'\n':indent e))++getJust :: (Error e,MonadError e m, Typeable a) => String -> Maybe a -> m a+{-# INLINE getJust #-}+getJust s ma@Nothing = throw $ "Impossible? Expected Just of type "++show (typeOf ma)++" but got nothing:\n"++indent s+getJust _s (Just a) = return a++defaultPackageName :: Utf8+defaultPackageName = Utf8 (LC.pack "defaultPackageName")++-- The "package" name turns out to be more complicated than I anticipated (when missing). Instead+-- of plain UTF8 annotate this with the PackageID newtype to force me to trace the usage. Later+-- change this to track the additional complexity.+--newtype PackageID a = PackageID { getPackageID :: a } deriving (Show)++data PackageID a = PackageID { _getPackageID :: a }+ | NoPackageID { _getNoPackageID :: a }+ deriving (Show)++instance Functor PackageID where+ fmap f (PackageID a) = PackageID (f a)+ fmap f (NoPackageID a) = NoPackageID (f a)++-- Used in MakeReflections.makeProtoInfo+getPackageID :: PackageID a -> a+getPackageID (PackageID a) = a+getPackageID (NoPackageID a) = a++-- The package field of FileDescriptorProto is set in Parser.hs.+-- 'getPackage' is the only direct user of this information in hprotoc.+-- The convertFileToPackage was developed looking at the Java output of Google's protoc.+-- In 2.0.5 this has lead to problems with the stricter import name resolution when the imported file has no package directive.+-- I need a fancier way of handling this.+getPackage :: D.FileDescriptorProto -> PackageID Utf8+getPackage fdp = case D.FileDescriptorProto.package fdp of+ Just a -> PackageID a+ Nothing -> case D.FileDescriptorProto.name fdp of+ Nothing -> NoPackageID defaultPackageName+ Just filename -> case convertFileToPackage filename of+ Nothing -> NoPackageID defaultPackageName+ Just name -> NoPackageID name++--getPackageUtf8 :: PackageID Utf8 -> Utf8+--getPackageUtf8 (PackageID {_getPackageID=x}) = x+--getPackageUtf8 (NoPackageID {_getNoPackageID=x}) = x++-- LOSES PackageID vs NoPackageID 2012-09-19+checkPackageID :: PackageID Utf8 -> Either String (PackageID (Bool,[IName Utf8]))+checkPackageID (PackageID a) = fmap PackageID (checkDIUtf8 a)+checkPackageID (NoPackageID a) = fmap NoPackageID (checkDIUtf8 a)++-- | 'convertFileToPackage' mimics what I observe protoc --java_out do to convert the file name to a+-- class name.+convertFileToPackage :: Utf8 -> Maybe Utf8+convertFileToPackage filename =+ let full = toString filename+ suffix = ".proto"+ noproto = if suffix `isSuffixOf` full then take (length full - length suffix) full else full+ convert :: Bool -> String -> String+ convert _ [] = []+ convert toUp (x:xs) | inRange ('a','z') x = if toUp+ then toUpper x : convert False xs+ else x : convert False xs+ | inRange ('A','Z') x = x : convert False xs+ | inRange ('0','9') x = x : convert True xs+ | '_' == x = x : convert True xs+ | otherwise = convert True xs+ converted = convert True noproto+ leading = case converted of+ (x:_) | inRange ('0','9') x -> "proto_" ++ converted+ _ -> converted+ in if null leading then Nothing else (Just (fromString leading))++-- This adds a leading dot if the input is non-empty+joinDot :: [IName String] -> FIName String+joinDot [] = err $ "joinDot on an empty list of IName!"+joinDot (x:xs) = fqAppend (promoteFI x) xs++checkFI :: [(FieldId,FieldId)] -> FieldId -> Bool+checkFI ers fid = any (`inRange` fid) ers++getExtRanges :: D.DescriptorProto -> [(FieldId,FieldId)]+getExtRanges d = concatMap check unchecked+ where check x@(lo,hi) | hi < lo = []+ | hi<19000 || 19999<lo = [x]+ | otherwise = concatMap check [(lo,18999),(20000,hi)]+ unchecked = F.foldr ((:) . extToPair) [] (D.DescriptorProto.extension_range d)+ extToPair (D.ExtensionRange+ { D.ExtensionRange.start = start+ , D.ExtensionRange.end = end }) =+ (maybe minBound FieldId start, maybe maxBound (FieldId . pred) end)++-- | By construction Env is 0 or more Local Entity namespaces followed+-- by 1 or more Global TopLevel namespaces (self and imported files).+-- Entities in first Global TopLevel namespace can refer to each other+-- and to Entities in the list of directly imported TopLevel namespaces only.+data Env = Local [IName String] EMap {- E'Message,E'Group,E'Service -} Env+ | Global TopLevel [TopLevel]+ deriving Show++-- | TopLevel corresponds to all items defined in a .proto file. This+-- includes the FileOptions since this will be consulted when+-- generating the Haskell module names, and the imported files are only+-- known through their TopLevel data.+data TopLevel = TopLevel { top'Path :: FilePath+ , top'Package :: PackageID [IName String]+ , top'FDP :: Either ErrStr D.FileDescriptorProto -- resolvedFDP'd+ , top'mVals :: EMap } deriving Show++-- | The EMap type is a local namespace attached to an entity+--+-- The E'Error values come from using unique to resolse name collisions when building EMap+type EMap = Map (IName String) E'Entity++-- | An Entity is some concrete item in the namespace of a proto file.+-- All Entity values have a leading-dot fully-qualified with the package "eName".+-- The E'Message,Group,Service have EMap namespaces to inner Entity items.+data Entity = E'Message { eName :: [IName String], validExtensions :: [(FieldId,FieldId)]+ , mVals :: EMap {- E'Message,Group,Field,Key,Enum -} }++ | E'Group { eName :: [IName String], mVals :: EMap {- E'Message,Group,Field,Key,Enum -} }++ | E'Service { eName :: [IName String], mVals :: EMap {- E'Method -} }++ | E'Key { eName :: [IName String], eMsg :: Either ErrStr Entity {- E'Message -}+ , fNumber :: FieldId, fType :: Maybe D.Type+ , mVal :: Maybe (Either ErrStr Entity) {- E'Message,Group,Enum -} }++ | E'Field { eName :: [IName String], fNumber :: FieldId, fType :: Maybe D.Type+ , mVal :: Maybe (Either ErrStr Entity) {- E'Message,Group,Enum -} }++ | E'Enum { eName :: [IName String], eVals :: Map (IName Utf8) Int32 }++ | E'Method { eName :: [IName String], eMsgIn,eMsgOut :: Maybe (Either ErrStr Entity) {- E'Message -} }+ deriving (Show)++-- This type handles entity errors by storing them rather than propagating or throwing them.+--+-- The E'Error values come from using unique to resolse name collisions when building EMap+data E'Entity = E'Ok Entity+ | E'Error String [E'Entity]+ deriving (Show)++newtype LocalFP = LocalFP { unLocalFP :: FilePath } deriving (Read,Show,Eq,Ord)+newtype CanonFP = CanonFP { unCanonFP :: FilePath } deriving (Read,Show,Eq,Ord)++fpLocalToCanon :: LocalFP -> CanonFP+fpLocalToCanon | Canon.pathSeparator == Local.pathSeparator = CanonFP . unLocalFP+ | otherwise = CanonFP . Canon.joinPath . Local.splitDirectories . unLocalFP++fpCanonToLocal :: CanonFP -> LocalFP+fpCanonToLocal | Canon.pathSeparator == Local.pathSeparator = LocalFP . unCanonFP+ | otherwise = LocalFP . Local.joinPath . Canon.splitDirectories . unCanonFP++-- Used to create optimal error messages+allowedGlobal :: Env -> [(PackageID [IName String],[IName String])]+allowedGlobal (Local _ _ env) = allowedGlobal env+allowedGlobal (Global t ts) = map allowedT (t:ts)++allowedT :: TopLevel -> (PackageID [IName String], [IName String])+allowedT tl = (top'Package tl,M.keys (top'mVals tl))++-- Used to create optional error messages+allowedLocal :: Env -> [([IName String],[IName String])]+allowedLocal (Global _t _ts) = []+allowedLocal (Local name vals env) = allowedE : allowedLocal env+ where allowedE :: ([IName String], [IName String])+ allowedE = (name,M.keys vals)++-- Create a mapping from the "official" name to the Haskell hierarchy mangled name+type ReMap = Map (FIName Utf8) ProtoName++data NameMap = NameMap ( PackageID (FIName Utf8) -- packageName from 'getPackage' on fdp+ , [MName String] -- hPrefix from command line+ , [MName String]) -- hParent from java_outer_classname, java_package, or 'getPackage'+ ReMap+ deriving (Show)++type RE a = ReaderT Env (Either ErrStr) a+++data SEnv = SEnv { my'Parent :: [IName String] -- top level value is derived from PackageID+ , my'Env :: Env }+-- , my'Template :: ProtoName }++-- E'Service here is arbitrary+emptyEntity :: Entity+emptyEntity = E'Service [IName "emptyEntity from myFix"] mempty++emptyEnv :: Env+emptyEnv = Global (TopLevel "emptyEnv from myFix" (PackageID [IName "emptyEnv form myFix"]) (Left "emptyEnv: top'FDP does not exist") mempty) []++instance Show SEnv where+ show (SEnv p e) = "(SEnv "++show p++" ; "++ whereEnv e ++ ")" --" ; "++show (haskellPrefix t,parentModule t)++ " )"++type ErrStr = String++type SE a = ReaderT SEnv (Either ErrStr) a++runSE :: SEnv -> SE a -> Either ErrStr a+runSE sEnv m = runReaderT m sEnv++fqName :: Entity -> FIName Utf8+fqName = fiFromString . joinDot . eName++fiFromString :: FIName String -> FIName Utf8+fiFromString = FIName . fromString . fiName++iToString :: IName Utf8 -> IName String+iToString = IName . toString . iName++-- Three entities provide child namespaces: E'Message, E'Group, and E'Service+get'mVals'E :: E'Entity -> Maybe EMap+get'mVals'E (E'Ok entity) = get'mVals entity+get'mVals'E (E'Error {}) = Nothing++get'mVals :: Entity -> Maybe EMap+get'mVals (E'Message {mVals = x}) = Just x+get'mVals (E'Group {mVals = x}) = Just x+get'mVals (E'Service {mVals = x}) = Just x+get'mVals _ = Nothing++-- | This is a helper for resolveEnv+toGlobal :: Env -> Env+toGlobal (Local _ _ env) = toGlobal env+toGlobal x@(Global {}) = x++getTL :: Env -> TopLevel+getTL (Local _ _ env) = getTL env+getTL (Global tl _tls) = tl++getTLS :: Env -> (TopLevel,[TopLevel])+getTLS (Local _ _ env) = getTLS env+getTLS (Global tl tls) = (tl, tls)++-- | This is used for resolving some UninterpretedOption names+resolveHere :: Entity -> Utf8 -> RE Entity+resolveHere parent nameU = do+ let rFail msg = throw ("Could not lookup "++show (toString nameU)++"\n"++indent msg)+ x <- getJust ("resolveHere: validI nameU failed for "++show nameU) (fmap iToString (validI nameU))+ case get'mVals parent of+ Just vals -> case M.lookup x vals of+ Just (E'Ok entity) -> return entity+ Just (E'Error s _) -> rFail ("because the name resolved to an error:\n" ++ indent s)+ Nothing -> rFail ("because there is no such name here: "++show (eName parent))+ Nothing -> rFail ("because environment has no local names:\n"++ishow (eName parent))++-- | 'resolvePredEnv' is the query operation for the Env namespace. It recognizes names beginning+-- with a '.' as already being fully-qualified names. This is called from the different monads via+-- resolveEnv, resolveMGE, and resolveM+--+-- The returned (Right _::Entity) will never be an E'Error, which results in (Left _::ErrStr) instead+resolvePredEnv :: String -> (E'Entity -> Bool) -> Utf8 -> Env -> Either ErrStr Entity+resolvePredEnv userMessage accept nameU envIn = do+ (isGlobal,xs) <- checkDIUtf8 nameU+ let mResult = if isGlobal then lookupEnv (map iToString xs) (toGlobal envIn)+ else lookupEnv (map iToString xs) envIn+ case mResult of+ Just (E'Ok e) -> return e+ Just (E'Error s _es) -> throw s+ Nothing -> throw . unlines $ [ "resolvePredEnv: Could not lookup " ++ show nameU+ , "which parses as " ++ show (isGlobal,xs)+ , "in environment: " ++ (whereEnv envIn)+ , "looking for: " ++ userMessage+ , "allowed (local): " ++ show (allowedLocal envIn)+ , "allowed (global): " ++ show (allowedGlobal envIn) ]+ where+ lookupEnv :: [IName String] -> Env -> Maybe E'Entity+ lookupEnv xs (Global tl tls) = let findThis = lookupTopLevel main xs+ where main = top'Package tl+ in msum (map findThis (tl:tls))+ lookupEnv xs (Local _ vals env) = filteredLookup vals xs <|> lookupEnv xs env++ lookupTopLevel :: PackageID [IName String] -> [IName String] -> TopLevel -> Maybe E'Entity+ lookupTopLevel main xs tl = + (if matchesMain main (top'Package tl) then filteredLookup (top'mVals tl) xs else Nothing)+ <|>+ (matchPrefix (top'Package tl) xs >>= filteredLookup (top'mVals tl))+ where matchesMain (PackageID {_getPackageID=a}) (PackageID {_getPackageID=b}) = a==b+ matchesMain (NoPackageID {}) (PackageID {}) = False -- XXX XXX XXX 2012-09-19 suspicious+ matchesMain (PackageID {}) (NoPackageID {}) = True+ matchesMain (NoPackageID {}) (NoPackageID {}) = True++ matchPrefix (NoPackageID {}) _ = Nothing+ matchPrefix (PackageID {_getPackageID=a}) ys = stripPrefix a ys++ filteredLookup valsIn namesIn =+ let lookupVals :: EMap -> [IName String] -> Maybe E'Entity+ lookupVals _vals [] = Nothing+ lookupVals vals [x] = M.lookup x vals+ lookupVals vals (x:xs) = do+ entity <- M.lookup x vals+ case get'mVals'E entity of+ Just vals' -> lookupVals vals' xs+ Nothing -> Nothing+ m'x = lookupVals valsIn namesIn+ in case m'x of+ Just entity | accept entity -> m'x+ _ -> Nothing++-- Used in resolveRE and getType.resolveSE. Accepts all types and so commits to first hit, but+-- caller may reject some types later.+resolveEnv :: Utf8 -> Env -> Either ErrStr Entity+resolveEnv = resolvePredEnv "Any item" (const True)++-- resolveRE is the often used workhorse of the fq* family of functions+resolveRE :: Utf8 -> RE Entity+resolveRE nameU = lift . (resolveEnv nameU) =<< ask++-- | 'getType' is used to lookup the type strings in service method records.+getType :: Show a => String -> (a -> Maybe Utf8) -> a -> SE (Maybe (Either ErrStr Entity))+getType s f a = do+ typeU <- getJust s (f a)+ case parseType (toString typeU) of+ Just _ -> return Nothing+ Nothing -> do ee <- resolveSE typeU+ return (Just (expectMGE ee))+ where+ -- All uses of this then apply expectMGE or expectM, so provide predicate 'skip' support.+ resolveSE :: Utf8 -> SE (Either ErrStr Entity)+ resolveSE nameU = fmap (resolveEnv nameU) (asks my'Env)++-- | 'expectMGE' is used by getType and 'entityField'+expectMGE :: Either ErrStr Entity -> Either ErrStr Entity+expectMGE ee@(Left {}) = ee+expectMGE ee@(Right e) | isMGE = ee+ | otherwise = throw $ "expectMGE: Name resolution failed to find a Message, Group, or Enum:\n"++ishow (eName e)+ -- cannot show all of "e" because this will loop and hang the hprotoc program+ where isMGE = case e of E'Message {} -> True+ E'Group {} -> True+ E'Enum {} -> True+ _ -> False++-- | This is a helper for resolveEnv and (Show SEnv) for error messages+whereEnv :: Env -> String+whereEnv (Local name _ env) = fiName (joinDot name) ++ " in "++show (top'Path . getTL $ env)+-- WAS whereEnv (Global tl _) = fiName (joinDot (getPackageID (top'Package tl))) ++ " in " ++ show (top'Path tl)+whereEnv (Global tl _) = formatPackageID ++ " in " ++ show (top'Path tl)+ where formatPackageID = case top'Package tl of+ PackageID {_getPackageID=x} -> fiName (joinDot x)+ NoPackageID {_getNoPackageID=y} -> show y++-- | 'partEither' separates the Left errors and Right success in the obvious way.+partEither :: [Either a b] -> ([a],[b])+partEither [] = ([],[])+partEither (Left a:xs) = let ~(ls,rs) = partEither xs+ in (a:ls,rs)+partEither (Right b:xs) = let ~(ls,rs) = partEither xs+ in (ls,b:rs)++-- | The 'unique' function is used with Data.Map.fromListWithKey to detect+-- name collisions and record this as E'Error entries in the map.+--+-- This constructs new E'Error values+unique :: IName String -> E'Entity -> E'Entity -> E'Entity+unique name (E'Error _ a) (E'Error _ b) = E'Error ("Namespace collision for "++show name) (a++b)+unique name (E'Error _ a) b = E'Error ("Namespace collision for "++show name) (a++[b])+unique name a (E'Error _ b) = E'Error ("Namespace collision for "++show name) (a:b)+unique name a b = E'Error ("Namespace collision for "++show name) [a,b]++maybeM :: Monad m => (x -> m a) -> (Maybe x) -> m (Maybe a)+maybeM f mx = maybe (return Nothing) (liftM Just . f) mx++-- ReaderT containing template stacked on WriterT of list of name translations stacked on error reporting+type MRM a = ReaderT ProtoName (WriterT [(FIName Utf8,ProtoName)] (Either ErrStr)) a++runMRM'Reader :: MRM a -> ProtoName -> WriterT [(FIName Utf8,ProtoName)] (Either ErrStr) a+runMRM'Reader = runReaderT++runMRM'Writer :: WriterT [(FIName Utf8,ProtoName)] (Either ErrStr) a -> Either ErrStr (a,[(FIName Utf8,ProtoName)])+runMRM'Writer = runWriterT++mrmName :: String -> (a -> Maybe Utf8) -> a -> MRM ProtoName+mrmName s f a = do+ template <- ask+ iSelf <- getJust s (validI =<< f a)+ let mSelf = mangle iSelf+ fqSelf = fqAppend (protobufName template) [iSelf]+ self = template { protobufName = fqSelf+ , baseName = mSelf }+ template' = template { protobufName = fqSelf+ , parentModule = parentModule template ++ [mSelf] }+ tell [(fqSelf,self)]+ return template'++-- Compute the nameMap that determine how to translate from proto names to haskell names+-- The loop oever makeNameMap uses the (optional) package name+-- makeNameMaps is called from the run' routine in ProtoCompile.hs for both standalone and plugin use.+-- hPrefix and hAs are command line controlled options.+-- hPrefix is "-p MODULE --prefix=MODULE dotted Haskell MODULE name to use as a prefix (default is none); last flag used"+-- hAs is "-a FILEPATH=MODULE --as=FILEPATH=MODULE assign prefix module to imported prot file: --as descriptor.proto=Text"+-- Note that 'setAs' puts both the full path and the basename as keys into the association list+makeNameMaps :: [MName String] -> [(CanonFP,[MName String])] -> Env -> Either ErrStr NameMap+makeNameMaps hPrefix hAs env = do+ let getPrefix fdp =+ case D.FileDescriptorProto.name fdp of+ Nothing -> hPrefix -- really likely to be an error elsewhere since this ought to be a filename+ Just n -> let path = CanonFP (toString n)+ in case lookup path hAs of+ Just p -> p+ Nothing -> case lookup (CanonFP . Canon.takeBaseName . unCanonFP $ path) hAs of+ Just p -> p+ Nothing -> hPrefix -- this is the usual branch unless overridden on command line+ let (tl,tls) = getTLS env+ (fdp:fdps) <- mapM top'FDP (tl:tls)+ (NameMap tuple m) <- makeNameMap (getPrefix fdp) fdp+ let f (NameMap _ x) = x+ ms <- fmap (map f) . mapM (\y -> makeNameMap (getPrefix y) y) $ fdps+ let nameMap = (NameMap tuple (M.unions (m:ms)))+-- trace (show nameMap) $ + return nameMap++-- | 'makeNameMap' conservatively checks its input.+makeNameMap :: [MName String] -> D.FileDescriptorProto -> Either ErrStr NameMap+makeNameMap hPrefix fdpIn = go (makeOne fdpIn) where+ go = fmap ((\(a,w) -> NameMap a (M.fromList w))) . runMRM'Writer++ makeOne fdp = do+ -- Create 'template' :: ProtoName using "Text.ProtocolBuffers.Identifiers" with error for baseName+ let rawPackage = getPackage fdp :: PackageID Utf8+ _ <- lift (checkPackageID rawPackage) -- guard-like effect+{-+ -- Previously patched way of doing this+ let packageName = case D.FileDescriptorProto.package fdp of+ Nothing -> FIName $ fromString ""+ Just p -> difi $ DIName p+-}+ let packageName :: PackageID (FIName Utf8)+ packageName = fmap (difi . DIName) rawPackage+ fi'package'name = getPackageID packageName+ rawParent <- getJust "makeNameMap.makeOne: impossible Nothing found" . msum $+ [ D.FileOptions.java_outer_classname =<< (D.FileDescriptorProto.options fdp)+ , D.FileOptions.java_package =<< (D.FileDescriptorProto.options fdp)+ , Just (getPackageID rawPackage)]+ diParent <- getJust ("makeNameMap.makeOne: invalid character in: "++show rawParent)+ (validDI rawParent)+ let hParent = map (mangle :: IName Utf8 -> MName String) . splitDI $ diParent+ template = ProtoName fi'package'name hPrefix hParent+ (error "makeNameMap.makeOne.template.baseName undefined")+ runMRM'Reader (mrmFile fdp) template+ return (packageName,hPrefix,hParent)+ -- Traversal of the named DescriptorProto types+ mrmFile :: D.FileDescriptorProto -> MRM ()+ mrmFile fdp = do+ F.mapM_ mrmMsg (D.FileDescriptorProto.message_type fdp)+ F.mapM_ mrmField (D.FileDescriptorProto.extension fdp)+ F.mapM_ mrmEnum (D.FileDescriptorProto.enum_type fdp)+ F.mapM_ mrmService (D.FileDescriptorProto.service fdp)+ mrmMsg dp = do+ template <- mrmName "mrmMsg.name" D.DescriptorProto.name dp+ local (const template) $ do+ F.mapM_ mrmEnum (D.DescriptorProto.enum_type dp)+ F.mapM_ mrmField (D.DescriptorProto.extension dp)+ F.mapM_ mrmField (D.DescriptorProto.field dp)+ F.mapM_ mrmMsg (D.DescriptorProto.nested_type dp)+ mrmField fdp = mrmName "mrmField.name" D.FieldDescriptorProto.name fdp+ mrmEnum edp = do+ template <- mrmName "mrmEnum.name" D.EnumDescriptorProto.name edp+ local (const template) $ F.mapM_ mrmEnumValue (D.EnumDescriptorProto.value edp)+ mrmEnumValue evdp = mrmName "mrmEnumValue.name" D.EnumValueDescriptorProto.name evdp+ mrmService sdp = do+ template <- mrmName "mrmService.name" D.ServiceDescriptorProto.name sdp+ local (const template) $ F.mapM_ mrmMethod (D.ServiceDescriptorProto.method sdp)+ mrmMethod mdp = mrmName "mrmMethod.name" D.MethodDescriptorProto.name mdp++getNames :: String -> (a -> Maybe Utf8) -> a -> SE (IName String,[IName String])+getNames errorMessage accessor record = do+ parent <- asks my'Parent+ iSelf <- fmap iToString $ getJust errorMessage (validI =<< accessor record)+ let names = parent ++ [ iSelf ]+ return (iSelf,names)++descend :: [IName String] -> Entity -> SE a -> SE a+descend names entity act = local mutate act+ where mutate (SEnv _parent env) = SEnv parent' env'+ where parent' = names -- cannot call eName ename, will cause <<loop>> with "getNames" -- XXX revisit+ env' = Local (eName entity) (mVals entity) env++-- Run each element of (Seq x) as (f x) with same initial environment and state.+-- Then merge the output states and sort out the failures and successes.+kids :: (x -> SE (IName String,E'Entity)) -> Seq x -> SE ([ErrStr],[(IName String,E'Entity)])+kids f xs = do sEnv <- ask+ let ans = map (runSE sEnv) . map f . F.toList $ xs+ return (partEither ans)++-- | 'makeTopLevel' takes a .proto file's FileDescriptorProto and the TopLevel values of its+-- directly imported file and constructs the TopLevel of the FileDescriptorProto in a Global+-- Environment.+--+-- This goes to some lengths to be a total function with good error messages. Errors in building+-- the skeleton of the namespace are detected and reported instead of returning the new 'Global'+-- environment. Collisions in the namespace are only detected when the offending name is looked up,+-- and will return an E'Error entity with a message and list of colliding Entity items. The+-- cross-linking of Entity fields may fail and this failure is stored in the corresponding Entity.+--+-- Also caught: name collisions in Enum definitions.+--+-- The 'mdo' usage has been replace by modified forms of 'mfix' that will generate useful error+-- values instead of calling 'error' and halting 'hprotoc'.+--+-- Used from loadProto'+makeTopLevel :: D.FileDescriptorProto -> PackageID [IName String] -> [TopLevel] -> Either ErrStr Env {- Global -}+makeTopLevel fdp packageName imports = do+ filePath <- getJust "makeTopLevel.filePath" (D.FileDescriptorProto.name fdp)+ let -- There should be no TYPE_GROUP in the extension list here, but to be safe:+ isGroup = (`elem` groupNames) where+ groupNamesRaw = map toString . mapMaybe D.FieldDescriptorProto.type_name+ . filter (maybe False (TYPE_GROUP ==) . D.FieldDescriptorProto.type') + $ (F.toList . D.FileDescriptorProto.extension $ fdp)+ groupNamesI = mapMaybe validI groupNamesRaw+ groupNamesDI = mapMaybe validDI groupNamesRaw -- These fully qualified names from using hprotoc as a plugin for protoc+ groupNames = groupNamesI ++ map (last . splitDI) groupNamesDI+ (bad,global) <- myFixE ("makeTopLevel myFixE",emptyEnv) $ \ global'Param ->+ let sEnv = SEnv (get'SEnv'root'from'PackageID packageName) global'Param+ in runSE sEnv $ do+ (bads,children) <- fmap unzip . sequence $+ [ kids (entityMsg isGroup) (D.FileDescriptorProto.message_type fdp)+ , kids (entityField True) (D.FileDescriptorProto.extension fdp)+ , kids entityEnum (D.FileDescriptorProto.enum_type fdp)+ , kids entityService (D.FileDescriptorProto.service fdp) ]+ let bad' = unlines (concat bads)+ global' = Global (TopLevel (toString filePath)+ packageName+ (resolveFDP fdp global')+ (M.fromListWithKey unique (concat children)))+ imports+ return (bad',global')+ -- Moving this outside the myFixE reduces the cases where myFixE generates an 'error' call.+ when (not (null bad)) $+ throw $ "makeTopLevel.bad: Some children failed for "++show filePath++"\n"++bad+ return global++ where resolveFDP :: D.FileDescriptorProto -> Env -> Either ErrStr D.FileDescriptorProto+ resolveFDP fdpIn env = runRE env (fqFileDP fdpIn)+ where runRE :: Env -> RE D.FileDescriptorProto -> Either ErrStr D.FileDescriptorProto+ runRE envIn m = runReaderT m envIn++ -- Used from makeTopLevel, from loadProto'+ get'SEnv'root'from'PackageID :: PackageID [IName String] -> [IName String]+ get'SEnv'root'from'PackageID = getPackageID -- was mPackageID before 2012-09-19+ -- where+ -- Used from get'SEnv makeTopLevel, from loadProto'+ -- mPackageID :: Monoid a => PackageID a -> a+ -- mPackageID (PackageID {_getPackageID=x}) = x+ -- mPackageID (NoPackageID {}) = mempty+++-- Copies of mFix for use the string in (Left msg) for the error message.+-- Note that the usual mfix for Either calls 'error' while this does not,+-- it uses a default value passed to myFix*.+myFixSE :: (String,a) -> (a -> SE (String,a)) -> SE (String,a)+myFixSE s f = ReaderT $ \r -> myFixE s (\a -> runReaderT (f a) r)++-- Note that f ignores the fst argument+myFixE :: (String,a) -> (a -> Either ErrStr (String,a)) -> Either ErrStr (String,a)+myFixE s f = let a = f (unRight a) in a+ where unRight (Right x) = snd x+ unRight (Left _msg) = snd s+-- ( "Text.ProtocolBuffers.ProtoCompile.Resolve: "++fst s ++":\n" ++ indent msg+-- , snd s)++{- ***+All the entity* functions are used by makeTopLevel and each other.+If there is no error then these return (IName String,E'Entity) and this E'Entity is always E'Ok.+ *** -}++-- Fix this to look at groupNamesDI as well as the original list of groupNamesI. This fixes a bug+-- in the plug-in usage because protoc will have already resolved the type_name to a fully qualified+-- name.+entityMsg :: (IName String -> Bool) -> D.DescriptorProto -> SE (IName String,E'Entity)+entityMsg isGroup dp = annErr ("entityMsg DescriptorProto name is "++show (D.DescriptorProto.name dp)) $ do+ (self,names) <- getNames "entityMsg.name" D.DescriptorProto.name dp+ numbers <- fmap Set.fromList . mapM (getJust "entityMsg.field.number" . D.FieldDescriptorProto.number) . F.toList . D.DescriptorProto.field $ dp+ when (Set.size numbers /= Seq.length (D.DescriptorProto.field dp)) $+ throwError $ "entityMsg.field.number: There must be duplicate field numbers for "++show names++"\n "++show numbers+ let groupNamesRaw = map toString . mapMaybe D.FieldDescriptorProto.type_name+ . filter (maybe False (TYPE_GROUP ==) . D.FieldDescriptorProto.type') + $ (F.toList . D.DescriptorProto.field $ dp) ++ (F.toList . D.DescriptorProto.extension $ dp)+ groupNamesI = mapMaybe validI groupNamesRaw+ groupNamesDI = mapMaybe validDI groupNamesRaw -- These fully qualified names from using hprotoc as a plugin for protoc+ groupNames = groupNamesI ++ map (last . splitDI) groupNamesDI+ isGroup' = (`elem` groupNames)+ (bad,entity) <- myFixSE ("myFixSE entityMsg",emptyEntity) $ \ entity'Param -> descend names entity'Param $ do+ (bads,children) <- fmap unzip . sequence $+ [ kids entityEnum (D.DescriptorProto.enum_type dp)+ , kids (entityField True) (D.DescriptorProto.extension dp)+ , kids (entityField False) (D.DescriptorProto.field dp)+ , kids (entityMsg isGroup') (D.DescriptorProto.nested_type dp) ]+ let bad' = unlines (concat bads)+ entity' | isGroup self = E'Group names (M.fromListWithKey unique (concat children))+ | otherwise = E'Message names (getExtRanges dp) (M.fromListWithKey unique (concat children))+ return (bad',entity')+ -- Moving this outside the myFixSE reduces the cases where myFixSE uses the error-default call.+ when (not (null bad)) $+ throwError $ "entityMsg.bad: Some children failed for "++show names++"\n"++bad+ return (self,E'Ok $ entity)++-- Among other things, this is where ambiguous type names in the proto file are resolved into a+-- Message or a Group or an Enum.+entityField :: Bool -> D.FieldDescriptorProto -> SE (IName String,E'Entity)+entityField isKey fdp = annErr ("entityField FieldDescriptorProto name is "++show (D.FieldDescriptorProto.name fdp)) $ do+ (self,names) <- getNames "entityField.name" D.FieldDescriptorProto.name fdp+ let isKey' = maybe False (const True) (D.FieldDescriptorProto.extendee fdp)+ when (isKey/=isKey') $+ throwError $ "entityField: Impossible? Expected key and got field or vice-versa:\n"++ishow ((isKey,isKey'),names,fdp)+ number <- getJust "entityField.name" . D.FieldDescriptorProto.number $ fdp+ let mType = D.FieldDescriptorProto.type' fdp+ typeName <- maybeM resolveMGE (D.FieldDescriptorProto.type_name fdp)+ if isKey+ then do+ extendee <- resolveM =<< getJust "entityField.extendee" (D.FieldDescriptorProto.extendee fdp)+ return (self,E'Ok $ E'Key names extendee (FieldId number) mType typeName)+ else+ return (self,E'Ok $ E'Field names (FieldId number) mType typeName)+ where+ resolveMGE :: Utf8 -> SE (Either ErrStr Entity)+ resolveMGE nameU = fmap (resolvePredEnv "Message or Group or Enum" isMGE nameU) (asks my'Env)+ where isMGE (E'Ok e') = case e' of E'Message {} -> True+ E'Group {} -> True+ E'Enum {} -> True+ _ -> False+ isMGE (E'Error {}) = False+ -- To be used for key extendee name resolution, but not part of the official protobuf-2.1.0 update, since made official+ resolveM :: Utf8 -> SE (Either ErrStr Entity)+ resolveM nameU = fmap (resolvePredEnv "Message" isM nameU) (asks my'Env)+ where isM (E'Ok e') = case e' of E'Message {} -> True+ _ -> False+ isM (E'Error {}) = False++entityEnum :: D.EnumDescriptorProto -> SE (IName String,E'Entity)+entityEnum edp@(D.EnumDescriptorProto {D.EnumDescriptorProto.value=vs}) = do+ (self,names) <- getNames "entityEnum.name" D.EnumDescriptorProto.name edp+ values <- mapM (getJust "entityEnum.value.number" . D.EnumValueDescriptorProto.number) . F.toList $ vs+{- Cannot match protoc if I enable this as a fatal check here+ when (Set.size (Set.fromList values) /= Seq.length vs) $+ throwError $ "entityEnum.value.number: There must be duplicate enum values for "++show names++"\n "++show values+-}+ justNames <- mapM (\v -> getJust ("entityEnum.value.name failed for "++show v) (D.EnumValueDescriptorProto.name v))+ . F.toList $ vs+ valNames <- mapM (\n -> getJust ("validI of entityEnum.value.name failed for "++show n) (validI n)) justNames+ let mapping = M.fromList (zip valNames values)+ when (M.size mapping /= Seq.length vs) $+ throwError $ "entityEnum.value.name: There must be duplicate enum names for "++show names++"\n "++show valNames+ descend'Enum names $ F.mapM_ entityEnumValue vs+ return (self,E'Ok $ E'Enum names mapping) -- discard values++ where entityEnumValue :: D.EnumValueDescriptorProto -> SE ()+ entityEnumValue evdp = do -- Merely use getNames to add mangled self to ReMap state+ _ <- getNames "entityEnumValue.name" D.EnumValueDescriptorProto.name evdp+ return ()++ descend'Enum :: [IName String] -> SE a -> SE a+ descend'Enum names act = local mutate act+ where mutate (SEnv _parent env) = SEnv names env++entityService :: D.ServiceDescriptorProto -> SE (IName String,E'Entity)+entityService sdp = annErr ("entityService ServiceDescriptorProto name is "++show (D.ServiceDescriptorProto.name sdp)) $ do+ (self,names) <- getNames "entityService.name" D.ServiceDescriptorProto.name sdp+ (bad,entity) <- myFixSE ("myFixSE entityService",emptyEntity) $ \ entity'Param ->+ descend names entity'Param $ do+ (badMethods',goodMethods) <- kids entityMethod (D.ServiceDescriptorProto.method sdp)+ let bad' = unlines badMethods'+ entity' = E'Service names (M.fromListWithKey unique goodMethods)+ return (bad',entity')+ -- Moving this outside the myFixSE reduces the cases where myFixSE generates an 'error' call.+ when (not (null bad)) $+ throwError $ "entityService.badMethods: Some methods failed for "++show names++"\n"++bad+ return (self,E'Ok entity)++entityMethod :: D.MethodDescriptorProto -> SE (IName String,E'Entity)+entityMethod mdp = do+ (self,names) <- getNames "entityMethod.name" D.MethodDescriptorProto.name mdp+ inputType <- getType "entityMethod.input_type" D.MethodDescriptorProto.input_type mdp+ outputType <- getType "entityMethod.output_type" D.MethodDescriptorProto.output_type mdp+ return (self,E'Ok $ E'Method names inputType outputType)++{- ***++The namespace Env is used to transform the original FileDescriptorProto into a canonical+FileDescriptorProto. The goal is to match the transformation done by Google's protoc program. This+will allow the "front end" vs "back end" of each program to cross-couple, which will at least allow+better testing of hprotoc and the new UninterpretedOption support.++The UninterpretedOption fields are converted by the resolveFDP code below.++These should be total functions with no 'error' or 'undefined' values possible.++*** -}++fqFail :: Show a => String -> a -> Entity -> RE b+fqFail msg dp entity = do+ env <- ask+ throw $ unlines [ msg, "resolving: "++show dp, "in environment: "++whereEnv env, "found: "++show (eName entity) ]++fqFileDP :: D.FileDescriptorProto -> RE D.FileDescriptorProto+fqFileDP fdp = annErr ("fqFileDP FileDescriptorProto (name,package) is "++show (D.FileDescriptorProto.name fdp,D.FileDescriptorProto.package fdp)) $ do+ newMessages <- T.mapM fqMessage (D.FileDescriptorProto.message_type fdp)+ newEnums <- T.mapM fqEnum (D.FileDescriptorProto.enum_type fdp)+ newServices <- T.mapM fqService (D.FileDescriptorProto.service fdp)+ newKeys <- T.mapM (fqField True) (D.FileDescriptorProto.extension fdp)+ consumeUNO $ fdp { D.FileDescriptorProto.message_type = newMessages+ , D.FileDescriptorProto.enum_type = newEnums+ , D.FileDescriptorProto.service = newServices+ , D.FileDescriptorProto.extension = newKeys }++fqMessage :: D.DescriptorProto -> RE D.DescriptorProto+fqMessage dp = annErr ("fqMessage DescriptorProto name is "++show (D.DescriptorProto.name dp)) $ do+ entity <- resolveRE =<< getJust "fqMessage.name" (D.DescriptorProto.name dp)+ (name,vals) <- case entity of+ E'Message {eName=name',mVals=vals'} -> return (name',vals')+ E'Group {eName=name',mVals=vals'} -> return (name',vals')+ _ -> fqFail "fqMessage.entity: did not resolve to an E'Message or E'Group:" dp entity+ local (\env -> (Local name vals env)) $ do+ newFields <- T.mapM (fqField False) (D.DescriptorProto.field dp)+ newKeys <- T.mapM (fqField True) (D.DescriptorProto.extension dp)+ newMessages <- T.mapM fqMessage (D.DescriptorProto.nested_type dp)+ newEnums <- T.mapM fqEnum (D.DescriptorProto.enum_type dp)+ consumeUNO $ dp { D.DescriptorProto.field = newFields+ , D.DescriptorProto.extension = newKeys+ , D.DescriptorProto.nested_type = newMessages+ , D.DescriptorProto.enum_type = newEnums }++fqService :: D.ServiceDescriptorProto -> RE D.ServiceDescriptorProto+fqService sdp = annErr ("fqService ServiceDescriptorProto name is "++show (D.ServiceDescriptorProto.name sdp)) $ do+ entity <- resolveRE =<< getJust "fqService.name" (D.ServiceDescriptorProto.name sdp)+ case entity of+ E'Service {eName=name,mVals=vals} -> do+ newMethods <- local (Local name vals) $ T.mapM fqMethod (D.ServiceDescriptorProto.method sdp)+ consumeUNO $ sdp { D.ServiceDescriptorProto.method = newMethods }+ _ -> fqFail "fqService.entity: did not resolve to a service:" sdp entity++fqMethod :: D.MethodDescriptorProto -> RE D.MethodDescriptorProto+fqMethod mdp = do+ entity <- resolveRE =<< getJust "fqMethod.name" (D.MethodDescriptorProto.name mdp)+ case entity of+ E'Method {eMsgIn=msgIn,eMsgOut=msgOut} -> do+ mdp1 <- case msgIn of+ Nothing -> return mdp+ Just resolveIn -> do+ new <- fmap fqName (lift resolveIn)+ return (mdp {D.MethodDescriptorProto.input_type = Just (fiName new)})+ mdp2 <- case msgOut of+ Nothing -> return mdp1+ Just resolveIn -> do+ new <- fmap fqName (lift resolveIn)+ return (mdp1 {D.MethodDescriptorProto.output_type = Just (fiName new)})+ consumeUNO mdp2+ _ -> fqFail "fqMethod.entity: did not resolve to a Method:" mdp entity++-- The field is a bit more complicated to resolve. The Key variant needs to resolve the extendee.+-- The type code from Parser.hs might be Nothing and this needs to be resolved to TYPE_MESSAGE or+-- TYPE_ENUM (at last!), and if it is the latter then any default value string is checked for+-- validity.+fqField :: Bool -> D.FieldDescriptorProto -> RE D.FieldDescriptorProto+fqField isKey fdp = annErr ("fqField FieldDescriptorProto name is "++show (D.FieldDescriptorProto.name fdp)) $ do+ let isKey' = maybe False (const True) (D.FieldDescriptorProto.extendee fdp)+ when (isKey/=isKey') $+ ask >>= \env -> throwError $ "fqField.isKey: Expected key and got field or vice-versa:\n"++ishow ((isKey,isKey'),whereEnv env,fdp)+ entity <- expectFK =<< resolveRE =<< getJust "fqField.name" (D.FieldDescriptorProto.name fdp)+ newExtendee <- case (isKey,entity) of+ (True,E'Key {eMsg=msg,fNumber=fNum}) -> do+ ext <- lift msg+ case ext of+ E'Message {} -> when (not (checkFI (validExtensions ext) fNum)) $+ throwError $ "fqField.newExtendee: Field Number of extention key invalid:\n"+ ++unlines ["Number is "++show (fNumber entity)+ ,"Valid ranges: "++show (validExtensions ext)+ ,"Extendee: "++show (eName ext)+ ,"Descriptor: "++show fdp]+ _ -> fqFail "fqField.ext: Key's target is not an E'Message:" fdp ext+ fmap (Just . fiName . fqName) . lift . eMsg $ entity+ (False,E'Field {}) -> return Nothing+ _ -> fqFail "fqField.entity: did not resolve to expected E'Key or E'Field:" fdp entity+ mTypeName <- maybeM lift (mVal entity) -- "Just (Left _)" triggers a throwError here (see comment for entityField)+ -- Finally fully determine D.Type, (type'==Nothing) meant ambiguously TYPE_MESSAGE or TYPE_ENUM from Parser.hs+ -- This has gotten more verbose with the addition of verifying packed is being used properly.+ actualType <- case (fType entity,mTypeName) of+ (Just TYPE_GROUP, Just (E'Group {})) | isNotPacked fdp -> return TYPE_GROUP+ | otherwise -> + fqFail ("fqField.actualType : This Group is invalid, you cannot pack a group field.") fdp entity+ (Nothing, Just (E'Message {})) | isNotPacked fdp -> return TYPE_MESSAGE+ | otherwise ->+ fqFail ("fqField.actualType : This Message is invalid, you cannot pack a message field.") fdp entity+ (Nothing, Just (E'Enum {})) | isNotPacked fdp -> return TYPE_ENUM+ | isRepeated fdp -> return TYPE_ENUM+ | otherwise ->+ fqFail ("fqField.actualType : This Enum is invalid, you cannot pack a non-repeated field.") fdp entity+ (Just t, Nothing) -> return t+ (Just TYPE_MESSAGE, Just (E'Message {})) -> return TYPE_MESSAGE+ (Just TYPE_ENUM, Just (E'Enum {})) -> return TYPE_ENUM+ (mt,me) -> fqFail ("fqField.actualType: "++show mt++" and "++show (fmap eName me)++" is invalid.") fdp entity+ -- Check that a default value of an TYPE_ENUM is valid+ case (mTypeName,D.FieldDescriptorProto.default_value fdp) of+ (Just ee@(E'Enum {eVals = enumVals}),Just enumVal) ->+ let badVal = throwError $ "fqField.default_value: Default enum value is invalid:\n"+ ++unlines ["Value is "++show (toString enumVal)+ ,"Allowed values from "++show (eName ee)+ ," are "++show (M.keys enumVals)+ ,"Descriptor: "++show fdp]+ in case validI enumVal of+ Nothing -> badVal+ Just iVal -> when (M.notMember iVal enumVals) badVal+ _ -> return ()+ consumeUNO $+ if isKey then (fdp { D.FieldDescriptorProto.extendee = newExtendee+ , D.FieldDescriptorProto.type' = Just actualType+ , D.FieldDescriptorProto.type_name = fmap (fiName . fqName) mTypeName })+ else (fdp { D.FieldDescriptorProto.type' = Just actualType+ , D.FieldDescriptorProto.type_name = fmap (fiName . fqName) mTypeName })++ where isRepeated :: D.FieldDescriptorProto -> Bool+ isRepeated (D.FieldDescriptorProto {+ D.FieldDescriptorProto.label =+ Just LABEL_REPEATED }) =+ True+ isRepeated _ = False++ isNotPacked :: D.FieldDescriptorProto -> Bool+ isNotPacked (D.FieldDescriptorProto { + D.FieldDescriptorProto.options =+ Just (D.FieldOptions { + D.FieldOptions.packed =+ Just isPacked })}) =+ not isPacked+ isNotPacked _ = True++ expectFK :: Entity -> RE Entity+ expectFK e | isFK = return e+ | otherwise = throwError $ "expectF: Name resolution failed to find a Field or Key:\n"++ishow (eName e)+ where isFK = case e of E'Field {} -> True+ E'Key {} -> True+ _ -> False++++fqEnum :: D.EnumDescriptorProto -> RE D.EnumDescriptorProto+fqEnum edp = do+ entity <- resolveRE =<< getJust "fqEnum.name" (D.EnumDescriptorProto.name edp)+ case entity of+ E'Enum {} -> do evdps <- T.mapM consumeUNO (D.EnumDescriptorProto.value edp)+ consumeUNO $ edp { D.EnumDescriptorProto.value = evdps }+ _ -> fqFail "fqEnum.entity: did not resolve to an E'Enum:" edp entity++{- The consumeUNO calls above hide this cut-and-pasted boilerplate between interpretOptions and the DescriptorProto type -}++class ConsumeUNO a where consumeUNO :: a -> RE a++instance ConsumeUNO D.EnumDescriptorProto where+ consumeUNO a = maybe (return a) (processOpt >=> \o -> return $ a { D.EnumDescriptorProto.options = Just o })+ (D.EnumDescriptorProto.options a)+ where processOpt m = do m' <- interpretOptions "EnumOptions" m (D.EnumOptions.uninterpreted_option m)+ return (m' { D.EnumOptions.uninterpreted_option = mempty })++instance ConsumeUNO D.EnumValueDescriptorProto where+ consumeUNO a = maybe (return a) (processOpt >=> \o -> return $ a { D.EnumValueDescriptorProto.options = Just o })+ (D.EnumValueDescriptorProto.options a)+ where processOpt m = do m' <- interpretOptions "EnumValueOptions" m (D.EnumValueOptions.uninterpreted_option m)+ return (m' { D.EnumValueOptions.uninterpreted_option = mempty })++instance ConsumeUNO D.MethodDescriptorProto where+ consumeUNO a = maybe (return a) (processOpt >=> \o -> return $ a { D.MethodDescriptorProto.options = Just o })+ (D.MethodDescriptorProto.options a)+ where processOpt m = do m' <- interpretOptions "MethodOptions" m (D.MethodOptions.uninterpreted_option m)+ return (m' { D.MethodOptions.uninterpreted_option = mempty })++instance ConsumeUNO D.ServiceDescriptorProto where+ consumeUNO a = maybe (return a) (processOpt >=> \o -> return $ a { D.ServiceDescriptorProto.options = Just o })+ (D.ServiceDescriptorProto.options a)+ where processOpt m = do m' <- interpretOptions "ServiceOptions" m (D.ServiceOptions.uninterpreted_option m)+ return (m' { D.ServiceOptions.uninterpreted_option = mempty })++instance ConsumeUNO D.FieldDescriptorProto where+ consumeUNO a = maybe (return a) (processOpt >=> \o -> return $ a { D.FieldDescriptorProto.options = Just o })+ (D.FieldDescriptorProto.options a)+ where processOpt m = do m' <- interpretOptions "FieldOptions" m (D.FieldOptions.uninterpreted_option m)+ return (m' { D.FieldOptions.uninterpreted_option = mempty })++instance ConsumeUNO D.FileDescriptorProto where+ consumeUNO a = maybe (return a) (processOpt >=> \o -> return $ a { D.FileDescriptorProto.options = Just o })+ (D.FileDescriptorProto.options a)+ where processOpt m = do m' <- interpretOptions "FileOptions" m (D.FileOptions.uninterpreted_option m)+ return (m' { D.FileOptions.uninterpreted_option = mempty })++instance ConsumeUNO D.DescriptorProto where+ consumeUNO a = maybe (return a) (processOpt >=> \o -> return $ a { D.DescriptorProto.options = Just o })+ (D.DescriptorProto.options a)+ where processOpt m = do m' <- interpretOptions "MessageOptions" m (D.MessageOptions.uninterpreted_option m)+ return (m' { D.MessageOptions.uninterpreted_option = mempty })++{- The boilerplate above feeds interpretOptions to do the real work -}++-- 'interpretOptions' is used by the 'consumeUNO' instances+-- This prepends the ["google","protobuf"] and updates all the options into the ExtField of msg+interpretOptions :: ExtendMessage msg => String -> msg -> Seq D.UninterpretedOption -> RE msg+interpretOptions name msg unos = do+ name' <- getJust ("interpretOptions: invalid name "++show name) (validI name)+ ios <- mapM (interpretOption [IName "google",IName "protobuf",name']) . F.toList $ unos+ let (ExtField ef) = getExtField msg+ ef' = foldl' (\m (k,v) -> seq v $ M.insertWithKey mergeWires k v m) ef ios++ mergeWires _k (ExtFromWire newData) (ExtFromWire oldData) =+ ExtFromWire (mappend oldData newData)+{-+ mergeWires k (ExtFromWire wt1 newData) (ExtFromWire wt2 oldData) =+ if wt1 /= wt2 then err $ "interpretOptions.mergeWires : ExtFromWire WireType mismatch while storing new options in extension fields: " ++ show (name,k,(wt1,wt2))+ else ExtFromWire wt2 (mappend oldData newData)+-}+ mergeWires k a b = err $ "interpretOptions.mergeWires : impossible case\n"++show (k,a,b)+ msg' = seq ef' (putExtField (ExtField ef') msg)+ return msg'++-- 'interpretOption' is called by 'interpretOptions'+-- The 'interpretOption' function is quite long because there are two things going on.+-- The first is the actual type must be retrieved from the UninterpretedOption and encoded.+-- The second is that messages/groups holding messages/groups ... holding the above must wrap this.+-- Both of the above might come from extension keys or from field names.+-- And as usual, there are many ways thing could conceivable go wrong or be out of bounds.+--+-- The first parameter must be a name such as ["google","protobuf","FieldOption"]+interpretOption :: [IName String] -> D.UninterpretedOption -> RE (FieldId,ExtFieldValue)+interpretOption optName uno = case F.toList (D.UninterpretedOption.name uno) of+ [] -> iFail $ "Empty name_part"+ (part:parts) -> go Nothing optName part parts+ where+ iFail :: String -> RE a -- needed by ghc-7.0.2+ iFail msg = do env <- ask+ throw $ unlines [ "interpretOption: Failed to handle UninterpretedOption for: "++show optName+ , " environment: "++whereEnv env+ , " value: "++show uno+ , " message: "++msg ]++ -- This takes care of an intermediate message or group type+ go :: Maybe Entity {- E'Message E'Group -} -> [IName String] -> D.NamePart -> [D.NamePart] -> RE (FieldId,ExtFieldValue)+ go mParent names (D.NamePart { D.NamePart.name_part = name+ , D.NamePart.is_extension = isKey }) (next:rest) = do+ -- get entity (Field or Key) and the TYPE_*+ -- fk will ceratinly be E'Field or E'Key+ (fk,entity) <-+ if not isKey+ then case mParent of+ Nothing -> iFail $ "Cannot resolve local (is_extension False) name, no parent; expected (key)."+ Just parent -> do+ entity'field <- resolveHere parent name+ case entity'field of+ (E'Field {}) ->+ case mVal entity'field of+ Nothing -> iFail $ "Intermediate entry E'Field is of basic type, not E'Message or E'Group: "++show (names,eName entity'field)+ Just val -> lift val >>= \e -> return (entity'field,e)+ _ -> iFail $ "Name "++show (toString name)++" was resolved but was not an E'Field: "++show (eName entity'field)+ else do entity'key <- resolveRE name+ case entity'key of+ (E'Key {eMsg=msg}) -> do+ extendee <- lift msg+ when (eName extendee /= names) $+ iFail $ "Intermediate entry E'Key extends wrong type: "++show (names,eName extendee)+ case mVal entity'key of+ Nothing-> iFail $ "Intermediate entry E'Key is of basic type, not E'Message or E'Group: "++show (names,eName entity'key)+ Just val -> lift val >>= \e -> return (entity'key,e)+ _ -> iFail $ "Name "++show (toString name)++" was resolved but was not an E'Key: "++show (eName entity'key)+ t <- case entity of+ E'Message {} -> return TYPE_MESSAGE+ E'Group {} -> return TYPE_GROUP+ _ -> iFail $ "Intermediate entry is not an E'Message or E'Group: "++show (eName entity)+ -- recursive call to get inner result+ (fid',ExtFromWire raw') <- go (Just entity) (eName entity) next rest+ -- wrap old tag + inner result with outer info+ let tag@(WireTag tag') = mkWireTag fid' wt'+ (EP wt' bs') = Seq.index raw' 0+ let fid = fNumber fk -- safe by construction of fk+ wt = toWireType (FieldType (fromEnum t))+ bs = runPut $+ case t of TYPE_MESSAGE -> do putSize (size'WireTag tag + LC.length bs')+ putVarUInt tag'+ putLazyByteString bs'+ TYPE_GROUP -> do putVarUInt tag'+ putLazyByteString bs'+ putVarUInt (succ (getWireTag (mkWireTag fid wt)))+ _ -> fail $ "bug! raw with type "++show t++" should be impossible"+ return (fid,ExtFromWire (Seq.singleton (EP wt bs)))++ -- This takes care of the acutal value of the option, which must be a basic type+ go mParent names (D.NamePart { D.NamePart.name_part = name+ , D.NamePart.is_extension = isKey }) [] = do+ -- get entity (Field or Key) and the TYPE_*+ fk <- if isKey then resolveRE name+ else case mParent of+ Just parent -> resolveHere parent name+ Nothing -> iFail $ "Cannot resolve local (is_extension False) name, no parent; expected (key)."+ case fk of+ E'Field {} | not isKey -> return ()+ E'Key {} | isKey -> do+ ext <- lift (eMsg fk)+ when (eName ext /= names) $ iFail $ "Last entry E'Key extends wrong type: "++show (names,eName ext)+ _ -> iFail $ "Last entity was resolved but was not an E'Field or E'Key: "++show fk+ t <- case (fType fk) of+ Nothing -> return TYPE_ENUM -- XXX not a good assumption with aggregate types !!!! This also covers groups and messages.+ Just TYPE_GROUP -> iFail $ "Last entry was a TYPE_GROUP instead of concrete value type" -- impossible+ Just TYPE_MESSAGE -> {- impossible -} iFail $ "Last entry was a TYPE_MESSAGE instead of concrete value type" -- impossible+ Just typeCode -> return typeCode+ -- Need to define a polymorphic 'done' to convert actual data type to its wire encoding+ let done :: Wire v => v -> RE (FieldId,ExtFieldValue)+ done v = let ft = FieldType (fromEnum t)+ wt = toWireType ft+ fid = fNumber fk+ in return (fid,ExtFromWire (Seq.singleton (EP wt (runPut (wirePut ft v)))))+ -- The actual type and value fed to 'done' depends on the values 't' and 'uno':+ case t of+ TYPE_ENUM -> -- Now must also also handle Message and Group+ case (mVal fk,D.UninterpretedOption.identifier_value uno,D.UninterpretedOption.aggregate_value uno) of+ (Just (Right (E'Enum {eVals=enumVals})),Just enumVal,_) ->+ case validI enumVal of+ Nothing -> iFail $ "invalid D.UninterpretedOption.identifier_value: "++show enumVal+ Just enumIVal -> case M.lookup enumIVal enumVals of+ Nothing -> iFail $ "enumVal lookup failed: "++show (enumIVal,M.keys enumVals)+ Just val -> done (fromEnum val) -- fromEnum :: Int32 -> Int+ (Just (Right (E'Enum {})),Nothing,_) -> iFail $ "No identifer_value value to lookup in E'Enum"+ (Just (Right (E'Message {})),_,Nothing) -> iFail "Expected aggregate syntax to set a message option"+ (Just (Right (E'Message {})),_,Just aggVal) -> iFail $ "\n\n\+ \=========================================================================================\n\+ \Google's 2.4.0 aggregate syntax for message options is not yet supported, value would be:\n\+ \=========================================================================================\n" ++ show aggVal+ (Just (Right (E'Group {})),_,Nothing) -> iFail "Expected aggregate syntax to set a group option (impossible?)"+ (Just (Right (E'Group {})),_,Just aggVal) -> iFail $ "\n\n\+ \=========================================================================================\n\+ \Google's 2.4.0 aggregate syntax for message options is not yet supported, value would be:\n\+ \=========================================================================================\n" ++ show aggVal+ (me,_,_) -> iFail $ "Expected Just E'Enum or E'Message or E'Group, got:\n"++show me++ TYPE_STRING -> do+ bs <- getJust "UninterpretedOption.string_value" (D.UninterpretedOption.string_value uno)+ maybe (done (Utf8 bs)) (\i -> iFail $ "Invalid utf8 in string_value at index: "++show i)+ (isValidUTF8 bs)+ + TYPE_BYTES -> done =<< getJust "UninterpretedOption.string_value" (D.UninterpretedOption.string_value uno)+ TYPE_BOOL -> done =<< bVal+ TYPE_DOUBLE -> done =<< dVal+ TYPE_FLOAT -> done =<< asFloat =<< dVal+ TYPE_INT64 -> done =<< (iVal :: RE Int64)+ TYPE_SFIXED64 -> done =<< (iVal :: RE Int64)+ TYPE_SINT64 -> done =<< (iVal :: RE Int64)+ TYPE_UINT64 -> done =<< (iVal :: RE Word64)+ TYPE_FIXED64 -> done =<< (iVal :: RE Word64)+ TYPE_INT32 -> done =<< (iVal :: RE Int32)+ TYPE_SFIXED32 -> done =<< (iVal :: RE Int32)+ TYPE_SINT32 -> done =<< (iVal :: RE Int32)+ TYPE_UINT32 -> done =<< (iVal :: RE Word32)+ TYPE_FIXED32 -> done =<< (iVal :: RE Word32)+ _ -> iFail $ "bug! go with type "++show t++" should be impossible"++ -- Machinery needed by the final call of go+ bVal :: RE Bool+ bVal = let true = Utf8 (U.fromString "true")+ false = Utf8 (U.fromString "false")+ in case D.UninterpretedOption.identifier_value uno of+ Just s | s == true -> return True+ | s == false -> return False+ _ -> iFail "Expected 'true' or 'false' identifier_value"+ dVal :: RE Double+ dVal = case (D.UninterpretedOption.negative_int_value uno+ ,D.UninterpretedOption.positive_int_value uno+ ,D.UninterpretedOption.double_value uno) of+ (_,_,Just d) -> return d+ (_,Just p,_) -> return (fromIntegral p)+ (Just n,_,_) -> return (fromIntegral n)+ _ -> iFail "No numeric value"+ asFloat :: Double -> RE Float+ asFloat d = let fmax :: Ratio Integer+ fmax = (2-(1%2)^(23::Int)) * (2^(127::Int))+ d' = toRational d+ in if (negate fmax <= d') && (d' <= fmax)+ then return (fromRational d')+ else iFail $ "Double out of range for Float: "++show d+ rangeCheck :: forall a. (Bounded a,Integral a) => Integer -> RE a+ rangeCheck i = let r = (toInteger (minBound ::a),toInteger (maxBound :: a))+ in if inRange r i then return (fromInteger i) else iFail $ "Constant out of range: "++show (r,i)+ asInt :: Double -> RE Integer+ asInt x = let (a,b) = properFraction x+ in if b==0 then return a+ else iFail $ "Double value not an integer: "++show x+ iVal :: (Bounded y, Integral y) => RE y+ iVal = case (D.UninterpretedOption.negative_int_value uno+ ,D.UninterpretedOption.positive_int_value uno+ ,D.UninterpretedOption.double_value uno) of+ (_,Just p,_) -> rangeCheck (toInteger p)+ (Just n,_,_) -> rangeCheck (toInteger n)+ (_,_,Just d) -> rangeCheck =<< asInt d+ _ -> iFail "No numeric value"++-- | 'findFile' looks through the current and import directories to find the target file on the system.+-- It also converts the relative path to a standard form to use as the name of the FileDescriptorProto.+findFile :: [LocalFP] -> LocalFP -> IO (Maybe (LocalFP,CanonFP)) -- absolute and canonical parts+findFile paths (LocalFP target) = test paths where+ test [] = return Nothing+ test (LocalFP path:rest) = do+ let fullname = Local.combine path target+ found <- doesFileExist fullname -- stop at first hit+ if not found+ then test rest+ else do truepath <- canonicalizePath path+ truefile <- canonicalizePath fullname+ if truepath `isPrefixOf` truefile+ then do let rel = fpLocalToCanon (LocalFP (Local.makeRelative truepath truefile))+ return (Just (LocalFP truefile,rel))+ else fail $ "file found but it is not below path, cannot make canonical name:\n path: "+ ++show truepath++"\n file: "++show truefile+++-- | Given a path, tries to find and parse a FileDescriptorProto+-- corresponding to it; returns also a canonicalised path.+type DescriptorReader m = (Monad m) => LocalFP -> m (D.FileDescriptorProto, LocalFP)++loadProto' :: (Functor r,Monad r) => DescriptorReader r -> LocalFP -> r (Env,[D.FileDescriptorProto])+loadProto' fdpReader protoFile = goState (load Set.empty protoFile) where+ goState act = do (env,m) <- runStateT act mempty+ let fromRight (Right x) = x+ fromRight (Left s) = error $ "loadProto failed to resolve a FileDescriptorProto: "++s+ return (env,map (fromRight . top'FDP . fst . getTLS) (M.elems m))+ load parentsIn file = do+ built <- get+ when (Set.member file parentsIn)+ (loadFailed file (unlines ["imports failed: recursive loop detected"+ ,unlines . map show . M.assocs $ built,show parentsIn]))+ case M.lookup file built of -- check memorized results+ Just result -> return result+ Nothing -> do+ (parsed'fdp, canonicalFile) <- lift $ fdpReader file+ let rawPackage = getPackage parsed'fdp+ packageName <- either (loadFailed canonicalFile . show)+ (return . fmap (map iToString . snd)) -- 2012-09-19 suspicious+ (checkPackageID rawPackage)++{-+-- OLD before 2012-09-19+ packageName <- either (loadFailed canonicalFile . show)+ (return . PackageID . map iToString . snd) -- 2012-09-19 suspicious+ (checkPackageID rawPackage)+-}++{-+ -- previously patched solution+ packageName <- case D.FileDescriptorProto.package parsed'fdp of+ Nothing -> return []+ Just p -> either (loadFailed canonicalFile . show)+ (return . map iToString . snd) $+ (checkDIUtf8 p)+-}+ let parents = Set.insert file parentsIn+ importList = map (fpCanonToLocal . CanonFP . toString) . F.toList . D.FileDescriptorProto.dependency $ parsed'fdp+ imports <- mapM (fmap getTL . load parents) importList+ let eEnv = makeTopLevel parsed'fdp packageName imports -- makeTopLevel is the "internal entry point" of Resolve.hs+ -- Stricly force these two value to report errors here+ global'env <- either (loadFailed file) return eEnv+ _ <- either (loadFailed file) return (top'FDP . getTL $ global'env)+ modify (M.insert file global'env) -- add to memorized results+ return global'env++loadFailed :: (Monad m) => LocalFP -> String -> m a+loadFailed f msg = fail . unlines $ ["Parsing proto:",show (unLocalFP f),"has failed with message",msg]++-- | Given a list of paths to search, loads proto files by+-- looking for them in the file system.+loadProto :: [LocalFP] -> LocalFP -> IO (Env,[D.FileDescriptorProto])+loadProto protoDirs protoFile = loadProto' findAndParseSource protoFile where+ findAndParseSource :: DescriptorReader IO+ findAndParseSource file = do+ mayToRead <- liftIO $ findFile protoDirs file+ case mayToRead of+ Nothing -> loadFailed file (unlines (["loading failed, could not find file: "++show (unLocalFP file)+ ,"Searched paths were:"] ++ map ((" "++).show.unLocalFP) protoDirs))+ Just (toRead,relpath) -> do+ protoContents <- liftIO $ do putStrLn ("Loading filepath: "++show (unLocalFP toRead))+ LC.readFile (unLocalFP toRead)+ parsed'fdp <- either (loadFailed toRead . show) return $+ (parseProto (unCanonFP relpath) protoContents)+ return (parsed'fdp, toRead)++loadCodeGenRequest :: CGR.CodeGeneratorRequest -> LocalFP -> (Env,[D.FileDescriptorProto])+loadCodeGenRequest req protoFile = runIdentity $ loadProto' lookUpParsedSource protoFile where+ lookUpParsedSource :: DescriptorReader Identity+ lookUpParsedSource file = case M.lookup file fdpsByName of+ Just result -> return (result, file)+ Nothing -> loadFailed file ("Request refers to file: "++show (unLocalFP file)+ ++" but it was not supplied in the request.")+ fdpsByName = M.fromList . map keyByName . F.toList . CGR.proto_file $ req+ keyByName fdp = (fdpName fdp, fdp)+ fdpName = LocalFP . maybe "" (LC.unpack . utf8) . D.FileDescriptorProto.name++-- wart: descend should take (eName,eMvals) not Entity+-- wart: myFix* obviously implements a WriterT by hand. Implement as WriterT ?
+ dist/build/Text/ProtocolBuffers/ProtoCompile/Lexer.hs view
@@ -0,0 +1,548 @@+{-# LANGUAGE CPP,MagicHash #-}+{-# LINE 1 "Text/ProtocolBuffers/ProtoCompile/Lexer.x" #-}++{-# OPTIONS_GHC -Wwarn #-}+module Text.ProtocolBuffers.ProtoCompile.Lexer (Lexed(..), alexScanTokens,getLinePos) where++import Control.Monad.Error()+import Codec.Binary.UTF8.String(encode)+import qualified Data.ByteString.Lazy as DBL+import Data.Char(ord,isHexDigit,isOctDigit,toLower)+import Data.Word(Word8)+import Numeric(readHex,readOct,readDec,readSigned,readFloat)+import qualified Data.ByteString.Lazy.Char8 as DBL8+++#if __GLASGOW_HASKELL__ >= 603+#include "ghcconfig.h"+#elif defined(__GLASGOW_HASKELL__)+#include "config.h"+#endif+#if __GLASGOW_HASKELL__ >= 503+import Data.Array+import Data.Char (ord)+import Data.Array.Base (unsafeAt)+#else+import Array+import Char (ord)+#endif+#if __GLASGOW_HASKELL__ >= 503+import GHC.Exts+#else+import GlaExts+#endif+{-# LINE 1 "templates/wrappers.hs" #-}+-- -----------------------------------------------------------------------------+-- Alex wrapper code.+--+-- This code is in the PUBLIC DOMAIN; you may copy it freely and use+-- it for any purpose whatsoever.++import Data.Word (Word8)+++import qualified Data.Char+import qualified Data.ByteString.Lazy as ByteString+import qualified Data.ByteString.Internal as ByteString (w2c)++++type Byte = Word8++-- -----------------------------------------------------------------------------+-- The input type+++++type AlexInput = (AlexPosn, -- current position,+ Char, -- previous char+ ByteString.ByteString) -- current input string++ignorePendingBytes :: AlexInput -> AlexInput+ignorePendingBytes i = i -- no pending bytes when lexing bytestrings++alexInputPrevChar :: AlexInput -> Char+alexInputPrevChar (p,c,s) = c++alexGetByte :: AlexInput -> Maybe (Byte,AlexInput)+alexGetByte (p,_,cs) | ByteString.null cs = Nothing+ | otherwise = let b = ByteString.head cs+ cs' = ByteString.tail cs+ c = ByteString.w2c b+ p' = alexMove p c+ in p' `seq` cs' `seq` Just (b, (p', c, cs'))+++++++-- -----------------------------------------------------------------------------+-- Token positions++-- `Posn' records the location of a token in the input text. It has three+-- fields: the address (number of chacaters preceding the token), line number+-- and column of a token within the file. `start_pos' gives the position of the+-- start of the file and `eof_pos' a standard encoding for the end of file.+-- `move_pos' calculates the new position after traversing a given character,+-- assuming the usual eight character tab stops.+++data AlexPosn = AlexPn !Int !Int !Int+ deriving (Eq,Show)++alexStartPos :: AlexPosn+alexStartPos = AlexPn 0 1 1++alexMove :: AlexPosn -> Char -> AlexPosn+alexMove (AlexPn a l c) '\t' = AlexPn (a+1) l (((c+7) `div` 8)*8+1)+alexMove (AlexPn a l c) '\n' = AlexPn (a+1) (l+1) 1+alexMove (AlexPn a l c) _ = AlexPn (a+1) l (c+1)+++-- -----------------------------------------------------------------------------+-- Default monad+++++-- -----------------------------------------------------------------------------+-- Monad (with ByteString input)+++++-- -----------------------------------------------------------------------------+-- Basic wrapper+++++-- -----------------------------------------------------------------------------+-- Basic wrapper, ByteString version+++++++-- -----------------------------------------------------------------------------+-- Posn wrapper++-- Adds text positions to the basic model.+++++-- -----------------------------------------------------------------------------+-- Posn wrapper, ByteString version+++--alexScanTokens :: ByteString -> [token]+alexScanTokens str = go (alexStartPos,'\n',str)+ where go inp@(pos,_,str) =+ case alexScan inp 0 of+ AlexEOF -> []+ AlexError ((AlexPn _ line column),_,_) -> error $ "lexical error at line " ++ (show line) ++ ", column " ++ (show column)+ AlexSkip inp' len -> go inp'+ AlexToken inp' len act -> act pos (ByteString.take (fromIntegral len) str) : go inp'++++-- -----------------------------------------------------------------------------+-- GScan wrapper++-- For compatibility with previous versions of Alex, and because we can.+++alex_base :: AlexAddr+alex_base = AlexA# "\x01\x00\x00\x00\x77\x00\x00\x00\x4d\x01\x00\x00\x43\x02\x00\x00\x39\x03\x00\x00\x46\x00\x00\x00\xb9\x03\x00\x00\x39\x04\x00\x00\xb9\x04\x00\x00\x39\x05\x00\x00\xb9\x05\x00\x00\x39\x06\x00\x00\xb9\x06\x00\x00\x39\x07\x00\x00\xb9\x07\x00\x00\x39\x08\x00\x00\xb9\x08\x00\x00\x2a\x09\x00\x00\x00\x00\x00\x00\xaa\x09\x00\x00\x00\x00\x00\x00\x1b\x0a\x00\x00\x00\x00\x00\x00\x8c\x0a\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\xfd\x0a\x00\x00\x00\x00\x00\x00\x3e\x0b\x00\x00\x00\x00\x00\x00\x7f\x0b\x00\x00\x7f\x0c\x00\x00\x3f\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x0c\x00\x00\x00\x00\x00\x00\x21\x0d\x00\x00\x00\x00\x00\x00\x62\x0d\x00\x00\x14\x00\x00\x00\x62\x0e\x00\x00\x22\x0e\x00\x00\x00\x00\x00\x00\x22\x0f\x00\x00\xe2\x0e\x00\x00\x00\x00\x00\x00\xb8\x0f\x00\x00\x00\x00\x00\x00\x24\x0f\x00\x00\x00\x00\x00\x00\xf9\x0f\x00\x00\xf9\x10\x00\x00\xb9\x10\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\xaf\x11\x00\x00\xa5\x12\x00\x00\x93\x01\x00\x00\x1e\x02\x00\x00\x28\x02\x00\x00\x3f\x02\x00\x00\xa5\x13\x00\x00\x65\x13\x00\x00\x00\x00\x00\x00\x65\x14\x00\x00\xe5\x14\x00\x00\xa5\x14\x00\x00\x00\x00\x00\x00\x59\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x15\x00\x00\x71\x16\x00\x00\x58\x02\x00\x00\x16\x03\x00\x00\x31\x03\x00\x00\x3b\x03\x00\x00\x8a\x11\x00\x00\x62\x02\x00\x00\xa2\x11\x00\x00\x67\x17\x00\x00\x00\x00\x00\x00\x5d\x18\x00\x00\xa1\x12\x00\x00\x00\x00\x00\x00\x3b\x16\x00\x00\x00\x00\x00\x00\x3d\x02\x00\x00\x21\x03\x00\x00\x53\x19\x00\x00\x00\x00\x00\x00\x49\x1a\x00\x00"#++alex_table :: AlexAddr+alex_table = AlexA# "\x00\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x46\x00\x46\x00\x46\x00\x46\x00\x46\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x46\x00\x5c\x00\x5d\x00\x4a\x00\x5c\x00\x5c\x00\x5c\x00\x5b\x00\x58\x00\x58\x00\x5c\x00\x5c\x00\x58\x00\x5a\x00\x57\x00\x59\x00\x4d\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x58\x00\x58\x00\x5c\x00\x58\x00\x5c\x00\x5c\x00\x5c\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x58\x00\x5c\x00\x58\x00\x5c\x00\x55\x00\x5c\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x58\x00\x5c\x00\x58\x00\x5c\x00\x5c\x00\xff\xff\x38\x00\x56\x00\x00\x00\x00\x00\x00\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x02\x00\x00\x00\x00\x00\x00\x00\x55\x00\x48\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x35\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x36\x00\x08\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x28\x00\x0d\x00\x1a\x00\x1a\x00\x1a\x00\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x21\x00\x0e\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x19\x00\x13\x00\x12\x00\x12\x00\x12\x00\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x21\x00\x0e\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x19\x00\x13\x00\x12\x00\x12\x00\x12\x00\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x46\x00\x46\x00\x46\x00\x46\x00\x46\x00\x30\x00\x00\x00\x00\x00\x53\x00\x00\x00\x4a\x00\x00\x00\x00\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x3c\x00\x00\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x00\x00\x3b\x00\x00\x00\x04\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2b\x00\x0c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\x10\x00\x14\x00\x14\x00\x14\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x00\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x51\x00\x51\x00\x00\x00\x4d\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x52\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x51\x00\x51\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2b\x00\x0c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\x10\x00\x14\x00\x14\x00\x14\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x3f\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x35\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x06\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x07\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2a\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x08\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x20\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x0b\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x0c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x19\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x21\x00\x0e\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x19\x00\x13\x00\x12\x00\x12\x00\x12\x00\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x53\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x0b\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\x0f\x00\x16\x00\x16\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x3a\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x0b\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\x0f\x00\x16\x00\x16\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x00\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x47\x00\x47\x00\x47\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x00\x00\x42\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x44\x00\x06\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x34\x00\x09\x00\x25\x00\x25\x00\x25\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x21\x00\x0e\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x19\x00\x13\x00\x12\x00\x12\x00\x12\x00\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3f\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x40\x00\x07\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x32\x00\x0a\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2b\x00\x0c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\x10\x00\x14\x00\x14\x00\x14\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x0b\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\x0f\x00\x16\x00\x16\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2b\x00\x0c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\x10\x00\x14\x00\x14\x00\x14\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x0b\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\x0f\x00\x16\x00\x16\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#++alex_check :: AlexAddr+alex_check = AlexA# "\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x0a\x00\x6e\x00\x66\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x2f\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2a\x00\xff\xff\xff\xff\x27\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\x5c\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x45\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x27\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x2e\x00\x22\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x5c\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00"#++alex_deflt :: AlexAddr+alex_deflt = AlexA# "\xff\xff\x30\x00\x30\x00\x03\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x18\x00\xff\xff\x1c\x00\x1c\x00\x1e\x00\x1e\x00\x22\x00\x22\x00\x27\x00\x27\x00\x2c\x00\x2c\x00\x2f\x00\x2f\x00\x30\x00\x30\x00\x30\x00\x31\x00\x31\x00\x33\x00\x33\x00\x37\x00\x37\x00\xff\xff\x03\x00\x03\x00\x03\x00\x39\x00\x39\x00\x39\x00\x30\x00\x41\x00\x41\x00\x45\x00\x45\x00\x5c\x00\x5c\x00\x5c\x00\xff\xff\x39\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4a\x00\x4a\x00\x4a\x00\x47\x00\xff\xff\x47\x00\x47\x00\xff\xff\xff\xff\xff\xff\x30\x00\x4a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x03\x00\xff\xff\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x03\x00\xff\xff\x39\x00"#++alex_accept = listArray (0::Int,93) [AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccSkip,AlexAccSkip,AlexAccSkip,AlexAccSkip,AlexAccSkip,AlexAccPred (alex_action_2) (alexRightContext 67)(AlexAccPred (alex_action_5) (alexRightContext 67)(AlexAcc (alex_action_6))),AlexAccPred (alex_action_3) (alexRightContext 67)(AlexAccPred (alex_action_5) (alexRightContext 67)(AlexAcc (alex_action_7))),AlexAccPred (alex_action_3) (alexRightContext 67)(AlexAccPred (alex_action_5) (alexRightContext 67)(AlexAcc (alex_action_7))),AlexAccPred (alex_action_4) (alexRightContext 67)(AlexAcc (alex_action_8)),AlexAccPred (alex_action_5) (alexRightContext 67)(AlexAcc (alex_action_9)),AlexAccPred (alex_action_5) (alexRightContext 67)(AlexAcc (alex_action_9)),AlexAccPred (alex_action_5) (alexRightContext 67)(AlexAcc (alex_action_9)),AlexAcc (alex_action_10),AlexAcc (alex_action_10),AlexAcc (alex_action_10),AlexAcc (alex_action_11),AlexAcc (alex_action_12),AlexAcc (alex_action_13),AlexAcc (alex_action_13),AlexAcc (alex_action_14),AlexAcc (alex_action_14),AlexAcc (alex_action_14),AlexAcc (alex_action_14),AlexAcc (alex_action_14)]+{-# LINE 58 "Text/ProtocolBuffers/ProtoCompile/Lexer.x" #-}++line :: AlexPosn -> Int+line (AlexPn _byte lineNum _col) = lineNum+{-# INLINE line #-}++data Lexed = L_Integer !Int !Integer+ | L_Double !Int !Double+ | L_Name !Int !DBL.ByteString+ | L_String !Int !DBL.ByteString !DBL.ByteString+ | L !Int !Char+ | L_Error !Int !String+ deriving (Show,Eq)++getLinePos :: Lexed -> Int+getLinePos x = case x of+ L_Integer i _ -> i+ L_Double i _ -> i+ L_Name i _ -> i+ L_String i _ _ -> i+ L i _ -> i+ L_Error i _ -> i++-- 'errAt' is the only access to L_Error, so I can see where it is created with pos+errAt :: AlexPosn -> [Char] -> Lexed+errAt pos msg = L_Error (line pos) $ "Lexical error (in Text.ProtocolBuffers.Lexer): "++ msg ++ ", at "++see pos where+ see (AlexPn char lineNum col) = "character "++show char++" line "++show lineNum++" column "++show col++"."++dieAt :: [Char] -> AlexPosn -> t -> Lexed+dieAt msg pos _s = errAt pos msg++wtfAt :: AlexPosn -> DBL8.ByteString -> Lexed+wtfAt pos s = errAt pos $ "unknown character "++show c++" (decimal "++show (ord c)++")"+ where (c:_) = DBL8.unpack s++{-# INLINE mayRead #-}+mayRead :: ReadS a -> String -> Maybe a+mayRead f s = case f s of [(a,"")] -> Just a; _ -> Nothing++-- Given the regexps above, the "parse* failed" messages should be impossible.+parseDec,parseOct,parseHex,parseDouble,parseStr,parseNinf,parseName,parseChar :: AlexPosn -> DBL8.ByteString -> Lexed+parseDec pos s = maybe (errAt pos "Impossible? parseDec failed")+ (L_Integer (line pos)) $ mayRead (readSigned readDec) (DBL8.unpack s)+parseOct pos s = maybe (errAt pos "Impossible? parseOct failed")+ (L_Integer (line pos)) $ mayRead (readSigned readOct) (DBL8.unpack s)+parseHex pos s = maybe (errAt pos "Impossible? parseHex failed")+ (L_Integer (line pos)) $ mayRead (readSigned (readHex . drop 2)) (DBL8.unpack s)+parseDouble pos s = maybe (errAt pos "Impossible? parseDouble failed")+ (L_Double (line pos)) $ mayRead (readSigned readFloat) (DBL8.unpack s)+-- The sDecode of the string contents may fail+parseStr pos s = let middle = DBL8.init . DBL8.tail $ s+ in either (errAt pos) (L_String (line pos) middle . DBL.pack)+ . sDecode . DBL8.unpack $ middle++-- Here s is always "-inf" matched by @ninf+parseNinf pos s = L_Name (line pos) s++parseName pos s = L_Name (line pos) s+parseChar pos s = L (line pos) (DBL8.head s)++-- Generalization of concat . unfoldr to monadic-Either form:+op :: ( [Char] -> Either String (Maybe ([Word8],[Char]))) -> [Char] -> Either String [Word8]+op one = go id where+ go f cs = case one cs of+ Left msg -> Left msg+ Right Nothing -> Right (f [])+ Right (Just (ws,cs')) -> go (f . (ws++)) cs'++-- Put this mess in the lexer, so the rest of the code can assume+-- everything is saner. The input is checked to really be "Char8"+-- values in the range [0..255] and to be c-escaped (in order to+-- render binary information printable). This decodes the c-escaping+-- and returns the binary data as Word8.+-- +-- A decoding error causes (Left msg) to be returned.+sDecode :: [Char] -> Either String [Word8]+sDecode = op one where+ one :: [Char] -> Either String (Maybe ([Word8],[Char]))+ one ('\\':xs) = unescape xs+ one (x:xs) = do x' <- checkChar8 x+ return $ Just (x',xs) -- main case of unescaped value+ one [] = return Nothing+ unescape [] = Left "cannot understand a string that ends with a backslash"+ unescape ys | 1 <= len =+ case mayRead readOct oct of+ Just w -> do w' <- checkByte w+ return $ Just (w',rest)+ Nothing -> Left $ "failed to decode octal sequence "++ys+ where oct = takeWhile isOctDigit (take 3 ys)+ len = length oct+ rest = drop len ys+ unescape (x:ys) | 'x' == toLower x && 1 <= len =+ case mayRead readHex hex of+ Just w -> do w' <- checkByte w+ return $ Just (w',rest)+ Nothing -> Left $ "failed to decode hex sequence "++ys+ where hex = takeWhile isHexDigit (take 2 ys)+ len = length hex+ rest = drop len ys + unescape ('u':ys) | ok =+ case mayRead readHex hex of+ Just w -> do w' <- checkUnicode w+ return $ Just (w',rest)+ Nothing -> Left $ "failed to decode 4 char unicode sequence "++ys+ where ok = all isHexDigit hex && 4 == length hex+ (hex,rest) = splitAt 4 ys+ unescape ('U':ys) | ok =+ case mayRead readHex hex of+ Just w -> do w' <- checkUnicode w+ return $ Just (w',rest)+ Nothing -> Left $ "failed to decode 8 char unicode sequence "++ys+ where ok = all isHexDigit hex && 8 == length hex+ (hex,rest) = splitAt 8 ys+ unescape (x:xs) = do x' <- decode x+ return $ Just ([x'],xs)+ decode :: Char -> Either String Word8+ decode 'a' = return 7+ decode 'b' = return 8+ decode 't' = return 9+ decode 'n' = return 10+ decode 'v' = return 11+ decode 'f' = return 12+ decode 'r' = return 13+ decode '\"' = return 34+ decode '\'' = return 39+ decode '?' = return 63 -- C99 rule : "\?" is '?'+ decode '\\' = return 92+ decode x | toLower x == 'x' = Left "cannot understand your 'xX' hexadecimal escaped value"+ decode x | toLower x == 'u' = Left "cannot understand your 'uU' unicode UTF-8 hexadecimal escaped value"+ decode _ = Left "cannot understand your backslash-escaped value"+ checkChar8 :: Char -> Either String [Word8]+ checkChar8 c | (0 <= i) && (i <= 255) = Right [toEnum i]+ | otherwise = Left $ "found Char out of range 0..255, value="++show (ord c)+ where i = fromEnum c+ checkByte :: Integer -> Either String [Word8]+ checkByte i | (0 <= i) && (i <= 255) = Right [fromInteger i]+ | otherwise = Left $ "found Oct/Hex Int out of range 0..255, value="++show i+ checkUnicode :: Integer -> Either String [Word8]+ checkUnicode i | (0 <= i) && (i <= 127) = Right [fromInteger i]+ | i <= maxChar = Right $ encode [ toEnum . fromInteger $ i ]+ | otherwise = Left $ "found Unicode Char out of range 0..0x10FFFF, value="++show i+ where maxChar = toInteger (fromEnum (maxBound ::Char)) -- 0x10FFFF+++alex_action_2 = parseDec +alex_action_3 = parseOct +alex_action_4 = parseHex +alex_action_5 = parseDouble +alex_action_6 = dieAt "decimal followed by invalid character" +alex_action_7 = dieAt "octal followed by invalid character" +alex_action_8 = dieAt "hex followed by invalid character" +alex_action_9 = dieAt "floating followed by invalid character" +alex_action_10 = parseStr +alex_action_11 = parseName +alex_action_12 = parseNinf +alex_action_13 = parseChar +alex_action_14 = wtfAt +{-# LINE 1 "templates/GenericTemplate.hs" #-}+-- -----------------------------------------------------------------------------+-- ALEX TEMPLATE+--+-- This code is in the PUBLIC DOMAIN; you may copy it freely and use+-- it for any purpose whatsoever.++-- -----------------------------------------------------------------------------+-- INTERNALS and main scanner engine++++++++-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.+#if __GLASGOW_HASKELL__ > 706+#define GTE(n,m) (tagToEnum# (n >=# m))+#define EQ(n,m) (tagToEnum# (n ==# m))+#else+#define GTE(n,m) (n >=# m)+#define EQ(n,m) (n ==# m)+#endif++++data AlexAddr = AlexA# Addr#+-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.+#if __GLASGOW_HASKELL__ < 503+uncheckedShiftL# = shiftL#+#endif++{-# INLINE alexIndexInt16OffAddr #-}+alexIndexInt16OffAddr (AlexA# arr) off =+#ifdef WORDS_BIGENDIAN+ narrow16Int# i+ where+ i = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)+ high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))+ low = int2Word# (ord# (indexCharOffAddr# arr off'))+ off' = off *# 2#+#else+ indexInt16OffAddr# arr off+#endif++++++{-# INLINE alexIndexInt32OffAddr #-}+alexIndexInt32OffAddr (AlexA# arr) off = +#ifdef WORDS_BIGENDIAN+ narrow32Int# i+ where+ i = word2Int# ((b3 `uncheckedShiftL#` 24#) `or#`+ (b2 `uncheckedShiftL#` 16#) `or#`+ (b1 `uncheckedShiftL#` 8#) `or#` b0)+ b3 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 3#)))+ b2 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 2#)))+ b1 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))+ b0 = int2Word# (ord# (indexCharOffAddr# arr off'))+ off' = off *# 4#+#else+ indexInt32OffAddr# arr off+#endif+++++++#if __GLASGOW_HASKELL__ < 503+quickIndex arr i = arr ! i+#else+-- GHC >= 503, unsafeAt is available from Data.Array.Base.+quickIndex = unsafeAt+#endif+++++-- -----------------------------------------------------------------------------+-- Main lexing routines++data AlexReturn a+ = AlexEOF+ | AlexError !AlexInput+ | AlexSkip !AlexInput !Int+ | AlexToken !AlexInput !Int a++-- alexScan :: AlexInput -> StartCode -> AlexReturn a+alexScan input (I# (sc))+ = alexScanUser undefined input (I# (sc))++alexScanUser user input (I# (sc))+ = case alex_scan_tkn user input 0# input sc AlexNone of+ (AlexNone, input') ->+ case alexGetByte input of+ Nothing -> ++++ AlexEOF+ Just _ ->++++ AlexError input'++ (AlexLastSkip input'' len, _) ->++++ AlexSkip input'' len++ (AlexLastAcc k input''' len, _) ->++++ AlexToken input''' len k+++-- Push the input through the DFA, remembering the most recent accepting+-- state it encountered.++alex_scan_tkn user orig_input len input s last_acc =+ input `seq` -- strict in the input+ let + new_acc = (check_accs (alex_accept `quickIndex` (I# (s))))+ in+ new_acc `seq`+ case alexGetByte input of+ Nothing -> (new_acc, input)+ Just (c, new_input) -> ++++ case fromIntegral c of { (I# (ord_c)) ->+ let+ base = alexIndexInt32OffAddr alex_base s+ offset = (base +# ord_c)+ check = alexIndexInt16OffAddr alex_check offset+ + new_s = if GTE(offset,0#) && EQ(check,ord_c)+ then alexIndexInt16OffAddr alex_table offset+ else alexIndexInt16OffAddr alex_deflt s+ in+ case new_s of+ -1# -> (new_acc, input)+ -- on an error, we want to keep the input *before* the+ -- character that failed, not after.+ _ -> alex_scan_tkn user orig_input (if c < 0x80 || c >= 0xC0 then (len +# 1#) else len)+ -- note that the length is increased ONLY if this is the 1st byte in a char encoding)+ new_input new_s new_acc+ }+ where+ check_accs (AlexAccNone) = last_acc+ check_accs (AlexAcc a ) = AlexLastAcc a input (I# (len))+ check_accs (AlexAccSkip) = AlexLastSkip input (I# (len))++ check_accs (AlexAccPred a predx rest)+ | predx user orig_input (I# (len)) input+ = AlexLastAcc a input (I# (len))+ | otherwise+ = check_accs rest+ check_accs (AlexAccSkipPred predx rest)+ | predx user orig_input (I# (len)) input+ = AlexLastSkip input (I# (len))+ | otherwise+ = check_accs rest+++data AlexLastAcc a+ = AlexNone+ | AlexLastAcc a !AlexInput !Int+ | AlexLastSkip !AlexInput !Int++instance Functor AlexLastAcc where+ fmap f AlexNone = AlexNone+ fmap f (AlexLastAcc x y z) = AlexLastAcc (f x) y z+ fmap f (AlexLastSkip x y) = AlexLastSkip x y++data AlexAcc a user+ = AlexAccNone+ | AlexAcc a+ | AlexAccSkip++ | AlexAccPred a (AlexAccPred user) (AlexAcc a user)+ | AlexAccSkipPred (AlexAccPred user) (AlexAcc a user)++type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool++-- -----------------------------------------------------------------------------+-- Predicates on a rule++alexAndPred p1 p2 user in1 len in2+ = p1 user in1 len in2 && p2 user in1 len in2++--alexPrevCharIsPred :: Char -> AlexAccPred _ +alexPrevCharIs c _ input _ _ = c == alexInputPrevChar input++alexPrevCharMatches f _ input _ _ = f (alexInputPrevChar input)++--alexPrevCharIsOneOfPred :: Array Char Bool -> AlexAccPred _ +alexPrevCharIsOneOf arr _ input _ _ = arr ! alexInputPrevChar input++--alexRightContext :: Int -> AlexAccPred _+alexRightContext (I# (sc)) user _ _ input = + case alex_scan_tkn user input 0# input sc AlexNone of+ (AlexNone, _) -> False+ _ -> True+ -- TODO: there's no need to find the longest+ -- match when checking the right context, just+ -- the first match will do.+++-- used by wrappers+iUnbox (I# (i)) = i+
+ dist/build/hprotoc/hprotoc-tmp/Text/ProtocolBuffers/ProtoCompile/Lexer.hs view
@@ -0,0 +1,548 @@+{-# LANGUAGE CPP,MagicHash #-}+{-# LINE 1 "Text/ProtocolBuffers/ProtoCompile/Lexer.x" #-}++{-# OPTIONS_GHC -Wwarn #-}+module Text.ProtocolBuffers.ProtoCompile.Lexer (Lexed(..), alexScanTokens,getLinePos) where++import Control.Monad.Error()+import Codec.Binary.UTF8.String(encode)+import qualified Data.ByteString.Lazy as DBL+import Data.Char(ord,isHexDigit,isOctDigit,toLower)+import Data.Word(Word8)+import Numeric(readHex,readOct,readDec,readSigned,readFloat)+import qualified Data.ByteString.Lazy.Char8 as DBL8+++#if __GLASGOW_HASKELL__ >= 603+#include "ghcconfig.h"+#elif defined(__GLASGOW_HASKELL__)+#include "config.h"+#endif+#if __GLASGOW_HASKELL__ >= 503+import Data.Array+import Data.Char (ord)+import Data.Array.Base (unsafeAt)+#else+import Array+import Char (ord)+#endif+#if __GLASGOW_HASKELL__ >= 503+import GHC.Exts+#else+import GlaExts+#endif+{-# LINE 1 "templates/wrappers.hs" #-}+-- -----------------------------------------------------------------------------+-- Alex wrapper code.+--+-- This code is in the PUBLIC DOMAIN; you may copy it freely and use+-- it for any purpose whatsoever.++import Data.Word (Word8)+++import qualified Data.Char+import qualified Data.ByteString.Lazy as ByteString+import qualified Data.ByteString.Internal as ByteString (w2c)++++type Byte = Word8++-- -----------------------------------------------------------------------------+-- The input type+++++type AlexInput = (AlexPosn, -- current position,+ Char, -- previous char+ ByteString.ByteString) -- current input string++ignorePendingBytes :: AlexInput -> AlexInput+ignorePendingBytes i = i -- no pending bytes when lexing bytestrings++alexInputPrevChar :: AlexInput -> Char+alexInputPrevChar (p,c,s) = c++alexGetByte :: AlexInput -> Maybe (Byte,AlexInput)+alexGetByte (p,_,cs) | ByteString.null cs = Nothing+ | otherwise = let b = ByteString.head cs+ cs' = ByteString.tail cs+ c = ByteString.w2c b+ p' = alexMove p c+ in p' `seq` cs' `seq` Just (b, (p', c, cs'))+++++++-- -----------------------------------------------------------------------------+-- Token positions++-- `Posn' records the location of a token in the input text. It has three+-- fields: the address (number of chacaters preceding the token), line number+-- and column of a token within the file. `start_pos' gives the position of the+-- start of the file and `eof_pos' a standard encoding for the end of file.+-- `move_pos' calculates the new position after traversing a given character,+-- assuming the usual eight character tab stops.+++data AlexPosn = AlexPn !Int !Int !Int+ deriving (Eq,Show)++alexStartPos :: AlexPosn+alexStartPos = AlexPn 0 1 1++alexMove :: AlexPosn -> Char -> AlexPosn+alexMove (AlexPn a l c) '\t' = AlexPn (a+1) l (((c+7) `div` 8)*8+1)+alexMove (AlexPn a l c) '\n' = AlexPn (a+1) (l+1) 1+alexMove (AlexPn a l c) _ = AlexPn (a+1) l (c+1)+++-- -----------------------------------------------------------------------------+-- Default monad+++++-- -----------------------------------------------------------------------------+-- Monad (with ByteString input)+++++-- -----------------------------------------------------------------------------+-- Basic wrapper+++++-- -----------------------------------------------------------------------------+-- Basic wrapper, ByteString version+++++++-- -----------------------------------------------------------------------------+-- Posn wrapper++-- Adds text positions to the basic model.+++++-- -----------------------------------------------------------------------------+-- Posn wrapper, ByteString version+++--alexScanTokens :: ByteString -> [token]+alexScanTokens str = go (alexStartPos,'\n',str)+ where go inp@(pos,_,str) =+ case alexScan inp 0 of+ AlexEOF -> []+ AlexError ((AlexPn _ line column),_,_) -> error $ "lexical error at line " ++ (show line) ++ ", column " ++ (show column)+ AlexSkip inp' len -> go inp'+ AlexToken inp' len act -> act pos (ByteString.take (fromIntegral len) str) : go inp'++++-- -----------------------------------------------------------------------------+-- GScan wrapper++-- For compatibility with previous versions of Alex, and because we can.+++alex_base :: AlexAddr+alex_base = AlexA# "\x01\x00\x00\x00\x77\x00\x00\x00\x4d\x01\x00\x00\x43\x02\x00\x00\x39\x03\x00\x00\x46\x00\x00\x00\xb9\x03\x00\x00\x39\x04\x00\x00\xb9\x04\x00\x00\x39\x05\x00\x00\xb9\x05\x00\x00\x39\x06\x00\x00\xb9\x06\x00\x00\x39\x07\x00\x00\xb9\x07\x00\x00\x39\x08\x00\x00\xb9\x08\x00\x00\x2a\x09\x00\x00\x00\x00\x00\x00\xaa\x09\x00\x00\x00\x00\x00\x00\x1b\x0a\x00\x00\x00\x00\x00\x00\x8c\x0a\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\xfd\x0a\x00\x00\x00\x00\x00\x00\x3e\x0b\x00\x00\x00\x00\x00\x00\x7f\x0b\x00\x00\x7f\x0c\x00\x00\x3f\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x0c\x00\x00\x00\x00\x00\x00\x21\x0d\x00\x00\x00\x00\x00\x00\x62\x0d\x00\x00\x14\x00\x00\x00\x62\x0e\x00\x00\x22\x0e\x00\x00\x00\x00\x00\x00\x22\x0f\x00\x00\xe2\x0e\x00\x00\x00\x00\x00\x00\xb8\x0f\x00\x00\x00\x00\x00\x00\x24\x0f\x00\x00\x00\x00\x00\x00\xf9\x0f\x00\x00\xf9\x10\x00\x00\xb9\x10\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\xaf\x11\x00\x00\xa5\x12\x00\x00\x93\x01\x00\x00\x1e\x02\x00\x00\x28\x02\x00\x00\x3f\x02\x00\x00\xa5\x13\x00\x00\x65\x13\x00\x00\x00\x00\x00\x00\x65\x14\x00\x00\xe5\x14\x00\x00\xa5\x14\x00\x00\x00\x00\x00\x00\x59\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x15\x00\x00\x71\x16\x00\x00\x58\x02\x00\x00\x16\x03\x00\x00\x31\x03\x00\x00\x3b\x03\x00\x00\x8a\x11\x00\x00\x62\x02\x00\x00\xa2\x11\x00\x00\x67\x17\x00\x00\x00\x00\x00\x00\x5d\x18\x00\x00\xa1\x12\x00\x00\x00\x00\x00\x00\x3b\x16\x00\x00\x00\x00\x00\x00\x3d\x02\x00\x00\x21\x03\x00\x00\x53\x19\x00\x00\x00\x00\x00\x00\x49\x1a\x00\x00"#++alex_table :: AlexAddr+alex_table = AlexA# "\x00\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x46\x00\x46\x00\x46\x00\x46\x00\x46\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x5c\x00\x46\x00\x5c\x00\x5d\x00\x4a\x00\x5c\x00\x5c\x00\x5c\x00\x5b\x00\x58\x00\x58\x00\x5c\x00\x5c\x00\x58\x00\x5a\x00\x57\x00\x59\x00\x4d\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x58\x00\x58\x00\x5c\x00\x58\x00\x5c\x00\x5c\x00\x5c\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x58\x00\x5c\x00\x58\x00\x5c\x00\x55\x00\x5c\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x58\x00\x5c\x00\x58\x00\x5c\x00\x5c\x00\xff\xff\x38\x00\x56\x00\x00\x00\x00\x00\x00\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x02\x00\x00\x00\x00\x00\x00\x00\x55\x00\x48\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x35\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x36\x00\x08\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x28\x00\x0d\x00\x1a\x00\x1a\x00\x1a\x00\x1b\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x21\x00\x0e\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x19\x00\x13\x00\x12\x00\x12\x00\x12\x00\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x21\x00\x0e\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x19\x00\x13\x00\x12\x00\x12\x00\x12\x00\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x46\x00\x46\x00\x46\x00\x46\x00\x46\x00\x30\x00\x00\x00\x00\x00\x53\x00\x00\x00\x4a\x00\x00\x00\x00\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x3c\x00\x00\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x50\x00\x00\x00\x3b\x00\x00\x00\x04\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2b\x00\x0c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\x10\x00\x14\x00\x14\x00\x14\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3c\x00\x00\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x51\x00\x51\x00\x00\x00\x4d\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x4b\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x52\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x4c\x00\x51\x00\x51\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2b\x00\x0c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\x10\x00\x14\x00\x14\x00\x14\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x3f\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x35\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x37\x00\x06\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x07\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2a\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x08\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x20\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x0b\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x0c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x19\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x21\x00\x0e\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x19\x00\x13\x00\x12\x00\x12\x00\x12\x00\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x4f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x3c\x00\x53\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x0b\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\x0f\x00\x16\x00\x16\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x3a\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x0b\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\x0f\x00\x16\x00\x16\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x00\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x47\x00\x47\x00\x47\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x47\x00\x47\x00\x47\x00\x47\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x00\x00\x42\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x44\x00\x06\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x34\x00\x09\x00\x25\x00\x25\x00\x25\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x22\x00\x21\x00\x0e\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x18\x00\x19\x00\x13\x00\x12\x00\x12\x00\x12\x00\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3f\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x40\x00\x07\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x31\x00\x32\x00\x0a\x00\x23\x00\x23\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2b\x00\x0c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\x10\x00\x14\x00\x14\x00\x14\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x0b\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\x0f\x00\x16\x00\x16\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2c\x00\x2b\x00\x0c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\x10\x00\x14\x00\x14\x00\x14\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x0b\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\x0f\x00\x16\x00\x16\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#++alex_check :: AlexAddr+alex_check = AlexA# "\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x0a\x00\x6e\x00\x66\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x5f\x00\x2f\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2a\x00\xff\xff\xff\xff\x27\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\x5c\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x45\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x27\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x2e\x00\x22\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x5c\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\xff\xff\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xff\xff\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00"#++alex_deflt :: AlexAddr+alex_deflt = AlexA# "\xff\xff\x30\x00\x30\x00\x03\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x18\x00\xff\xff\x1c\x00\x1c\x00\x1e\x00\x1e\x00\x22\x00\x22\x00\x27\x00\x27\x00\x2c\x00\x2c\x00\x2f\x00\x2f\x00\x30\x00\x30\x00\x30\x00\x31\x00\x31\x00\x33\x00\x33\x00\x37\x00\x37\x00\xff\xff\x03\x00\x03\x00\x03\x00\x39\x00\x39\x00\x39\x00\x30\x00\x41\x00\x41\x00\x45\x00\x45\x00\x5c\x00\x5c\x00\x5c\x00\xff\xff\x39\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4a\x00\x4a\x00\x4a\x00\x47\x00\xff\xff\x47\x00\x47\x00\xff\xff\xff\xff\xff\xff\x30\x00\x4a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x03\x00\xff\xff\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x03\x00\xff\xff\x39\x00"#++alex_accept = listArray (0::Int,93) [AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccSkip,AlexAccSkip,AlexAccSkip,AlexAccSkip,AlexAccSkip,AlexAccPred (alex_action_2) (alexRightContext 67)(AlexAccPred (alex_action_5) (alexRightContext 67)(AlexAcc (alex_action_6))),AlexAccPred (alex_action_3) (alexRightContext 67)(AlexAccPred (alex_action_5) (alexRightContext 67)(AlexAcc (alex_action_7))),AlexAccPred (alex_action_3) (alexRightContext 67)(AlexAccPred (alex_action_5) (alexRightContext 67)(AlexAcc (alex_action_7))),AlexAccPred (alex_action_4) (alexRightContext 67)(AlexAcc (alex_action_8)),AlexAccPred (alex_action_5) (alexRightContext 67)(AlexAcc (alex_action_9)),AlexAccPred (alex_action_5) (alexRightContext 67)(AlexAcc (alex_action_9)),AlexAccPred (alex_action_5) (alexRightContext 67)(AlexAcc (alex_action_9)),AlexAcc (alex_action_10),AlexAcc (alex_action_10),AlexAcc (alex_action_10),AlexAcc (alex_action_11),AlexAcc (alex_action_12),AlexAcc (alex_action_13),AlexAcc (alex_action_13),AlexAcc (alex_action_14),AlexAcc (alex_action_14),AlexAcc (alex_action_14),AlexAcc (alex_action_14),AlexAcc (alex_action_14)]+{-# LINE 58 "Text/ProtocolBuffers/ProtoCompile/Lexer.x" #-}++line :: AlexPosn -> Int+line (AlexPn _byte lineNum _col) = lineNum+{-# INLINE line #-}++data Lexed = L_Integer !Int !Integer+ | L_Double !Int !Double+ | L_Name !Int !DBL.ByteString+ | L_String !Int !DBL.ByteString !DBL.ByteString+ | L !Int !Char+ | L_Error !Int !String+ deriving (Show,Eq)++getLinePos :: Lexed -> Int+getLinePos x = case x of+ L_Integer i _ -> i+ L_Double i _ -> i+ L_Name i _ -> i+ L_String i _ _ -> i+ L i _ -> i+ L_Error i _ -> i++-- 'errAt' is the only access to L_Error, so I can see where it is created with pos+errAt :: AlexPosn -> [Char] -> Lexed+errAt pos msg = L_Error (line pos) $ "Lexical error (in Text.ProtocolBuffers.Lexer): "++ msg ++ ", at "++see pos where+ see (AlexPn char lineNum col) = "character "++show char++" line "++show lineNum++" column "++show col++"."++dieAt :: [Char] -> AlexPosn -> t -> Lexed+dieAt msg pos _s = errAt pos msg++wtfAt :: AlexPosn -> DBL8.ByteString -> Lexed+wtfAt pos s = errAt pos $ "unknown character "++show c++" (decimal "++show (ord c)++")"+ where (c:_) = DBL8.unpack s++{-# INLINE mayRead #-}+mayRead :: ReadS a -> String -> Maybe a+mayRead f s = case f s of [(a,"")] -> Just a; _ -> Nothing++-- Given the regexps above, the "parse* failed" messages should be impossible.+parseDec,parseOct,parseHex,parseDouble,parseStr,parseNinf,parseName,parseChar :: AlexPosn -> DBL8.ByteString -> Lexed+parseDec pos s = maybe (errAt pos "Impossible? parseDec failed")+ (L_Integer (line pos)) $ mayRead (readSigned readDec) (DBL8.unpack s)+parseOct pos s = maybe (errAt pos "Impossible? parseOct failed")+ (L_Integer (line pos)) $ mayRead (readSigned readOct) (DBL8.unpack s)+parseHex pos s = maybe (errAt pos "Impossible? parseHex failed")+ (L_Integer (line pos)) $ mayRead (readSigned (readHex . drop 2)) (DBL8.unpack s)+parseDouble pos s = maybe (errAt pos "Impossible? parseDouble failed")+ (L_Double (line pos)) $ mayRead (readSigned readFloat) (DBL8.unpack s)+-- The sDecode of the string contents may fail+parseStr pos s = let middle = DBL8.init . DBL8.tail $ s+ in either (errAt pos) (L_String (line pos) middle . DBL.pack)+ . sDecode . DBL8.unpack $ middle++-- Here s is always "-inf" matched by @ninf+parseNinf pos s = L_Name (line pos) s++parseName pos s = L_Name (line pos) s+parseChar pos s = L (line pos) (DBL8.head s)++-- Generalization of concat . unfoldr to monadic-Either form:+op :: ( [Char] -> Either String (Maybe ([Word8],[Char]))) -> [Char] -> Either String [Word8]+op one = go id where+ go f cs = case one cs of+ Left msg -> Left msg+ Right Nothing -> Right (f [])+ Right (Just (ws,cs')) -> go (f . (ws++)) cs'++-- Put this mess in the lexer, so the rest of the code can assume+-- everything is saner. The input is checked to really be "Char8"+-- values in the range [0..255] and to be c-escaped (in order to+-- render binary information printable). This decodes the c-escaping+-- and returns the binary data as Word8.+-- +-- A decoding error causes (Left msg) to be returned.+sDecode :: [Char] -> Either String [Word8]+sDecode = op one where+ one :: [Char] -> Either String (Maybe ([Word8],[Char]))+ one ('\\':xs) = unescape xs+ one (x:xs) = do x' <- checkChar8 x+ return $ Just (x',xs) -- main case of unescaped value+ one [] = return Nothing+ unescape [] = Left "cannot understand a string that ends with a backslash"+ unescape ys | 1 <= len =+ case mayRead readOct oct of+ Just w -> do w' <- checkByte w+ return $ Just (w',rest)+ Nothing -> Left $ "failed to decode octal sequence "++ys+ where oct = takeWhile isOctDigit (take 3 ys)+ len = length oct+ rest = drop len ys+ unescape (x:ys) | 'x' == toLower x && 1 <= len =+ case mayRead readHex hex of+ Just w -> do w' <- checkByte w+ return $ Just (w',rest)+ Nothing -> Left $ "failed to decode hex sequence "++ys+ where hex = takeWhile isHexDigit (take 2 ys)+ len = length hex+ rest = drop len ys + unescape ('u':ys) | ok =+ case mayRead readHex hex of+ Just w -> do w' <- checkUnicode w+ return $ Just (w',rest)+ Nothing -> Left $ "failed to decode 4 char unicode sequence "++ys+ where ok = all isHexDigit hex && 4 == length hex+ (hex,rest) = splitAt 4 ys+ unescape ('U':ys) | ok =+ case mayRead readHex hex of+ Just w -> do w' <- checkUnicode w+ return $ Just (w',rest)+ Nothing -> Left $ "failed to decode 8 char unicode sequence "++ys+ where ok = all isHexDigit hex && 8 == length hex+ (hex,rest) = splitAt 8 ys+ unescape (x:xs) = do x' <- decode x+ return $ Just ([x'],xs)+ decode :: Char -> Either String Word8+ decode 'a' = return 7+ decode 'b' = return 8+ decode 't' = return 9+ decode 'n' = return 10+ decode 'v' = return 11+ decode 'f' = return 12+ decode 'r' = return 13+ decode '\"' = return 34+ decode '\'' = return 39+ decode '?' = return 63 -- C99 rule : "\?" is '?'+ decode '\\' = return 92+ decode x | toLower x == 'x' = Left "cannot understand your 'xX' hexadecimal escaped value"+ decode x | toLower x == 'u' = Left "cannot understand your 'uU' unicode UTF-8 hexadecimal escaped value"+ decode _ = Left "cannot understand your backslash-escaped value"+ checkChar8 :: Char -> Either String [Word8]+ checkChar8 c | (0 <= i) && (i <= 255) = Right [toEnum i]+ | otherwise = Left $ "found Char out of range 0..255, value="++show (ord c)+ where i = fromEnum c+ checkByte :: Integer -> Either String [Word8]+ checkByte i | (0 <= i) && (i <= 255) = Right [fromInteger i]+ | otherwise = Left $ "found Oct/Hex Int out of range 0..255, value="++show i+ checkUnicode :: Integer -> Either String [Word8]+ checkUnicode i | (0 <= i) && (i <= 127) = Right [fromInteger i]+ | i <= maxChar = Right $ encode [ toEnum . fromInteger $ i ]+ | otherwise = Left $ "found Unicode Char out of range 0..0x10FFFF, value="++show i+ where maxChar = toInteger (fromEnum (maxBound ::Char)) -- 0x10FFFF+++alex_action_2 = parseDec +alex_action_3 = parseOct +alex_action_4 = parseHex +alex_action_5 = parseDouble +alex_action_6 = dieAt "decimal followed by invalid character" +alex_action_7 = dieAt "octal followed by invalid character" +alex_action_8 = dieAt "hex followed by invalid character" +alex_action_9 = dieAt "floating followed by invalid character" +alex_action_10 = parseStr +alex_action_11 = parseName +alex_action_12 = parseNinf +alex_action_13 = parseChar +alex_action_14 = wtfAt +{-# LINE 1 "templates/GenericTemplate.hs" #-}+-- -----------------------------------------------------------------------------+-- ALEX TEMPLATE+--+-- This code is in the PUBLIC DOMAIN; you may copy it freely and use+-- it for any purpose whatsoever.++-- -----------------------------------------------------------------------------+-- INTERNALS and main scanner engine++++++++-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.+#if __GLASGOW_HASKELL__ > 706+#define GTE(n,m) (tagToEnum# (n >=# m))+#define EQ(n,m) (tagToEnum# (n ==# m))+#else+#define GTE(n,m) (n >=# m)+#define EQ(n,m) (n ==# m)+#endif++++data AlexAddr = AlexA# Addr#+-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.+#if __GLASGOW_HASKELL__ < 503+uncheckedShiftL# = shiftL#+#endif++{-# INLINE alexIndexInt16OffAddr #-}+alexIndexInt16OffAddr (AlexA# arr) off =+#ifdef WORDS_BIGENDIAN+ narrow16Int# i+ where+ i = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)+ high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))+ low = int2Word# (ord# (indexCharOffAddr# arr off'))+ off' = off *# 2#+#else+ indexInt16OffAddr# arr off+#endif++++++{-# INLINE alexIndexInt32OffAddr #-}+alexIndexInt32OffAddr (AlexA# arr) off = +#ifdef WORDS_BIGENDIAN+ narrow32Int# i+ where+ i = word2Int# ((b3 `uncheckedShiftL#` 24#) `or#`+ (b2 `uncheckedShiftL#` 16#) `or#`+ (b1 `uncheckedShiftL#` 8#) `or#` b0)+ b3 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 3#)))+ b2 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 2#)))+ b1 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))+ b0 = int2Word# (ord# (indexCharOffAddr# arr off'))+ off' = off *# 4#+#else+ indexInt32OffAddr# arr off+#endif+++++++#if __GLASGOW_HASKELL__ < 503+quickIndex arr i = arr ! i+#else+-- GHC >= 503, unsafeAt is available from Data.Array.Base.+quickIndex = unsafeAt+#endif+++++-- -----------------------------------------------------------------------------+-- Main lexing routines++data AlexReturn a+ = AlexEOF+ | AlexError !AlexInput+ | AlexSkip !AlexInput !Int+ | AlexToken !AlexInput !Int a++-- alexScan :: AlexInput -> StartCode -> AlexReturn a+alexScan input (I# (sc))+ = alexScanUser undefined input (I# (sc))++alexScanUser user input (I# (sc))+ = case alex_scan_tkn user input 0# input sc AlexNone of+ (AlexNone, input') ->+ case alexGetByte input of+ Nothing -> ++++ AlexEOF+ Just _ ->++++ AlexError input'++ (AlexLastSkip input'' len, _) ->++++ AlexSkip input'' len++ (AlexLastAcc k input''' len, _) ->++++ AlexToken input''' len k+++-- Push the input through the DFA, remembering the most recent accepting+-- state it encountered.++alex_scan_tkn user orig_input len input s last_acc =+ input `seq` -- strict in the input+ let + new_acc = (check_accs (alex_accept `quickIndex` (I# (s))))+ in+ new_acc `seq`+ case alexGetByte input of+ Nothing -> (new_acc, input)+ Just (c, new_input) -> ++++ case fromIntegral c of { (I# (ord_c)) ->+ let+ base = alexIndexInt32OffAddr alex_base s+ offset = (base +# ord_c)+ check = alexIndexInt16OffAddr alex_check offset+ + new_s = if GTE(offset,0#) && EQ(check,ord_c)+ then alexIndexInt16OffAddr alex_table offset+ else alexIndexInt16OffAddr alex_deflt s+ in+ case new_s of+ -1# -> (new_acc, input)+ -- on an error, we want to keep the input *before* the+ -- character that failed, not after.+ _ -> alex_scan_tkn user orig_input (if c < 0x80 || c >= 0xC0 then (len +# 1#) else len)+ -- note that the length is increased ONLY if this is the 1st byte in a char encoding)+ new_input new_s new_acc+ }+ where+ check_accs (AlexAccNone) = last_acc+ check_accs (AlexAcc a ) = AlexLastAcc a input (I# (len))+ check_accs (AlexAccSkip) = AlexLastSkip input (I# (len))++ check_accs (AlexAccPred a predx rest)+ | predx user orig_input (I# (len)) input+ = AlexLastAcc a input (I# (len))+ | otherwise+ = check_accs rest+ check_accs (AlexAccSkipPred predx rest)+ | predx user orig_input (I# (len)) input+ = AlexLastSkip input (I# (len))+ | otherwise+ = check_accs rest+++data AlexLastAcc a+ = AlexNone+ | AlexLastAcc a !AlexInput !Int+ | AlexLastSkip !AlexInput !Int++instance Functor AlexLastAcc where+ fmap f AlexNone = AlexNone+ fmap f (AlexLastAcc x y z) = AlexLastAcc (f x) y z+ fmap f (AlexLastSkip x y) = AlexLastSkip x y++data AlexAcc a user+ = AlexAccNone+ | AlexAcc a+ | AlexAccSkip++ | AlexAccPred a (AlexAccPred user) (AlexAcc a user)+ | AlexAccSkipPred (AlexAccPred user) (AlexAcc a user)++type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool++-- -----------------------------------------------------------------------------+-- Predicates on a rule++alexAndPred p1 p2 user in1 len in2+ = p1 user in1 len in2 && p2 user in1 len in2++--alexPrevCharIsPred :: Char -> AlexAccPred _ +alexPrevCharIs c _ input _ _ = c == alexInputPrevChar input++alexPrevCharMatches f _ input _ _ = f (alexInputPrevChar input)++--alexPrevCharIsOneOfPred :: Array Char Bool -> AlexAccPred _ +alexPrevCharIsOneOf arr _ input _ _ = arr ! alexInputPrevChar input++--alexRightContext :: Int -> AlexAccPred _+alexRightContext (I# (sc)) user _ _ input = + case alex_scan_tkn user input 0# input sc AlexNone of+ (AlexNone, _) -> False+ _ -> True+ -- TODO: there's no need to find the longest+ -- match when checking the right context, just+ -- the first match will do.+++-- used by wrappers+iUnbox (I# (i)) = i+
+ google-proto-files/google/protobuf/descriptor.proto view
@@ -0,0 +1,533 @@+// Protocol Buffers - Google's data interchange format+// Copyright 2008 Google Inc. All rights reserved.+// http://code.google.com/p/protobuf/+//+// Redistribution and use in source and binary forms, with or without+// modification, are permitted provided that the following conditions are+// met:+//+// * Redistributions of source code must retain the above copyright+// notice, this list of conditions and the following disclaimer.+// * Redistributions in binary form must reproduce the above+// copyright notice, this list of conditions and the following disclaimer+// in the documentation and/or other materials provided with the+// distribution.+// * Neither the name of Google Inc. nor the names of its+// contributors may be used to endorse or promote products derived from+// this software without specific prior written permission.+//+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.++// Author: kenton@google.com (Kenton Varda)+// Based on original Protocol Buffers design by+// Sanjay Ghemawat, Jeff Dean, and others.+//+// The messages in this file describe the definitions found in .proto files.+// A valid .proto file can be translated directly to a FileDescriptorProto+// without any other information (e.g. without reading its imports).++++package google.protobuf;+option java_package = "com.google.protobuf";+option java_outer_classname = "DescriptorProtos";++// descriptor.proto must be optimized for speed because reflection-based+// algorithms don't work during bootstrapping.+option optimize_for = SPEED;++// The protocol compiler can output a FileDescriptorSet containing the .proto+// files it parses.+message FileDescriptorSet {+ repeated FileDescriptorProto file = 1;+}++// Describes a complete .proto file.+message FileDescriptorProto {+ optional string name = 1; // file name, relative to root of source tree+ optional string package = 2; // e.g. "foo", "foo.bar", etc.++ // Names of files imported by this file.+ repeated string dependency = 3;++ // All top-level definitions in this file.+ repeated DescriptorProto message_type = 4;+ repeated EnumDescriptorProto enum_type = 5;+ repeated ServiceDescriptorProto service = 6;+ repeated FieldDescriptorProto extension = 7;++ optional FileOptions options = 8;++ // This field contains optional information about the original source code.+ // You may safely remove this entire field whithout harming runtime+ // functionality of the descriptors -- the information is needed only by+ // development tools.+ optional SourceCodeInfo source_code_info = 9;+}++// Describes a message type.+message DescriptorProto {+ optional string name = 1;++ repeated FieldDescriptorProto field = 2;+ repeated FieldDescriptorProto extension = 6;++ repeated DescriptorProto nested_type = 3;+ repeated EnumDescriptorProto enum_type = 4;++ message ExtensionRange {+ optional int32 start = 1;+ optional int32 end = 2;+ }+ repeated ExtensionRange extension_range = 5;++ optional MessageOptions options = 7;+}++// Describes a field within a message.+message FieldDescriptorProto {+ enum Type {+ // 0 is reserved for errors.+ // Order is weird for historical reasons.+ TYPE_DOUBLE = 1;+ TYPE_FLOAT = 2;+ TYPE_INT64 = 3; // Not ZigZag encoded. Negative numbers+ // take 10 bytes. Use TYPE_SINT64 if negative+ // values are likely.+ TYPE_UINT64 = 4;+ TYPE_INT32 = 5; // Not ZigZag encoded. Negative numbers+ // take 10 bytes. Use TYPE_SINT32 if negative+ // values are likely.+ TYPE_FIXED64 = 6;+ TYPE_FIXED32 = 7;+ TYPE_BOOL = 8;+ TYPE_STRING = 9;+ TYPE_GROUP = 10; // Tag-delimited aggregate.+ TYPE_MESSAGE = 11; // Length-delimited aggregate.++ // New in version 2.+ TYPE_BYTES = 12;+ TYPE_UINT32 = 13;+ TYPE_ENUM = 14;+ TYPE_SFIXED32 = 15;+ TYPE_SFIXED64 = 16;+ TYPE_SINT32 = 17; // Uses ZigZag encoding.+ TYPE_SINT64 = 18; // Uses ZigZag encoding.+ };++ enum Label {+ // 0 is reserved for errors+ LABEL_OPTIONAL = 1;+ LABEL_REQUIRED = 2;+ LABEL_REPEATED = 3;+ // TODO(sanjay): Should we add LABEL_MAP?+ };++ optional string name = 1;+ optional int32 number = 3;+ optional Label label = 4;++ // If type_name is set, this need not be set. If both this and type_name+ // are set, this must be either TYPE_ENUM or TYPE_MESSAGE.+ optional Type type = 5;++ // For message and enum types, this is the name of the type. If the name+ // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping+ // rules are used to find the type (i.e. first the nested types within this+ // message are searched, then within the parent, on up to the root+ // namespace).+ optional string type_name = 6;++ // For extensions, this is the name of the type being extended. It is+ // resolved in the same manner as type_name.+ optional string extendee = 2;++ // For numeric types, contains the original text representation of the value.+ // For booleans, "true" or "false".+ // For strings, contains the default text contents (not escaped in any way).+ // For bytes, contains the C escaped value. All bytes >= 128 are escaped.+ // TODO(kenton): Base-64 encode?+ optional string default_value = 7;++ optional FieldOptions options = 8;+}++// Describes an enum type.+message EnumDescriptorProto {+ optional string name = 1;++ repeated EnumValueDescriptorProto value = 2;++ optional EnumOptions options = 3;+}++// Describes a value within an enum.+message EnumValueDescriptorProto {+ optional string name = 1;+ optional int32 number = 2;++ optional EnumValueOptions options = 3;+}++// Describes a service.+message ServiceDescriptorProto {+ optional string name = 1;+ repeated MethodDescriptorProto method = 2;++ optional ServiceOptions options = 3;+}++// Describes a method of a service.+message MethodDescriptorProto {+ optional string name = 1;++ // Input and output type names. These are resolved in the same way as+ // FieldDescriptorProto.type_name, but must refer to a message type.+ optional string input_type = 2;+ optional string output_type = 3;++ optional MethodOptions options = 4;+}++// ===================================================================+// Options++// Each of the definitions above may have "options" attached. These are+// just annotations which may cause code to be generated slightly differently+// or may contain hints for code that manipulates protocol messages.+//+// Clients may define custom options as extensions of the *Options messages.+// These extensions may not yet be known at parsing time, so the parser cannot+// store the values in them. Instead it stores them in a field in the *Options+// message called uninterpreted_option. This field must have the same name+// across all *Options messages. We then use this field to populate the+// extensions when we build a descriptor, at which point all protos have been+// parsed and so all extensions are known.+//+// Extension numbers for custom options may be chosen as follows:+// * For options which will only be used within a single application or+// organization, or for experimental options, use field numbers 50000+// through 99999. It is up to you to ensure that you do not use the+// same number for multiple options.+// * For options which will be published and used publicly by multiple+// independent entities, e-mail kenton@google.com to reserve extension+// numbers. Simply tell me how many you need and I'll send you back a+// set of numbers to use -- there's no need to explain how you intend to+// use them. If this turns out to be popular, a web service will be set up+// to automatically assign option numbers.+++message FileOptions {++ // Sets the Java package where classes generated from this .proto will be+ // placed. By default, the proto package is used, but this is often+ // inappropriate because proto packages do not normally start with backwards+ // domain names.+ optional string java_package = 1;+++ // If set, all the classes from the .proto file are wrapped in a single+ // outer class with the given name. This applies to both Proto1+ // (equivalent to the old "--one_java_file" option) and Proto2 (where+ // a .proto always translates to a single class, but you may want to+ // explicitly choose the class name).+ optional string java_outer_classname = 8;++ // If set true, then the Java code generator will generate a separate .java+ // file for each top-level message, enum, and service defined in the .proto+ // file. Thus, these types will *not* be nested inside the outer class+ // named by java_outer_classname. However, the outer class will still be+ // generated to contain the file's getDescriptor() method as well as any+ // top-level extensions defined in the file.+ optional bool java_multiple_files = 10 [default=false];++ // If set true, then the Java code generator will generate equals() and+ // hashCode() methods for all messages defined in the .proto file. This is+ // purely a speed optimization, as the AbstractMessage base class includes+ // reflection-based implementations of these methods.+ optional bool java_generate_equals_and_hash = 20 [default=false];++ // Generated classes can be optimized for speed or code size.+ enum OptimizeMode {+ SPEED = 1; // Generate complete code for parsing, serialization,+ // etc.+ CODE_SIZE = 2; // Use ReflectionOps to implement these methods.+ LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.+ }+ optional OptimizeMode optimize_for = 9 [default=SPEED];+++++ // Should generic services be generated in each language? "Generic" services+ // are not specific to any particular RPC system. They are generated by the+ // main code generators in each language (without additional plugins).+ // Generic services were the only kind of service generation supported by+ // early versions of proto2.+ //+ // Generic services are now considered deprecated in favor of using plugins+ // that generate code specific to your particular RPC system. Therefore,+ // these default to false. Old code which depends on generic services should+ // explicitly set them to true.+ optional bool cc_generic_services = 16 [default=false];+ optional bool java_generic_services = 17 [default=false];+ optional bool py_generic_services = 18 [default=false];++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++message MessageOptions {+ // Set true to use the old proto1 MessageSet wire format for extensions.+ // This is provided for backwards-compatibility with the MessageSet wire+ // format. You should not use this for any other reason: It's less+ // efficient, has fewer features, and is more complicated.+ //+ // The message must be defined exactly as follows:+ // message Foo {+ // option message_set_wire_format = true;+ // extensions 4 to max;+ // }+ // Note that the message cannot have any defined fields; MessageSets only+ // have extensions.+ //+ // All extensions of your type must be singular messages; e.g. they cannot+ // be int32s, enums, or repeated messages.+ //+ // Because this is an option, the above two restrictions are not enforced by+ // the protocol compiler.+ optional bool message_set_wire_format = 1 [default=false];++ // Disables the generation of the standard "descriptor()" accessor, which can+ // conflict with a field of the same name. This is meant to make migration+ // from proto1 easier; new code should avoid fields named "descriptor".+ optional bool no_standard_descriptor_accessor = 2 [default=false];++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++message FieldOptions {+ // The ctype option instructs the C++ code generator to use a different+ // representation of the field than it normally would. See the specific+ // options below. This option is not yet implemented in the open source+ // release -- sorry, we'll try to include it in a future version!+ optional CType ctype = 1 [default = STRING];+ enum CType {+ // Default mode.+ STRING = 0;++ CORD = 1;++ STRING_PIECE = 2;+ }+ // The packed option can be enabled for repeated primitive fields to enable+ // a more efficient representation on the wire. Rather than repeatedly+ // writing the tag and type for each element, the entire array is encoded as+ // a single length-delimited blob.+ optional bool packed = 2;+++ // Is this field deprecated?+ // Depending on the target platform, this can emit Deprecated annotations+ // for accessors, or it will be completely ignored; in the very least, this+ // is a formalization for deprecating fields.+ optional bool deprecated = 3 [default=false];++ // EXPERIMENTAL. DO NOT USE.+ // For "map" fields, the name of the field in the enclosed type that+ // is the key for this map. For example, suppose we have:+ // message Item {+ // required string name = 1;+ // required string value = 2;+ // }+ // message Config {+ // repeated Item items = 1 [experimental_map_key="name"];+ // }+ // In this situation, the map key for Item will be set to "name".+ // TODO: Fully-implement this, then remove the "experimental_" prefix.+ optional string experimental_map_key = 9;++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++message EnumOptions {++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++message EnumValueOptions {+ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++message ServiceOptions {++ // Note: Field numbers 1 through 32 are reserved for Google's internal RPC+ // framework. We apologize for hoarding these numbers to ourselves, but+ // we were already using them long before we decided to release Protocol+ // Buffers.++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++message MethodOptions {++ // Note: Field numbers 1 through 32 are reserved for Google's internal RPC+ // framework. We apologize for hoarding these numbers to ourselves, but+ // we were already using them long before we decided to release Protocol+ // Buffers.++ // The parser stores options it doesn't recognize here. See above.+ repeated UninterpretedOption uninterpreted_option = 999;++ // Clients can define custom options in extensions of this message. See above.+ extensions 1000 to max;+}++// A message representing a option the parser does not recognize. This only+// appears in options protos created by the compiler::Parser class.+// DescriptorPool resolves these when building Descriptor objects. Therefore,+// options protos in descriptor objects (e.g. returned by Descriptor::options(),+// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions+// in them.+message UninterpretedOption {+ // The name of the uninterpreted option. Each string represents a segment in+ // a dot-separated name. is_extension is true iff a segment represents an+ // extension (denoted with parentheses in options specs in .proto files).+ // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents+ // "foo.(bar.baz).qux".+ message NamePart {+ required string name_part = 1;+ required bool is_extension = 2;+ }+ repeated NamePart name = 2;++ // The value of the uninterpreted option, in whatever type the tokenizer+ // identified it as during parsing. Exactly one of these should be set.+ optional string identifier_value = 3;+ optional uint64 positive_int_value = 4;+ optional int64 negative_int_value = 5;+ optional double double_value = 6;+ optional bytes string_value = 7;+ optional string aggregate_value = 8;+}++// ===================================================================+// Optional source code info++// Encapsulates information about the original source file from which a+// FileDescriptorProto was generated.+message SourceCodeInfo {+ // A Location identifies a piece of source code in a .proto file which+ // corresponds to a particular definition. This information is intended+ // to be useful to IDEs, code indexers, documentation generators, and similar+ // tools.+ //+ // For example, say we have a file like:+ // message Foo {+ // optional string foo = 1;+ // }+ // Let's look at just the field definition:+ // optional string foo = 1;+ // ^ ^^ ^^ ^ ^^^+ // a bc de f ghi+ // We have the following locations:+ // span path represents+ // [a,i) [ 4, 0, 2, 0 ] The whole field definition.+ // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).+ // [c,d) [ 4, 0, 2, 0, 5 ] The type (string).+ // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).+ // [g,h) [ 4, 0, 2, 0, 3 ] The number (1).+ //+ // Notes:+ // - A location may refer to a repeated field itself (i.e. not to any+ // particular index within it). This is used whenever a set of elements are+ // logically enclosed in a single code segment. For example, an entire+ // extend block (possibly containing multiple extension definitions) will+ // have an outer location whose path refers to the "extensions" repeated+ // field without an index.+ // - Multiple locations may have the same path. This happens when a single+ // logical declaration is spread out across multiple places. The most+ // obvious example is the "extend" block again -- there may be multiple+ // extend blocks in the same scope, each of which will have the same path.+ // - A location's span is not always a subset of its parent's span. For+ // example, the "extendee" of an extension declaration appears at the+ // beginning of the "extend" block and is shared by all extensions within+ // the block.+ // - Just because a location's span is a subset of some other location's span+ // does not mean that it is a descendent. For example, a "group" defines+ // both a type and a field in a single declaration. Thus, the locations+ // corresponding to the type and field and their components will overlap.+ // - Code which tries to interpret locations should probably be designed to+ // ignore those that it doesn't understand, as more types of locations could+ // be recorded in the future.+ repeated Location location = 1;+ message Location {+ // Identifies which part of the FileDescriptorProto was defined at this+ // location.+ //+ // Each element is a field number or an index. They form a path from+ // the root FileDescriptorProto to the place where the definition. For+ // example, this path:+ // [ 4, 3, 2, 7, 1 ]+ // refers to:+ // file.message_type(3) // 4, 3+ // .field(7) // 2, 7+ // .name() // 1+ // This is because FileDescriptorProto.message_type has field number 4:+ // repeated DescriptorProto message_type = 4;+ // and DescriptorProto.field has field number 2:+ // repeated FieldDescriptorProto field = 2;+ // and FieldDescriptorProto.name has field number 1:+ // optional string name = 1;+ //+ // Thus, the above path gives the location of a field name. If we removed+ // the last element:+ // [ 4, 3, 2, 7 ]+ // this path refers to the whole field declaration (from the beginning+ // of the label to the terminating semicolon).+ repeated int32 path = 1 [packed=true];++ // Always has exactly three or four elements: start line, start column,+ // end line (optional, otherwise assumed same as start line), end column.+ // These are packed into a single field for efficiency. Note that line+ // and column numbers are zero-based -- typically you will want to add+ // 1 to each before displaying to a user.+ repeated int32 span = 2 [packed=true];++ // TODO(kenton): Record comments appearing before and after the+ // declaration.+ }+}
+ google-proto-files/google/protobuf/plugin.proto view
@@ -0,0 +1,145 @@+// Protocol Buffers - Google's data interchange format+// Copyright 2008 Google Inc. All rights reserved.+// http://code.google.com/p/protobuf/+//+// Redistribution and use in source and binary forms, with or without+// modification, are permitted provided that the following conditions are+// met:+//+// * Redistributions of source code must retain the above copyright+// notice, this list of conditions and the following disclaimer.+// * Redistributions in binary form must reproduce the above+// copyright notice, this list of conditions and the following disclaimer+// in the documentation and/or other materials provided with the+// distribution.+// * Neither the name of Google Inc. nor the names of its+// contributors may be used to endorse or promote products derived from+// this software without specific prior written permission.+//+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.++// Author: kenton@google.com (Kenton Varda)+//+// WARNING: The plugin interface is currently EXPERIMENTAL and is subject to+// change.+//+// protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is+// just a program that reads a CodeGeneratorRequest from stdin and writes a+// CodeGeneratorResponse to stdout.+//+// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead+// of dealing with the raw protocol defined here.+//+// A plugin executable needs only to be placed somewhere in the path. The+// plugin should be named "protoc-gen-$NAME", and will then be used when the+// flag "--${NAME}_out" is passed to protoc.++package google.protobuf.compiler;++import "google/protobuf/descriptor.proto";++// An encoded CodeGeneratorRequest is written to the plugin's stdin.+message CodeGeneratorRequest {+ // The .proto files that were explicitly listed on the command-line. The+ // code generator should generate code only for these files. Each file's+ // descriptor will be included in proto_file, below.+ repeated string file_to_generate = 1;++ // The generator parameter passed on the command-line.+ optional string parameter = 2;++ // FileDescriptorProtos for all files in files_to_generate and everything+ // they import. The files will appear in topological order, so each file+ // appears before any file that imports it.+ //+ // protoc guarantees that all proto_files will be written after+ // the fields above, even though this is not technically guaranteed by the+ // protobuf wire format. This theoretically could allow a plugin to stream+ // in the FileDescriptorProtos and handle them one by one rather than read+ // the entire set into memory at once. However, as of this writing, this+ // is not similarly optimized on protoc's end -- it will store all fields in+ // memory at once before sending them to the plugin.+ repeated FileDescriptorProto proto_file = 15;+}++// The plugin writes an encoded CodeGeneratorResponse to stdout.+message CodeGeneratorResponse {+ // Error message. If non-empty, code generation failed. The plugin process+ // should exit with status code zero even if it reports an error in this way.+ //+ // This should be used to indicate errors in .proto files which prevent the+ // code generator from generating correct code. Errors which indicate a+ // problem in protoc itself -- such as the input CodeGeneratorRequest being+ // unparseable -- should be reported by writing a message to stderr and+ // exiting with a non-zero status code.+ optional string error = 1;++ // Represents a single generated file.+ message File {+ // The file name, relative to the output directory. The name must not+ // contain "." or ".." components and must be relative, not be absolute (so,+ // the file cannot lie outside the output directory). "/" must be used as+ // the path separator, not "\".+ //+ // If the name is omitted, the content will be appended to the previous+ // file. This allows the generator to break large files into small chunks,+ // and allows the generated text to be streamed back to protoc so that large+ // files need not reside completely in memory at one time. Note that as of+ // this writing protoc does not optimize for this -- it will read the entire+ // CodeGeneratorResponse before writing files to disk.+ optional string name = 1;++ // If non-empty, indicates that the named file should already exist, and the+ // content here is to be inserted into that file at a defined insertion+ // point. This feature allows a code generator to extend the output+ // produced by another code generator. The original generator may provide+ // insertion points by placing special annotations in the file that look+ // like:+ // @@protoc_insertion_point(NAME)+ // The annotation can have arbitrary text before and after it on the line,+ // which allows it to be placed in a comment. NAME should be replaced with+ // an identifier naming the point -- this is what other generators will use+ // as the insertion_point. Code inserted at this point will be placed+ // immediately above the line containing the insertion point (thus multiple+ // insertions to the same point will come out in the order they were added).+ // The double-@ is intended to make it unlikely that the generated code+ // could contain things that look like insertion points by accident.+ //+ // For example, the C++ code generator places the following line in the+ // .pb.h files that it generates:+ // // @@protoc_insertion_point(namespace_scope)+ // This line appears within the scope of the file's package namespace, but+ // outside of any particular class. Another plugin can then specify the+ // insertion_point "namespace_scope" to generate additional classes or+ // other declarations that should be placed in this scope.+ //+ // Note that if the line containing the insertion point begins with+ // whitespace, the same whitespace will be added to every line of the+ // inserted text. This is useful for languages like Python, where+ // indentation matters. In these languages, the insertion point comment+ // should be indented the same amount as any inserted code will need to be+ // in order to work correctly in that context.+ //+ // The code generator that generates the initial file and the one which+ // inserts into it must both run as part of a single invocation of protoc.+ // Code generators are executed in the order in which they appear on the+ // command line.+ //+ // If |insertion_point| is present, |name| must also be present.+ optional string insertion_point = 2;++ // The file contents.+ optional string content = 15;+ }+ repeated File file = 15;+}
+ hprotoc-fork.cabal view
@@ -0,0 +1,130 @@+name: hprotoc-fork+version: 2.0.16+cabal-version: >= 1.6+build-type: Simple+license: BSD3+license-file: LICENSE+copyright: (c) 2008-2012 Christopher Edward Kuklewicz+author: Christopher Edward Kuklewicz+maintainer: Stefan Wehr <wehr@cp-med.com>+stability: Experimental+homepage: http://darcs.factisresearch.com/pub/protocol-buffers-fork/+package-url: http://hackage.haskell.org/package/hprotoc-fork+synopsis: Parse Google Protocol Buffer specifications+description: Parse language defined at <http://code.google.com/apis/protocolbuffers/docs/proto.html> and general haskell code to implement messages. This is a fork of the hprotoc library at http://hackage.haskell.org/package/hprotoc+category: Text+Tested-With: GHC == 7.0.3+extra-source-files: README,+ google-proto-files/google/protobuf/descriptor.proto,+ google-proto-files/google/protobuf/plugin.proto++flag small_base+ description: Choose the new smaller, split-up base package.++Executable hprotoc+ build-depends: protocol-buffers-fork == 2.0.16,+ protocol-buffers-descriptor-fork == 2.0.16+ Main-Is: Text/ProtocolBuffers/ProtoCompile.hs+ Hs-Source-Dirs: .,+ protoc-gen-haskell+ build-tools: alex+ ghc-options: -O2 -Wall -fspec-constr-count=10+ ghc-prof-options: -O2 -auto-all -prof+ build-depends: array,+ binary,+ bytestring,+ containers,+ directory >= 1.0.0.1,+ filepath >= 1.1.0.0,+ haskell-src-exts == 1.15.*,+ mtl,+ parsec,+-- parsec < 3,+ utf8-string++ if flag(small_base)+ build-depends: base == 4.*+ else+ build-depends: base == 3.*++ other-modules: Paths_hprotoc_fork+ Text.Google.Protobuf.Compiler+ Text.Google.Protobuf.Compiler.CodeGeneratorRequest+ Text.Google.Protobuf.Compiler.CodeGeneratorResponse+ Text.Google.Protobuf.Compiler.CodeGeneratorResponse.File+ Text.ProtocolBuffers.ProtoCompile.BreakRecursion+ Text.ProtocolBuffers.ProtoCompile.Gen+ Text.ProtocolBuffers.ProtoCompile.Identifiers+ Text.ProtocolBuffers.ProtoCompile.Instances+ Text.ProtocolBuffers.ProtoCompile.Lexer+ Text.ProtocolBuffers.ProtoCompile.MakeReflections+ Text.ProtocolBuffers.ProtoCompile.Parser+ Text.ProtocolBuffers.ProtoCompile.Resolve+ extensions: DeriveDataTypeable,+ EmptyDataDecls,+ FlexibleContexts + FlexibleInstances,+ FunctionalDependencies,+ GADTs,+ GeneralizedNewtypeDeriving,+ MagicHash,+ MultiParamTypeClasses,+ PatternGuards,+ RankNTypes,+ DoRec,+ ScopedTypeVariables,+ TypeSynonymInstances+-- PatternSignatures++Library+ build-depends: protocol-buffers-fork == 2.0.16,+ protocol-buffers-descriptor-fork == 2.0.16+ Hs-Source-Dirs: .,+ protoc-gen-haskell+ build-tools: alex+ ghc-options: -O2 -Wall -fspec-constr-count=10+ ghc-prof-options: -O2 -auto-all -prof+ build-depends: array,+ binary,+ bytestring,+ containers,+ directory >= 1.0.0.1,+ filepath >= 1.1.0.0,+ haskell-src-exts == 1.15.*,+ mtl,+ parsec,+ utf8-string++ if flag(small_base)+ build-depends: base == 4.*+ else+ build-depends: base == 3.*++ exposed-modules: Text.ProtocolBuffers.ProtoCompile.Parser+ Text.ProtocolBuffers.ProtoCompile.Resolve+ Text.ProtocolBuffers.ProtoCompile.MakeReflections++ other-modules: Paths_hprotoc_fork+ Text.Google.Protobuf.Compiler+ Text.Google.Protobuf.Compiler.CodeGeneratorRequest+ Text.Google.Protobuf.Compiler.CodeGeneratorResponse+ Text.Google.Protobuf.Compiler.CodeGeneratorResponse.File+ Text.ProtocolBuffers.ProtoCompile.BreakRecursion+ Text.ProtocolBuffers.ProtoCompile.Gen+ Text.ProtocolBuffers.ProtoCompile.Identifiers+ Text.ProtocolBuffers.ProtoCompile.Instances+ Text.ProtocolBuffers.ProtoCompile.Lexer+ extensions: DeriveDataTypeable,+ EmptyDataDecls,+ FlexibleContexts+ FlexibleInstances,+ FunctionalDependencies,+ GADTs,+ GeneralizedNewtypeDeriving,+ MagicHash,+ MultiParamTypeClasses,+ PatternGuards,+ RankNTypes,+ DoRec,+ ScopedTypeVariables,+ TypeSynonymInstances
+ protoc-gen-haskell/Text/Google/Protobuf/Compiler.hs view
@@ -0,0 +1,20 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Text.Google.Protobuf.Compiler (protoInfo, fileDescriptorProto) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import Text.DescriptorProtos.FileDescriptorProto (FileDescriptorProto)+import Text.ProtocolBuffers.Reflections (ProtoInfo)+import qualified Text.ProtocolBuffers.WireMessage as P' (wireGet,getFromBS)+ +protoInfo :: ProtoInfo+protoInfo+ = Prelude'.read+ "ProtoInfo {protoMod = ProtoName {protobufName = FIName \".google.protobuf.compiler\", haskellPrefix = [MName \"Text\"], parentModule = [MName \"Google\",MName \"Protobuf\"], baseName = MName \"Compiler\"}, protoFilePath = [\"Text\",\"Google\",\"Protobuf\",\"Compiler.hs\"], protoSource = \"google/protobuf/plugin.proto\", extensionKeys = fromList [], messages = [DescriptorInfo {descName = ProtoName {protobufName = FIName \".google.protobuf.compiler.CodeGeneratorRequest\", haskellPrefix = [MName \"Text\"], parentModule = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\"], baseName = MName \"CodeGeneratorRequest\"}, descFilePath = [\"Text\",\"Google\",\"Protobuf\",\"Compiler\",\"CodeGeneratorRequest.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorRequest.file_to_generate\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorRequest\"], baseName' = FName \"file_to_generate\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorRequest.parameter\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorRequest\"], baseName' = FName \"parameter\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorRequest.proto_file\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorRequest\"], baseName' = FName \"proto_file\"}, fieldNumber = FieldId {getFieldId = 15}, wireTag = WireTag {getWireTag = 122}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".google.protobuf.FileDescriptorProto\", haskellPrefix = [MName \"Text\"], parentModule = [MName \"DescriptorProtos\"], baseName = MName \"FileDescriptorProto\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = True, lazyFields = False},DescriptorInfo {descName = ProtoName {protobufName = FIName \".google.protobuf.compiler.CodeGeneratorResponse\", haskellPrefix = [MName \"Text\"], parentModule = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\"], baseName = MName \"CodeGeneratorResponse\"}, descFilePath = [\"Text\",\"Google\",\"Protobuf\",\"Compiler\",\"CodeGeneratorResponse.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorResponse.error\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\"], baseName' = FName \"error\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorResponse.file\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\"], baseName' = FName \"file\"}, fieldNumber = FieldId {getFieldId = 15}, wireTag = WireTag {getWireTag = 122}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".google.protobuf.compiler.CodeGeneratorResponse.File\", haskellPrefix = [MName \"Text\"], parentModule = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\"], baseName = MName \"File\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = True, lazyFields = False},DescriptorInfo {descName = ProtoName {protobufName = FIName \".google.protobuf.compiler.CodeGeneratorResponse.File\", haskellPrefix = [MName \"Text\"], parentModule = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\"], baseName = MName \"File\"}, descFilePath = [\"Text\",\"Google\",\"Protobuf\",\"Compiler\",\"CodeGeneratorResponse\",\"File.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorResponse.File.name\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\",MName \"File\"], baseName' = FName \"name\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\",MName \"File\"], baseName' = FName \"insertion_point\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorResponse.File.content\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\",MName \"File\"], baseName' = FName \"content\"}, fieldNumber = FieldId {getFieldId = 15}, wireTag = WireTag {getWireTag = 122}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = True, lazyFields = False}], enums = [], knownKeyMap = fromList []}"+ +fileDescriptorProto :: FileDescriptorProto+fileDescriptorProto+ = P'.getFromBS (P'.wireGet 11)+ (P'.pack+ "\134\ETX\n\FSgoogle/protobuf/plugin.proto\DC2\CANgoogle.protobuf.compiler\SUB google/protobuf/descriptor.proto\"}\n\DC4CodeGeneratorRequest\DC2\CAN\n\DLEfile_to_generate\CAN\SOH \ETX(\t\DC2\DC1\n\tparameter\CAN\STX \SOH(\t\DC28\n\nproto_file\CAN\SI \ETX(\v2$.google.protobuf.FileDescriptorProto\"\170\SOH\n\NAKCodeGeneratorResponse\DC2\r\n\ENQerror\CAN\SOH \SOH(\t\DC2B\n\EOTfile\CAN\SI \ETX(\v24.google.protobuf.compiler.CodeGeneratorResponse.File\SUB>\n\EOTFile\DC2\f\n\EOTname\CAN\SOH \SOH(\t\DC2\ETB\n\SIinsertion_point\CAN\STX \SOH(\t\DC2\SI\n\acontent\CAN\SI \SOH(\t")
+ protoc-gen-haskell/Text/Google/Protobuf/Compiler/CodeGeneratorRequest.hs view
@@ -0,0 +1,70 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Text.Google.Protobuf.Compiler.CodeGeneratorRequest (CodeGeneratorRequest(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Text.DescriptorProtos.FileDescriptorProto as DescriptorProtos (FileDescriptorProto)+ +data CodeGeneratorRequest = CodeGeneratorRequest{file_to_generate :: !(P'.Seq P'.Utf8), parameter :: !(P'.Maybe P'.Utf8),+ proto_file :: !(P'.Seq DescriptorProtos.FileDescriptorProto),+ unknown'field :: !P'.UnknownField}+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable)+ +instance P'.UnknownMessage CodeGeneratorRequest where+ getUnknownField = unknown'field+ putUnknownField u'f msg = msg{unknown'field = u'f}+ +instance P'.Mergeable CodeGeneratorRequest where+ mergeAppend (CodeGeneratorRequest x'1 x'2 x'3 x'4) (CodeGeneratorRequest y'1 y'2 y'3 y'4)+ = CodeGeneratorRequest (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+ +instance P'.Default CodeGeneratorRequest where+ defaultValue = CodeGeneratorRequest P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire CodeGeneratorRequest where+ wireSize ft' self'@(CodeGeneratorRequest x'1 x'2 x'3 x'4)+ = case ft' of+ 10 -> calc'Size+ 11 -> P'.prependMessageSize calc'Size+ _ -> P'.wireSizeErr ft' self'+ where+ calc'Size = (P'.wireSizeRep 1 9 x'1 + P'.wireSizeOpt 1 9 x'2 + P'.wireSizeRep 1 11 x'3 + P'.wireSizeUnknownField x'4)+ wirePut ft' self'@(CodeGeneratorRequest x'1 x'2 x'3 x'4)+ = case ft' of+ 10 -> put'Fields+ 11 -> do+ P'.putSize (P'.wireSize 10 self')+ put'Fields+ _ -> P'.wirePutErr ft' self'+ where+ put'Fields+ = do+ P'.wirePutRep 10 9 x'1+ P'.wirePutOpt 18 9 x'2+ P'.wirePutRep 122 11 x'3+ P'.wirePutUnknownField x'4+ wireGet ft'+ = case ft' of+ 10 -> P'.getBareMessageWith (P'.catch'Unknown update'Self)+ 11 -> P'.getMessageWith (P'.catch'Unknown update'Self)+ _ -> P'.wireGetErr ft'+ where+ update'Self wire'Tag old'Self+ = case wire'Tag of+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{file_to_generate = P'.append (file_to_generate old'Self) new'Field})+ (P'.wireGet 9)+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{parameter = Prelude'.Just new'Field}) (P'.wireGet 9)+ 122 -> Prelude'.fmap (\ !new'Field -> old'Self{proto_file = P'.append (proto_file old'Self) new'Field}) (P'.wireGet 11)+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> CodeGeneratorRequest) CodeGeneratorRequest where+ getVal m' f' = f' m'+ +instance P'.GPB CodeGeneratorRequest+ +instance P'.ReflectDescriptor CodeGeneratorRequest where+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList []) (P'.fromDistinctAscList [10, 18, 122])+ reflectDescriptorInfo _+ = Prelude'.read+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".google.protobuf.compiler.CodeGeneratorRequest\", haskellPrefix = [MName \"Text\"], parentModule = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\"], baseName = MName \"CodeGeneratorRequest\"}, descFilePath = [\"Text\",\"Google\",\"Protobuf\",\"Compiler\",\"CodeGeneratorRequest.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorRequest.file_to_generate\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorRequest\"], baseName' = FName \"file_to_generate\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorRequest.parameter\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorRequest\"], baseName' = FName \"parameter\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorRequest.proto_file\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorRequest\"], baseName' = FName \"proto_file\"}, fieldNumber = FieldId {getFieldId = 15}, wireTag = WireTag {getWireTag = 122}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".google.protobuf.FileDescriptorProto\", haskellPrefix = [MName \"Text\"], parentModule = [MName \"DescriptorProtos\"], baseName = MName \"FileDescriptorProto\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = True, lazyFields = False}"
+ protoc-gen-haskell/Text/Google/Protobuf/Compiler/CodeGeneratorResponse.hs view
@@ -0,0 +1,67 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Text.Google.Protobuf.Compiler.CodeGeneratorResponse (CodeGeneratorResponse(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+import qualified Text.Google.Protobuf.Compiler.CodeGeneratorResponse.File as Google.Protobuf.Compiler.CodeGeneratorResponse (File)+ +data CodeGeneratorResponse = CodeGeneratorResponse{error :: !(P'.Maybe P'.Utf8),+ file :: !(P'.Seq Google.Protobuf.Compiler.CodeGeneratorResponse.File),+ unknown'field :: !P'.UnknownField}+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable)+ +instance P'.UnknownMessage CodeGeneratorResponse where+ getUnknownField = unknown'field+ putUnknownField u'f msg = msg{unknown'field = u'f}+ +instance P'.Mergeable CodeGeneratorResponse where+ mergeAppend (CodeGeneratorResponse x'1 x'2 x'3) (CodeGeneratorResponse y'1 y'2 y'3)+ = CodeGeneratorResponse (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3)+ +instance P'.Default CodeGeneratorResponse where+ defaultValue = CodeGeneratorResponse P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire CodeGeneratorResponse where+ wireSize ft' self'@(CodeGeneratorResponse x'1 x'2 x'3)+ = case ft' of+ 10 -> calc'Size+ 11 -> P'.prependMessageSize calc'Size+ _ -> P'.wireSizeErr ft' self'+ where+ calc'Size = (P'.wireSizeOpt 1 9 x'1 + P'.wireSizeRep 1 11 x'2 + P'.wireSizeUnknownField x'3)+ wirePut ft' self'@(CodeGeneratorResponse x'1 x'2 x'3)+ = case ft' of+ 10 -> put'Fields+ 11 -> do+ P'.putSize (P'.wireSize 10 self')+ put'Fields+ _ -> P'.wirePutErr ft' self'+ where+ put'Fields+ = do+ P'.wirePutOpt 10 9 x'1+ P'.wirePutRep 122 11 x'2+ P'.wirePutUnknownField x'3+ wireGet ft'+ = case ft' of+ 10 -> P'.getBareMessageWith (P'.catch'Unknown update'Self)+ 11 -> P'.getMessageWith (P'.catch'Unknown update'Self)+ _ -> P'.wireGetErr ft'+ where+ update'Self wire'Tag old'Self+ = case wire'Tag of+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{error = Prelude'.Just new'Field}) (P'.wireGet 9)+ 122 -> Prelude'.fmap (\ !new'Field -> old'Self{file = P'.append (file old'Self) new'Field}) (P'.wireGet 11)+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> CodeGeneratorResponse) CodeGeneratorResponse where+ getVal m' f' = f' m'+ +instance P'.GPB CodeGeneratorResponse+ +instance P'.ReflectDescriptor CodeGeneratorResponse where+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList []) (P'.fromDistinctAscList [10, 122])+ reflectDescriptorInfo _+ = Prelude'.read+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".google.protobuf.compiler.CodeGeneratorResponse\", haskellPrefix = [MName \"Text\"], parentModule = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\"], baseName = MName \"CodeGeneratorResponse\"}, descFilePath = [\"Text\",\"Google\",\"Protobuf\",\"Compiler\",\"CodeGeneratorResponse.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorResponse.error\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\"], baseName' = FName \"error\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorResponse.file\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\"], baseName' = FName \"file\"}, fieldNumber = FieldId {getFieldId = 15}, wireTag = WireTag {getWireTag = 122}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = True, mightPack = False, typeCode = FieldType {getFieldType = 11}, typeName = Just (ProtoName {protobufName = FIName \".google.protobuf.compiler.CodeGeneratorResponse.File\", haskellPrefix = [MName \"Text\"], parentModule = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\"], baseName = MName \"File\"}), hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = True, lazyFields = False}"
+ protoc-gen-haskell/Text/Google/Protobuf/Compiler/CodeGeneratorResponse/File.hs view
@@ -0,0 +1,67 @@+{-# LANGUAGE BangPatterns, DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses #-}+module Text.Google.Protobuf.Compiler.CodeGeneratorResponse.File (File(..)) where+import Prelude ((+), (/))+import qualified Prelude as Prelude'+import qualified Data.Typeable as Prelude'+import qualified Text.ProtocolBuffers.Header as P'+ +data File = File{name :: !(P'.Maybe P'.Utf8), insertion_point :: !(P'.Maybe P'.Utf8), content :: !(P'.Maybe P'.Utf8),+ unknown'field :: !P'.UnknownField}+ deriving (Prelude'.Show, Prelude'.Eq, Prelude'.Ord, Prelude'.Typeable)+ +instance P'.UnknownMessage File where+ getUnknownField = unknown'field+ putUnknownField u'f msg = msg{unknown'field = u'f}+ +instance P'.Mergeable File where+ mergeAppend (File x'1 x'2 x'3 x'4) (File y'1 y'2 y'3 y'4)+ = File (P'.mergeAppend x'1 y'1) (P'.mergeAppend x'2 y'2) (P'.mergeAppend x'3 y'3) (P'.mergeAppend x'4 y'4)+ +instance P'.Default File where+ defaultValue = File P'.defaultValue P'.defaultValue P'.defaultValue P'.defaultValue+ +instance P'.Wire File where+ wireSize ft' self'@(File x'1 x'2 x'3 x'4)+ = case ft' of+ 10 -> calc'Size+ 11 -> P'.prependMessageSize calc'Size+ _ -> P'.wireSizeErr ft' self'+ where+ calc'Size = (P'.wireSizeOpt 1 9 x'1 + P'.wireSizeOpt 1 9 x'2 + P'.wireSizeOpt 1 9 x'3 + P'.wireSizeUnknownField x'4)+ wirePut ft' self'@(File x'1 x'2 x'3 x'4)+ = case ft' of+ 10 -> put'Fields+ 11 -> do+ P'.putSize (P'.wireSize 10 self')+ put'Fields+ _ -> P'.wirePutErr ft' self'+ where+ put'Fields+ = do+ P'.wirePutOpt 10 9 x'1+ P'.wirePutOpt 18 9 x'2+ P'.wirePutOpt 122 9 x'3+ P'.wirePutUnknownField x'4+ wireGet ft'+ = case ft' of+ 10 -> P'.getBareMessageWith (P'.catch'Unknown update'Self)+ 11 -> P'.getMessageWith (P'.catch'Unknown update'Self)+ _ -> P'.wireGetErr ft'+ where+ update'Self wire'Tag old'Self+ = case wire'Tag of+ 10 -> Prelude'.fmap (\ !new'Field -> old'Self{name = Prelude'.Just new'Field}) (P'.wireGet 9)+ 18 -> Prelude'.fmap (\ !new'Field -> old'Self{insertion_point = Prelude'.Just new'Field}) (P'.wireGet 9)+ 122 -> Prelude'.fmap (\ !new'Field -> old'Self{content = Prelude'.Just new'Field}) (P'.wireGet 9)+ _ -> let (field'Number, wire'Type) = P'.splitWireTag wire'Tag in P'.unknown field'Number wire'Type old'Self+ +instance P'.MessageAPI msg' (msg' -> File) File where+ getVal m' f' = f' m'+ +instance P'.GPB File+ +instance P'.ReflectDescriptor File where+ getMessageInfo _ = P'.GetMessageInfo (P'.fromDistinctAscList []) (P'.fromDistinctAscList [10, 18, 122])+ reflectDescriptorInfo _+ = Prelude'.read+ "DescriptorInfo {descName = ProtoName {protobufName = FIName \".google.protobuf.compiler.CodeGeneratorResponse.File\", haskellPrefix = [MName \"Text\"], parentModule = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\"], baseName = MName \"File\"}, descFilePath = [\"Text\",\"Google\",\"Protobuf\",\"Compiler\",\"CodeGeneratorResponse\",\"File.hs\"], isGroup = False, fields = fromList [FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorResponse.File.name\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\",MName \"File\"], baseName' = FName \"name\"}, fieldNumber = FieldId {getFieldId = 1}, wireTag = WireTag {getWireTag = 10}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\",MName \"File\"], baseName' = FName \"insertion_point\"}, fieldNumber = FieldId {getFieldId = 2}, wireTag = WireTag {getWireTag = 18}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing},FieldInfo {fieldName = ProtoFName {protobufName' = FIName \".google.protobuf.compiler.CodeGeneratorResponse.File.content\", haskellPrefix' = [MName \"Text\"], parentModule' = [MName \"Google\",MName \"Protobuf\",MName \"Compiler\",MName \"CodeGeneratorResponse\",MName \"File\"], baseName' = FName \"content\"}, fieldNumber = FieldId {getFieldId = 15}, wireTag = WireTag {getWireTag = 122}, packedTag = Nothing, wireTagLength = 1, isPacked = False, isRequired = False, canRepeat = False, mightPack = False, typeCode = FieldType {getFieldType = 9}, typeName = Nothing, hsRawDefault = Nothing, hsDefault = Nothing}], keys = fromList [], extRanges = [], knownKeys = fromList [], storeUnknown = True, lazyFields = False}"